File size: 6,828 Bytes
d044abe | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 | """Original deterministic task algebra and independent Python behavioral oracle.
No runtime-generated candidate code is executed by this module.
"""
import itertools
import random
import string
SCALAR = {
'double':('double it',lambda n:2*n),
'negate':('negate it',lambda n:-n),
'absolute':('take its absolute value',abs),
'square':('square it',lambda n:n*n),
'successor':('add one',lambda n:n+1),
'sign':('replace it with -1, 0, or 1 according to its sign',lambda n:(n>0)-(n<0)),
'positive':('replace negative values with zero',lambda n:max(n,0)),
'even':('replace it with 1 if even, otherwise 0',lambda n:int(n%2==0)),
'clamp':('clamp it to the inclusive range -5 to 5',lambda n:max(-5,min(5,n))),
'ones':('take the last decimal digit of its absolute value',lambda n:abs(n)%10),
'tens':('take the tens digit of its absolute value',lambda n:abs(n)//10%10),
'negative':('replace it with 1 if negative, otherwise 0',lambda n:int(n<0)),
'complement':('subtract it from ten',lambda n:10-n),
}
STRINGS = {
'upper':('convert lowercase ASCII letters to uppercase',lambda s:s.upper()),
'lower':('convert uppercase ASCII letters to lowercase',lambda s:s.lower()),
'reverse':('reverse the characters',lambda s:s[::-1]),
'trim':('remove leading and trailing spaces',lambda s:s.strip(' ')),
'letters':('keep only ASCII letters',lambda s:''.join(c for c in s if c in string.ascii_letters)),
'digits':('keep only decimal digits',lambda s:''.join(c for c in s if c in string.digits)),
'no_vowels':('remove vowels aeiou in either case',lambda s:''.join(c for c in s if c.lower() not in 'aeiou')),
'no_spaces':('remove every space',lambda s:s.replace(' ','')),
'first_half':('keep the first floor(length/2) characters',lambda s:s[:len(s)//2]),
'second_half':('keep characters from index floor(length/2) onward',lambda s:s[len(s)//2:]),
'swap_case':('swap the case of ASCII letters',lambda s:s.swapcase()),
'collapse':('replace each run of spaces with one space',lambda s:__import__('re').sub(' +',' ',s)),
}
FILTERS={
'all':('all items',lambda x,i:True),
'positive':('positive items',lambda x,i:x>0),
'negative':('negative items',lambda x,i:x<0),
'even':('even items',lambda x,i:x%2==0),
'odd':('odd items',lambda x,i:x%2!=0),
'nonzero':('nonzero items',lambda x,i:x!=0),
'small':('items with absolute value at most three',lambda x,i:abs(x)<=3),
'large':('items with absolute value greater than three',lambda x,i:abs(x)>3),
'even_index':('items at even zero-based indices',lambda x,i:i%2==0),
'odd_index':('items at odd zero-based indices',lambda x,i:i%2==1),
}
REDUCERS={
'sum':'sum', 'count':'count', 'product':'product', 'min':'minimum', 'max':'maximum',
'first':'first value','last':'last value','range':'maximum minus minimum',
'distinct':'number of distinct values','frequency':'largest frequency of a value',
}
def reduce_values(key,values):
if key=='sum':return sum(values)
if key=='count':return len(values)
if key=='product':
import math
return math.prod(values)
if key=='distinct':return len(set(values))
if key=='frequency':
from collections import Counter
return max(Counter(values).values(),default=0)
if not values:return 0
return {'min':lambda:min(values),'max':lambda:max(values),'first':lambda:values[0],
'last':lambda:values[-1],'range':lambda:max(values)-min(values)}[key]()
def oracle(spec,value):
if spec['kind'] in ('scalar','string'):
operations=SCALAR if spec['kind']=='scalar' else STRINGS
for step in spec['steps']:value=operations[step][1](value)
return value
selected=[x for i,x in enumerate(value) if FILTERS[spec['filter']][1](x,i)]
if spec.get('map'):selected=[SCALAR[spec['map']][1](x) for x in selected]
return reduce_values(spec['reduce'],selected)
def probes(kind):
rng=random.Random(20261105)
if kind=='scalar':return list(range(-120,121))
if kind=='string':
return ['', 'a','A','0',' ', ' Ab9 eE! 02 ', 'aeiouAEIOU', 'xyzXYZ', '123456', ' a b ',
'odd!?', 'Aa0 !', 'bCdEf']+[''.join(rng.choice('aAbBcCeE019 !?') for _ in range(rng.randrange(1,24))) for _ in range(120)]
return [[],[0],[1],[-1],[2,-3,0,5,2],[-4,-4,-1],[1,2,3,4], [4,3,2,1], [0,0,0], [1,-1,1,-1]]+[
[rng.randint(-6,6) for _ in range(rng.randrange(1,9))] for _ in range(180)]
def bank(kind):
if kind in ('scalar','string'):
ops=SCALAR if kind=='scalar' else STRINGS
candidates=[{'kind':kind,'steps':list(pair)} for pair in itertools.product(ops,repeat=2)]
else:
candidates=[{'kind':'array','filter':f,'reduce':r} for f,r in itertools.product(FILTERS,REDUCERS)]
# An exhaustive finite probe signature rejects algebraic/behavioral duplicates
# in this restricted grammar, including reordered commuting operations.
seen=set();out=[]
for spec in candidates:
signature=tuple(oracle(spec,x) for x in probes(kind))
if signature in seen:continue
seen.add(signature);out.append(spec)
return out
def instruction(spec):
kind=spec['kind']
if kind in ('scalar','string'):
ops=SCALAR if kind=='scalar' else STRINGS
return ('Starting with n, ' if kind=='scalar' else 'Starting with ASCII string s, ')+', then '.join(ops[k][0] for k in spec['steps'])+'. Return the result.'
text='Select '+FILTERS[spec['filter']][0]+' from values in original order. '
if spec.get('map'):text+='For each selected item, '+SCALAR[spec['map']][0]+'. '
text+='Return their '+REDUCERS[spec['reduce']]+'. '
if spec['reduce']=='product':text+='The empty product is 1.'
elif spec['reduce'] not in ('sum','count','distinct','frequency'):text+='Return 0 when none are selected.'
return text
def task_specs():
scalars=bank('scalar');strings=bank('string');arrays=bank('array')
assert len(scalars)>=80 and len(strings)>=70 and len(arrays)>=75,(len(scalars),len(strings),len(arrays))
# Interleave operation families so shorter language allocations retain diversity.
rng=random.Random(7301)
for b in (scalars,strings,arrays):rng.shuffle(b)
easy=[]
for i in range(80):
easy.append(scalars[i])
if i<70:easy.append(strings[i])
medium=arrays[:75]
seen={tuple(oracle(s,x) for x in probes('array')) for s in medium}
moderate=[]
candidates=[{'kind':'array','filter':f,'map':m,'reduce':r}
for f,m,r in itertools.product(FILTERS,('absolute','square','negate','double','sign','successor'),REDUCERS)
if r!='count']
rng.shuffle(candidates)
for s in candidates:
sig=tuple(oracle(s,x) for x in probes('array'))
if sig in seen:continue
seen.add(sig);moderate.append(s)
if len(moderate)==25:break
return {'easy':easy,'medium':medium,'moderate':moderate}
|