| """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)] |
| |
| |
| 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)) |
| |
| 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} |
|
|
