| """Harder algorithmic repair families with independent small-instance oracles.""" |
| import ast |
| from fractions import Fraction |
|
|
|
|
| def allocation_ref(workers,jobs,quotes): |
| cost={(w,j):c for w,j,c in quotes} |
| slots=[j for j,d in jobs for _ in range(d)] |
| remaining=dict(workers) |
| best=(0,0) |
| def search(i,filled,total): |
| nonlocal best |
| if i==len(slots): |
| if filled>best[0] or (filled==best[0] and total<best[1]): |
| best=(filled,total) |
| return |
| search(i+1,filled,total) |
| j=slots[i] |
| for w in remaining: |
| if remaining[w]>0 and (w,j) in cost: |
| remaining[w]-=1 |
| search(i+1,filled+1,total+cost[w,j]) |
| remaining[w]+=1 |
| search(0,0,0) |
| return {'filled':best[0],'cost':best[1]} |
|
|
|
|
| def expression_ref(text): |
| |
| tree=ast.parse(text.strip().replace('^','**'),mode='eval') |
| def evaluate(n): |
| if isinstance(n,ast.Constant) and type(n.value) is int: |
| return Fraction(n.value) |
| if isinstance(n,ast.UnaryOp): |
| v=evaluate(n.operand) |
| return -v if isinstance(n.op,ast.USub) else v |
| a,b=evaluate(n.left),evaluate(n.right) |
| if isinstance(n.op,ast.Add): return a+b |
| if isinstance(n.op,ast.Sub): return a-b |
| if isinstance(n.op,ast.Mult): return a*b |
| if isinstance(n.op,ast.Div): return a/b |
| if isinstance(n.op,ast.Pow): return a**b |
| raise ValueError('operator') |
| return str(evaluate(tree.body)) |
|
|
|
|
| HARD_SPECS={ |
| 'allocation': ( |
| 'solve(workers,jobs,quotes): workers=[[name,capacity],...], jobs=[[name,demand],...], quotes=[[worker,job,cost_per_unit],...] (unique pairs, nonnegative integer costs). Unquoted assignments are forbidden. Allocate integer units, never exceed a worker capacity or job demand. First maximize total filled demand, then minimize cost among all such allocations. Return exactly {filled:int,cost:int}. A greedy edge ordering is insufficient; reassignment may be necessary. Names in each list are unique. Empty and disconnected instances are valid; do not mutate inputs.', |
| { |
| 'network.py': "def edge(graph,a,b,cap,cost):\n graph[a].append([b,len(graph[b]),cap,cost])\n graph[b].append([a,len(graph[a])-1,0,-cost])\n", |
| 'paths.py': "def shortest(graph,source):\n n=len(graph)\n distance=[None]*n\n parent=[None]*n\n distance[source]=0\n for turn in range(n-1):\n changed=False\n for a in range(n):\n if distance[a] is not None:\n for idx,e in enumerate(graph[a]):\n b,rev,cap,cost=e\n if cap>0 and (distance[b] is None or distance[a]+cost<distance[b]):\n distance[b]=distance[a]+cost\n parent[b]=(a,idx)\n changed=True\n if not changed:\n break\n return distance,parent\n", |
| 'augment.py': "def send(graph,parent,source,sink):\n path=[]\n v=sink\n while v!=source:\n a,idx=parent[v]\n path.append((a,idx))\n v=a\n amount=min(graph[a][idx][2] for a,idx in path)\n for a,idx in path:\n b,rev,cap,cost=graph[a][idx]\n graph[a][idx][2]-=amount\n graph[b][rev][2]+=amount\n return amount\n", |
| 'main.py': "from network import edge\nfrom paths import shortest\nfrom augment import send\ndef solve(workers,jobs,quotes):\n wmap={name:i+1 for i,(name,c) in enumerate(workers)}\n jmap={name:len(workers)+i+1 for i,(name,d) in enumerate(jobs)}\n source,sink=0,len(workers)+len(jobs)+1\n graph=[[] for i in range(sink+1)]\n for name,c in workers:\n edge(graph,source,wmap[name],c,0)\n for name,d in jobs:\n edge(graph,jmap[name],sink,d,0)\n for w,j,c in quotes:\n edge(graph,wmap[w],jmap[j],sum(d for name,d in jobs),c)\n filled,total=0,0\n while True:\n distance,parent=shortest(graph,source)\n if distance[sink] is None:\n break\n amount=send(graph,parent,source,sink)\n filled+=amount\n total+=amount*distance[sink]\n return {'filled':filled,'cost':total}\n", |
| }, [('network.py','len(graph[a])-1,0,-cost','len(graph[a])-1,0,cost'), |
| ('paths.py','range(n-1)','range(1)'), |
| ('augment.py','amount=min(','amount=max(')]), |
| 'expression': ( |
| 'solve(text): text is a valid arithmetic expression of nonnegative integer literals, whitespace, parentheses, unary +/- and binary + - * / ^. Use exact rational arithmetic. Power is right-associative and binds MORE tightly than unary signs; multiplication/division are left-associative and bind more tightly than addition/subtraction. Exponents evaluate to nonnegative integers; no zero divisor occurs. Return the canonical fractions.Fraction string, integer if denominator=1, else numerator/denominator. Example -2^2 is -4, 2^3^2 is 512, 8/4/2 is 1. Input unchanged.', |
| { |
| 'lex.py': "def tokens(text):\n out=[]\n i=0\n while i<len(text):\n c=text[i]\n if c.isspace():\n i+=1\n elif c.isdigit():\n j=i+1\n while j<len(text) and text[j].isdigit():\n j+=1\n out.append(text[i:j])\n i=j\n else:\n out.append(c)\n i+=1\n return out\n", |
| 'binding.py': "def powers(op):\n if op in ('+','-'): return (10,11)\n if op in ('*','/'): return (20,21)\n if op=='^': return (40,40)\n return (-1,-1)\n", |
| 'unary.py': "def precedence():\n return 30\n", |
| 'main.py': "from fractions import Fraction\nfrom lex import tokens\nfrom binding import powers\nfrom unary import precedence\ndef parse(ts,pos,minimum):\n token=ts[pos]\n if token in ('+','-'):\n value,pos=parse(ts,pos+1,precedence())\n if token=='-': value=-value\n elif token=='(':\n value,pos=parse(ts,pos+1,0)\n if ts[pos]!=')': raise ValueError('parenthesis')\n pos+=1\n else:\n value=Fraction(int(token))\n pos+=1\n while pos<len(ts):\n op=ts[pos]\n left,right=powers(op)\n if left<minimum: break\n other,pos=parse(ts,pos+1,right)\n if op=='+': value+=other\n elif op=='-': value-=other\n elif op=='*': value*=other\n elif op=='/': value/=other\n elif op=='^': value=value**other\n return value,pos\ndef solve(text):\n ts=tokens(text)\n value,pos=parse(ts,0,0)\n if pos!=len(ts): raise ValueError('trailing tokens')\n return str(value)\n", |
| }, [('lex.py','while j<len(text) and text[j].isdigit():','while False:'), |
| ('binding.py',"if op=='^': return (40,40)","if op=='^': return (40,41)"), |
| ('unary.py','return 30','return 50')]), |
| } |
|
|
|
|
| def hard_cases(family,rng): |
| out=[] |
| def add(group,*args): |
| out.append({'group':group,'args':list(args)}) |
| if family=='allocation': |
| add('empty',[],[],[]) |
| add('reroute',[['a',1],['b',1]],[['x',1],['y',1]],[['a','x',1],['a','y',2],['b','x',2],['b','y',100]]) |
| add('bottleneck',[['a',4]],[['x',1]],[['a','x',3]]) |
| add('shortfall',[['a',2]],[['x',1],['y',3]],[['a','x',2]]) |
| add('reverse_order',[['b',1],['a',1]],[['y',1],['x',1]],[['a','x',1],['a','y',2],['b','x',2],['b','y',100]]) |
| for i in range(30): |
| workers=[[f'w{j}',rng.randint(1,3)] for j in range(rng.randint(2,3))] |
| jobs=[[f'j{j}',rng.randint(1,2)] for j in range(rng.randint(2,3))] |
| quotes=[[w,j,rng.randint(0,20)] for w,c in workers for j,d in jobs if rng.random()<.8] |
| rng.shuffle(workers); rng.shuffle(jobs); rng.shuffle(quotes) |
| add('random',workers,jobs,quotes) |
| else: |
| add('literal',str(rng.randint(10,99))) |
| add('unary',f'-{rng.randint(2,5)}^2') |
| add('power','2^3^2') |
| add('rational','8/4/2 + 1/3') |
| add('parentheses','-(12 + 3) * (5 - 8)') |
| def expression(depth): |
| if depth==0: return str(rng.randint(1,20)) |
| op=rng.choice(['+','-','*','/','^']) |
| a=expression(depth-1) |
| b=str(rng.randint(1,5)) if op=='/' else str(rng.randint(0,3)) if op=='^' else expression(depth-1) |
| value=f'({a} {op} {b})' |
| return '-'+value if rng.random()<.25 else value |
| for i in range(30): add('random',expression(rng.randint(1,3))) |
| return out |
|
|
