Datasets:
Download curation/v3/scripts/cases.py from dsfasdfaserwer/Dataset: direct link, hf CLI and curl.
- Browser
- Download file 11.8 kB
-
https://huggingface.co/datasets/dsfasdfaserwer/Dataset/resolve/main/curation/v3/scripts/cases.py
- Command line
-
hf download hf://datasets/dsfasdfaserwer/Dataset/curation/v3/scripts/cases.py
-
curl -L -o cases.py https://huggingface.co/datasets/dsfasdfaserwer/Dataset/resolve/main/curation/v3/scripts/cases.py
11.8 kB
| """Explicit, non-executing source adapters and independent deterministic oracles. | |
| A source adapter changes only representation / function dispatch, never expected | |
| answers. Original input_output strings and their hashes remain in provenance. | |
| """ | |
| from pathlib import Path | |
| import ast | |
| import itertools | |
| import json | |
| import math | |
| import random | |
| import re | |
| ROOT = Path(__file__).resolve().parents[1] | |
| SELECTED = [5, 6, 7, 14, 25, 26, 30, 50, 51, 59] | |
| SOURCE_SOLUTION_INDEX = {5: 0, 6: 0, 7: 0, 14: 0, 25: 1, 26: 3, 30: 0, 50: 0, 51: 0, 59: 2} | |
| SOURCE_ENTRY = {6: 'Solution.minimum_Number', 7: 'Solution.minTime', | |
| 14: 'Solution.findSubString', 25: 'Solution.maximumProfit', | |
| 30: 'Solution.findPoisonedDuration'} | |
| FINAL_ENTRY = {6: 'smallest_rearrangement', 7: 'minimum_paint_time', | |
| 14: 'smallest_covering_window', 25: 'maximum_profit', | |
| 30: 'total_active_time'} | |
| SEED = 20260801 | |
| def load_row(index): | |
| return json.loads((ROOT / 'candidates' / f'{index:05d}.json').read_text()) | |
| def source_cases(index): | |
| row = load_row(index) | |
| test = json.loads(row['input_output']) | |
| if len(test['inputs']) != len(test['outputs']) or not test['inputs']: | |
| raise ValueError('Empty or mismatched source test arrays') | |
| cases = [] | |
| for j, (raw, expected) in enumerate(zip(test['inputs'], test['outputs'])): | |
| case = {'id': f'source-{j:04d}', 'kind': 'source'} | |
| if index == 6: | |
| args = [ast.literal_eval(raw.split('=', 1)[1].strip())] | |
| answer = str(expected) | |
| elif index == 7: | |
| n = int(re.search(r'\bn\s*=\s*(\d+)', raw)[1]) | |
| k = int(re.search(r'\bk\s*=\s*(\d+)', raw)[1]) | |
| arr = [int(x.strip()) for x in re.search(r'\{([^}]*)\}', raw)[1].split(',')] | |
| if n != len(arr): raise ValueError('Bad source n') | |
| args, answer = [arr, n, k], int(expected) | |
| elif index == 14: | |
| args, answer = [ast.literal_eval(raw)], int(expected) | |
| elif index == 25: | |
| n = int(re.search(r'\bn\s*=\s*(\d+)', raw)[1]) | |
| prices = ast.literal_eval(re.search(r'prices\s*=\s*(\[[^\]]*\])', raw)[1]) | |
| if n != len(prices): raise ValueError('Bad source n') | |
| args, answer = [prices, n], int(expected) | |
| elif index == 30: | |
| args, answer = raw, int(expected) | |
| else: | |
| if not isinstance(raw, str) or not isinstance(expected, str): | |
| raise ValueError('Unrecognized stdin representation') | |
| case.update(mode='stdin', input=raw, expected=expected) | |
| cases.append(case) | |
| continue | |
| case.update(mode='call', args=args, expected=answer) | |
| cases.append(case) | |
| return cases | |
| def final_source_cases(index): | |
| cases = source_cases(index) | |
| for case in cases: | |
| if index == 7: | |
| arr, n, k = case['args']; case['args'] = [arr, k] | |
| elif index == 25: | |
| prices, n = case['args']; case['args'] = [prices] | |
| return cases | |
| def extra_cases(index): | |
| rng = random.Random(SEED + index) | |
| cases = [] | |
| def call(args, expected, note='independent small-case oracle'): | |
| cases.append({'id': f'extra-{len(cases):04d}', 'kind': 'supplemental', | |
| 'mode': 'call', 'args': args, 'expected': expected, 'note': note}) | |
| def stdin(text, expected, note='independent small-case oracle'): | |
| cases.append({'id': f'extra-{len(cases):04d}', 'kind': 'supplemental', | |
| 'mode': 'stdin', 'input': text, 'expected': str(expected), 'note': note}) | |
| if index == 5: | |
| # Independent of multiplicative generation: repeatedly divide each integer. | |
| def smooth(value): | |
| for prime in (2, 3, 5): | |
| while value % prime == 0: | |
| value //= prime | |
| return value == 1 | |
| prefix = [0] | |
| for value in range(1, 2501): prefix.append(prefix[-1] + smooth(value)) | |
| pairs = [(1,1), (2,2), (7,7), (3,8), (1,2500)] | |
| for _ in range(115): | |
| lo = rng.randint(1, 2500); hi = rng.randint(lo, 2500); pairs.append((lo,hi)) | |
| for start in range(0, len(pairs), 20): | |
| part = pairs[start:start+20] | |
| stdin(''.join(f'{lo} {hi}\n' for lo,hi in part) + '0\n', | |
| ''.join(f'{prefix[hi]-prefix[lo-1]}\n' for lo,hi in part), | |
| 'Trial-division oracle; up to 20 independent range queries per process') | |
| stdin('0\n', '', 'Empty query stream: terminator only') | |
| elif index == 6: | |
| strings = ['0', '0000', '1', '10', '1000', '111', '90900', '846903', '55010'] | |
| strings += [''.join(rng.choice('0012349') for _ in range(rng.randint(1,7))) for _ in range(100)] | |
| for s in strings: | |
| candidates = [''.join(p) for p in set(itertools.permutations(s)) if p[0] != '0'] | |
| call([s], min(candidates) if candidates else s, 'Enumerate all unique digit permutations; preserve all-zero strings') | |
| call(['9'*49999+'0'*50000+'1'], '1'+'0'*50000+'9'*49999, '100,000-digit boundary, analytically known result') | |
| elif index == 7: | |
| def brute(arr, k): | |
| n = len(arr); best = sum(arr) | |
| for mask in range(1 << (n-1)): | |
| if mask.bit_count()+1 > k: continue | |
| part, maximum = arr[0], 0 | |
| for j in range(1,n): | |
| if mask & (1 << (j-1)): | |
| maximum=max(maximum,part); part=arr[j] | |
| else: part+=arr[j] | |
| best=min(best,max(maximum,part)) | |
| return best | |
| samples = [([5],1), ([5],10), ([10,20,30,40],2), ([1,100,1],2), ([9,9,9],1)] | |
| samples += [([rng.randint(1,25) for _ in range(rng.randint(1,8))],rng.randint(1,10)) for _ in range(100)] | |
| for arr,k in samples: call([arr,k],brute(arr,k),'Enumerate every contiguous partition using at most k groups') | |
| for k in (1,10,100000): call([[1]*100000,k],(100000+k-1)//k,'100,000 boards, closed-form balanced all-ones boundary') | |
| elif index == 14: | |
| def brute(s): | |
| target=set(s); best=len(s) | |
| for left in range(len(s)): | |
| for right in range(left+1,len(s)+1): | |
| if set(s[left:right])==target: best=min(best,right-left) | |
| return best | |
| values=['a','aaaaa','Aa','AABBBCBBAC','aaab','GEEKSGEEKSFOR','aabcbcdbca'] | |
| values += [''.join(rng.choice('aAbBC') for _ in range(rng.randint(1,13))) for _ in range(110)] | |
| for s in values: call([s],brute(s),'Enumerate all substrings and compare character sets; case-sensitive') | |
| call(['a'*99999+'B'],2,'100,000-character boundary with final required character') | |
| elif index == 25: | |
| def brute(prices): | |
| # Enumerate buy/sell/skip decisions, independent of adjacent-difference formula. | |
| def solve(day, holding): | |
| if day == len(prices): return -10**9 if holding else 0 | |
| best=solve(day+1,holding) | |
| alternative=(prices[day]+solve(day+1,False)) if holding else (-prices[day]+solve(day+1,True)) | |
| return max(best,alternative) | |
| return solve(0,False) | |
| values=[[1],[7,6,5],[1,2,3],[4,4,4],[7,1,5,3,6,4]] | |
| values += [[rng.randint(1,30) for _ in range(rng.randint(1,9))] for _ in range(100)] | |
| for prices in values: call([prices],brute(prices),'Exhaustive trading decisions with at most one held share and no fees') | |
| call([[1,100000]*50000],99999*50000,'100,000-day alternating boundary') | |
| elif index == 26: | |
| def brute(dolls): | |
| best=0 | |
| for mask in range(1,1<<len(dolls)): | |
| chosen=sorted(dolls[j] for j in range(len(dolls)) if mask>>j&1) | |
| if all(a[0]<b[0] and a[1]<b[1] for a,b in zip(chosen,chosen[1:])): | |
| best=max(best,len(chosen)) | |
| return best | |
| samples=[[(1,1),(1,2)],[(1,2),(2,1)],[(1,1),(2,2)],[(1,3),(2,1),(3,2)]] | |
| grid=list(itertools.product(range(1,9),repeat=2)) | |
| samples += [rng.sample(grid,rng.randint(2,8)) for _ in range(90)] | |
| def pack(dolls): | |
| cut=len(dolls)//2 | |
| return str(cut)+'\n'+''.join(f'{h} {r}\n' for h,r in dolls[:cut])+str(len(dolls)-cut)+'\n'+''.join(f'{h} {r}\n' for h,r in dolls[cut:])+'0\n' | |
| for dolls in samples: stdin(pack(dolls),str(brute(dolls))+'\n','Exhaustively enumerate subsets; both height and radius must grow strictly') | |
| stdin(pack([(i,i) for i in range(1,201)]),'200\n','Maximum two 100-doll groups, all nestable') | |
| stdin(pack([(10,i) for i in range(1,201)]),'1\n','Equal heights must never chain') | |
| elif index == 30: | |
| samples=[([],0),([],7),([0],0),([1,4],2),([1,2],2),([1,1,1],4),([0,2,4],2)] | |
| samples += [(sorted(rng.randint(0,35) for _ in range(rng.randint(0,12))),rng.randint(0,10)) for _ in range(100)] | |
| for times,duration in samples: | |
| occupied=set() | |
| for t in times: occupied.update(range(t,t+duration)) | |
| call([times,duration],len(occupied),'Union of individual integer time units, independent of adjacent-gap formula') | |
| call([list(range(10000)),10000000],10009999,'10,000 events and maximum duration; analytically known continuous union') | |
| elif index == 50: | |
| for n in range(2,6): | |
| for k in range(1,7): | |
| answer=sum(math.gcd(*seq) for seq in itertools.product(range(1,k+1),repeat=n))%1000000007 | |
| stdin(f'{n} {k}\n',str(answer)+'\n','Enumerate all K^N sequences and evaluate math.gcd directly') | |
| stdin('100000 1\n','1\n','Maximum N, K=1 boundary') | |
| stdin('100000 2\n',str((pow(2,100000,1000000007)+1)%1000000007)+'\n','K=2: all tuples have gcd 1 except the all-2 tuple') | |
| elif index == 51: | |
| for _ in range(100): | |
| n=rng.randint(1,6); k=rng.randint(1,50) | |
| a=[rng.randint(0,40) for _ in range(n)]; b=[rng.randint(0,40) for _ in range(n)] | |
| exists=any(all(x+y>=k for x,y in zip(a,p)) for p in itertools.permutations(b)) | |
| stdin(f'1\n{n} {k}\n'+ ' '.join(map(str,a))+'\n'+' '.join(map(str,b))+'\n', | |
| 'YES\n' if exists else 'NO\n','Enumerate all pairings by permuting B; keep A fixed without loss of generality') | |
| stdin('1\n1000 1000000000\n'+' '.join(['0']*1000)+'\n'+' '.join(['1000000000']*1000)+'\n','YES\n','Maximum n and threshold, equality boundary') | |
| elif index == 59: | |
| def naive(n): | |
| arr=[0]*n | |
| for value in range(1,n+1): | |
| longest=0; chosen=None; left=0 | |
| while left<n: | |
| if arr[left]: left+=1; continue | |
| right=left | |
| while right<n and arr[right]==0: right+=1 | |
| if right-left>longest: longest=right-left; chosen=(left,right) | |
| left=right | |
| left,right=chosen; arr[(left+right-1)//2]=value | |
| return arr | |
| # Every n up to 80, grouped in one valid stdin stream. | |
| stdin('80\n'+''.join(f'{n}\n' for n in range(1,81)), | |
| ''.join(' '.join(map(str,naive(n)))+'\n' for n in range(1,81)), | |
| 'Directly rescan all zero runs after every placement for each n=1..80') | |
| n=200000; intervals=[]; todo=[(0,n-1)] | |
| while todo: | |
| left,right=todo.pop(); mid=(left+right)//2 | |
| intervals.append((-(right-left+1),left,mid)) | |
| if left<mid: todo.append((left,mid-1)) | |
| if mid<right: todo.append((mid+1,right)) | |
| ans=[0]*n | |
| for value,(_,left,mid) in enumerate(sorted(intervals),1): ans[mid]=value | |
| stdin(f'1\n{n}\n',' '.join(map(str,ans))+'\n','Maximum n; independent offline interval-tree ordering rather than online heap') | |
| else: | |
| raise ValueError(index) | |
| return cases | |