Skip to content

Instantly share code, notes, and snippets.

@eruo005-dev

eruo005-dev/qwen-2.5-coder-7b-instruct-Q4_K_M-humaneval.tmp.log

Created May 28, 2026 20:46
Show Gist options

  • Select an option

    Learn more about clone URLs
  • Save eruo005-dev/d933320d45624cb9d70cfc353bd003d5 to your computer and use it in GitHub Desktop.

Select an option

Learn more about clone URLs
Save eruo005-dev/d933320d45624cb9d70cfc353bd003d5 to your computer and use it in GitHub Desktop.
Download ZIP
runlocalai_evalplus_qwen-2.5-coder-7b-instruct-Q4_K_M-humaneval
Raw
qwen-2.5-coder-7b-instruct-Q4_K_M-humaneval.tmp.log
=== runlocalai HumanEval+ run ===
model: qwen-2.5-coder-7b-instruct (Qwen 2.5 Coder 7B Instruct)
quant: Q4_K_M
runtime: ollama-0.24
hardware: rtx-3080-16gb-mobile
dataset: humaneval
num_ctx: 8192
samples: .humaneval-runs\qwen-2.5-coder-7b-instruct-Q4_K_M-humaneval-1779999855414.jsonl
raw: .humaneval-runs\qwen-2.5-coder-7b-instruct-Q4_K_M-humaneval-1779999855414.raw.jsonl
started: 2026-05-28T20:24:15.412Z
finished: 2026-05-28T20:46:55.006Z
wall: 22.7 min
pass@1: 0.811
score: 81.1/100
reproduce: pnpm tsx scripts/run-humaneval-plus.ts --slug qwen-2.5-coder-7b-instruct --quant Q4_K_M --runtime ollama-0.24 --hardware rtx-3080-16gb-mobile --endpoint http://localhost:11434/v1 --model-name qwen2.5-coder:7b --dataset humaneval --num-ctx 8192 --python python --parallel 4 --notes "First-party HumanEval+ on RTX 3080 Laptop 16GB via Ollama 0.24. Windows-safe scoring via scripts/evalplus_score_windows.py (monkey-patches SIGALRM time_limit + bypasses resource rlimit)."
=== generation stdout follows ===
Dataset: humaneval | tasks: 164 | resume: 0 done
Samples: .humaneval-runs\qwen-2.5-coder-7b-instruct-Q4_K_M-humaneval-1779999855414.jsonl
Raw: .humaneval-runs\qwen-2.5-coder-7b-instruct-Q4_K_M-humaneval-1779999855414.raw.jsonl
[ 1/164] generate HumanEval/0
wrote 543 chars in 6.4s | ETA 17.4 min
[ 2/164] generate HumanEval/1
wrote 913 chars in 6.9s | ETA 18.0 min
[ 3/164] generate HumanEval/2
wrote 360 chars in 4.2s | ETA 15.7 min
[ 4/164] generate HumanEval/3
wrote 588 chars in 4.7s | ETA 14.8 min
[ 5/164] generate HumanEval/4
wrote 582 chars in 5.6s | ETA 14.8 min
[ 6/164] generate HumanEval/5
wrote 541 chars in 4.7s | ETA 14.3 min
[ 7/164] generate HumanEval/6
wrote 772 chars in 6.1s | ETA 14.5 min
[ 8/164] generate HumanEval/7
wrote 400 chars in 4.1s | ETA 13.9 min
[ 9/164] generate HumanEval/8
wrote 585 chars in 7.5s | ETA 14.4 min
[ 10/164] generate HumanEval/9
wrote 493 chars in 4.6s | ETA 14.1 min
[ 11/164] generate HumanEval/10
wrote 813 chars in 6.2s | ETA 14.2 min
[ 12/164] generate HumanEval/11
wrote 550 chars in 5.4s | ETA 14.0 min
[ 13/164] generate HumanEval/12
wrote 482 chars in 4.3s | ETA 13.7 min
[ 14/164] generate HumanEval/13
wrote 269 chars in 4.5s | ETA 13.5 min
[ 15/164] generate HumanEval/14
wrote 313 chars in 3.8s | ETA 13.1 min
[ 16/164] generate HumanEval/15
wrote 266 chars in 3.7s | ETA 12.8 min
[ 17/164] generate HumanEval/16
wrote 295 chars in 4.2s | ETA 12.6 min
[ 18/164] generate HumanEval/17
wrote 985 chars in 7.2s | ETA 12.7 min
[ 19/164] generate HumanEval/18
wrote 480 chars in 5.5s | ETA 12.7 min
[ 20/164] generate HumanEval/19
wrote 726 chars in 7.0s | ETA 12.8 min
[ 21/164] generate HumanEval/20
wrote 782 chars in 6.5s | ETA 12.9 min
[ 22/164] generate HumanEval/21
wrote 491 chars in 5.0s | ETA 12.7 min
[ 23/164] generate HumanEval/22
wrote 331 chars in 4.1s | ETA 12.5 min
[ 24/164] generate HumanEval/23
wrote 153 chars in 3.2s | ETA 12.2 min
[ 25/164] generate HumanEval/24
wrote 260 chars in 4.2s | ETA 12.0 min
[ 26/164] generate HumanEval/25
wrote 740 chars in 6.4s | ETA 12.0 min
[ 27/164] generate HumanEval/26
wrote 477 chars in 4.3s | ETA 11.9 min
[ 28/164] generate HumanEval/27
wrote 100 chars in 3.4s | ETA 11.6 min
[ 29/164] generate HumanEval/28
wrote 285 chars in 3.5s | ETA 11.4 min
[ 30/164] generate HumanEval/29
wrote 388 chars in 4.0s | ETA 11.3 min
[ 31/164] generate HumanEval/30
wrote 262 chars in 4.4s | ETA 11.1 min
[ 32/164] generate HumanEval/31
wrote 562 chars in 7.0s | ETA 11.2 min
[ 33/164] generate HumanEval/32
wrote 1185 chars in 8.6s | ETA 11.3 min
[ 34/164] generate HumanEval/33
wrote 1133 chars in 8.5s | ETA 11.5 min
[ 35/164] generate HumanEval/34
wrote 172 chars in 3.7s | ETA 11.3 min
[ 36/164] generate HumanEval/35
wrote 200 chars in 3.8s | ETA 11.1 min
[ 37/164] generate HumanEval/36
wrote 364 chars in 5.3s | ETA 11.0 min
[ 38/164] generate HumanEval/37
wrote 1041 chars in 7.9s | ETA 11.1 min
[ 39/164] generate HumanEval/38
wrote 460 chars in 4.5s | ETA 11.0 min
[ 40/164] generate HumanEval/39
wrote 557 chars in 6.5s | ETA 10.9 min
[ 41/164] generate HumanEval/40
wrote 707 chars in 7.9s | ETA 11.0 min
[ 42/164] generate HumanEval/41
wrote 828 chars in 5.9s | ETA 10.9 min
[ 43/164] generate HumanEval/42
wrote 239 chars in 5.9s | ETA 10.8 min
[ 44/164] generate HumanEval/43
wrote 148 chars in 5.0s | ETA 10.7 min
[ 45/164] generate HumanEval/44
wrote 413 chars in 5.4s | ETA 10.7 min
[ 46/164] generate HumanEval/45
wrote 158 chars in 3.6s | ETA 10.5 min
[ 47/164] generate HumanEval/46
wrote 230 chars in 4.9s | ETA 10.4 min
[ 48/164] generate HumanEval/47
wrote 342 chars in 5.6s | ETA 10.3 min
[ 49/164] generate HumanEval/48
wrote 271 chars in 3.6s | ETA 10.2 min
[ 50/164] generate HumanEval/49
wrote 252 chars in 5.7s | ETA 10.1 min
[ 51/164] generate HumanEval/50
wrote 209 chars in 3.4s | ETA 9.9 min
[ 52/164] generate HumanEval/51
wrote 116 chars in 4.6s | ETA 9.8 min
[ 53/164] generate HumanEval/52
wrote 263 chars in 4.9s | ETA 9.7 min
[ 54/164] generate HumanEval/53
wrote 151 chars in 3.7s | ETA 9.6 min
[ 55/164] generate HumanEval/54
wrote 216 chars in 5.5s | ETA 9.5 min
[ 56/164] generate HumanEval/55
wrote 309 chars in 5.1s | ETA 9.4 min
[ 57/164] generate HumanEval/56
wrote 270 chars in 4.7s | ETA 9.3 min
[ 58/164] generate HumanEval/57
wrote 298 chars in 4.1s | ETA 9.2 min
[ 59/164] generate HumanEval/58
wrote 434 chars in 6.5s | ETA 9.1 min
[ 60/164] generate HumanEval/59
wrote 741 chars in 6.4s | ETA 9.1 min
[ 61/164] generate HumanEval/60
wrote 266 chars in 5.5s | ETA 9.0 min
[ 62/164] generate HumanEval/61
wrote 270 chars in 4.6s | ETA 8.9 min
[ 63/164] generate HumanEval/62
wrote 333 chars in 4.5s | ETA 8.8 min
[ 64/164] generate HumanEval/63
wrote 206 chars in 4.7s | ETA 8.7 min
[ 65/164] generate HumanEval/64
wrote 847 chars in 6.9s | ETA 8.6 min
[ 66/164] generate HumanEval/65
wrote 493 chars in 5.2s | ETA 8.6 min
[ 67/164] generate HumanEval/66
wrote 65 chars in 4.6s | ETA 8.4 min
[ 68/164] generate HumanEval/67
wrote 401 chars in 5.7s | ETA 8.4 min
[ 69/164] generate HumanEval/68
wrote 434 chars in 4.3s | ETA 8.3 min
[ 70/164] generate HumanEval/69
wrote 573 chars in 5.9s | ETA 8.2 min
[ 71/164] generate HumanEval/70
wrote 637 chars in 6.2s | ETA 8.1 min
[ 72/164] generate HumanEval/71
wrote 792 chars in 7.0s | ETA 8.1 min
[ 73/164] generate HumanEval/72
wrote 360 chars in 5.5s | ETA 8.0 min
[ 74/164] generate HumanEval/73
wrote 675 chars in 7.4s | ETA 7.9 min
[ 75/164] generate HumanEval/74
wrote 419 chars in 6.5s | ETA 7.9 min
[ 76/164] generate HumanEval/75
wrote 417 chars in 4.7s | ETA 7.8 min
[ 77/164] generate HumanEval/76
wrote 547 chars in 6.8s | ETA 7.7 min
[ 78/164] generate HumanEval/77
wrote 233 chars in 4.7s | ETA 7.6 min
[ 79/164] generate HumanEval/78
wrote 542 chars in 6.1s | ETA 7.5 min
[ 80/164] generate HumanEval/79
wrote 733 chars in 7.6s | ETA 7.5 min
[ 81/164] generate HumanEval/80
wrote 573 chars in 6.7s | ETA 7.4 min
[ 82/164] generate HumanEval/81
wrote 909 chars in 7.6s | ETA 7.4 min
[ 83/164] generate HumanEval/82
wrote 471 chars in 5.8s | ETA 7.3 min
[ 84/164] generate HumanEval/83
wrote 529 chars in 5.7s | ETA 7.2 min
[ 85/164] generate HumanEval/84
wrote 662 chars in 5.6s | ETA 7.1 min
[ 86/164] generate HumanEval/85
wrote 237 chars in 3.8s | ETA 7.0 min
[ 87/164] generate HumanEval/86
wrote 814 chars in 6.5s | ETA 6.9 min
[ 88/164] generate HumanEval/87
wrote 412 chars in 6.4s | ETA 6.9 min
[ 89/164] generate HumanEval/88
wrote 196 chars in 5.3s | ETA 6.8 min
[ 90/164] generate HumanEval/89
wrote 816 chars in 6.9s | ETA 6.7 min
[ 91/164] generate HumanEval/90
wrote 221 chars in 4.7s | ETA 6.6 min
[ 92/164] generate HumanEval/91
wrote 665 chars in 6.0s | ETA 6.5 min
[ 93/164] generate HumanEval/92
wrote 294 chars in 5.2s | ETA 6.4 min
[ 94/164] generate HumanEval/93
wrote 904 chars in 7.2s | ETA 6.4 min
[ 95/164] generate HumanEval/94
wrote 547 chars in 9.9s | ETA 6.3 min
[ 96/164] generate HumanEval/95
wrote 453 chars in 4.2s | ETA 6.2 min
[ 97/164] generate HumanEval/96
wrote 483 chars in 7.0s | ETA 6.1 min
[ 98/164] generate HumanEval/97
wrote 540 chars in 6.6s | ETA 6.1 min
[ 99/164] generate HumanEval/98
wrote 603 chars in 5.9s | ETA 6.0 min
[100/164] generate HumanEval/99
wrote 743 chars in 7.0s | ETA 5.9 min
[101/164] generate HumanEval/100
wrote 756 chars in 7.9s | ETA 5.8 min
[102/164] generate HumanEval/101
wrote 501 chars in 4.7s | ETA 5.7 min
[103/164] generate HumanEval/102
wrote 515 chars in 5.9s | ETA 5.6 min
[104/164] generate HumanEval/103
wrote 168 chars in 4.9s | ETA 5.5 min
[105/164] generate HumanEval/104
wrote 519 chars in 6.3s | ETA 5.5 min
[106/164] generate HumanEval/105
wrote 644 chars in 7.3s | ETA 5.4 min
[107/164] generate HumanEval/106
wrote 383 chars in 4.8s | ETA 5.3 min
[108/164] generate HumanEval/107
wrote 330 chars in 4.8s | ETA 5.2 min
[109/164] generate HumanEval/108
wrote 353 chars in 4.9s | ETA 5.1 min
[110/164] generate HumanEval/109
wrote 247 chars in 4.5s | ETA 5.0 min
[111/164] generate HumanEval/110
wrote 1082 chars in 8.9s | ETA 4.9 min
[112/164] generate HumanEval/111
wrote 1029 chars in 9.0s | ETA 4.8 min
[113/164] generate HumanEval/112
wrote 270 chars in 4.8s | ETA 4.7 min
[114/164] generate HumanEval/113
wrote 830 chars in 9.0s | ETA 4.7 min
[115/164] generate HumanEval/114
wrote 464 chars in 6.2s | ETA 4.6 min
[116/164] generate HumanEval/115
wrote 134 chars in 6.2s | ETA 4.5 min
[117/164] generate HumanEval/116
wrote 81 chars in 5.0s | ETA 4.4 min
[118/164] generate HumanEval/117
wrote 1259 chars in 10.3s | ETA 4.3 min
[119/164] generate HumanEval/118
wrote 223 chars in 5.1s | ETA 4.2 min
[120/164] generate HumanEval/119
wrote 432 chars in 5.4s | ETA 4.1 min
[121/164] generate HumanEval/120
wrote 161 chars in 4.9s | ETA 4.0 min
[122/164] generate HumanEval/121
wrote 339 chars in 4.8s | ETA 3.9 min
[123/164] generate HumanEval/122
wrote 479 chars in 6.1s | ETA 3.9 min
[124/164] generate HumanEval/123
wrote 1324 chars in 9.9s | ETA 3.8 min
[125/164] generate HumanEval/124
wrote 1444 chars in 16.2s | ETA 3.7 min
[126/164] generate HumanEval/125
wrote 457 chars in 6.3s | ETA 3.7 min
[127/164] generate HumanEval/126
wrote 710 chars in 11.4s | ETA 3.6 min
[128/164] generate HumanEval/127
wrote 587 chars in 7.7s | ETA 3.5 min
[129/164] generate HumanEval/128
wrote 336 chars in 5.8s | ETA 3.4 min
[130/164] generate HumanEval/129
wrote 558 chars in 8.1s | ETA 3.3 min
[131/164] generate HumanEval/130
wrote 449 chars in 6.2s | ETA 3.2 min
[132/164] generate HumanEval/131
wrote 431 chars in 5.8s | ETA 3.1 min
[133/164] generate HumanEval/132
wrote 381 chars in 5.6s | ETA 3.0 min
[134/164] generate HumanEval/133
wrote 527 chars in 8.3s | ETA 2.9 min
[135/164] generate HumanEval/134
wrote 181 chars in 4.8s | ETA 2.8 min
[136/164] generate HumanEval/135
wrote 467 chars in 6.0s | ETA 2.7 min
[137/164] generate HumanEval/136
wrote 317 chars in 5.5s | ETA 2.6 min
[138/164] generate HumanEval/137
wrote 491 chars in 6.0s | ETA 2.5 min
[139/164] generate HumanEval/138
wrote 549 chars in 6.5s | ETA 2.4 min
[140/164] generate HumanEval/139
wrote 885 chars in 7.8s | ETA 2.3 min
[141/164] generate HumanEval/140
wrote 906 chars in 8.7s | ETA 2.3 min
[142/164] generate HumanEval/141
wrote 1074 chars in 11.9s | ETA 2.2 min
[143/164] generate HumanEval/142
wrote 292 chars in 5.9s | ETA 2.1 min
[144/164] generate HumanEval/143
wrote 971 chars in 9.4s | ETA 2.0 min
[145/164] generate HumanEval/144
wrote 443 chars in 6.3s | ETA 1.9 min
[146/164] generate HumanEval/145
wrote 178 chars in 4.5s | ETA 1.8 min
[147/164] generate HumanEval/146
wrote 297 chars in 5.4s | ETA 1.7 min
[148/164] generate HumanEval/147
wrote 350 chars in 5.1s | ETA 1.6 min
[149/164] generate HumanEval/148
wrote 386 chars in 6.4s | ETA 1.5 min
[150/164] generate HumanEval/149
wrote 307 chars in 4.7s | ETA 1.4 min
[151/164] generate HumanEval/150
wrote 498 chars in 8.2s | ETA 1.3 min
[152/164] generate HumanEval/151
wrote 388 chars in 6.3s | ETA 1.2 min
[153/164] generate HumanEval/152
wrote 461 chars in 6.2s | ETA 1.1 min
[154/164] generate HumanEval/153
wrote 348 chars in 4.0s | ETA 1.0 min
[155/164] generate HumanEval/154
wrote 606 chars in 8.0s | ETA 0.9 min
[156/164] generate HumanEval/155
wrote 835 chars in 7.6s | ETA 0.8 min
[157/164] generate HumanEval/156
wrote 757 chars in 10.2s | ETA 0.7 min
[158/164] generate HumanEval/157
wrote 246 chars in 4.9s | ETA 0.6 min
[159/164] generate HumanEval/158
wrote 963 chars in 8.8s | ETA 0.5 min
[160/164] generate HumanEval/159
wrote 1109 chars in 12.8s | ETA 0.4 min
[161/164] generate HumanEval/160
wrote 610 chars in 7.4s | ETA 0.3 min
[162/164] generate HumanEval/161
wrote 364 chars in 5.3s | ETA 0.2 min
[163/164] generate HumanEval/162
wrote 331 chars in 4.6s | ETA 0.1 min
[164/164] generate HumanEval/163
wrote 510 chars in 6.0s | ETA 0.0 min
Done: .humaneval-runs\qwen-2.5-coder-7b-instruct-Q4_K_M-humaneval-1779999855414.jsonl
=== generation stderr follows ===
=== scorer stdout follows ===
Load from ground-truth from C:\Users\eruo0\AppData\Local\evalplus\evalplus\Cache\916d9bfe7b490c2447245ec91595fa4f.pkl
Reading samples...
humaneval (base tests)
pass@1: 0.841
humaneval+ (base + extra tests)
pass@1: 0.811
=== scorer stderr follows ===
0it [00:00, ?it/s] 112it [00:00, 1119.31it/s] 164it [00:00, 1535.97it/s]
0%| | 0/164 [00:00<?, ?it/s] 1%| | 1/164 [00:09<26:34, 9.78s/it] 3%|3 | 5/164 [00:16<07:42, 2.91s/it] 5%|5 | 9/164 [00:24<06:12, 2.40s/it] 7%|7 | 12/164 [00:25<03:58, 1.57s/it] 8%|7 | 13/164 [00:33<06:24, 2.55s/it] 10%|9 | 16/164 [00:39<05:49, 2.36s/it] 10%|# | 17/164 [00:40<05:13, 2.13s/it] 12%|#2 | 20/164 [00:46<05:00, 2.09s/it] 13%|#2 | 21/164 [00:47<04:30, 1.89s/it] 15%|#4 | 24/164 [00:53<04:35, 1.97s/it] 15%|#5 | 25/164 [00:54<04:07, 1.78s/it] 16%|#6 | 27/164 [00:55<03:13, 1.42s/it] 17%|#7 | 28/164 [01:00<04:38, 2.05s/it] 18%|#7 | 29/164 [01:01<03:58, 1.77s/it] 19%|#8 | 31/164 [01:02<03:00, 1.36s/it] 20%|#9 | 32/164 [01:07<04:41, 2.13s/it] 20%|## | 33/164 [01:08<03:54, 1.79s/it] 21%|##1 | 35/164 [01:09<02:47, 1.30s/it] 22%|##1 | 36/164 [01:14<04:35, 2.15s/it] 23%|##2 | 37/164 [01:14<03:45, 1.78s/it] 23%|##3 | 38/164 [01:15<03:21, 1.60s/it] 24%|##3 | 39/164 [01:16<02:40, 1.28s/it] 24%|##4 | 40/164 [01:21<04:40, 2.26s/it] 25%|##5 | 41/164 [01:21<03:41, 1.80s/it] 26%|##5 | 42/164 [01:22<03:14, 1.59s/it] 26%|##6 | 43/164 [01:23<02:34, 1.28s/it] 27%|##6 | 44/164 [01:28<04:38, 2.32s/it] 27%|##7 | 45/164 [01:28<03:37, 1.83s/it] 28%|##8 | 46/164 [01:30<03:15, 1.65s/it] 29%|##8 | 47/164 [01:30<02:37, 1.35s/it] 29%|##9 | 48/164 [01:36<05:11, 2.68s/it] 30%|##9 | 49/164 [01:37<04:05, 2.13s/it] 30%|### | 50/164 [01:38<03:34, 1.88s/it] 31%|###1 | 51/164 [01:39<02:46, 1.47s/it] 32%|###1 | 52/164 [01:44<04:57, 2.65s/it] 32%|###2 | 53/164 [01:45<03:46, 2.04s/it] 33%|###2 | 54/164 [01:46<03:25, 1.87s/it] 34%|###4 | 56/164 [01:52<04:04, 2.27s/it] 35%|###4 | 57/164 [01:52<03:17, 1.85s/it] 35%|###5 | 58/164 [01:54<03:09, 1.79s/it] 37%|###6 | 60/164 [01:59<03:49, 2.21s/it] 37%|###7 | 61/164 [02:00<03:06, 1.81s/it] 38%|###7 | 62/164 [02:02<03:02, 1.79s/it] 39%|###9 | 64/164 [02:07<03:40, 2.20s/it] 40%|###9 | 65/164 [02:08<02:58, 1.80s/it] 40%|#### | 66/164 [02:10<03:04, 1.88s/it] 41%|####1 | 68/164 [02:16<03:39, 2.28s/it] 42%|####2 | 69/164 [02:16<02:57, 1.87s/it] 43%|####2 | 70/164 [02:18<02:54, 1.86s/it] 44%|####3 | 72/164 [02:24<03:34, 2.33s/it] 45%|####4 | 73/164 [02:24<02:52, 1.90s/it] 45%|####5 | 74/164 [02:26<02:48, 1.88s/it] 46%|####6 | 76/164 [02:33<03:36, 2.47s/it] 47%|####6 | 77/164 [02:33<02:57, 2.04s/it] 48%|####7 | 78/164 [02:36<03:04, 2.15s/it] 49%|####8 | 80/164 [02:41<03:22, 2.40s/it] 49%|####9 | 81/164 [02:42<02:42, 1.96s/it] 50%|##### | 82/164 [02:43<02:32, 1.86s/it] 51%|#####1 | 84/164 [02:50<03:15, 2.45s/it] 52%|#####1 | 85/164 [02:50<02:34, 1.95s/it] 52%|#####2 | 86/164 [02:52<02:22, 1.83s/it] 54%|#####3 | 88/164 [02:57<02:47, 2.20s/it] 54%|#####4 | 89/164 [02:57<02:11, 1.76s/it] 55%|#####4 | 90/164 [02:59<02:05, 1.70s/it] 56%|#####6 | 92/164 [03:05<02:36, 2.18s/it] 57%|#####6 | 93/164 [03:05<02:03, 1.74s/it] 57%|#####7 | 94/164 [03:07<02:03, 1.76s/it] 58%|#####7 | 95/164 [03:13<03:17, 2.86s/it] 59%|#####9 | 97/164 [03:14<02:04, 1.86s/it] 60%|#####9 | 98/164 [03:15<01:50, 1.68s/it] 60%|###### | 99/164 [03:21<02:56, 2.71s/it] 62%|######1 | 101/164 [03:22<02:05, 1.99s/it] 62%|######2 | 102/164 [03:23<01:48, 1.76s/it] 63%|######2 | 103/164 [03:29<02:51, 2.81s/it] 63%|######3 | 104/164 [03:31<02:28, 2.48s/it] 64%|######4 | 105/164 [03:32<01:56, 1.97s/it] 65%|######4 | 106/164 [03:32<01:25, 1.48s/it] 65%|######5 | 107/164 [03:38<02:44, 2.89s/it] 66%|######5 | 108/164 [03:40<02:18, 2.47s/it] 66%|######6 | 109/164 [03:40<01:45, 1.92s/it] 68%|######7 | 111/164 [03:47<02:12, 2.50s/it] 68%|######8 | 112/164 [03:48<01:55, 2.23s/it] 69%|######8 | 113/164 [03:49<01:32, 1.81s/it] 70%|######9 | 114/164 [03:49<01:07, 1.35s/it] 70%|####### | 115/164 [03:56<02:20, 2.88s/it] 71%|####### | 116/164 [03:57<01:57, 2.44s/it] 71%|#######1 | 117/164 [03:58<01:29, 1.91s/it] 73%|#######2 | 119/164 [04:03<01:46, 2.36s/it] 73%|#######3 | 120/164 [04:05<01:32, 2.09s/it] 74%|#######3 | 121/164 [04:05<01:12, 1.69s/it] 75%|#######5 | 123/164 [04:11<01:33, 2.28s/it] 76%|#######5 | 124/164 [04:13<01:22, 2.07s/it] 76%|#######6 | 125/164 [04:14<01:13, 1.88s/it] 77%|#######7 | 127/164 [04:20<01:22, 2.24s/it] 78%|#######8 | 128/164 [04:21<01:13, 2.04s/it] 79%|#######8 | 129/164 [04:21<00:58, 1.66s/it] 79%|#######9 | 130/164 [04:29<01:46, 3.14s/it] 80%|#######9 | 131/164 [04:29<01:21, 2.46s/it] 80%|######## | 132/164 [04:30<01:00, 1.90s/it] 81%|########1 | 133/164 [04:37<01:42, 3.32s/it] 82%|########1 | 134/164 [04:37<01:14, 2.48s/it] 82%|########2 | 135/164 [04:38<00:56, 1.96s/it] 83%|########2 | 136/164 [04:45<01:35, 3.41s/it] 84%|########3 | 137/164 [04:45<01:08, 2.55s/it] 84%|########4 | 138/164 [04:46<00:52, 2.01s/it] 85%|########4 | 139/164 [04:53<01:29, 3.60s/it] 85%|########5 | 140/164 [04:54<01:03, 2.63s/it] 86%|########5 | 141/164 [04:54<00:48, 2.09s/it] 87%|########6 | 142/164 [05:01<01:18, 3.57s/it] 87%|########7 | 143/164 [05:02<00:55, 2.64s/it] 88%|########7 | 144/164 [05:03<00:41, 2.06s/it] 88%|########8 | 145/164 [05:09<01:05, 3.43s/it] 89%|########9 | 146/164 [05:10<00:44, 2.50s/it] 90%|########9 | 147/164 [05:14<00:51, 3.04s/it] 90%|######### | 148/164 [05:17<00:49, 3.09s/it] 91%|######### | 149/164 [05:17<00:33, 2.23s/it] 91%|#########1| 150/164 [05:21<00:37, 2.67s/it] 92%|#########2| 151/164 [05:24<00:36, 2.77s/it] 93%|#########2| 152/164 [05:24<00:23, 1.99s/it] 93%|#########3| 153/164 [05:28<00:27, 2.51s/it] 94%|#########3| 154/164 [05:28<00:18, 1.83s/it] 95%|#########4| 155/164 [05:32<00:22, 2.52s/it] 96%|#########5| 157/164 [05:36<00:14, 2.13s/it] 96%|#########6| 158/164 [05:36<00:09, 1.64s/it] 97%|#########6| 159/164 [05:39<00:10, 2.00s/it] 98%|#########8| 161/164 [05:42<00:05, 1.84s/it] 99%|#########8| 162/164 [05:42<00:02, 1.44s/it] 99%|#########9| 163/164 [05:45<00:01, 1.80s/it] 100%|##########| 164/164 [05:45<00:00, 2.11s/it]
=== sanitized samples jsonl follows ===
{"task_id": "HumanEval/0", "solution": "from typing import List\ndef has_close_elements(numbers: List[float], threshold: float) -> bool:\n \"\"\" Check if in given list of numbers, are any two numbers closer to each other than\n given threshold.\n >>> has_close_elements([1.0, 2.0, 3.0], 0.5)\n False\n >>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0], 0.3)\n True\n \"\"\"\n numbers.sort() # Sort the list to make comparison easier\n for i in range(len(numbers) - 1):\n if abs(numbers[i] - numbers[i + 1]) < threshold:\n return True\n return False"}
{"task_id": "HumanEval/1", "solution": "from typing import List\ndef separate_paren_groups(paren_string: str) -> List[str]:\n \"\"\" Input to this function is a string containing multiple groups of nested parentheses. Your goal is to\n separate those group into separate strings and return the list of those.\n Separate groups are balanced (each open brace is properly closed) and not nested within each other\n Ignore any spaces in the input string.\n >>> separate_paren_groups('( ) (( )) (( )( ))')\n ['()', '(())', '(()())']\n \"\"\"\n result = []\n current_group = []\n depth = 0\n\n for char in paren_string.replace(\" \", \"\"):\n if char == '(':\n depth += 1\n current_group.append(char)\n elif char == ')':\n depth -= 1\n current_group.append(char)\n if depth == 0:\n result.append(''.join(current_group))\n current_group = []\n\n return result"}
{"task_id": "HumanEval/2", "solution": "def truncate_number(number: float) -> float:\n \"\"\" Given a positive floating point number, it can be decomposed into\n and integer part (largest integer smaller than given number) and decimals\n (leftover part always smaller than 1).\n\n Return the decimal part of the number.\n >>> truncate_number(3.5)\n 0.5\n \"\"\"\n return number - int(number)"}
{"task_id": "HumanEval/3", "solution": "from typing import List\ndef below_zero(operations: List[int]) -> bool:\n \"\"\" You're given a list of deposit and withdrawal operations on a bank account that starts with\n zero balance. Your task is to detect if at any point the balance of account fallls below zero, and\n at that point function should return True. Otherwise it should return False.\n >>> below_zero([1, 2, 3])\n False\n >>> below_zero([1, 2, -4, 5])\n True\n \"\"\"\n balance = 0\n for operation in operations:\n balance += operation\n if balance < 0:\n return True\n return False"}
{"task_id": "HumanEval/4", "solution": "from typing import List\ndef mean_absolute_deviation(numbers: List[float]) -> float:\n \"\"\" For a given list of input numbers, calculate Mean Absolute Deviation\n around the mean of this dataset.\n Mean Absolute Deviation is the average absolute difference between each\n element and a centerpoint (mean in this case):\n MAD = average | x - x_mean |\n >>> mean_absolute_deviation([1.0, 2.0, 3.0, 4.0])\n 1.0\n \"\"\"\n if not numbers:\n return 0.0\n\n mean = sum(numbers) / len(numbers)\n mad = sum(abs(x - mean) for x in numbers) / len(numbers)\n return mad"}
{"task_id": "HumanEval/5", "solution": "from typing import *\nfrom collections import *\nfrom typing import List\ndef intersperse(numbers: List[int], delimeter: int) -> List[int]:\n \"\"\" Insert a number 'delimeter' between every two consecutive elements of input list `numbers'\n >>> intersperse([], 4)\n []\n >>> intersperse([1, 2, 3], 4)\n [1, 4, 2, 4, 3]\n \"\"\"\n if not numbers:\n return []\n\n result = []\n for i in range(len(numbers) - 1):\n result.append(numbers[i])\n result.append(delimeter)\n result.append(numbers[-1])\n\n return result"}
{"task_id": "HumanEval/6", "solution": "from typing import List\ndef parse_nested_parens(paren_string: str) -> List[int]:\n \"\"\" Input to this function is a string represented multiple groups for nested parentheses separated by spaces.\n For each of the group, output the deepest level of nesting of parentheses.\n E.g. (()()) has maximum two levels of nesting while ((())) has three.\n\n >>> parse_nested_parens('(()()) ((())) () ((())()())')\n [2, 3, 1, 3]\n \"\"\"\n def max_depth(s: str) -> int:\n depth = max_depth = 0\n for char in s:\n if char == '(':\n depth += 1\n max_depth = max(max_depth, depth)\n elif char == ')':\n depth -= 1\n return max_depth\n\n return [max_depth(group) for group in paren_string.split()]"}
{"task_id": "HumanEval/7", "solution": "from typing import *\nfrom collections import *\ndef filter_by_substring(strings: List[str], substring: str) -> List[str]:\n \"\"\" Filter an input list of strings only for ones that contain given substring\n >>> filter_by_substring([], 'a')\n []\n >>> filter_by_substring(['abc', 'bacd', 'cde', 'array'], 'a')\n ['abc', 'bacd', 'array']\n \"\"\"\n return [s for s in strings if substring in s]"}
{"task_id": "HumanEval/8", "solution": "from typing import *\nfrom collections import *\ndef sum_product(numbers: List[int]) -> Tuple[int, int]:\n \"\"\" For a given list of integers, return a tuple consisting of a sum and a product of all the integers in a list.\n Empty sum should be equal to 0 and empty product should be equal to 1.\n >>> sum_product([])\n (0, 1)\n >>> sum_product([1, 2, 3, 4])\n (10, 24)\n \"\"\"\n if not numbers:\n return (0, 1)\n \n total_sum = sum(numbers)\n total_product = 1\n for number in numbers:\n total_product *= number\n \n return (total_sum, total_product)"}
{"task_id": "HumanEval/9", "solution": "from typing import List\ndef rolling_max(numbers: List[int]) -> List[int]:\n \"\"\" From a given list of integers, generate a list of rolling maximum element found until given moment\n in the sequence.\n >>> rolling_max([1, 2, 3, 2, 3, 4, 2])\n [1, 2, 3, 3, 3, 4, 4]\n \"\"\"\n if not numbers:\n return []\n\n result = []\n current_max = float('-inf')\n for number in numbers:\n current_max = max(current_max, number)\n result.append(current_max)\n\n return result"}
{"task_id": "HumanEval/10", "solution": "def is_palindrome(string: str) -> bool:\n \"\"\" Test if given string is a palindrome \"\"\"\n return string == string[::-1]\ndef make_palindrome(string: str) -> str:\n \"\"\" Find the shortest palindrome that begins with a supplied string.\n Algorithm idea is simple:\n - Find the longest postfix of supplied string that is a palindrome.\n - Append to the end of the string reverse of a string prefix that comes before the palindromic suffix.\n >>> make_palindrome('')\n ''\n >>> make_palindrome('cat')\n 'catac'\n >>> make_palindrome('cata')\n 'catac'\n \"\"\"\n if is_palindrome(string):\n return string\n\n for i in range(len(string), -1, -1):\n if is_palindrome(string[i:]):\n prefix_to_reverse = string[:i]\n break\n\n return string + prefix_to_reverse[::-1]"}
{"task_id": "HumanEval/11", "solution": "from typing import *\nfrom collections import *\ndef string_xor(a: str, b: str) -> str:\n \"\"\" Input are two strings a and b consisting only of 1s and 0s.\n Perform binary XOR on these inputs and return result also as a string.\n >>> string_xor('010', '110')\n '100'\n \"\"\"\n # Ensure both strings are of the same length\n max_len = max(len(a), len(b))\n a = a.zfill(max_len)\n b = b.zfill(max_len)\n\n # Perform XOR operation character by character\n result = ''.join('1' if x != y else '0' for x, y in zip(a, b))\n\n return result"}
{"task_id": "HumanEval/12", "solution": "from typing import List, Optional\ndef longest(strings: List[str]) -> Optional[str]:\n \"\"\" Out of list of strings, return the longest one. Return the first one in case of multiple\n strings of the same length. Return None in case the input list is empty.\n >>> longest([])\n\n >>> longest(['a', 'b', 'c'])\n 'a'\n >>> longest(['a', 'bb', 'ccc'])\n 'ccc'\n \"\"\"\n if not strings:\n return None\n longest_string = max(strings, key=len)\n return longest_string"}
{"task_id": "HumanEval/13", "solution": "def greatest_common_divisor(a: int, b: int) -> int:\n \"\"\" Return a greatest common divisor of two integers a and b\n >>> greatest_common_divisor(3, 5)\n 1\n >>> greatest_common_divisor(25, 15)\n 5\n \"\"\"\n while b != 0:\n a, b = b, a % b\n return a"}
{"task_id": "HumanEval/14", "solution": "from typing import *\nfrom collections import *\nfrom typing import List\ndef all_prefixes(string: str) -> List[str]:\n \"\"\" Return list of all prefixes from shortest to longest of the input string\n >>> all_prefixes('abc')\n ['a', 'ab', 'abc']\n \"\"\"\n return [string[:i] for i in range(1, len(string) + 1)]"}
{"task_id": "HumanEval/15", "solution": "def string_sequence(n: int) -> str:\n \"\"\" Return a string containing space-delimited numbers starting from 0 upto n inclusive.\n >>> string_sequence(0)\n '0'\n >>> string_sequence(5)\n '0 1 2 3 4 5'\n \"\"\"\n return ' '.join(str(i) for i in range(n + 1))"}
{"task_id": "HumanEval/16", "solution": "def count_distinct_characters(string: str) -> int:\n \"\"\" Given a string, find out how many distinct characters (regardless of case) does it consist of\n >>> count_distinct_characters('xyzXYZ')\n 3\n >>> count_distinct_characters('Jerry')\n 4\n \"\"\"\n return len(set(string.lower()))"}
{"task_id": "HumanEval/17", "solution": "from typing import List\ndef parse_music(music_string: str) -> List[int]:\n \"\"\" Input to this function is a string representing musical notes in a special ASCII format.\n Your task is to parse this string and return list of integers corresponding to how many beats does each\n not last.\n\n Here is a legend:\n 'o' - whole note, lasts four beats\n 'o|' - half note, lasts two beats\n '.|' - quater note, lasts one beat\n\n >>> parse_music('o o| .| o| o| .| .| .| .| o o')\n [4, 2, 1, 2, 2, 1, 1, 1, 1, 4, 4]\n \"\"\"\n # Split the input string into individual notes\n notes = music_string.split()\n \n # Initialize an empty list to store the number of beats for each note\n beats = []\n \n # Iterate over each note and determine its duration in beats\n for note in notes:\n if note == 'o':\n beats.append(4)\n elif note == 'o|':\n beats.append(2)\n elif note == '.|':\n beats.append(1)\n \n return beats"}
{"task_id": "HumanEval/18", "solution": "def how_many_times(string: str, substring: str) -> int:\n \"\"\" Find how many times a given substring can be found in the original string. Count overlaping cases.\n >>> how_many_times('', 'a')\n 0\n >>> how_many_times('aaa', 'a')\n 3\n >>> how_many_times('aaaa', 'aa')\n 3\n \"\"\"\n count = 0\n start = 0\n while True:\n start = string.find(substring, start)\n if start == -1: \n break\n count += 1\n start += 1\n return count"}
{"task_id": "HumanEval/19", "solution": "from typing import *\nfrom collections import *\ndef sort_numbers(numbers: str) -> str:\n \"\"\" Input is a space-delimited string of numberals from 'zero' to 'nine'.\n Valid choices are 'zero', 'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight' and 'nine'.\n Return the string with numbers sorted from smallest to largest\n >>> sort_numbers('three one five')\n 'one three five'\n \"\"\"\n num_map = {\n \"zero\": 0,\n \"one\": 1,\n \"two\": 2,\n \"three\": 3,\n \"four\": 4,\n \"five\": 5,\n \"six\": 6,\n \"seven\": 7,\n \"eight\": 8,\n \"nine\": 9\n }\n \n sorted_numbers = sorted(numbers.split(), key=lambda x: num_map[x])\n return ' '.join(sorted_numbers)"}
{"task_id": "HumanEval/20", "solution": "from typing import List, Tuple\ndef find_closest_elements(numbers: List[float]) -> Tuple[float, float]:\n \"\"\" From a supplied list of numbers (of length at least two) select and return two that are the closest to each\n other and return them in order (smaller number, larger number).\n >>> find_closest_elements([1.0, 2.0, 3.0, 4.0, 5.0, 2.2])\n (2.0, 2.2)\n >>> find_closest_elements([1.0, 2.0, 3.0, 4.0, 5.0, 2.0])\n (2.0, 2.0)\n \"\"\"\n numbers.sort()\n closest_pair = (numbers[0], numbers[1])\n min_diff = abs(numbers[1] - numbers[0])\n\n for i in range(1, len(numbers) - 1):\n diff = abs(numbers[i + 1] - numbers[i])\n if diff < min_diff:\n min_diff = diff\n closest_pair = (numbers[i], numbers[i + 1])\n\n return closest_pair"}
{"task_id": "HumanEval/21", "solution": "from typing import List\ndef rescale_to_unit(numbers: List[float]) -> List[float]:\n \"\"\" Given list of numbers (of at least two elements), apply a linear transform to that list,\n such that the smallest number will become 0 and the largest will become 1\n >>> rescale_to_unit([1.0, 2.0, 3.0, 4.0, 5.0])\n [0.0, 0.25, 0.5, 0.75, 1.0]\n \"\"\"\n min_val = min(numbers)\n max_val = max(numbers)\n range_val = max_val - min_val\n return [(x - min_val) / range_val for x in numbers]"}
{"task_id": "HumanEval/22", "solution": "from typing import List, Any\ndef filter_integers(values: List[Any]) -> List[int]:\n \"\"\" Filter given list of any python values only for integers\n >>> filter_integers(['a', 3.14, 5])\n [5]\n >>> filter_integers([1, 2, 3, 'abc', {}, []])\n [1, 2, 3]\n \"\"\"\n return [value for value in values if isinstance(value, int)]"}
{"task_id": "HumanEval/23", "solution": "def strlen(string: str) -> int:\n \"\"\" Return length of given string\n >>> strlen('')\n 0\n >>> strlen('abc')\n 3\n \"\"\"\n return len(string)"}
{"task_id": "HumanEval/24", "solution": "def largest_divisor(n: int) -> int:\n \"\"\" For a given number n, find the largest number that divides n evenly, smaller than n\n >>> largest_divisor(15)\n 5\n \"\"\"\n for i in range(n - 1, 0, -1):\n if n % i == 0:\n return i\n return 1"}
{"task_id": "HumanEval/25", "solution": "from typing import List\ndef factorize(n: int) -> List[int]:\n \"\"\" Return list of prime factors of given integer in the order from smallest to largest.\n Each of the factors should be listed number of times corresponding to how many times it appeares in factorization.\n Input number should be equal to the product of all factors\n >>> factorize(8)\n [2, 2, 2]\n >>> factorize(25)\n [5, 5]\n >>> factorize(70)\n [2, 5, 7]\n \"\"\"\n factors = []\n # Start with the smallest prime number\n divisor = 2\n while n >= divisor * divisor:\n if n % divisor:\n divisor += 1\n else:\n n //= divisor\n factors.append(divisor)\n if n > 1:\n factors.append(n)\n return factors"}
{"task_id": "HumanEval/26", "solution": "from typing import *\nfrom collections import *\ndef remove_duplicates(numbers: List[int]) -> List[int]:\n \"\"\" From a list of integers, remove all elements that occur more than once.\n Keep order of elements left the same as in the input.\n >>> remove_duplicates([1, 2, 3, 2, 4])\n [1, 3, 4]\n \"\"\"\n seen = set()\n result = []\n for number in numbers:\n if number not in seen:\n seen.add(number)\n result.append(number)\n return result"}
{"task_id": "HumanEval/27", "solution": "def flip_case(s: str) -> str:\n return ''.join(c.lower() if c.isupper() else c.upper() for c in s)"}
{"task_id": "HumanEval/28", "solution": "from typing import *\nfrom collections import *\nfrom typing import List\ndef concatenate(strings: List[str]) -> str:\n \"\"\" Concatenate list of strings into a single string\n >>> concatenate([])\n ''\n >>> concatenate(['a', 'b', 'c'])\n 'abc'\n \"\"\"\n return ''.join(strings)"}
{"task_id": "HumanEval/29", "solution": "from typing import *\nfrom collections import *\ndef filter_by_prefix(strings: List[str], prefix: str) -> List[str]:\n \"\"\" Filter an input list of strings only for ones that start with a given prefix.\n >>> filter_by_prefix([], 'a')\n []\n >>> filter_by_prefix(['abc', 'bcd', 'cde', 'array'], 'a')\n ['abc', 'array']\n \"\"\"\n return [s for s in strings if s.startswith(prefix)]"}
{"task_id": "HumanEval/30", "solution": "def get_positive(l: list):\n \"\"\"Return only positive numbers in the list.\n >>> get_positive([-1, 2, -4, 5, 6])\n [2, 5, 6]\n >>> get_positive([5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10])\n [5, 3, 2, 3, 9, 123, 1]\n \"\"\"\n return [x for x in l if x > 0]"}
{"task_id": "HumanEval/31", "solution": "def is_prime(n):\n \"\"\"Return true if a given number is prime, and false otherwise.\n >>> is_prime(6)\n False\n >>> is_prime(101)\n True\n >>> is_prime(11)\n True\n >>> is_prime(13441)\n True\n >>> is_prime(61)\n True\n >>> is_prime(4)\n False\n >>> is_prime(1)\n False\n \"\"\"\n if n <= 1:\n return False\n if n <= 3:\n return True\n if n % 2 == 0 or n % 3 == 0:\n return False\n i = 5\n while i * i <= n:\n if n % i == 0 or n % (i + 2) == 0:\n return False\n i += 6\n return True"}
{"task_id": "HumanEval/32", "solution": "import math\ndef poly(xs: list, x: float):\n \"\"\"\n Evaluates polynomial with coefficients xs at point x.\n return xs[0] + xs[1] * x + xs[1] * x^2 + .... xs[n] * x^n\n \"\"\"\n return sum([coeff * math.pow(x, i) for i, coeff in enumerate(xs)])\ndef find_zero(xs: list):\n \"\"\" xs are coefficients of a polynomial.\n find_zero find x such that poly(x) = 0.\n find_zero returns only one zero point, even if there are many.\n Moreover, find_zero only takes list xs having even number of coefficients\n and largest non zero coefficient as it guarantees\n a solution.\n >>> round(find_zero([1, 2]), 2) # f(x) = 1 + 2x\n -0.5\n >>> round(find_zero([-6, 11, -6, 1]), 2) # (x - 1) * (x - 2) * (x - 3) = -6 + 11x - 6x^2 + x^3\n 1.0\n \"\"\"\n if len(xs) % 2 != 0 or xs[-1] == 0:\n raise ValueError(\"List must have an even number of coefficients and the largest non-zero coefficient must be non-zero.\")\n \n # Use Newton's method to find a root\n x = 0.0\n while True:\n fx = poly(xs, x)\n fpx = sum([i * coeff * math.pow(x, i-1) for i, coeff in enumerate(xs)][1:])\n if abs(fx) < 1e-6:\n return round(x, 2)\n x -= fx / fpx"}
{"task_id": "HumanEval/33", "solution": "def sort_third(l: list):\n \"\"\"This function takes a list l and returns a list l' such that\n l' is identical to l in the indicies that are not divisible by three, while its values at the indicies that are divisible by three are equal\n to the values of the corresponding indicies of l, but sorted.\n >>> sort_third([1, 2, 3])\n [1, 2, 3]\n >>> sort_third([5, 6, 3, 4, 8, 9, 2])\n [2, 6, 3, 4, 8, 9, 5]\n \"\"\"\n # Extract elements at indices divisible by three\n third_elements = [l[i] for i in range(len(l)) if i % 3 == 0]\n \n # Sort the extracted elements\n sorted_third_elements = sorted(third_elements)\n \n # Create a new list to store the result\n l_prime = []\n \n # Counter for sorted_third_elements\n sort_index = 0\n \n # Iterate through the original list and construct the new list\n for i in range(len(l)):\n if i % 3 == 0:\n # Replace element with sorted value\n l_prime.append(sorted_third_elements[sort_index])\n sort_index += 1\n else:\n # Keep the original element\n l_prime.append(l[i])\n \n return l_prime"}
{"task_id": "HumanEval/34", "solution": "def unique(l: list):\n \"\"\"Return sorted unique elements in a list\n >>> unique([5, 3, 5, 2, 3, 3, 9, 0, 123])\n [0, 2, 3, 5, 9, 123]\n \"\"\"\n return sorted(set(l))"}
{"task_id": "HumanEval/35", "solution": "def max_element(l: list):\n \"\"\"Return maximum element in the list.\n >>> max_element([1, 2, 3])\n 3\n >>> max_element([5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10])\n 123\n \"\"\"\n return max(l)"}
{"task_id": "HumanEval/36", "solution": "def fizz_buzz(n: int) -> int:\n \"\"\"Return the number of times the digit 7 appears in integers less than n which are divisible by 11 or 13.\n >>> fizz_buzz(50)\n 0\n >>> fizz_buzz(78)\n 2\n >>> fizz_buzz(79)\n 3\n \"\"\"\n count = 0\n for i in range(n):\n if i % 11 == 0 or i % 13 == 0:\n count += str(i).count('7')\n return count"}
{"task_id": "HumanEval/37", "solution": "def sort_even(l: list):\n \"\"\"This function takes a list l and returns a list l' such that\n l' is identical to l in the odd indicies, while its values at the even indicies are equal\n to the values of the even indicies of l, but sorted.\n >>> sort_even([1, 2, 3])\n [1, 2, 3]\n >>> sort_even([5, 6, 3, 4])\n [3, 6, 5, 4]\n \"\"\"\n # Extract the elements at even indices\n even_elements = [l[i] for i in range(len(l)) if i % 2 == 0]\n \n # Sort the extracted elements\n even_elements.sort()\n \n # Create a new list to store the result\n l_prime = []\n \n # Counter for the sorted even elements\n even_index = 0\n \n # Iterate through the original list and construct the new list\n for i in range(len(l)):\n if i % 2 == 0:\n # Append the next sorted even element\n l_prime.append(even_elements[even_index])\n even_index += 1\n else:\n # Append the element from the original list at odd index\n l_prime.append(l[i])\n \n return l_prime"}
{"task_id": "HumanEval/38", "solution": "def decode_cyclic(s: str):\n \"\"\"\n takes as input string encoded with encode_cyclic function. Returns decoded string.\n \"\"\"\n # split string to groups. Each of length 3.\n groups = [s[(3 * i):min((3 * i + 3), len(s))] for i in range((len(s) + 2) // 3)]\n # cycle elements in each group back. Unless group has fewer elements than 3.\n groups = [(group[-1] + group[:-1]) if len(group) == 3 else group for group in groups]\n return \"\".join(groups)"}
{"task_id": "HumanEval/39", "solution": "from sympy import isprime\ndef prime_fib(n: int):\n \"\"\"\n prime_fib returns n-th number that is a Fibonacci number and it's also prime.\n >>> prime_fib(1)\n 2\n >>> prime_fib(2)\n 3\n >>> prime_fib(3)\n 5\n >>> prime_fib(4)\n 13\n >>> prime_fib(5)\n 89\n \"\"\"\n def fib_generator():\n a, b = 0, 1\n while True:\n yield b\n a, b = b, a + b\n\n count = 0\n for fib_num in fib_generator():\n if isprime(fib_num):\n count += 1\n if count == n:\n return fib_num"}
{"task_id": "HumanEval/40", "solution": "def triples_sum_to_zero(l: list):\n \"\"\"\n triples_sum_to_zero takes a list of integers as an input.\n it returns True if there are three distinct elements in the list that\n sum to zero, and False otherwise.\n\n >>> triples_sum_to_zero([1, 3, 5, 0])\n False\n >>> triples_sum_to_zero([1, 3, -2, 1])\n True\n >>> triples_sum_to_zero([1, 2, 3, 7])\n False\n >>> triples_sum_to_zero([2, 4, -5, 3, 9, 7])\n True\n >>> triples_sum_to_zero([1])\n False\n \"\"\"\n n = len(l)\n for i in range(n):\n seen = set()\n target = -l[i]\n for j in range(i + 1, n):\n if target - l[j] in seen:\n return True\n seen.add(l[j])\n return False"}
{"task_id": "HumanEval/41", "solution": "def car_race_collision(n: int) -> int:\n \"\"\"\n Imagine a road that's a perfectly straight infinitely long line.\n n cars are driving left to right; simultaneously, a different set of n cars\n are driving right to left. The two sets of cars start out being very far from\n each other. All cars move in the same speed. Two cars are said to collide\n when a car that's moving left to right hits a car that's moving right to left.\n However, the cars are infinitely sturdy and strong; as a result, they continue moving\n in their trajectory as if they did not collide.\n\n This function outputs the number of such collisions.\n \"\"\"\n # Since each car going left to right will eventually collide with each car\n # going right to left, the total number of collisions is simply n * n.\n return n * n\nn = 5"}
{"task_id": "HumanEval/42", "solution": "def incr_list(l: list):\n \"\"\"Return list with elements incremented by 1.\n >>> incr_list([1, 2, 3])\n [2, 3, 4]\n >>> incr_list([5, 3, 5, 2, 3, 3, 9, 0, 123])\n [6, 4, 6, 3, 4, 4, 10, 1, 124]\n \"\"\"\n return [x + 1 for x in l]"}
{"task_id": "HumanEval/43", "solution": "def pairs_sum_to_zero(l):\n seen = set()\n for num in l:\n if -num in seen:\n return True\n seen.add(num)\n return False"}
{"task_id": "HumanEval/44", "solution": "def change_base(x: int, base: int) -> str:\n \"\"\"Change numerical base of input number x to base.\n return string representation after the conversion.\n base numbers are less than 10.\n >>> change_base(8, 3)\n '22'\n >>> change_base(8, 2)\n '1000'\n >>> change_base(7, 2)\n '111'\n \"\"\"\n if x < base:\n return str(x)\n else:\n return change_base(x // base, base) + str(x % base)"}
{"task_id": "HumanEval/45", "solution": "def triangle_area(a, h):\n \"\"\"Given length of a side and high return area for a triangle.\n >>> triangle_area(5, 3)\n 7.5\n \"\"\"\n return 0.5 * a * h"}
{"task_id": "HumanEval/46", "solution": "def fib4(n: int) -> int:\n if n < 2:\n return 0\n elif n == 2:\n return 2\n else:\n a, b, c, d = 0, 0, 2, 0\n for _ in range(3, n + 1):\n a, b, c, d = b, c, d, a + b + c + d\n return d"}
{"task_id": "HumanEval/47", "solution": "def median(l: list):\n \"\"\"Return median of elements in the list l.\n >>> median([3, 1, 2, 4, 5])\n 3\n >>> median([-10, 4, 6, 1000, 10, 20])\n 15.0\n \"\"\"\n sorted_l = sorted(l)\n n = len(sorted_l)\n mid = n // 2\n if n % 2 == 1:\n return sorted_l[mid]\n else:\n return (sorted_l[mid - 1] + sorted_l[mid]) / 2"}
{"task_id": "HumanEval/48", "solution": "def is_palindrome(text: str):\n \"\"\"\n Checks if given string is a palindrome\n >>> is_palindrome('')\n True\n >>> is_palindrome('aba')\n True\n >>> is_palindrome('aaaaa')\n True\n >>> is_palindrome('zbcd')\n False\n \"\"\"\n return text == text[::-1]"}
{"task_id": "HumanEval/49", "solution": "def modp(n: int, p: int) -> int:\n \"\"\"Return 2^n modulo p (be aware of numerics).\n >>> modp(3, 5)\n 3\n >>> modp(1101, 101)\n 2\n >>> modp(0, 101)\n 1\n >>> modp(3, 11)\n 8\n >>> modp(100, 101)\n 1\n \"\"\"\n return pow(2, n, p)"}
{"task_id": "HumanEval/50", "solution": "def decode_shift(s: str):\n \"\"\"\n takes as input string encoded with encode_shift function. Returns decoded string.\n \"\"\"\n return \"\".join([chr(((ord(ch) - 5 - ord(\"a\")) % 26) + ord(\"a\")) for ch in s])"}
{"task_id": "HumanEval/51", "solution": "def remove_vowels(text):\n vowels = \"aeiouAEIOU\"\n return ''.join([char for char in text if char not in vowels])"}
{"task_id": "HumanEval/52", "solution": "def below_threshold(l: list, t: int) -> bool:\n \"\"\"Return True if all numbers in the list l are below threshold t.\n >>> below_threshold([1, 2, 4, 10], 100)\n True\n >>> below_threshold([1, 20, 4, 10], 5)\n False\n \"\"\"\n return all(x < t for x in l)"}
{"task_id": "HumanEval/53", "solution": "import doctest\ndef add(x: int, y: int) -> int:\n \"\"\"Add two numbers x and y\n >>> add(2, 3)\n 5\n >>> add(5, 7)\n 12\n \"\"\"\n return x + y"}
{"task_id": "HumanEval/54", "solution": "def same_chars(s0: str, s1: str) -> bool:\n # Create a set of characters from each string\n set_s0 = set(s0)\n set_s1 = set(s1)\n \n # Compare the sets to check if they are equal\n return set_s0 == set_s1"}
{"task_id": "HumanEval/55", "solution": "def fib(n: int) -> int:\n \"\"\"Return n-th Fibonacci number.\n >>> fib(10)\n 55\n >>> fib(1)\n 1\n >>> fib(8)\n 21\n \"\"\"\n if n <= 0:\n return 0\n elif n == 1:\n return 1\n else:\n a, b = 0, 1\n for _ in range(2, n + 1):\n a, b = b, a + b\n return b"}
{"task_id": "HumanEval/56", "solution": "def correct_bracketing(brackets: str) -> bool:\n balance = 0\n for bracket in brackets:\n if bracket == '<':\n balance += 1\n elif bracket == '>':\n balance -= 1\n if balance < 0:\n return False\n return balance == 0"}
{"task_id": "HumanEval/57", "solution": "def monotonic(l: list):\n \"\"\"Return True if list elements are monotonically increasing or decreasing.\n >>> monotonic([1, 2, 4, 20])\n True\n >>> monotonic([1, 20, 4, 10])\n False\n >>> monotonic([4, 1, 0, -10])\n True\n \"\"\"\n return l == sorted(l) or l == sorted(l, reverse=True)"}
{"task_id": "HumanEval/58", "solution": "def common(l1: list, l2: list):\n \"\"\"Return sorted unique common elements for two lists.\n >>> common([1, 4, 3, 34, 653, 2, 5], [5, 7, 1, 5, 9, 653, 121])\n [1, 5, 653]\n >>> common([5, 3, 2, 8], [3, 2])\n [2, 3]\n\n \"\"\"\n # Convert both lists to sets to remove duplicates and find the intersection\n common_elements = set(l1) & set(l2)\n # Return the sorted list of common elements\n return sorted(common_elements)"}
{"task_id": "HumanEval/59", "solution": "def largest_prime_factor(n: int) -> int:\n \"\"\"Return the largest prime factor of n. Assume n > 1 and is not a prime.\n >>> largest_prime_factor(13195)\n 29\n >>> largest_prime_factor(2048)\n 2\n \"\"\"\n # Initialize the largest prime factor to the smallest possible value\n largest_prime = -1\n \n # Divide n by 2 until it becomes odd\n while n % 2 == 0:\n largest_prime = 2\n n //= 2\n \n # Check for odd factors from 3 onwards\n factor = 3\n while factor * factor <= n:\n while n % factor == 0:\n largest_prime = factor\n n //= factor\n factor += 2\n \n # If n is a prime number greater than 2\n if n > 2:\n largest_prime = n\n \n return largest_prime"}
{"task_id": "HumanEval/60", "solution": "def sum_to_n(n: int) -> int:\n \"\"\"sum_to_n is a function that sums numbers from 1 to n.\n >>> sum_to_n(30)\n 465\n >>> sum_to_n(100)\n 5050\n >>> sum_to_n(5)\n 15\n >>> sum_to_n(10)\n 55\n >>> sum_to_n(1)\n 1\n \"\"\"\n return n * (n + 1) // 2"}
{"task_id": "HumanEval/61", "solution": "def correct_bracketing(brackets: str) -> bool:\n balance = 0\n for bracket in brackets:\n if bracket == '(':\n balance += 1\n elif bracket == ')':\n balance -= 1\n if balance < 0:\n return False\n return balance == 0"}
{"task_id": "HumanEval/62", "solution": "def derivative(xs: list):\n \"\"\" xs represent coefficients of a polynomial.\n xs[0] + xs[1] * x + xs[2] * x^2 + ....\n Return derivative of this polynomial in the same form.\n >>> derivative([3, 1, 2, 4, 5])\n [1, 4, 12, 20]\n >>> derivative([1, 2, 3])\n [2, 6]\n \"\"\"\n return [i * xs[i] for i in range(1, len(xs))]"}
{"task_id": "HumanEval/63", "solution": "def fibfib(n: int) -> int:\n if n == 0 or n == 1:\n return 0\n elif n == 2:\n return 1\n \n a, b, c = 0, 0, 1\n for _ in range(3, n + 1):\n a, b, c = b, c, a + b + c\n return c"}
{"task_id": "HumanEval/64", "solution": "def vowels_count(s):\n \"\"\"Write a function vowels_count which takes a string representing\n a word as input and returns the number of vowels in the string.\n Vowels in this case are 'a', 'e', 'i', 'o', 'u'. Here, 'y' is also a\n vowel, but only when it is at the end of the given word.\n\n Example:\n >>> vowels_count(\"abcde\")\n 2\n >>> vowels_count(\"ACEDY\")\n 3\n \"\"\"\n # Define the set of vowels\n vowels = {'a', 'e', 'i', 'o', 'u'}\n \n # Convert the string to lowercase to handle both cases\n s = s.lower()\n \n # Initialize the count of vowels\n count = 0\n \n # Iterate through each character in the string\n for char in s:\n if char in vowels:\n count += 1\n \n # Check if 'y' is at the end and treat it as a vowel\n if s.endswith('y'):\n count += 1\n \n return count"}
{"task_id": "HumanEval/65", "solution": "def circular_shift(x, shift):\n \"\"\"Circular shift the digits of the integer x, shift the digits right by shift\n and return the result as a string.\n If shift > number of digits, return digits reversed.\n >>> circular_shift(12, 1)\n \"21\"\n >>> circular_shift(12, 2)\n \"12\"\n \"\"\"\n x_str = str(x)\n num_digits = len(x_str)\n \n if shift >= num_digits:\n return x_str[::-1]\n else:\n shift = shift % num_digits\n return x_str[-shift:] + x_str[:-shift]"}
{"task_id": "HumanEval/66", "solution": "def digitSum(s):\n return sum(ord(c) for c in s if c.isupper())"}
{"task_id": "HumanEval/67", "solution": "import re\ndef fruit_distribution(s, n):\n # Use regular expressions to find the numbers in the string\n numbers = re.findall(r'\\d+', s)\n # Convert the found numbers to integers and sum them up\n total_apples_and_oranges = sum(map(int, numbers))\n # Subtract the total number of apples and oranges from the total number of fruits\n mangoes = n - total_apples_and_oranges\n return mangoes"}
{"task_id": "HumanEval/68", "solution": "def pluck(arr):\n if not arr: # Check if the array is empty\n return []\n \n smallest_even = float('inf')\n index_of_smallest_even = -1\n \n for i, value in enumerate(arr):\n if value % 2 == 0 and value < smallest_even:\n smallest_even = value\n index_of_smallest_even = i\n \n if smallest_even == float('inf'):\n return []\n \n return [smallest_even, index_of_smallest_even]"}
{"task_id": "HumanEval/69", "solution": "from collections import Counter\ndef search(lst):\n # Count the frequency of each number in the list\n freq = Counter(lst)\n \n # Initialize the result to -1, assuming no such number exists\n result = -1\n \n # Iterate through the items in the frequency dictionary\n for num, count in freq.items():\n # Check if the number's frequency is greater than or equal to the number itself\n if count >= num:\n # Update the result with the maximum of the current result and the number\n result = max(result, num)\n \n return result"}
{"task_id": "HumanEval/70", "solution": "def strange_sort_list(lst):\n # Sort the list to easily pick min and max\n sorted_lst = sorted(lst)\n result = []\n # Use two pointers to pick elements from the start (min) and end (max) of the sorted list\n left, right = 0, len(sorted_lst) - 1\n while left <= right:\n if left == right:\n # If there's only one element left, append it to the result\n result.append(sorted_lst[left])\n else:\n # Append the minimum and then the maximum from the remaining elements\n result.extend([sorted_lst[left], sorted_lst[right]])\n left += 1\n right -= 1\n return result"}
{"task_id": "HumanEval/71", "solution": "import math\ndef triangle_area(a, b, c):\n '''\n Given the lengths of the three sides of a triangle. Return the area of\n the triangle rounded to 2 decimal points if the three sides form a valid triangle. \n Otherwise return -1\n Three sides make a valid triangle when the sum of any two sides is greater \n than the third side.\n Example:\n triangle_area(3, 4, 5) == 6.00\n triangle_area(1, 2, 10) == -1\n '''\n # Check if the sides form a valid triangle\n if a + b <= c or a + c <= b or b + c <= a:\n return -1\n \n # Calculate the semi-perimeter\n s = (a + b + c) / 2\n \n # Calculate the area using Heron's formula\n area = math.sqrt(s * (s - a) * (s - b) * (s - c))\n \n # Return the area rounded to 2 decimal points\n return round(area, 2)"}
{"task_id": "HumanEval/72", "solution": "def will_it_fly(q, w):\n # Check if the list q is a palindrome\n if q != q[::-1]:\n return False\n \n # Calculate the sum of the elements in the list q\n total_weight = sum(q)\n \n # Check if the total weight is less than or equal to the maximum possible weight w\n if total_weight <= w:\n return True\n else:\n return False"}
{"task_id": "HumanEval/73", "solution": "def smallest_change(arr):\n \"\"\"\n Given an array arr of integers, find the minimum number of elements that\n need to be changed to make the array palindromic. A palindromic array is an array that\n is read the same backwards and forwards. In one change, you can change one element to any other element.\n\n For example:\n smallest_change([1,2,3,5,4,7,9,6]) == 4\n smallest_change([1, 2, 3, 4, 3, 2, 2]) == 1\n smallest_change([1, 2, 3, 2, 1]) == 0\n \"\"\"\n left = 0\n right = len(arr) - 1\n changes = 0\n \n while left < right:\n if arr[left] != arr[right]:\n changes += 1\n left += 1\n right -= 1\n \n return changes"}
{"task_id": "HumanEval/74", "solution": "def total_match(lst1, lst2):\n # Calculate the total number of characters in all strings of each list\n total_chars_lst1 = sum(len(s) for s in lst1)\n total_chars_lst2 = sum(len(s) for s in lst2)\n\n # Compare the totals and return the appropriate list\n if total_chars_lst1 < total_chars_lst2:\n return lst1\n elif total_chars_lst2 < total_chars_lst1:\n return lst2\n else:\n return lst1"}
{"task_id": "HumanEval/75", "solution": "def is_multiply_prime(a):\n def is_prime(n):\n if n <= 1:\n return False\n for i in range(2, int(n**0.5) + 1):\n if n % i == 0:\n return False\n return True\n\n prime_factors = 0\n for i in range(2, a + 1):\n if a % i == 0 and is_prime(i):\n prime_factors += 1\n while a % i == 0:\n a //= i\n return prime_factors == 3"}
{"task_id": "HumanEval/76", "solution": "def is_simple_power(x, n):\n \"\"\"Your task is to write a function that returns true if a number x is a simple\n power of n and false in other cases.\n x is a simple power of n if n**int=x\n For example:\n is_simple_power(1, 4) => true\n is_simple_power(2, 2) => true\n is_simple_power(8, 2) => true\n is_simple_power(3, 2) => false\n is_simple_power(3, 1) => false\n is_simple_power(5, 3) => false\n \"\"\"\n if n == 1:\n return x == 1\n power = 0\n while n ** power < x:\n power += 1\n return n ** power == x"}
{"task_id": "HumanEval/77", "solution": "def iscube(a):\n # Calculate the cube root of the absolute value of 'a'\n cube_root = abs(a) ** (1/3)\n \n # Check if the cube root is an integer by comparing it to its rounded value\n return round(cube_root) ** 3 == abs(a)"}
{"task_id": "HumanEval/78", "solution": "def hex_key(num):\n # Define a set of prime hexadecimal digits\n prime_hex_digits = {'2', '3', '5', '7', 'B', 'D'}\n \n # Initialize a counter for prime digits\n prime_count = 0\n \n # Iterate through each character in the input string\n for char in num:\n # Check if the character is a prime hexadecimal digit\n if char in prime_hex_digits:\n # Increment the counter if it is a prime digit\n prime_count += 1\n \n # Return the total count of prime hexadecimal digits\n return prime_count"}
{"task_id": "HumanEval/79", "solution": "def decimal_to_binary(decimal):\n \"\"\"You will be given a number in decimal form and your task is to convert it\n to binary format. The function should return a string, with each character representing a binary\n number. Each character in the string will be '0' or '1'.\n\n There will be an extra couple of characters 'db' at the beginning and at the end of the string.\n The extra characters are there to help with the format.\n\n Examples:\n decimal_to_binary(15) # returns \"db1111db\"\n decimal_to_binary(32) # returns \"db100000db\"\n \"\"\"\n if decimal == 0:\n return \"db0db\"\n binary = \"\"\n while decimal > 0:\n binary = str(decimal % 2) + binary\n decimal //= 2\n return f\"db{binary}db\""}
{"task_id": "HumanEval/80", "solution": "def is_happy(s):\n \"\"\"You are given a string s.\n Your task is to check if the string is happy or not.\n A string is happy if its length is at least 3 and every 3 consecutive letters are distinct\n For example:\n is_happy(a) => False\n is_happy(aa) => False\n is_happy(abcd) => True\n is_happy(aabb) => False\n is_happy(adb) => True\n is_happy(xyy) => False\n \"\"\"\n if len(s) < 3:\n return False\n \n for i in range(len(s) - 2):\n if s[i] == s[i+1] or s[i] == s[i+2] or s[i+1] == s[i+2]:\n return False\n \n return True"}
{"task_id": "HumanEval/81", "solution": "def numerical_letter_grade(grades):\n letter_grades = []\n for gpa in grades:\n if gpa == 4.0:\n letter_grades.append('A+')\n elif gpa > 3.7:\n letter_grades.append('A')\n elif gpa > 3.3:\n letter_grades.append('A-')\n elif gpa > 3.0:\n letter_grades.append('B+')\n elif gpa > 2.7:\n letter_grades.append('B')\n elif gpa > 2.3:\n letter_grades.append('B-')\n elif gpa > 2.0:\n letter_grades.append('C+')\n elif gpa > 1.7:\n letter_grades.append('C')\n elif gpa > 1.3:\n letter_grades.append('C-')\n elif gpa > 1.0:\n letter_grades.append('D+')\n elif gpa > 0.7:\n letter_grades.append('D')\n elif gpa > 0.0:\n letter_grades.append('D-')\n else:\n letter_grades.append('E')\n return letter_grades"}
{"task_id": "HumanEval/82", "solution": "def prime_length(string):\n \"\"\"Write a function that takes a string and returns True if the string\n length is a prime number or False otherwise\n Examples\n prime_length('Hello') == True\n prime_length('abcdcba') == True\n prime_length('kittens') == True\n prime_length('orange') == False\n \"\"\"\n n = len(string)\n if n <= 1:\n return False\n for i in range(2, int(n**0.5) + 1):\n if n % i == 0:\n return False\n return True"}
{"task_id": "HumanEval/83", "solution": "def starts_one_ends(n):\n \"\"\"\n Given a positive integer n, return the count of the numbers of n-digit\n positive integers that start or end with 1.\n \"\"\"\n if n == 1:\n return 1 # Only '1' is the number that starts and ends with 1\n else:\n # For n > 1, calculate the count\n # Numbers starting with 1: 1xxxx... (n-1 digits)\n # Numbers ending with 1 but not starting with 1: xxxx...1 (n-1 digits) - 1 (to avoid double counting '1xxxx...1')\n return 2 * (10 ** (n - 1)) - 10 ** (n - 2)"}
{"task_id": "HumanEval/84", "solution": "def solve(N):\n \"\"\"Given a positive integer N, return the total sum of its digits in binary.\n \n Example\n For N = 1000, the sum of digits will be 1 the output should be \"1\".\n For N = 150, the sum of digits will be 6 the output should be \"110\".\n For N = 147, the sum of digits will be 12 the output should be \"1100\".\n \n Variables:\n @N integer\n Constraints: 0 \u2264 N \u2264 10000.\n Output:\n a string of binary number\n \"\"\"\n # Calculate the sum of digits of N\n digit_sum = sum(int(digit) for digit in str(N))\n \n # Convert the sum to binary and return it as a string\n return bin(digit_sum)[2:]"}
{"task_id": "HumanEval/85", "solution": "def add(lst):\n \"\"\"Given a non-empty list of integers lst. add the even elements that are at odd indices.\n\n Examples:\n add([4, 2, 6, 7]) ==> 2 \n \"\"\"\n return sum(x for i, x in enumerate(lst) if i % 2 == 1 and x % 2 == 0)"}
{"task_id": "HumanEval/86", "solution": "def anti_shuffle(s):\n \"\"\"\n Write a function that takes a string and returns an ordered version of it.\n Ordered version of string, is a string where all words (separated by space)\n are replaced by a new word where all the characters arranged in\n ascending order based on ascii value.\n Note: You should keep the order of words and blank spaces in the sentence.\n\n For example:\n anti_shuffle('Hi') returns 'Hi'\n anti_shuffle('hello') returns 'ehllo'\n anti_shuffle('Hello World!!!') returns 'Hello !!!Wdlor'\n \"\"\"\n # Split the string into words\n words = s.split()\n \n # Process each word to sort its characters\n sorted_words = [''.join(sorted(word)) for word in words]\n \n # Join the sorted words back into a single string with spaces\n return ' '.join(sorted_words)"}
{"task_id": "HumanEval/87", "solution": "def get_row(lst, x):\n result = []\n for i, row in enumerate(lst):\n for j, value in enumerate(row[::-1]): # Reverse the row to sort by columns in descending order later\n if value == x:\n result.append((i, len(row) - 1 - j)) # Adjust column index due to reversal\n return sorted(result, key=lambda item: (item[0], -item[1])) # Sort by rows ascending and columns descending"}
{"task_id": "HumanEval/88", "solution": "def sort_array(array):\n if not array:\n return []\n \n sorted_array = sorted(array)\n if (array[0] + array[-1]) % 2 == 0:\n sorted_array.reverse()\n \n return sorted_array"}
{"task_id": "HumanEval/89", "solution": "def encrypt(s):\n \"\"\"Create a function encrypt that takes a string as an argument and\n returns a string encrypted with the alphabet being rotated. \n The alphabet should be rotated in a manner such that the letters \n shift down by two multiplied to two places.\n For example:\n encrypt('hi') returns 'lm'\n encrypt('asdfghjkl') returns 'ewhjklnop'\n encrypt('gf') returns 'kj'\n encrypt('et') returns 'ix'\n \"\"\"\n result = []\n for char in s:\n if char.isalpha():\n shift = (2 * 2) % 26\n if char.islower():\n result.append(chr((ord(char) - ord('a') + shift) % 26 + ord('a')))\n else:\n result.append(chr((ord(char) - ord('A') + shift) % 26 + ord('A')))\n else:\n result.append(char)\n return ''.join(result)"}
{"task_id": "HumanEval/90", "solution": "def next_smallest(lst):\n if len(lst) < 2:\n return None\n \n unique_elements = list(set(lst))\n if len(unique_elements) < 2:\n return None\n \n unique_elements.sort()\n return unique_elements[1]"}
{"task_id": "HumanEval/91", "solution": "import re\ndef is_bored(S):\n \"\"\"\n You'll be given a string of words, and your task is to count the number\n of boredoms. A boredom is a sentence that starts with the word \"I\".\n Sentences are delimited by '.', '?' or '!'.\n \n For example:\n >>> is_bored(\"Hello world\")\n 0\n >>> is_bored(\"The sky is blue. The sun is shining. I love this weather\")\n 1\n \"\"\"\n # Split the string into sentences using regex to match '.', '?' or '!'\n sentences = re.split(r'[.?!]\\s*', S)\n # Count the number of sentences that start with \"I\"\n boredom_count = sum(sentence.startswith('I') for sentence in sentences if sentence)\n return boredom_count"}
{"task_id": "HumanEval/92", "solution": "def any_int(x, y, z):\n # Check if all numbers are integers\n if not all(isinstance(i, int) for i in [x, y, z]):\n return False\n \n # Check if any number is equal to the sum of the other two\n if x == y + z or y == x + z or z == x + y:\n return True\n \n return False"}
{"task_id": "HumanEval/93", "solution": "def encode(message):\n \"\"\"\n Write a function that takes a message, and encodes in such a \n way that it swaps case of all letters, replaces all vowels in \n the message with the letter that appears 2 places ahead of that \n vowel in the english alphabet. \n Assume only letters. \n \n Examples:\n >>> encode('test')\n 'TGST'\n >>> encode('This is a message')\n 'tHKS KS C MGSSCGG'\n \"\"\"\n vowels = \"aeiou\"\n shifted_vowels = {v: chr((ord(v) - 97 + 2) % 26 + 97) for v in vowels}\n shifted_vowels.update({v.upper(): chr((ord(v.upper()) - 65 + 2) % 26 + 65) for v in vowels})\n \n def swap_case_and_shift(c):\n if c.isalpha():\n if c.lower() in vowels:\n return shifted_vowels[c]\n else:\n return c.swapcase()\n else:\n return c\n \n return ''.join(swap_case_and_shift(char) for char in message)"}
{"task_id": "HumanEval/94", "solution": "def is_prime(n):\n \"\"\"Check if a number is prime.\"\"\"\n if n <= 1:\n return False\n for i in range(2, int(n**0.5) + 1):\n if n % i == 0:\n return False\n return True\ndef skjkasdkd(lst):\n \"\"\"Find the largest prime value and return the sum of its digits.\"\"\"\n max_prime = 0\n for num in lst:\n if is_prime(num) and num > max_prime:\n max_prime = num\n \n # Calculate the sum of digits of the largest prime number\n digit_sum = sum(int(digit) for digit in str(max_prime))\n return digit_sum"}
{"task_id": "HumanEval/95", "solution": "def check_dict_case(dict):\n if not dict:\n return False\n\n lower_case = upper_case = None\n\n for key in dict.keys():\n if not isinstance(key, str):\n return False\n\n if lower_case is None and upper_case is None:\n lower_case = key.islower()\n upper_case = key.isupper()\n elif (lower_case and not key.islower()) or (upper_case and not key.isupper()):\n return False\n\n return True"}
{"task_id": "HumanEval/96", "solution": "def is_prime(num):\n \"\"\"Helper function to check if a number is prime.\"\"\"\n if num <= 1:\n return False\n for i in range(2, int(num**0.5) + 1):\n if num % i == 0:\n return False\n return True\ndef count_up_to(n):\n \"\"\"Function that returns an array of the first n prime numbers less than n.\"\"\"\n primes = []\n num = 2\n while len(primes) < n and num < n:\n if is_prime(num):\n primes.append(num)\n num += 1\n return primes"}
{"task_id": "HumanEval/97", "solution": "def multiply(a, b):\n \"\"\"Complete the function that takes two integers and returns \n the product of their unit digits.\n Assume the input is always valid.\n Examples:\n multiply(148, 412) should return 16.\n multiply(19, 28) should return 72.\n multiply(2020, 1851) should return 0.\n multiply(14,-15) should return 20.\n \"\"\"\n # Extract the unit digits of both numbers\n unit_digit_a = abs(a) % 10\n unit_digit_b = abs(b) % 10\n \n # Return the product of the unit digits\n return unit_digit_a * unit_digit_b"}
{"task_id": "HumanEval/98", "solution": "def count_upper(s):\n \"\"\"\n Given a string s, count the number of uppercase vowels in even indices.\n \n For example:\n count_upper('aBCdEf') returns 1\n count_upper('abcdefg') returns 0\n count_upper('dBBE') returns 0\n \"\"\"\n # Define the set of uppercase vowels\n uppercase_vowels = {'A', 'E', 'I', 'O', 'U'}\n \n # Initialize a counter for uppercase vowels at even indices\n count = 0\n \n # Iterate over the string, considering only even indices\n for i in range(0, len(s), 2):\n if s[i] in uppercase_vowels:\n count += 1\n \n return count"}
{"task_id": "HumanEval/99", "solution": "def closest_integer(value):\n \"\"\"\n Create a function that takes a value (string) representing a number\n and returns the closest integer to it. If the number is equidistant\n from two integers, round it away from zero.\n\n Examples\n >>> closest_integer(\"10\")\n 10\n >>> closest_integer(\"15.3\")\n 15\n\n Note:\n Rounding away from zero means that if the given number is equidistant\n from two integers, the one you should return is the one that is the\n farthest from zero. For example closest_integer(\"14.5\") should\n return 15 and closest_integer(\"-14.5\") should return -15.\n \"\"\"\n num = float(value)\n if abs(num - round(num)) == 0.5:\n return int(num + (num > 0))\n else:\n return round(num)"}
{"task_id": "HumanEval/100", "solution": "def make_a_pile(n):\n \"\"\"\n Given a positive integer n, you have to make a pile of n levels of stones.\n The first level has n stones.\n The number of stones in the next level is:\n - the next odd number if n is odd.\n - the next even number if n is even.\n Return the number of stones in each level in a list, where element at index\n i represents the number of stones in the level (i+1).\n\n Examples:\n >>> make_a_pile(3)\n [3, 5, 7]\n \"\"\"\n pile = []\n current_stones = n\n for _ in range(n):\n pile.append(current_stones)\n if n % 2 == 0: # If n is even\n current_stones += 2 # Next even number\n else: # If n is odd\n current_stones += 2 # Next odd number\n return pile"}
{"task_id": "HumanEval/101", "solution": "def words_string(s):\n \"\"\"\n You will be given a string of words separated by commas or spaces. Your task is\n to split the string into words and return an array of the words.\n \n For example:\n words_string(\"Hi, my name is John\") == [\"Hi\", \"my\", \"name\", \"is\", \"John\"]\n words_string(\"One, two, three, four, five, six\") == [\"One\", \"two\", \"three\", \"four\", \"five\", \"six\"]\n \"\"\"\n # Split the string by either comma or space and return the result\n return s.replace(',', ' ').split()"}
{"task_id": "HumanEval/102", "solution": "def choose_num(x, y):\n \"\"\"This function takes two positive numbers x and y and returns the\n biggest even integer number that is in the range [x, y] inclusive. If \n there's no such number, then the function should return -1.\n\n For example:\n choose_num(12, 15) = 14\n choose_num(13, 12) = -1\n \"\"\"\n if x > y:\n return -1\n # Start from y and go down to x, looking for the first even number\n for num in range(y, x - 1, -1):\n if num % 2 == 0:\n return num\n return -1"}
{"task_id": "HumanEval/103", "solution": "def rounded_avg(n, m):\n if n > m:\n return -1\n total = sum(range(n, m + 1))\n count = m - n + 1\n average = round(total / count)\n return bin(average)"}
{"task_id": "HumanEval/104", "solution": "def unique_digits(x):\n \"\"\"Given a list of positive integers x. return a sorted list of all \n elements that hasn't any even digit.\n\n Note: Returned list should be sorted in increasing order.\n \n For example:\n >>> unique_digits([15, 33, 1422, 1])\n [1, 15, 33]\n >>> unique_digits([152, 323, 1422, 10])\n []\n \"\"\"\n def has_no_even_digit(num):\n return all(int(digit) % 2 != 0 for digit in str(num))\n \n result = [num for num in x if has_no_even_digit(num)]\n return sorted(result)"}
{"task_id": "HumanEval/105", "solution": "def by_length(arr):\n # Define the mapping from digits to their names\n digit_to_name = {\n 1: \"One\", 2: \"Two\", 3: \"Three\", 4: \"Four\",\n 5: \"Five\", 6: \"Six\", 7: \"Seven\", 8: \"Eight\", 9: \"Nine\"\n }\n \n # Filter out numbers that are not between 1 and 9\n filtered_arr = [num for num in arr if 1 <= num <= 9]\n \n # Sort the filtered array\n sorted_arr = sorted(filtered_arr)\n \n # Reverse the sorted array\n reversed_arr = sorted_arr[::-1]\n \n # Replace each digit with its corresponding name\n result = [digit_to_name[num] for num in reversed_arr]\n \n return result\narr = [2, 1, 1, 4, 5, 8, 2, 3]"}
{"task_id": "HumanEval/106", "solution": "def f(n):\n def factorial(x):\n if x == 0 or x == 1:\n return 1\n else:\n return x * factorial(x - 1)\n \n def sum_to_i(i):\n return i * (i + 1) // 2\n \n result = []\n for i in range(1, n + 1):\n if i % 2 == 0:\n result.append(factorial(i))\n else:\n result.append(sum_to_i(i))\n \n return result"}
{"task_id": "HumanEval/107", "solution": "def is_palindrome(num):\n return str(num) == str(num)[::-1]\ndef even_odd_palindrome(n):\n even_count = 0\n odd_count = 0\n\n for i in range(1, n + 1):\n if is_palindrome(i):\n if i % 2 == 0:\n even_count += 1\n else:\n odd_count += 1\n\n return (even_count, odd_count)"}
{"task_id": "HumanEval/108", "solution": "def count_nums(arr):\n def sum_of_digits(n):\n if n >= 0:\n return sum(int(digit) for digit in str(n))\n else:\n digits = [int(d) for d in str(n)[1:]]\n digits[0] *= -1\n return sum(digits)\n\n count = 0\n for num in arr:\n if sum_of_digits(num) > 0:\n count += 1\n return count"}
{"task_id": "HumanEval/109", "solution": "def move_one_ball(arr):\n if not arr:\n return True\n \n n = len(arr)\n sorted_arr = sorted(arr)\n \n for i in range(n):\n if arr == sorted_arr:\n return True\n arr.insert(0, arr.pop())\n \n return False"}
{"task_id": "HumanEval/110", "solution": "def exchange(lst1, lst2):\n \"\"\"In this problem, you will implement a function that takes two lists of numbers,\n and determines whether it is possible to perform an exchange of elements\n between them to make lst1 a list of only even numbers.\n There is no limit on the number of exchanged elements between lst1 and lst2.\n If it is possible to exchange elements between the lst1 and lst2 to make\n all the elements of lst1 to be even, return \"YES\".\n Otherwise, return \"NO\".\n For example:\n exchange([1, 2, 3, 4], [1, 2, 3, 4]) => \"YES\"\n exchange([1, 2, 3, 4], [1, 5, 3, 4]) => \"NO\"\n It is assumed that the input lists will be non-empty.\n \"\"\"\n # Count the number of odd elements in lst1\n odd_count = sum(1 for x in lst1 if x % 2 != 0)\n \n # Count the number of even elements in lst2\n even_count_in_lst2 = sum(1 for x in lst2 if x % 2 == 0)\n \n # If there are enough even elements in lst2 to exchange with all odd elements in lst1, return \"YES\"\n if even_count_in_lst2 >= odd_count:\n return \"YES\"\n else:\n return \"NO\""}
{"task_id": "HumanEval/111", "solution": "from collections import Counter\ndef histogram(test):\n \"\"\"Given a string representing a space separated lowercase letters, return a dictionary\n of the letter with the most repetition and containing the corresponding count.\n If several letters have the same occurrence, return all of them.\n \n Example:\n histogram('a b c') == {'a': 1, 'b': 1, 'c': 1}\n histogram('a b b a') == {'a': 2, 'b': 2}\n histogram('a b c a b') == {'a': 2, 'b': 2}\n histogram('b b b b a') == {'b': 4}\n histogram('') == {}\n\n \"\"\"\n # Split the input string into individual letters\n letters = test.split()\n \n # Count the occurrences of each letter\n letter_counts = Counter(letters)\n \n if not letter_counts:\n return {}\n \n # Find the maximum occurrence count\n max_count = max(letter_counts.values())\n \n # Filter the dictionary to include only letters with the maximum count\n result = {letter: count for letter, count in letter_counts.items() if count == max_count}\n \n return result"}
{"task_id": "HumanEval/112", "solution": "def reverse_delete(s, c):\n # Remove characters from s that are in c\n result = ''.join([char for char in s if char not in c])\n \n # Check if the resulting string is a palindrome\n is_palindrome = result == result[::-1]\n \n return (result, is_palindrome)"}
{"task_id": "HumanEval/113", "solution": "def odd_count(lst):\n \"\"\"Given a list of strings, where each string consists of only digits, return a list.\n Each element i of the output should be \"the number of odd elements in the\n string i of the input.\" where all the i's should be replaced by the number\n of odd digits in the i'th string of the input.\n\n >>> odd_count(['1234567'])\n [\"the number of odd elements 4n the str4ng 4 of the 4nput.\"]\n >>> odd_count(['3',\"11111111\"])\n [\"the number of odd elements 1n the str1ng 1 of the 1nput.\",\n \"the number of odd elements 8n the str8ng 8 of the 8nput.\"]\n \"\"\"\n result = []\n for s in lst:\n count = sum(1 for char in s if int(char) % 2 != 0)\n output = f\"the number of odd elements {count}n the str{count}ng {count} of the {count}nput.\"\n result.append(output)\n return result"}
{"task_id": "HumanEval/114", "solution": "def minSubArraySum(nums):\n \"\"\"\n Given an array of integers nums, find the minimum sum of any non-empty sub-array\n of nums.\n Example\n minSubArraySum([2, 3, 4, 1, 2, 4]) == 1\n minSubArraySum([-1, -2, -3]) == -6\n \"\"\"\n if not nums:\n return 0\n \n min_sum = float('inf')\n current_sum = 0\n \n for num in nums:\n current_sum = min(num, current_sum + num)\n min_sum = min(min_sum, current_sum)\n \n return min_sum"}
{"task_id": "HumanEval/115", "solution": "import math\ndef max_fill(grid, capacity):\n total_water = sum(sum(row) for row in grid)\n return math.ceil(total_water / capacity)"}
{"task_id": "HumanEval/116", "solution": "def sort_array(arr):\n return sorted(arr, key=lambda x: (bin(x).count('1'), x))"}
{"task_id": "HumanEval/117", "solution": "def select_words(s, n):\n \"\"\"Given a string s and a natural number n, you have been tasked to implement \n a function that returns a list of all words from string s that contain exactly \n n consonants, in order these words appear in the string s.\n If the string s is empty then the function should return an empty list.\n Note: you may assume the input string contains only letters and spaces.\n Examples:\n select_words(\"Mary had a little lamb\", 4) ==> [\"little\"]\n select_words(\"Mary had a little lamb\", 3) ==> [\"Mary\", \"lamb\"]\n select_words(\"simple white space\", 2) ==> []\n select_words(\"Hello world\", 4) ==> [\"world\"]\n select_words(\"Uncle sam\", 3) ==> [\"Uncle\"]\n \"\"\"\n # Define vowels for comparison\n vowels = 'aeiouAEIOU'\n # Split the string into words\n words = s.split()\n # Initialize an empty list to store the result\n result = []\n \n # Iterate over each word in the list\n for word in words:\n # Count the number of consonants in the current word\n consonant_count = sum(1 for char in word if char.isalpha() and char not in vowels)\n # If the count matches n, add the word to the result list\n if consonant_count == n:\n result.append(word)\n \n return result"}
{"task_id": "HumanEval/118", "solution": "def get_closest_vowel(word):\n vowels = \"aeiouAEIOU\"\n for i in range(len(word) - 2, 0, -1):\n if word[i] in vowels and word[i-1] not in vowels and word[i+1] not in vowels:\n return word[i]\n return \"\""}
{"task_id": "HumanEval/119", "solution": "def match_parens(lst):\n def is_balanced(s):\n balance = 0\n for char in s:\n if char == '(':\n balance += 1\n else:\n balance -= 1\n if balance < 0:\n return False\n return balance == 0\n\n first_order = lst[0] + lst[1]\n second_order = lst[1] + lst[0]\n return 'Yes' if is_balanced(first_order) or is_balanced(second_order) else 'No'"}
{"task_id": "HumanEval/120", "solution": "def maximum(arr, k):\n # Sort the array in descending order\n arr.sort(reverse=True)\n # Return the first k elements of the sorted array\n return arr[:k]"}
{"task_id": "HumanEval/121", "solution": "def solution(lst):\n \"\"\"Given a non-empty list of integers, return the sum of all of the odd elements that are in even positions.\n \n\n Examples\n solution([5, 8, 7, 1]) ==> 12\n solution([3, 3, 3, 3, 3]) ==> 9\n solution([30, 13, 24, 321]) ==>0\n \"\"\"\n return sum(x for i, x in enumerate(lst) if i % 2 == 1 and x % 2 == 1)"}
{"task_id": "HumanEval/122", "solution": "def add_elements(arr, k):\n \"\"\"\n Given a non-empty array of integers arr and an integer k, return\n the sum of the elements with at most two digits from the first k elements of arr.\n\n Example:\n\n Input: arr = [111,21,3,4000,5,6,7,8,9], k = 4\n Output: 24 # sum of 21 + 3\n\n Constraints:\n 1. 1 <= len(arr) <= 100\n 2. 1 <= k <= len(arr)\n \"\"\"\n return sum(x for x in arr[:k] if -99 <= x <= 99)\narr = [111, 21, 3, 4000, 5, 6, 7, 8, 9]\nk = 4"}
{"task_id": "HumanEval/123", "solution": "def get_odd_collatz(n):\n \"\"\"\n Given a positive integer n, return a sorted list that has the odd numbers in collatz sequence.\n\n The Collatz conjecture is a conjecture in mathematics that concerns a sequence defined\n as follows: start with any positive integer n. Then each term is obtained from the \n previous term as follows: if the previous term is even, the next term is one half of \n the previous term. If the previous term is odd, the next term is 3 times the previous\n term plus 1. The conjecture is that no matter what value of n, the sequence will always reach 1.\n\n Note: \n 1. Collatz(1) is [1].\n 2. returned list sorted in increasing order.\n\n For example:\n get_odd_collatz(5) returns [1, 5] # The collatz sequence for 5 is [5, 16, 8, 4, 2, 1], so the odd numbers are only 1, and 5.\n \"\"\"\n if n <= 0:\n raise ValueError(\"Input must be a positive integer\")\n \n collatz_sequence = []\n while n != 1:\n collatz_sequence.append(n)\n if n % 2 == 0:\n n = n // 2\n else:\n n = 3 * n + 1\n \n # Add the final number 1 to the sequence\n collatz_sequence.append(1)\n \n # Filter out the odd numbers and sort them\n odd_numbers = sorted([num for num in collatz_sequence if num % 2 != 0])\n \n return odd_numbers"}
{"task_id": "HumanEval/124", "solution": "from datetime import datetime\ndef valid_date(date):\n \"\"\"You have to write a function which validates a given date string and\n returns True if the date is valid otherwise False.\n The date is valid if all of the following rules are satisfied:\n 1. The date string is not empty.\n 2. The number of days is not less than 1 or higher than 31 days for months 1,3,5,7,8,10,12. And the number of days is not less than 1 or higher than 30 days for months 4,6,9,11. And, the number of days is not less than 1 or higher than 29 for the month 2.\n 3. The months should not be less than 1 or higher than 12.\n 4. The date should be in the format: mm-dd-yyyy\n\n for example: \n valid_date('03-11-2000') => True\n\n valid_date('15-01-2012') => False\n\n valid_date('04-0-2040') => False\n\n valid_date('06-04-2020') => True\n\n valid_date('06/04/2020') => False\n \"\"\"\n if not date:\n return False\n \n try:\n month, day, year = map(int, date.split('-'))\n except ValueError:\n return False\n \n if month < 1 or month > 12:\n return False\n \n if day < 1:\n return False\n \n if month in [4, 6, 9, 11] and day > 30:\n return False\n elif month == 2 and day > 29:\n return False\n elif month in [1, 3, 5, 7, 8, 10, 12] and day > 31:\n return False\n \n try:\n datetime(year, month, day)\n except ValueError:\n return False\n \n return True"}
{"task_id": "HumanEval/125", "solution": "def split_words(txt):\n # Check for whitespace and split if present\n if ' ' in txt:\n return txt.split()\n # Check for commas and split if present\n elif ',' in txt:\n return txt.split(',')\n else:\n # Count the number of lowercase letters with odd order in the alphabet\n count = 0\n for char in txt:\n if char.islower() and (ord(char) - ord('a')) % 2 == 1:\n count += 1\n return count"}
{"task_id": "HumanEval/126", "solution": "def is_sorted(lst):\n # Check if the list is empty or has one element, which is trivially sorted\n if len(lst) <= 1:\n return True\n \n # Initialize a variable to keep track of the previous number\n prev = lst[0]\n \n # Iterate through the list starting from the second element\n for num in lst[1:]:\n # Check if the current number is less than the previous one (not sorted)\n if num < prev:\n return False\n # Check for more than one duplicate of the same number\n elif num == prev:\n return False\n # Update the previous number to the current one\n prev = num\n \n # If no issues were found, the list is sorted\n return True"}
{"task_id": "HumanEval/127", "solution": "def is_prime(n):\n \"\"\"Helper function to check if a number is prime.\"\"\"\n if n <= 1:\n return False\n for i in range(2, int(n**0.5) + 1):\n if n % i == 0:\n return False\n return True\ndef intersection(interval1, interval2):\n \"\"\"Determine if the length of the intersection of two intervals is a prime number.\"\"\"\n start = max(interval1[0], interval2[0])\n end = min(interval1[1], interval2[1])\n \n if start > end:\n return \"NO\"\n \n length_of_intersection = end - start + 1\n return \"YES\" if is_prime(length_of_intersection) else \"NO\""}
{"task_id": "HumanEval/128", "solution": "def prod_signs(arr):\n if not arr:\n return None\n \n product_of_signs = 1\n sum_of_magnitudes = 0\n \n for num in arr:\n if num == 0:\n return 0\n elif num < 0:\n product_of_signs *= -1\n \n sum_of_magnitudes += abs(num)\n \n return sum_of_magnitudes * product_of_signs"}
{"task_id": "HumanEval/129", "solution": "from typing import List\ndef minPath(grid: List[List[int]], k: int) -> List[int]:\n N = len(grid)\n directions = [(0, 1), (1, 0), (-1, 0), (0, -1)]\n \n def dfs(x, y, path):\n if len(path) == k:\n paths.append(path[:])\n return\n for dx, dy in directions:\n nx, ny = x + dx, y + dy\n if 0 <= nx < N and 0 <= ny < N:\n dfs(nx, ny, path + [grid[nx][ny]])\n \n paths = []\n for i in range(N):\n for j in range(N):\n dfs(i, j, [grid[i][j]])\n \n return min(paths)"}
{"task_id": "HumanEval/130", "solution": "def tri(n):\n if n == 0:\n return [1]\n elif n == 1:\n return [1, 3]\n \n tribonacci = [1, 3, 2] # Starting with the first three numbers of the Tribonacci sequence\n \n for i in range(3, n + 1):\n if i % 2 == 0:\n tribonacci.append(1 + i / 2)\n else:\n next_value = tribonacci[i - 1] + tribonacci[i - 2] + tribonacci[i - 3]\n tribonacci.append(next_value)\n \n return tribonacci"}
{"task_id": "HumanEval/131", "solution": "def digits(n):\n \"\"\"Given a positive integer n, return the product of the odd digits.\n Return 0 if all digits are even.\n For example:\n digits(1) == 1\n digits(4) == 0\n digits(235) == 15\n \"\"\"\n product = 1\n has_odd = False\n for digit in str(n):\n int_digit = int(digit)\n if int_digit % 2 == 1:\n product *= int_digit\n has_odd = True\n return product if has_odd else 0"}
{"task_id": "HumanEval/132", "solution": "def is_nested(string):\n stack = []\n nested = False\n \n for char in string:\n if char == '[':\n stack.append(char)\n elif char == ']' and stack:\n stack.pop()\n # If the stack is not empty after popping, it means there's a nested structure.\n if stack:\n nested = True\n \n return nested and not stack"}
{"task_id": "HumanEval/133", "solution": "import math\ndef sum_squares(lst):\n \"\"\"You are given a list of numbers.\n You need to return the sum of squared numbers in the given list,\n round each element in the list to the upper int(Ceiling) first.\n Examples:\n For lst = [1,2,3] the output should be 14\n For lst = [1,4,9] the output should be 98\n For lst = [1,3,5,7] the output should be 84\n For lst = [1.4,4.2,0] the output should be 29\n For lst = [-2.4,1,1] the output should be 6\n \n\n \"\"\"\n return sum(math.ceil(num) ** 2 for num in lst)"}
{"task_id": "HumanEval/134", "solution": "import re\ndef check_if_last_char_is_a_letter(txt):\n # Check if the last character is an alphabetical letter and not part of a word\n return bool(re.search(r'\\b[a-zA-Z]$', txt))"}
{"task_id": "HumanEval/135", "solution": "def can_arrange(arr):\n \"\"\"Create a function which returns the largest index of an element which\n is not greater than or equal to the element immediately preceding it. If\n no such element exists then return -1. The given array will not contain\n duplicate values.\n\n Examples:\n can_arrange([1,2,4,3,5]) = 3\n can_arrange([1,2,3]) = -1\n \"\"\"\n for i in range(len(arr) - 1, 0, -1):\n if arr[i] < arr[i - 1]:\n return i\n return -1"}
{"task_id": "HumanEval/136", "solution": "def largest_smallest_integers(lst):\n negative_ints = [x for x in lst if x < 0]\n positive_ints = [x for x in lst if x > 0]\n\n largest_negative = max(negative_ints) if negative_ints else None\n smallest_positive = min(positive_ints) if positive_ints else None\n\n return (largest_negative, smallest_positive)"}
{"task_id": "HumanEval/137", "solution": "def compare_one(a, b):\n # Helper function to convert string to float if necessary\n def to_float(val):\n if isinstance(val, str):\n val = val.replace(',', '.')\n return float(val)\n return val\n \n # Convert both values to floats for comparison\n a_float = to_float(a)\n b_float = to_float(b)\n \n # Compare the float values\n if a_float > b_float:\n return a\n elif b_float > a_float:\n return b\n else:\n return None"}
{"task_id": "HumanEval/138", "solution": "def is_equal_to_sum_even(n):\n \"\"\"Evaluate whether the given number n can be written as the sum of exactly 4 positive even numbers\n Example\n is_equal_to_sum_even(4) == False\n is_equal_to_sum_even(6) == False\n is_equal_to_sum_even(8) == True\n \"\"\"\n # Since the smallest sum of 4 positive even numbers is 2+2+2+2=8, any number less than 8 cannot be expressed as such.\n if n < 8:\n return False\n # If n is even and greater than or equal to 8, it can always be expressed as the sum of 4 even numbers.\n return n % 2 == 0"}
{"task_id": "HumanEval/139", "solution": "python\ndef brazilian_factorial(n):\n \"\"\"The Brazilian factorial is defined as:\n brazilian_factorial(n) = n! * (n-1)! * (n-2)! * ... * 1!\n where n > 0\n\n For example:\n >>> special_factorial(4)\n 288\n\n The function will receive an integer as input and should return the special\n factorial of this integer.\n \"\"\"\n result = 1\n for i in range(1, n + 1):\n factorial = 1\n for j in range(1, i + 1):\n factorial *= j\n result *= factorial\n return result\n\n# Check function to verify the correctness of the solution\ndef check_brazilian_factorial():\n assert brazilian_factorial(4) == 288, \"Test case 1 failed\"\n assert brazilian_factorial(5) == 34560, \"Test case 2 failed\"\n assert brazilian_factorial(6) == 24883200, \"Test case 3 failed\"\n print(\"All test cases passed!\")\n\n# Run the check function\ncheck_brazilian_factorial()"}
{"task_id": "HumanEval/140", "solution": "def fix_spaces(text):\n \"\"\"\n Given a string text, replace all spaces in it with underscores, \n and if a string has more than 2 consecutive spaces, \n then replace all consecutive spaces with - \n \n fix_spaces(\"Example\") == \"Example\"\n fix_spaces(\"Example 1\") == \"Example_1\"\n fix_spaces(\" Example 2\") == \"_Example_2\"\n fix_spaces(\" Example 3\") == \"_Example-3\"\n \"\"\"\n result = []\n space_count = 0\n\n for char in text:\n if char == ' ':\n space_count += 1\n else:\n if space_count > 2:\n result.append('-')\n elif space_count > 0:\n result.extend(['_'] * space_count)\n result.append(char)\n space_count = 0\n\n # Handle trailing spaces\n if space_count > 2:\n result.append('-')\n elif space_count > 0:\n result.extend(['_'] * space_count)\n\n return ''.join(result)"}
{"task_id": "HumanEval/141", "solution": "import re\ndef file_name_check(file_name):\n \"\"\"Create a function which takes a string representing a file's name, and returns\n 'Yes' if the the file's name is valid, and returns 'No' otherwise.\n A file's name is considered to be valid if and only if all the following conditions \n are met:\n - There should not be more than three digits ('0'-'9') in the file's name.\n - The file's name contains exactly one dot '.'\n - The substring before the dot should not be empty, and it starts with a letter from \n the latin alphapet ('a'-'z' and 'A'-'Z').\n - The substring after the dot should be one of these: ['txt', 'exe', 'dll']\n Examples:\n file_name_check(\"example.txt\") # => 'Yes'\n file_name_check(\"1example.dll\") # => 'No' (the name should start with a latin alphapet letter)\n \"\"\"\n # Regular expression to match the file name criteria\n pattern = r'^[a-zA-Z][^\\d]*\\d{0,3}[^\\d]*\\.(txt|exe|dll)$'\n \n # Check if the file name matches the pattern\n if re.match(pattern, file_name):\n return 'Yes'\n else:\n return 'No'"}
{"task_id": "HumanEval/142", "solution": "def sum_squares(lst):\n total_sum = 0\n for index, value in enumerate(lst):\n if index % 3 == 0:\n total_sum += value ** 2\n elif index % 4 == 0 and index % 3 != 0:\n total_sum += value ** 3\n else:\n total_sum += value\n return total_sum"}
{"task_id": "HumanEval/143", "solution": "def is_prime(n):\n \"\"\"Check if a number is prime.\"\"\"\n if n <= 1:\n return False\n for i in range(2, int(n**0.5) + 1):\n if n % i == 0:\n return False\n return True\ndef words_in_sentence(sentence):\n \"\"\"\n You are given a string representing a sentence,\n the sentence contains some words separated by a space,\n and you have to return a string that contains the words from the original sentence,\n whose lengths are prime numbers,\n the order of the words in the new string should be the same as the original one.\n\n Example 1:\n Input: sentence = \"This is a test\"\n Output: \"is\"\n\n Example 2:\n Input: sentence = \"lets go for swimming\"\n Output: \"go for\"\n\n Constraints:\n * 1 <= len(sentence) <= 100\n * sentence contains only letters\n \"\"\"\n words = sentence.split()\n prime_length_words = [word for word in words if is_prime(len(word))]\n return ' '.join(prime_length_words)"}
{"task_id": "HumanEval/144", "solution": "def simplify(x, n):\n # Split the fractions into numerator and denominator\n x_num, x_den = map(int, x.split('/'))\n n_num, n_den = map(int, n.split('/'))\n \n # Calculate the product of the numerators and denominators\n product_num = x_num * n_num\n product_den = x_den * n_den\n \n # Check if the product is a whole number by seeing if the numerator is divisible by the denominator\n return product_num % product_den == 0"}
{"task_id": "HumanEval/145", "solution": "def order_by_points(nums):\n def digit_sum(n):\n return sum(int(digit) for digit in str(abs(n)))\n \n return sorted(nums, key=lambda x: (digit_sum(x), nums.index(x)))"}
{"task_id": "HumanEval/146", "solution": "def specialFilter(nums):\n def is_odd_and_greater_than_10(num):\n if num <= 10:\n return False\n str_num = str(abs(num))\n return int(str_num[0]) % 2 == 1 and int(str_num[-1]) % 2 == 1\n\n count = sum(is_odd_and_greater_than_10(num) for num in nums)\n return count"}
{"task_id": "HumanEval/147", "solution": "def get_max_triples(n):\n def calculate_a(i):\n return i * i - i + 1\n\n a = [calculate_a(i) for i in range(1, n + 1)]\n \n count = 0\n for i in range(n):\n for j in range(i + 1, n):\n for k in range(j + 1, n):\n if (a[i] + a[j] + a[k]) % 3 == 0:\n count += 1\n \n return count\nn = 5"}
{"task_id": "HumanEval/148", "solution": "def bf(planet1, planet2):\n planets = [\"Mercury\", \"Venus\", \"Earth\", \"Mars\", \"Jupiter\", \"Saturn\", \"Uranus\", \"Neptune\"]\n if planet1 not in planets or planet2 not in planets:\n return ()\n \n index1, index2 = planets.index(planet1), planets.index(planet2)\n \n if index1 > index2:\n index1, index2 = index2, index1\n \n return tuple(planets[index1 + 1:index2])"}
{"task_id": "HumanEval/149", "solution": "def sorted_list_sum(lst):\n # Filter out strings with odd lengths\n even_length_lst = [word for word in lst if len(word) % 2 == 0]\n \n # Sort the list by length, and then alphabetically for words of the same length\n even_length_lst.sort(key=lambda x: (len(x), x))\n \n return even_length_lst"}
{"task_id": "HumanEval/150", "solution": "def is_prime(num):\n \"\"\"Helper function to check if a number is prime.\"\"\"\n if num <= 1:\n return False\n for i in range(2, int(num**0.5) + 1):\n if num % i == 0:\n return False\n return True\ndef x_or_y(n, x, y):\n \"\"\"A simple program which should return the value of x if n is \n a prime number and should return the value of y otherwise.\n\n Examples:\n for x_or_y(7, 34, 12) == 34\n for x_or_y(15, 8, 5) == 5\n \n \"\"\"\n return x if is_prime(n) else y"}
{"task_id": "HumanEval/151", "solution": "def double_the_difference(lst):\n # Filter out negative numbers and non-integers\n filtered_nums = [num for num in lst if num >= 0 and isinstance(num, int)]\n \n # Filter out even numbers\n odd_nums = [num for num in filtered_nums if num % 2 != 0]\n \n # Calculate the sum of squares of the odd numbers\n result = sum([num ** 2 for num in odd_nums])\n \n return result"}
{"task_id": "HumanEval/152", "solution": "def compare(game, guess):\n # Initialize an empty list to store the differences\n differences = []\n \n # Iterate through each match and its corresponding guess\n for i in range(len(game)):\n # Calculate the absolute difference between the game score and the guess\n diff = abs(game[i] - guess[i])\n # Append the difference to the list\n differences.append(diff)\n \n # Return the list of differences\n return differences"}
{"task_id": "HumanEval/153", "solution": "def Strongest_Extension(class_name, extensions):\n def calculate_strength(extension):\n CAP = sum(1 for char in extension if char.isupper())\n SM = sum(1 for char in extension if char.islower())\n return CAP - SM\n\n strongest_extension = max(extensions, key=calculate_strength)\n return f\"{class_name}.{strongest_extension}\""}
{"task_id": "HumanEval/154", "solution": "def cycpattern_check(a, b):\n \"\"\"You are given 2 words. You need to return True if the second word or any of its rotations is a substring in the first word\n cycpattern_check(\"abcd\",\"abd\") => False\n cycpattern_check(\"hello\",\"ell\") => True\n cycpattern_check(\"whassup\",\"psus\") => False\n cycpattern_check(\"abab\",\"baa\") => True\n cycpattern_check(\"efef\",\"eeff\") => False\n cycpattern_check(\"himenss\",\"simen\") => True\n\n \"\"\"\n if b in a:\n return True\n for i in range(1, len(b)):\n rotated_b = b[i:] + b[:i]\n if rotated_b in a:\n return True\n return False"}
{"task_id": "HumanEval/155", "solution": "def even_odd_count(num):\n \"\"\"Given an integer. return a tuple that has the number of even and odd digits respectively.\n\n Example:\n even_odd_count(-12) ==> (1, 1)\n even_odd_count(123) ==> (1, 2)\n \"\"\"\n # Convert the number to its absolute value and then to a string\n num_str = str(abs(num))\n \n # Initialize counters for even and odd digits\n even_count = 0\n odd_count = 0\n \n # Iterate through each character in the string representation of the number\n for char in num_str:\n digit = int(char)\n \n # Check if the digit is even or odd and update the respective counter\n if digit % 2 == 0:\n even_count += 1\n else:\n odd_count += 1\n \n # Return a tuple containing the counts of even and odd digits\n return (even_count, odd_count)"}
{"task_id": "HumanEval/156", "solution": "def int_to_mini_roman(number):\n \"\"\"\n Given a positive integer, obtain its roman numeral equivalent as a string,\n and return it in lowercase.\n Restrictions: 1 <= num <= 1000\n\n Examples:\n >>> int_to_mini_roman(19) == 'xix'\n >>> int_to_mini_roman(152) == 'clii'\n >>> int_to_mini_roman(426) == 'cdxxvi'\n \"\"\"\n val = [\n 1000, 900, 500, 400,\n 100, 90, 50, 40,\n 10, 9, 5, 4,\n 1\n ]\n syms = [\n \"m\", \"cm\", \"d\", \"cd\",\n \"c\", \"xc\", \"l\", \"xl\",\n \"x\", \"ix\", \"v\", \"iv\",\n \"i\"\n ]\n roman_numeral = ''\n i = 0\n while number > 0:\n for _ in range(number // val[i]):\n roman_numeral += syms[i]\n number -= val[i]\n i += 1\n return roman_numeral"}
{"task_id": "HumanEval/157", "solution": "def right_angle_triangle(a, b, c):\n # Sort the sides to ensure the longest side is last (hypotenuse)\n sides = sorted([a, b, c])\n # Check if the Pythagorean theorem holds for these sides\n return sides[0]**2 + sides[1]**2 == sides[2]**2"}
{"task_id": "HumanEval/158", "solution": "def find_max(words):\n \"\"\"Write a function that accepts a list of strings.\n The list contains different words. Return the word with maximum number\n of unique characters. If multiple strings have maximum number of unique\n characters, return the one which comes first in lexicographical order.\n\n find_max([\"name\", \"of\", \"string\"]) == \"string\"\n find_max([\"name\", \"enam\", \"game\"]) == \"enam\"\n find_max([\"aaaaaaa\", \"bb\" ,\"cc\"]) == \"aaaaaaa\"\n \"\"\"\n if not words:\n return \"\"\n\n # Sort the list lexicographically first to ensure that if there are multiple\n # words with the same number of unique characters, the one that comes first\n # in lexicographical order is returned.\n words.sort()\n\n max_unique_chars = 0\n max_word = \"\"\n for word in words:\n unique_chars = len(set(word))\n if unique_chars > max_unique_chars:\n max_unique_chars = unique_chars\n max_word = word\n\n return max_word"}
{"task_id": "HumanEval/159", "solution": "def eat(number, need, remaining):\n \"\"\"\n You're a hungry rabbit, and you already have eaten a certain number of carrots,\n but now you need to eat more carrots to complete the day's meals.\n you should return an array of [ total number of eaten carrots after your meals,\n the number of carrots left after your meals ]\n if there are not enough remaining carrots, you will eat all remaining carrots, but will still be hungry.\n \n Example:\n * eat(5, 6, 10) -> [11, 4]\n * eat(4, 8, 9) -> [12, 1]\n * eat(1, 10, 10) -> [11, 0]\n * eat(2, 11, 5) -> [7, 0]\n \n Variables:\n @number : integer\n the number of carrots that you have eaten.\n @need : integer\n the number of carrots that you need to eat.\n @remaining : integer\n the number of remaining carrots thet exist in stock\n \n Constrain:\n * 0 <= number <= 1000\n * 0 <= need <= 1000\n * 0 <= remaining <= 1000\n\n Have fun :)\n \"\"\"\n if need <= remaining:\n return [number + need, remaining - need]\n else:\n return [number + remaining, 0]"}
{"task_id": "HumanEval/160", "solution": "def do_algebra(operator, operand):\n # Initialize the result with the first operand\n result = operand[0]\n \n # Iterate through the operators and operands to build and evaluate the expression\n for i in range(len(operator)):\n if operator[i] == '+':\n result += operand[i + 1]\n elif operator[i] == '-':\n result -= operand[i + 1]\n elif operator[i] == '*':\n result *= operand[i + 1]\n elif operator[i] == '//':\n result //= operand[i + 1]\n elif operator[i] == '**':\n result **= operand[i + 1]\n \n return result"}
{"task_id": "HumanEval/161", "solution": "def solve(s):\n # Check if the string contains any letters\n contains_letter = any(char.isalpha() for char in s)\n \n if contains_letter:\n # Reverse the case of each letter\n return ''.join(char.swapcase() if char.isalpha() else char for char in s)\n else:\n # Reverse the entire string if no letters are present\n return s[::-1]"}
{"task_id": "HumanEval/162", "solution": "import hashlib\ndef string_to_md5(text):\n \"\"\"\n Given a string 'text', return its md5 hash equivalent string.\n If 'text' is an empty string, return None.\n\n >>> string_to_md5('Hello world') == '3e25960a79dbc69b674cd4ec67a72c62'\n \"\"\"\n if not text:\n return None\n return hashlib.md5(text.encode()).hexdigest()"}
{"task_id": "HumanEval/163", "solution": "def generate_integers(a, b):\n \"\"\"\n Given two positive integers a and b, return the even digits between a\n and b, in ascending order.\n\n For example:\n generate_integers(2, 8) => [2, 4, 6, 8]\n generate_integers(8, 2) => [2, 4, 6, 8]\n generate_integers(10, 14) => []\n \"\"\"\n # Ensure a is less than b for the range function\n if a > b:\n a, b = b, a\n \n # Generate and return the list of even numbers between a and b\n return [num for num in range(a, b + 1) if num % 2 == 0]"}
=== raw completions jsonl follows ===
{"task_id": "HumanEval/0", "solution": "```\npython\nfrom typing import List\n\n\ndef has_close_elements(numbers: List[float], threshold: float) -> bool:\n \"\"\" Check if in given list of numbers, are any two numbers closer to each other than\n given threshold.\n >>> has_close_elements([1.0, 2.0, 3.0], 0.5)\n False\n >>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0], 0.3)\n True\n \"\"\"\n numbers.sort() # Sort the list to make comparison easier\n for i in range(len(numbers) - 1):\n if abs(numbers[i] - numbers[i + 1]) < threshold:\n return True\n return False\n\n\n# Test cases\nprint(has_close_elements([1.0, 2.0, 3.0], 0.5)) # Expected output: False\nprint(has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0], 0.3)) # Expected output: True\n```"}
{"task_id": "HumanEval/1", "solution": "```\npython\nfrom typing import List\n\n\ndef separate_paren_groups(paren_string: str) -> List[str]:\n \"\"\" Input to this function is a string containing multiple groups of nested parentheses. Your goal is to\n separate those group into separate strings and return the list of those.\n Separate groups are balanced (each open brace is properly closed) and not nested within each other\n Ignore any spaces in the input string.\n >>> separate_paren_groups('( ) (( )) (( )( ))')\n ['()', '(())', '(()())']\n \"\"\"\n result = []\n current_group = []\n depth = 0\n\n for char in paren_string.replace(\" \", \"\"):\n if char == '(':\n depth += 1\n current_group.append(char)\n elif char == ')':\n depth -= 1\n current_group.append(char)\n if depth == 0:\n result.append(''.join(current_group))\n current_group = []\n\n return result\n\n\n# Check function to verify the correctness of the solution\ndef check():\n assert separate_paren_groups('( ) (( )) (( )( ))') == ['()', '(())', '(()())']\n assert separate_paren_groups('()()') == ['()', '()']\n assert separate_paren_groups('((()))(())()') == ['((()))', '(())', '()']\n assert separate_paren_groups('') == []\n print(\"All tests passed!\")\n\n\ncheck()\n```"}
{"task_id": "HumanEval/2", "solution": "```\npython\ndef truncate_number(number: float) -> float:\n \"\"\" Given a positive floating point number, it can be decomposed into\n and integer part (largest integer smaller than given number) and decimals\n (leftover part always smaller than 1).\n\n Return the decimal part of the number.\n >>> truncate_number(3.5)\n 0.5\n \"\"\"\n return number - int(number)\n\n# Test the function\nprint(truncate_number(3.5)) # Expected output: 0.5\n```"}
{"task_id": "HumanEval/3", "solution": "```\npython\nfrom typing import List\n\n\ndef below_zero(operations: List[int]) -> bool:\n \"\"\" You're given a list of deposit and withdrawal operations on a bank account that starts with\n zero balance. Your task is to detect if at any point the balance of account fallls below zero, and\n at that point function should return True. Otherwise it should return False.\n >>> below_zero([1, 2, 3])\n False\n >>> below_zero([1, 2, -4, 5])\n True\n \"\"\"\n balance = 0\n for operation in operations:\n balance += operation\n if balance < 0:\n return True\n return False\n```"}
{"task_id": "HumanEval/4", "solution": "```\npython\nfrom typing import List\n\n\ndef mean_absolute_deviation(numbers: List[float]) -> float:\n \"\"\" For a given list of input numbers, calculate Mean Absolute Deviation\n around the mean of this dataset.\n Mean Absolute Deviation is the average absolute difference between each\n element and a centerpoint (mean in this case):\n MAD = average | x - x_mean |\n >>> mean_absolute_deviation([1.0, 2.0, 3.0, 4.0])\n 1.0\n \"\"\"\n if not numbers:\n return 0.0\n\n mean = sum(numbers) / len(numbers)\n mad = sum(abs(x - mean) for x in numbers) / len(numbers)\n return mad\n\n\n# Test the function with provided data points\nprint(mean_absolute_deviation([1.0, 2.0, 3.0, 4.0])) # Expected output: 1.0\n```"}
{"task_id": "HumanEval/5", "solution": "```\npython\nfrom typing import *\nfrom collections import *\nfrom typing import List\n\n\ndef intersperse(numbers: List[int], delimeter: int) -> List[int]:\n \"\"\" Insert a number 'delimeter' between every two consecutive elements of input list `numbers'\n >>> intersperse([], 4)\n []\n >>> intersperse([1, 2, 3], 4)\n [1, 4, 2, 4, 3]\n \"\"\"\n if not numbers:\n return []\n\n result = []\n for i in range(len(numbers) - 1):\n result.append(numbers[i])\n result.append(delimeter)\n result.append(numbers[-1])\n\n return result\n```"}
{"task_id": "HumanEval/6", "solution": "```\npython\nfrom typing import List\n\n\ndef parse_nested_parens(paren_string: str) -> List[int]:\n \"\"\" Input to this function is a string represented multiple groups for nested parentheses separated by spaces.\n For each of the group, output the deepest level of nesting of parentheses.\n E.g. (()()) has maximum two levels of nesting while ((())) has three.\n\n >>> parse_nested_parens('(()()) ((())) () ((())()())')\n [2, 3, 1, 3]\n \"\"\"\n def max_depth(s: str) -> int:\n depth = max_depth = 0\n for char in s:\n if char == '(':\n depth += 1\n max_depth = max(max_depth, depth)\n elif char == ')':\n depth -= 1\n return max_depth\n\n return [max_depth(group) for group in paren_string.split()]\n\n\n# Test the function with the provided example\nprint(parse_nested_parens('(()()) ((())) () ((())()())')) # Output: [2, 3, 1, 3]\n```"}
{"task_id": "HumanEval/7", "solution": "```\npython\nfrom typing import *\nfrom collections import *\n\ndef filter_by_substring(strings: List[str], substring: str) -> List[str]:\n \"\"\" Filter an input list of strings only for ones that contain given substring\n >>> filter_by_substring([], 'a')\n []\n >>> filter_by_substring(['abc', 'bacd', 'cde', 'array'], 'a')\n ['abc', 'bacd', 'array']\n \"\"\"\n return [s for s in strings if substring in s]\n```"}
{"task_id": "HumanEval/8", "solution": "```\npython\nfrom typing import *\nfrom collections import *\n\ndef sum_product(numbers: List[int]) -> Tuple[int, int]:\n \"\"\" For a given list of integers, return a tuple consisting of a sum and a product of all the integers in a list.\n Empty sum should be equal to 0 and empty product should be equal to 1.\n >>> sum_product([])\n (0, 1)\n >>> sum_product([1, 2, 3, 4])\n (10, 24)\n \"\"\"\n if not numbers:\n return (0, 1)\n \n total_sum = sum(numbers)\n total_product = 1\n for number in numbers:\n total_product *= number\n \n return (total_sum, total_product)\n\n# Check function to verify the correctness of the solution\ndef check_function():\n assert sum_product([]) == (0, 1), \"Test with empty list failed\"\n assert sum_product([1, 2, 3, 4]) == (10, 24), \"Test with [1, 2, 3, 4] failed\"\n assert sum_product([5]) == (5, 5), \"Test with single element [5] failed\"\n assert sum_product([-1, -2, -3, -4]) == (-10, 24), \"Test with negative numbers [-1, -2, -3, -4] failed\"\n print(\"All tests passed!\")\n\n# Run the check function to verify the solution\ncheck_function()\n```"}
{"task_id": "HumanEval/9", "solution": "```\npython\nfrom typing import List\n\n\ndef rolling_max(numbers: List[int]) -> List[int]:\n \"\"\" From a given list of integers, generate a list of rolling maximum element found until given moment\n in the sequence.\n >>> rolling_max([1, 2, 3, 2, 3, 4, 2])\n [1, 2, 3, 3, 3, 4, 4]\n \"\"\"\n if not numbers:\n return []\n\n result = []\n current_max = float('-inf')\n for number in numbers:\n current_max = max(current_max, number)\n result.append(current_max)\n\n return result\n```"}
{"task_id": "HumanEval/10", "solution": "```\npython\ndef is_palindrome(string: str) -> bool:\n \"\"\" Test if given string is a palindrome \"\"\"\n return string == string[::-1]\n\n\ndef make_palindrome(string: str) -> str:\n \"\"\" Find the shortest palindrome that begins with a supplied string.\n Algorithm idea is simple:\n - Find the longest postfix of supplied string that is a palindrome.\n - Append to the end of the string reverse of a string prefix that comes before the palindromic suffix.\n >>> make_palindrome('')\n ''\n >>> make_palindrome('cat')\n 'catac'\n >>> make_palindrome('cata')\n 'catac'\n \"\"\"\n if is_palindrome(string):\n return string\n\n for i in range(len(string), -1, -1):\n if is_palindrome(string[i:]):\n prefix_to_reverse = string[:i]\n break\n\n return string + prefix_to_reverse[::-1]\n\n# Test cases\nprint(make_palindrome('')) # Output: ''\nprint(make_palindrome('cat')) # Output: 'catac'\nprint(make_palindrome('cata')) # Output: 'catac'\n```"}
{"task_id": "HumanEval/11", "solution": "```\npython\nfrom typing import *\nfrom collections import *\n\ndef string_xor(a: str, b: str) -> str:\n \"\"\" Input are two strings a and b consisting only of 1s and 0s.\n Perform binary XOR on these inputs and return result also as a string.\n >>> string_xor('010', '110')\n '100'\n \"\"\"\n # Ensure both strings are of the same length\n max_len = max(len(a), len(b))\n a = a.zfill(max_len)\n b = b.zfill(max_len)\n\n # Perform XOR operation character by character\n result = ''.join('1' if x != y else '0' for x, y in zip(a, b))\n\n return result\n\n# Test the function with provided data point\nprint(string_xor('010', '110')) # Expected output: '100'\n```"}
{"task_id": "HumanEval/12", "solution": "```\npython\nfrom typing import List, Optional\n\n\ndef longest(strings: List[str]) -> Optional[str]:\n \"\"\" Out of list of strings, return the longest one. Return the first one in case of multiple\n strings of the same length. Return None in case the input list is empty.\n >>> longest([])\n\n >>> longest(['a', 'b', 'c'])\n 'a'\n >>> longest(['a', 'bb', 'ccc'])\n 'ccc'\n \"\"\"\n if not strings:\n return None\n longest_string = max(strings, key=len)\n return longest_string\n```"}
{"task_id": "HumanEval/13", "solution": "```\npython\ndef greatest_common_divisor(a: int, b: int) -> int:\n \"\"\" Return a greatest common divisor of two integers a and b\n >>> greatest_common_divisor(3, 5)\n 1\n >>> greatest_common_divisor(25, 15)\n 5\n \"\"\"\n while b != 0:\n a, b = b, a % b\n return a\n\n# Test cases\nprint(greatest_common_divisor(3, 5)) # Output: 1\nprint(greatest_common_divisor(25, 15)) # Output: 5\n```"}
{"task_id": "HumanEval/14", "solution": "```\npython\nfrom typing import *\nfrom collections import *\nfrom typing import List\n\n\ndef all_prefixes(string: str) -> List[str]:\n \"\"\" Return list of all prefixes from shortest to longest of the input string\n >>> all_prefixes('abc')\n ['a', 'ab', 'abc']\n \"\"\"\n return [string[:i] for i in range(1, len(string) + 1)]\n```"}
{"task_id": "HumanEval/15", "solution": "```\npython\ndef string_sequence(n: int) -> str:\n \"\"\" Return a string containing space-delimited numbers starting from 0 upto n inclusive.\n >>> string_sequence(0)\n '0'\n >>> string_sequence(5)\n '0 1 2 3 4 5'\n \"\"\"\n return ' '.join(str(i) for i in range(n + 1))\n```"}
{"task_id": "HumanEval/16", "solution": "```\npython\ndef count_distinct_characters(string: str) -> int:\n \"\"\" Given a string, find out how many distinct characters (regardless of case) does it consist of\n >>> count_distinct_characters('xyzXYZ')\n 3\n >>> count_distinct_characters('Jerry')\n 4\n \"\"\"\n return len(set(string.lower()))\n\n# Test cases\nprint(count_distinct_characters('xyzXYZ')) # Output: 3\nprint(count_distinct_characters('Jerry')) # Output: 4\n```"}
{"task_id": "HumanEval/17", "solution": "```\npython\nfrom typing import List\n\n\ndef parse_music(music_string: str) -> List[int]:\n \"\"\" Input to this function is a string representing musical notes in a special ASCII format.\n Your task is to parse this string and return list of integers corresponding to how many beats does each\n not last.\n\n Here is a legend:\n 'o' - whole note, lasts four beats\n 'o|' - half note, lasts two beats\n '.|' - quater note, lasts one beat\n\n >>> parse_music('o o| .| o| o| .| .| .| .| o o')\n [4, 2, 1, 2, 2, 1, 1, 1, 1, 4, 4]\n \"\"\"\n # Split the input string into individual notes\n notes = music_string.split()\n \n # Initialize an empty list to store the number of beats for each note\n beats = []\n \n # Iterate over each note and determine its duration in beats\n for note in notes:\n if note == 'o':\n beats.append(4)\n elif note == 'o|':\n beats.append(2)\n elif note == '.|':\n beats.append(1)\n \n return beats\n\n\n# Test the function with the provided example\nprint(parse_music('o o| .| o| o| .| .| .| .| o o'))\n```"}
{"task_id": "HumanEval/18", "solution": "```\npython\ndef how_many_times(string: str, substring: str) -> int:\n \"\"\" Find how many times a given substring can be found in the original string. Count overlaping cases.\n >>> how_many_times('', 'a')\n 0\n >>> how_many_times('aaa', 'a')\n 3\n >>> how_many_times('aaaa', 'aa')\n 3\n \"\"\"\n count = 0\n start = 0\n while True:\n start = string.find(substring, start)\n if start == -1: \n break\n count += 1\n start += 1\n return count\n\n# Test cases\nprint(how_many_times('', 'a')) # Expected output: 0\nprint(how_many_times('aaa', 'a')) # Expected output: 3\nprint(how_many_times('aaaa', 'aa')) # Expected output: 3\n```"}
{"task_id": "HumanEval/19", "solution": "```\npython\nfrom typing import *\nfrom collections import *\n\ndef sort_numbers(numbers: str) -> str:\n \"\"\" Input is a space-delimited string of numberals from 'zero' to 'nine'.\n Valid choices are 'zero', 'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight' and 'nine'.\n Return the string with numbers sorted from smallest to largest\n >>> sort_numbers('three one five')\n 'one three five'\n \"\"\"\n num_map = {\n \"zero\": 0,\n \"one\": 1,\n \"two\": 2,\n \"three\": 3,\n \"four\": 4,\n \"five\": 5,\n \"six\": 6,\n \"seven\": 7,\n \"eight\": 8,\n \"nine\": 9\n }\n \n sorted_numbers = sorted(numbers.split(), key=lambda x: num_map[x])\n return ' '.join(sorted_numbers)\n\n# Check function to verify the correctness of the solution\ndef check():\n assert sort_numbers('three one five') == 'one three five'\n assert sort_numbers('nine eight seven') == 'seven eight nine'\n assert sort_numbers('zero four two') == 'zero two four'\n assert sort_numbers('six three nine one') == 'one three six nine'\n print(\"All tests passed!\")\n\ncheck()\n```"}
{"task_id": "HumanEval/20", "solution": "```\npython\nfrom typing import List, Tuple\n\n\ndef find_closest_elements(numbers: List[float]) -> Tuple[float, float]:\n \"\"\" From a supplied list of numbers (of length at least two) select and return two that are the closest to each\n other and return them in order (smaller number, larger number).\n >>> find_closest_elements([1.0, 2.0, 3.0, 4.0, 5.0, 2.2])\n (2.0, 2.2)\n >>> find_closest_elements([1.0, 2.0, 3.0, 4.0, 5.0, 2.0])\n (2.0, 2.0)\n \"\"\"\n numbers.sort()\n closest_pair = (numbers[0], numbers[1])\n min_diff = abs(numbers[1] - numbers[0])\n\n for i in range(1, len(numbers) - 1):\n diff = abs(numbers[i + 1] - numbers[i])\n if diff < min_diff:\n min_diff = diff\n closest_pair = (numbers[i], numbers[i + 1])\n\n return closest_pair\n```"}
{"task_id": "HumanEval/21", "solution": "```\npython\nfrom typing import List\n\n\ndef rescale_to_unit(numbers: List[float]) -> List[float]:\n \"\"\" Given list of numbers (of at least two elements), apply a linear transform to that list,\n such that the smallest number will become 0 and the largest will become 1\n >>> rescale_to_unit([1.0, 2.0, 3.0, 4.0, 5.0])\n [0.0, 0.25, 0.5, 0.75, 1.0]\n \"\"\"\n min_val = min(numbers)\n max_val = max(numbers)\n range_val = max_val - min_val\n return [(x - min_val) / range_val for x in numbers]\n```"}
{"task_id": "HumanEval/22", "solution": "```\npython\nfrom typing import List, Any\n\n\ndef filter_integers(values: List[Any]) -> List[int]:\n \"\"\" Filter given list of any python values only for integers\n >>> filter_integers(['a', 3.14, 5])\n [5]\n >>> filter_integers([1, 2, 3, 'abc', {}, []])\n [1, 2, 3]\n \"\"\"\n return [value for value in values if isinstance(value, int)]\n```"}
{"task_id": "HumanEval/23", "solution": "```\npython\ndef strlen(string: str) -> int:\n \"\"\" Return length of given string\n >>> strlen('')\n 0\n >>> strlen('abc')\n 3\n \"\"\"\n return len(string)\n```"}
{"task_id": "HumanEval/24", "solution": "```\npython\ndef largest_divisor(n: int) -> int:\n \"\"\" For a given number n, find the largest number that divides n evenly, smaller than n\n >>> largest_divisor(15)\n 5\n \"\"\"\n for i in range(n - 1, 0, -1):\n if n % i == 0:\n return i\n return 1\n\n# Test the function with the provided test case\nprint(largest_divisor(15)) # Output should be 5\n```"}
{"task_id": "HumanEval/25", "solution": "```\npython\nfrom typing import List\n\n\ndef factorize(n: int) -> List[int]:\n \"\"\" Return list of prime factors of given integer in the order from smallest to largest.\n Each of the factors should be listed number of times corresponding to how many times it appeares in factorization.\n Input number should be equal to the product of all factors\n >>> factorize(8)\n [2, 2, 2]\n >>> factorize(25)\n [5, 5]\n >>> factorize(70)\n [2, 5, 7]\n \"\"\"\n factors = []\n # Start with the smallest prime number\n divisor = 2\n while n >= divisor * divisor:\n if n % divisor:\n divisor += 1\n else:\n n //= divisor\n factors.append(divisor)\n if n > 1:\n factors.append(n)\n return factors\n\n\n# Test cases\nprint(factorize(8)) # Output: [2, 2, 2]\nprint(factorize(25)) # Output: [5, 5]\nprint(factorize(70)) # Output: [2, 5, 7]\n```"}
{"task_id": "HumanEval/26", "solution": "```\npython\nfrom typing import *\nfrom collections import *\n\ndef remove_duplicates(numbers: List[int]) -> List[int]:\n \"\"\" From a list of integers, remove all elements that occur more than once.\n Keep order of elements left the same as in the input.\n >>> remove_duplicates([1, 2, 3, 2, 4])\n [1, 3, 4]\n \"\"\"\n seen = set()\n result = []\n for number in numbers:\n if number not in seen:\n seen.add(number)\n result.append(number)\n return result\n```"}
{"task_id": "HumanEval/27", "solution": "```\npython\ndef flip_case(s: str) -> str:\n return ''.join(c.lower() if c.isupper() else c.upper() for c in s)\n\n# Test the function\nprint(flip_case('Hello')) # Output: hELLO\n```"}
{"task_id": "HumanEval/28", "solution": "```\npython\nfrom typing import *\nfrom collections import *\nfrom typing import List\n\n\ndef concatenate(strings: List[str]) -> str:\n \"\"\" Concatenate list of strings into a single string\n >>> concatenate([])\n ''\n >>> concatenate(['a', 'b', 'c'])\n 'abc'\n \"\"\"\n return ''.join(strings)\n```"}
{"task_id": "HumanEval/29", "solution": "```\npython\nfrom typing import *\nfrom collections import *\n\ndef filter_by_prefix(strings: List[str], prefix: str) -> List[str]:\n \"\"\" Filter an input list of strings only for ones that start with a given prefix.\n >>> filter_by_prefix([], 'a')\n []\n >>> filter_by_prefix(['abc', 'bcd', 'cde', 'array'], 'a')\n ['abc', 'array']\n \"\"\"\n return [s for s in strings if s.startswith(prefix)]\n```"}
{"task_id": "HumanEval/30", "solution": "```\npython\ndef get_positive(l: list):\n \"\"\"Return only positive numbers in the list.\n >>> get_positive([-1, 2, -4, 5, 6])\n [2, 5, 6]\n >>> get_positive([5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10])\n [5, 3, 2, 3, 9, 123, 1]\n \"\"\"\n return [x for x in l if x > 0]\n```"}
{"task_id": "HumanEval/31", "solution": "```\npython\ndef is_prime(n):\n \"\"\"Return true if a given number is prime, and false otherwise.\n >>> is_prime(6)\n False\n >>> is_prime(101)\n True\n >>> is_prime(11)\n True\n >>> is_prime(13441)\n True\n >>> is_prime(61)\n True\n >>> is_prime(4)\n False\n >>> is_prime(1)\n False\n \"\"\"\n if n <= 1:\n return False\n if n <= 3:\n return True\n if n % 2 == 0 or n % 3 == 0:\n return False\n i = 5\n while i * i <= n:\n if n % i == 0 or n % (i + 2) == 0:\n return False\n i += 6\n return True\n\n# Test cases\nprint(is_prime(6)) # Expected output: False\nprint(is_prime(101)) # Expected output: True\nprint(is_prime(11)) # Expected output: True\nprint(is_prime(13441)) # Expected output: True\nprint(is_prime(61)) # Expected output: True\nprint(is_prime(4)) # Expected output: False\nprint(is_prime(1)) # Expected output: False\n```"}
{"task_id": "HumanEval/32", "solution": "```\npython\nimport math\n\n\ndef poly(xs: list, x: float):\n \"\"\"\n Evaluates polynomial with coefficients xs at point x.\n return xs[0] + xs[1] * x + xs[1] * x^2 + .... xs[n] * x^n\n \"\"\"\n return sum([coeff * math.pow(x, i) for i, coeff in enumerate(xs)])\n\n\ndef find_zero(xs: list):\n \"\"\" xs are coefficients of a polynomial.\n find_zero find x such that poly(x) = 0.\n find_zero returns only one zero point, even if there are many.\n Moreover, find_zero only takes list xs having even number of coefficients\n and largest non zero coefficient as it guarantees\n a solution.\n >>> round(find_zero([1, 2]), 2) # f(x) = 1 + 2x\n -0.5\n >>> round(find_zero([-6, 11, -6, 1]), 2) # (x - 1) * (x - 2) * (x - 3) = -6 + 11x - 6x^2 + x^3\n 1.0\n \"\"\"\n if len(xs) % 2 != 0 or xs[-1] == 0:\n raise ValueError(\"List must have an even number of coefficients and the largest non-zero coefficient must be non-zero.\")\n \n # Use Newton's method to find a root\n x = 0.0\n while True:\n fx = poly(xs, x)\n fpx = sum([i * coeff * math.pow(x, i-1) for i, coeff in enumerate(xs)][1:])\n if abs(fx) < 1e-6:\n return round(x, 2)\n x -= fx / fpx\n```"}
{"task_id": "HumanEval/33", "solution": "```\npython\ndef sort_third(l: list):\n \"\"\"This function takes a list l and returns a list l' such that\n l' is identical to l in the indicies that are not divisible by three, while its values at the indicies that are divisible by three are equal\n to the values of the corresponding indicies of l, but sorted.\n >>> sort_third([1, 2, 3])\n [1, 2, 3]\n >>> sort_third([5, 6, 3, 4, 8, 9, 2])\n [2, 6, 3, 4, 8, 9, 5]\n \"\"\"\n # Extract elements at indices divisible by three\n third_elements = [l[i] for i in range(len(l)) if i % 3 == 0]\n \n # Sort the extracted elements\n sorted_third_elements = sorted(third_elements)\n \n # Create a new list to store the result\n l_prime = []\n \n # Counter for sorted_third_elements\n sort_index = 0\n \n # Iterate through the original list and construct the new list\n for i in range(len(l)):\n if i % 3 == 0:\n # Replace element with sorted value\n l_prime.append(sorted_third_elements[sort_index])\n sort_index += 1\n else:\n # Keep the original element\n l_prime.append(l[i])\n \n return l_prime\n\n# Test cases\nprint(sort_third([1, 2, 3])) # Output: [1, 2, 3]\nprint(sort_third([5, 6, 3, 4, 8, 9, 2])) # Output: [2, 6, 3, 4, 8, 9, 5]\n```"}
{"task_id": "HumanEval/34", "solution": "```\npython\ndef unique(l: list):\n \"\"\"Return sorted unique elements in a list\n >>> unique([5, 3, 5, 2, 3, 3, 9, 0, 123])\n [0, 2, 3, 5, 9, 123]\n \"\"\"\n return sorted(set(l))\n```"}
{"task_id": "HumanEval/35", "solution": "```\npython\ndef max_element(l: list):\n \"\"\"Return maximum element in the list.\n >>> max_element([1, 2, 3])\n 3\n >>> max_element([5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10])\n 123\n \"\"\"\n return max(l)\n```"}
{"task_id": "HumanEval/36", "solution": "```\npython\ndef fizz_buzz(n: int) -> int:\n \"\"\"Return the number of times the digit 7 appears in integers less than n which are divisible by 11 or 13.\n >>> fizz_buzz(50)\n 0\n >>> fizz_buzz(78)\n 2\n >>> fizz_buzz(79)\n 3\n \"\"\"\n count = 0\n for i in range(n):\n if i % 11 == 0 or i % 13 == 0:\n count += str(i).count('7')\n return count\n\n# Test cases\nprint(fizz_buzz(50)) # Expected output: 0\nprint(fizz_buzz(78)) # Expected output: 2\nprint(fizz_buzz(79)) # Expected output: 3\n```"}
{"task_id": "HumanEval/37", "solution": "```\npython\ndef sort_even(l: list):\n \"\"\"This function takes a list l and returns a list l' such that\n l' is identical to l in the odd indicies, while its values at the even indicies are equal\n to the values of the even indicies of l, but sorted.\n >>> sort_even([1, 2, 3])\n [1, 2, 3]\n >>> sort_even([5, 6, 3, 4])\n [3, 6, 5, 4]\n \"\"\"\n # Extract the elements at even indices\n even_elements = [l[i] for i in range(len(l)) if i % 2 == 0]\n \n # Sort the extracted elements\n even_elements.sort()\n \n # Create a new list to store the result\n l_prime = []\n \n # Counter for the sorted even elements\n even_index = 0\n \n # Iterate through the original list and construct the new list\n for i in range(len(l)):\n if i % 2 == 0:\n # Append the next sorted even element\n l_prime.append(even_elements[even_index])\n even_index += 1\n else:\n # Append the element from the original list at odd index\n l_prime.append(l[i])\n \n return l_prime\n\n# Test cases\nprint(sort_even([1, 2, 3])) # Output: [1, 2, 3]\nprint(sort_even([5, 6, 3, 4])) # Output: [3, 6, 5, 4]\n```"}
{"task_id": "HumanEval/38", "solution": "```\npython\ndef decode_cyclic(s: str):\n \"\"\"\n takes as input string encoded with encode_cyclic function. Returns decoded string.\n \"\"\"\n # split string to groups. Each of length 3.\n groups = [s[(3 * i):min((3 * i + 3), len(s))] for i in range((len(s) + 2) // 3)]\n # cycle elements in each group back. Unless group has fewer elements than 3.\n groups = [(group[-1] + group[:-1]) if len(group) == 3 else group for group in groups]\n return \"\".join(groups)\n```"}
{"task_id": "HumanEval/39", "solution": "```\npython\nfrom sympy import isprime\n\ndef prime_fib(n: int):\n \"\"\"\n prime_fib returns n-th number that is a Fibonacci number and it's also prime.\n >>> prime_fib(1)\n 2\n >>> prime_fib(2)\n 3\n >>> prime_fib(3)\n 5\n >>> prime_fib(4)\n 13\n >>> prime_fib(5)\n 89\n \"\"\"\n def fib_generator():\n a, b = 0, 1\n while True:\n yield b\n a, b = b, a + b\n\n count = 0\n for fib_num in fib_generator():\n if isprime(fib_num):\n count += 1\n if count == n:\n return fib_num\n\n# Test cases\nprint(prime_fib(1)) # Output: 2\nprint(prime_fib(2)) # Output: 3\nprint(prime_fib(3)) # Output: 5\nprint(prime_fib(4)) # Output: 13\nprint(prime_fib(5)) # Output: 89\n```"}
{"task_id": "HumanEval/40", "solution": "```\npython\ndef triples_sum_to_zero(l: list):\n \"\"\"\n triples_sum_to_zero takes a list of integers as an input.\n it returns True if there are three distinct elements in the list that\n sum to zero, and False otherwise.\n\n >>> triples_sum_to_zero([1, 3, 5, 0])\n False\n >>> triples_sum_to_zero([1, 3, -2, 1])\n True\n >>> triples_sum_to_zero([1, 2, 3, 7])\n False\n >>> triples_sum_to_zero([2, 4, -5, 3, 9, 7])\n True\n >>> triples_sum_to_zero([1])\n False\n \"\"\"\n n = len(l)\n for i in range(n):\n seen = set()\n target = -l[i]\n for j in range(i + 1, n):\n if target - l[j] in seen:\n return True\n seen.add(l[j])\n return False\n\n# Test cases\nprint(triples_sum_to_zero([1, 3, 5, 0])) # Expected output: False\nprint(triples_sum_to_zero([1, 3, -2, 1])) # Expected output: True\nprint(triples_sum_to_zero([1, 2, 3, 7])) # Expected output: False\nprint(triples_sum_to_zero([2, 4, -5, 3, 9, 7])) # Expected output: True\nprint(triples_sum_to_zero([1])) # Expected output: False\n```"}
{"task_id": "HumanEval/41", "solution": "```\npython\ndef car_race_collision(n: int) -> int:\n \"\"\"\n Imagine a road that's a perfectly straight infinitely long line.\n n cars are driving left to right; simultaneously, a different set of n cars\n are driving right to left. The two sets of cars start out being very far from\n each other. All cars move in the same speed. Two cars are said to collide\n when a car that's moving left to right hits a car that's moving right to left.\n However, the cars are infinitely sturdy and strong; as a result, they continue moving\n in their trajectory as if they did not collide.\n\n This function outputs the number of such collisions.\n \"\"\"\n # Since each car going left to right will eventually collide with each car\n # going right to left, the total number of collisions is simply n * n.\n return n * n\n\n# Example usage:\nn = 5\nprint(f\"Number of collisions for {n} cars in each direction: {car_race_collision(n)}\")\n```"}
{"task_id": "HumanEval/42", "solution": "```\npython\ndef incr_list(l: list):\n \"\"\"Return list with elements incremented by 1.\n >>> incr_list([1, 2, 3])\n [2, 3, 4]\n >>> incr_list([5, 3, 5, 2, 3, 3, 9, 0, 123])\n [6, 4, 6, 3, 4, 4, 10, 1, 124]\n \"\"\"\n return [x + 1 for x in l]\n\n# Test cases\nprint(incr_list([1, 2, 3])) # Expected output: [2, 3, 4]\nprint(incr_list([5, 3, 5, 2, 3, 3, 9, 0, 123])) # Expected output: [6, 4, 6, 3, 4, 4, 10, 1, 124]\n```"}
{"task_id": "HumanEval/43", "solution": "```\npython\ndef pairs_sum_to_zero(l):\n seen = set()\n for num in l:\n if -num in seen:\n return True\n seen.add(num)\n return False\n\n# Test cases\nprint(pairs_sum_to_zero([1, 3, 5, 0])) # Expected output: False\nprint(pairs_sum_to_zero([1, 3, -2, 1])) # Expected output: False\nprint(pairs_sum_to_zero([1, 2, 3, 7])) # Expected output: False\nprint(pairs_sum_to_zero([2, 4, -5, 3, 5, 7])) # Expected output: True\nprint(pairs_sum_to_zero([1])) # Expected output: False\n```"}
{"task_id": "HumanEval/44", "solution": "```\npython\ndef change_base(x: int, base: int) -> str:\n \"\"\"Change numerical base of input number x to base.\n return string representation after the conversion.\n base numbers are less than 10.\n >>> change_base(8, 3)\n '22'\n >>> change_base(8, 2)\n '1000'\n >>> change_base(7, 2)\n '111'\n \"\"\"\n if x < base:\n return str(x)\n else:\n return change_base(x // base, base) + str(x % base)\n\n# Test cases\nprint(change_base(8, 3)) # Output: '22'\nprint(change_base(8, 2)) # Output: '1000'\nprint(change_base(7, 2)) # Output: '111'\n```"}
{"task_id": "HumanEval/45", "solution": "```\npython\ndef triangle_area(a, h):\n \"\"\"Given length of a side and high return area for a triangle.\n >>> triangle_area(5, 3)\n 7.5\n \"\"\"\n return 0.5 * a * h\n\n# Test the function\nprint(triangle_area(5, 3)) # Expected output: 7.5\n```"}
{"task_id": "HumanEval/46", "solution": "```\npython\ndef fib4(n: int) -> int:\n if n < 2:\n return 0\n elif n == 2:\n return 2\n else:\n a, b, c, d = 0, 0, 2, 0\n for _ in range(3, n + 1):\n a, b, c, d = b, c, d, a + b + c + d\n return d\n\n# Test cases\nprint(fib4(5)) # Output: 4\nprint(fib4(6)) # Output: 8\nprint(fib4(7)) # Output: 14\n```"}
{"task_id": "HumanEval/47", "solution": "```\npython\ndef median(l: list):\n \"\"\"Return median of elements in the list l.\n >>> median([3, 1, 2, 4, 5])\n 3\n >>> median([-10, 4, 6, 1000, 10, 20])\n 15.0\n \"\"\"\n sorted_l = sorted(l)\n n = len(sorted_l)\n mid = n // 2\n if n % 2 == 1:\n return sorted_l[mid]\n else:\n return (sorted_l[mid - 1] + sorted_l[mid]) / 2\n\n# Test cases\nprint(median([3, 1, 2, 4, 5])) # Output: 3\nprint(median([-10, 4, 6, 1000, 10, 20])) # Output: 15.0\n```"}
{"task_id": "HumanEval/48", "solution": "```\npython\ndef is_palindrome(text: str):\n \"\"\"\n Checks if given string is a palindrome\n >>> is_palindrome('')\n True\n >>> is_palindrome('aba')\n True\n >>> is_palindrome('aaaaa')\n True\n >>> is_palindrome('zbcd')\n False\n \"\"\"\n return text == text[::-1]\n```"}
{"task_id": "HumanEval/49", "solution": "```\npython\ndef modp(n: int, p: int) -> int:\n \"\"\"Return 2^n modulo p (be aware of numerics).\n >>> modp(3, 5)\n 3\n >>> modp(1101, 101)\n 2\n >>> modp(0, 101)\n 1\n >>> modp(3, 11)\n 8\n >>> modp(100, 101)\n 1\n \"\"\"\n return pow(2, n, p)\n\n# Test cases to verify the correctness of the function\nassert modp(3, 5) == 3\nassert modp(1101, 101) == 2\nassert modp(0, 101) == 1\nassert modp(3, 11) == 8\nassert modp(100, 101) == 1\n```"}
{"task_id": "HumanEval/50", "solution": "```\npython\ndef decode_shift(s: str):\n \"\"\"\n takes as input string encoded with encode_shift function. Returns decoded string.\n \"\"\"\n return \"\".join([chr(((ord(ch) - 5 - ord(\"a\")) % 26) + ord(\"a\")) for ch in s])\n```"}
{"task_id": "HumanEval/51", "solution": "```\npython\ndef remove_vowels(text):\n vowels = \"aeiouAEIOU\"\n return ''.join([char for char in text if char not in vowels])\n\n# Test cases\nprint(remove_vowels('')) # Output: ''\nprint(remove_vowels(\"abcdef\\nghijklm\")) # Output: 'bcdf\\nghjklm'\nprint(remove_vowels('abcdef')) # Output: 'bcdf'\nprint(remove_vowels('aaaaa')) # Output: ''\nprint(remove_vowels('aaBAA')) # Output: 'B'\nprint(remove_vowels('zbcd')) # Output: 'zbcd'\n```"}
{"task_id": "HumanEval/52", "solution": "```\npython\ndef below_threshold(l: list, t: int) -> bool:\n \"\"\"Return True if all numbers in the list l are below threshold t.\n >>> below_threshold([1, 2, 4, 10], 100)\n True\n >>> below_threshold([1, 20, 4, 10], 5)\n False\n \"\"\"\n return all(x < t for x in l)\n\n# Test cases\nprint(below_threshold([1, 2, 4, 10], 100)) # Expected output: True\nprint(below_threshold([1, 20, 4, 10], 5)) # Expected output: False\n```"}
{"task_id": "HumanEval/53", "solution": "```\npython\ndef add(x: int, y: int) -> int:\n \"\"\"Add two numbers x and y\n >>> add(2, 3)\n 5\n >>> add(5, 7)\n 12\n \"\"\"\n return x + y\n\n# Test the function with doctest\nimport doctest\ndoctest.testmod()\n```"}
{"task_id": "HumanEval/54", "solution": "```\npython\ndef same_chars(s0: str, s1: str) -> bool:\n # Create a set of characters from each string\n set_s0 = set(s0)\n set_s1 = set(s1)\n \n # Compare the sets to check if they are equal\n return set_s0 == set_s1\n\n# Test cases\nprint(same_chars('eabcdzzzz', 'dddzzzzzzzddeddabc')) # True\nprint(same_chars('abcd', 'dddddddabc')) # True\nprint(same_chars('dddddddabc', 'abcd')) # True\nprint(same_chars('eabcd', 'dddddddabc')) # False\nprint(same_chars('abcd', 'dddddddabce')) # False\nprint(same_chars('eabcdzzzz', 'dddzzzzzzzddddabc')) # False\n```"}
{"task_id": "HumanEval/55", "solution": "```\npython\ndef fib(n: int) -> int:\n \"\"\"Return n-th Fibonacci number.\n >>> fib(10)\n 55\n >>> fib(1)\n 1\n >>> fib(8)\n 21\n \"\"\"\n if n <= 0:\n return 0\n elif n == 1:\n return 1\n else:\n a, b = 0, 1\n for _ in range(2, n + 1):\n a, b = b, a + b\n return b\n\n# Test cases\nprint(fib(10)) # Output: 55\nprint(fib(1)) # Output: 1\nprint(fib(8)) # Output: 21\n```"}
{"task_id": "HumanEval/56", "solution": "```\npython\ndef correct_bracketing(brackets: str) -> bool:\n balance = 0\n for bracket in brackets:\n if bracket == '<':\n balance += 1\n elif bracket == '>':\n balance -= 1\n if balance < 0:\n return False\n return balance == 0\n\n# Test cases\nprint(correct_bracketing(\"<\")) # Expected output: False\nprint(correct_bracketing(\"<>\")) # Expected output: True\nprint(correct_bracketing(\"<<><>>\")) # Expected output: True\nprint(correct_bracketing(\"><<>\")) # Expected output: False\n```"}
{"task_id": "HumanEval/57", "solution": "```\npython\ndef monotonic(l: list):\n \"\"\"Return True if list elements are monotonically increasing or decreasing.\n >>> monotonic([1, 2, 4, 20])\n True\n >>> monotonic([1, 20, 4, 10])\n False\n >>> monotonic([4, 1, 0, -10])\n True\n \"\"\"\n return l == sorted(l) or l == sorted(l, reverse=True)\n```"}
{"task_id": "HumanEval/58", "solution": "```\npython\ndef common(l1: list, l2: list):\n \"\"\"Return sorted unique common elements for two lists.\n >>> common([1, 4, 3, 34, 653, 2, 5], [5, 7, 1, 5, 9, 653, 121])\n [1, 5, 653]\n >>> common([5, 3, 2, 8], [3, 2])\n [2, 3]\n\n \"\"\"\n # Convert both lists to sets to remove duplicates and find the intersection\n common_elements = set(l1) & set(l2)\n # Return the sorted list of common elements\n return sorted(common_elements)\n\n# Test cases\nprint(common([1, 4, 3, 34, 653, 2, 5], [5, 7, 1, 5, 9, 653, 121])) # Output: [1, 5, 653]\nprint(common([5, 3, 2, 8], [3, 2])) # Output: [2, 3]\n```"}
{"task_id": "HumanEval/59", "solution": "```\npython\ndef largest_prime_factor(n: int) -> int:\n \"\"\"Return the largest prime factor of n. Assume n > 1 and is not a prime.\n >>> largest_prime_factor(13195)\n 29\n >>> largest_prime_factor(2048)\n 2\n \"\"\"\n # Initialize the largest prime factor to the smallest possible value\n largest_prime = -1\n \n # Divide n by 2 until it becomes odd\n while n % 2 == 0:\n largest_prime = 2\n n //= 2\n \n # Check for odd factors from 3 onwards\n factor = 3\n while factor * factor <= n:\n while n % factor == 0:\n largest_prime = factor\n n //= factor\n factor += 2\n \n # If n is a prime number greater than 2\n if n > 2:\n largest_prime = n\n \n return largest_prime\n\n# Test cases\nprint(largest_prime_factor(13195)) # Output: 29\nprint(largest_prime_factor(2048)) # Output: 2\n```"}
{"task_id": "HumanEval/60", "solution": "```\npython\ndef sum_to_n(n: int) -> int:\n \"\"\"sum_to_n is a function that sums numbers from 1 to n.\n >>> sum_to_n(30)\n 465\n >>> sum_to_n(100)\n 5050\n >>> sum_to_n(5)\n 15\n >>> sum_to_n(10)\n 55\n >>> sum_to_n(1)\n 1\n \"\"\"\n return n * (n + 1) // 2\n\n# Test cases to verify the correctness of the function\nassert sum_to_n(30) == 465\nassert sum_to_n(100) == 5050\nassert sum_to_n(5) == 15\nassert sum_to_n(10) == 55\nassert sum_to_n(1) == 1\n```"}
{"task_id": "HumanEval/61", "solution": "```\npython\ndef correct_bracketing(brackets: str) -> bool:\n balance = 0\n for bracket in brackets:\n if bracket == '(':\n balance += 1\n elif bracket == ')':\n balance -= 1\n if balance < 0:\n return False\n return balance == 0\n\n# Test cases\nprint(correct_bracketing(\"(\")) # Expected output: False\nprint(correct_bracketing(\"()\")) # Expected output: True\nprint(correct_bracketing(\"(()())\")) # Expected output: True\nprint(correct_bracketing(\")(()\")) # Expected output: False\n```"}
{"task_id": "HumanEval/62", "solution": "```\npython\ndef derivative(xs: list):\n \"\"\" xs represent coefficients of a polynomial.\n xs[0] + xs[1] * x + xs[2] * x^2 + ....\n Return derivative of this polynomial in the same form.\n >>> derivative([3, 1, 2, 4, 5])\n [1, 4, 12, 20]\n >>> derivative([1, 2, 3])\n [2, 6]\n \"\"\"\n return [i * xs[i] for i in range(1, len(xs))]\n```"}
{"task_id": "HumanEval/63", "solution": "```\npython\ndef fibfib(n: int) -> int:\n if n == 0 or n == 1:\n return 0\n elif n == 2:\n return 1\n \n a, b, c = 0, 0, 1\n for _ in range(3, n + 1):\n a, b, c = b, c, a + b + c\n return c\n\n# Test cases\nprint(fibfib(1)) # Output: 0\nprint(fibfib(5)) # Output: 4\nprint(fibfib(8)) # Output: 24\n```"}
{"task_id": "HumanEval/64", "solution": "```\npython\ndef vowels_count(s):\n \"\"\"Write a function vowels_count which takes a string representing\n a word as input and returns the number of vowels in the string.\n Vowels in this case are 'a', 'e', 'i', 'o', 'u'. Here, 'y' is also a\n vowel, but only when it is at the end of the given word.\n\n Example:\n >>> vowels_count(\"abcde\")\n 2\n >>> vowels_count(\"ACEDY\")\n 3\n \"\"\"\n # Define the set of vowels\n vowels = {'a', 'e', 'i', 'o', 'u'}\n \n # Convert the string to lowercase to handle both cases\n s = s.lower()\n \n # Initialize the count of vowels\n count = 0\n \n # Iterate through each character in the string\n for char in s:\n if char in vowels:\n count += 1\n \n # Check if 'y' is at the end and treat it as a vowel\n if s.endswith('y'):\n count += 1\n \n return count\n\n# Test cases to verify the function\nprint(vowels_count(\"abcde\")) # Expected output: 2\nprint(vowels_count(\"ACEDY\")) # Expected output: 3\n```"}
{"task_id": "HumanEval/65", "solution": "```\npython\ndef circular_shift(x, shift):\n \"\"\"Circular shift the digits of the integer x, shift the digits right by shift\n and return the result as a string.\n If shift > number of digits, return digits reversed.\n >>> circular_shift(12, 1)\n \"21\"\n >>> circular_shift(12, 2)\n \"12\"\n \"\"\"\n x_str = str(x)\n num_digits = len(x_str)\n \n if shift >= num_digits:\n return x_str[::-1]\n else:\n shift = shift % num_digits\n return x_str[-shift:] + x_str[:-shift]\n\n# Test cases\nprint(circular_shift(12, 1)) # Output: \"21\"\nprint(circular_shift(12, 2)) # Output: \"12\"\n```"}
{"task_id": "HumanEval/66", "solution": "```\npython\ndef digitSum(s):\n return sum(ord(c) for c in s if c.isupper())\n\n# Test cases\nprint(digitSum(\"\")) # Output: 0\nprint(digitSum(\"abAB\")) # Output: 131\nprint(digitSum(\"abcCd\")) # Output: 67\nprint(digitSum(\"helloE\")) # Output: 69\nprint(digitSum(\"woArBld\")) # Output: 131\nprint(digitSum(\"aAaaaXa\")) # Output: 153\n```"}
{"task_id": "HumanEval/67", "solution": "```\npython\nimport re\n\ndef fruit_distribution(s, n):\n # Use regular expressions to find the numbers in the string\n numbers = re.findall(r'\\d+', s)\n # Convert the found numbers to integers and sum them up\n total_apples_and_oranges = sum(map(int, numbers))\n # Subtract the total number of apples and oranges from the total number of fruits\n mangoes = n - total_apples_and_oranges\n return mangoes\n\n# Test cases\nprint(fruit_distribution(\"5 apples and 6 oranges\", 19)) # Output: 8\nprint(fruit_distribution(\"0 apples and 1 oranges\", 3)) # Output: 2\nprint(fruit_distribution(\"2 apples and 3 oranges\", 100)) # Output: 95\nprint(fruit_distribution(\"100 apples and 1 oranges\", 120)) # Output: 19\n```"}
{"task_id": "HumanEval/68", "solution": "```\npython\ndef pluck(arr):\n if not arr: # Check if the array is empty\n return []\n \n smallest_even = float('inf')\n index_of_smallest_even = -1\n \n for i, value in enumerate(arr):\n if value % 2 == 0 and value < smallest_even:\n smallest_even = value\n index_of_smallest_even = i\n \n if smallest_even == float('inf'):\n return []\n \n return [smallest_even, index_of_smallest_even]\n```"}
{"task_id": "HumanEval/69", "solution": "```\npython\nfrom collections import Counter\n\ndef search(lst):\n # Count the frequency of each number in the list\n freq = Counter(lst)\n \n # Initialize the result to -1, assuming no such number exists\n result = -1\n \n # Iterate through the items in the frequency dictionary\n for num, count in freq.items():\n # Check if the number's frequency is greater than or equal to the number itself\n if count >= num:\n # Update the result with the maximum of the current result and the number\n result = max(result, num)\n \n return result\n\n# Test cases\nprint(search([4, 1, 2, 2, 3, 1])) # Output: 2\nprint(search([1, 2, 2, 3, 3, 3, 4, 4, 4])) # Output: 3\nprint(search([5, 5, 4, 4, 4])) # Output: -1\n```"}
{"task_id": "HumanEval/70", "solution": "```\npython\ndef strange_sort_list(lst):\n # Sort the list to easily pick min and max\n sorted_lst = sorted(lst)\n result = []\n # Use two pointers to pick elements from the start (min) and end (max) of the sorted list\n left, right = 0, len(sorted_lst) - 1\n while left <= right:\n if left == right:\n # If there's only one element left, append it to the result\n result.append(sorted_lst[left])\n else:\n # Append the minimum and then the maximum from the remaining elements\n result.extend([sorted_lst[left], sorted_lst[right]])\n left += 1\n right -= 1\n return result\n\n# Test cases\nprint(strange_sort_list([1, 2, 3, 4])) # Output: [1, 4, 2, 3]\nprint(strange_sort_list([5, 5, 5, 5])) # Output: [5, 5, 5, 5]\nprint(strange_sort_list([])) # Output: []\n```"}
{"task_id": "HumanEval/71", "solution": "```\npython\nimport math\n\ndef triangle_area(a, b, c):\n '''\n Given the lengths of the three sides of a triangle. Return the area of\n the triangle rounded to 2 decimal points if the three sides form a valid triangle. \n Otherwise return -1\n Three sides make a valid triangle when the sum of any two sides is greater \n than the third side.\n Example:\n triangle_area(3, 4, 5) == 6.00\n triangle_area(1, 2, 10) == -1\n '''\n # Check if the sides form a valid triangle\n if a + b <= c or a + c <= b or b + c <= a:\n return -1\n \n # Calculate the semi-perimeter\n s = (a + b + c) / 2\n \n # Calculate the area using Heron's formula\n area = math.sqrt(s * (s - a) * (s - b) * (s - c))\n \n # Return the area rounded to 2 decimal points\n return round(area, 2)\n\n# Test cases\nprint(triangle_area(3, 4, 5)) # Expected output: 6.00\nprint(triangle_area(1, 2, 10)) # Expected output: -1\n```"}
{"task_id": "HumanEval/72", "solution": "```\npython\ndef will_it_fly(q, w):\n # Check if the list q is a palindrome\n if q != q[::-1]:\n return False\n \n # Calculate the sum of the elements in the list q\n total_weight = sum(q)\n \n # Check if the total weight is less than or equal to the maximum possible weight w\n if total_weight <= w:\n return True\n else:\n return False\n\n# Test cases\nprint(will_it_fly([1, 2], 5)) # \u279e False\nprint(will_it_fly([3, 2, 3], 1)) # \u279e False\nprint(will_it_fly([3, 2, 3], 9)) # \u279e True\nprint(will_it_fly([3], 5)) # \u279e True\n```"}
{"task_id": "HumanEval/73", "solution": "```\npython\ndef smallest_change(arr):\n \"\"\"\n Given an array arr of integers, find the minimum number of elements that\n need to be changed to make the array palindromic. A palindromic array is an array that\n is read the same backwards and forwards. In one change, you can change one element to any other element.\n\n For example:\n smallest_change([1,2,3,5,4,7,9,6]) == 4\n smallest_change([1, 2, 3, 4, 3, 2, 2]) == 1\n smallest_change([1, 2, 3, 2, 1]) == 0\n \"\"\"\n left = 0\n right = len(arr) - 1\n changes = 0\n \n while left < right:\n if arr[left] != arr[right]:\n changes += 1\n left += 1\n right -= 1\n \n return changes\n\n# Check function to verify the correctness of the solution\ndef check():\n assert smallest_change([1,2,3,5,4,7,9,6]) == 4\n assert smallest_change([1, 2, 3, 4, 3, 2, 2]) == 1\n assert smallest_change([1, 2, 3, 2, 1]) == 0\n print(\"All test cases pass.\")\n\ncheck()\n```"}
{"task_id": "HumanEval/74", "solution": "```\npython\ndef total_match(lst1, lst2):\n # Calculate the total number of characters in all strings of each list\n total_chars_lst1 = sum(len(s) for s in lst1)\n total_chars_lst2 = sum(len(s) for s in lst2)\n\n # Compare the totals and return the appropriate list\n if total_chars_lst1 < total_chars_lst2:\n return lst1\n elif total_chars_lst2 < total_chars_lst1:\n return lst2\n else:\n return lst1\n\n# Test cases\nprint(total_match([], [])) # \u279e []\nprint(total_match(['hi', 'admin'], ['hI', 'Hi'])) # \u279e ['hI', 'Hi']\nprint(total_match(['hi', 'admin'], ['hi', 'hi', 'admin', 'project'])) # \u279e ['hi', 'admin']\nprint(total_match(['hi', 'admin'], ['hI', 'hi', 'hi'])) # \u279e ['hI', 'hi', 'hi']\nprint(total_match(['4'], ['1', '2', '3', '4', '5'])) # \u279e ['4']\n```"}
{"task_id": "HumanEval/75", "solution": "```\npython\ndef is_multiply_prime(a):\n def is_prime(n):\n if n <= 1:\n return False\n for i in range(2, int(n**0.5) + 1):\n if n % i == 0:\n return False\n return True\n\n prime_factors = 0\n for i in range(2, a + 1):\n if a % i == 0 and is_prime(i):\n prime_factors += 1\n while a % i == 0:\n a //= i\n return prime_factors == 3\n\n# Test the function\nprint(is_multiply_prime(30)) # Output: True\n```"}
{"task_id": "HumanEval/76", "solution": "```\npython\ndef is_simple_power(x, n):\n \"\"\"Your task is to write a function that returns true if a number x is a simple\n power of n and false in other cases.\n x is a simple power of n if n**int=x\n For example:\n is_simple_power(1, 4) => true\n is_simple_power(2, 2) => true\n is_simple_power(8, 2) => true\n is_simple_power(3, 2) => false\n is_simple_power(3, 1) => false\n is_simple_power(5, 3) => false\n \"\"\"\n if n == 1:\n return x == 1\n power = 0\n while n ** power < x:\n power += 1\n return n ** power == x\n\n# Test cases\nprint(is_simple_power(1, 4)) # True\nprint(is_simple_power(2, 2)) # True\nprint(is_simple_power(8, 2)) # True\nprint(is_simple_power(3, 2)) # False\nprint(is_simple_power(3, 1)) # False\nprint(is_simple_power(5, 3)) # False\n```"}
{"task_id": "HumanEval/77", "solution": "```\npython\ndef iscube(a):\n # Calculate the cube root of the absolute value of 'a'\n cube_root = abs(a) ** (1/3)\n \n # Check if the cube root is an integer by comparing it to its rounded value\n return round(cube_root) ** 3 == abs(a)\n\n# Test cases\nprint(iscube(1)) # True\nprint(iscube(2)) # False\nprint(iscube(-1)) # True\nprint(iscube(64)) # True\nprint(iscube(0)) # True\nprint(iscube(180)) # False\n```"}
{"task_id": "HumanEval/78", "solution": "```\npython\ndef hex_key(num):\n # Define a set of prime hexadecimal digits\n prime_hex_digits = {'2', '3', '5', '7', 'B', 'D'}\n \n # Initialize a counter for prime digits\n prime_count = 0\n \n # Iterate through each character in the input string\n for char in num:\n # Check if the character is a prime hexadecimal digit\n if char in prime_hex_digits:\n # Increment the counter if it is a prime digit\n prime_count += 1\n \n # Return the total count of prime hexadecimal digits\n return prime_count\n\n# Test cases\nprint(hex_key(\"AB\")) # Output: 1\nprint(hex_key(\"1077E\")) # Output: 2\nprint(hex_key(\"ABED1A33\")) # Output: 4\nprint(hex_key(\"123456789ABCDEF0\")) # Output: 6\nprint(hex_key(\"2020\")) # Output: 2\n```"}
{"task_id": "HumanEval/79", "solution": "```\npython\ndef decimal_to_binary(decimal):\n \"\"\"You will be given a number in decimal form and your task is to convert it\n to binary format. The function should return a string, with each character representing a binary\n number. Each character in the string will be '0' or '1'.\n\n There will be an extra couple of characters 'db' at the beginning and at the end of the string.\n The extra characters are there to help with the format.\n\n Examples:\n decimal_to_binary(15) # returns \"db1111db\"\n decimal_to_binary(32) # returns \"db100000db\"\n \"\"\"\n if decimal == 0:\n return \"db0db\"\n binary = \"\"\n while decimal > 0:\n binary = str(decimal % 2) + binary\n decimal //= 2\n return f\"db{binary}db\"\n\n# Check function to verify the correctness of the solution\ndef check_function():\n assert decimal_to_binary(15) == \"db1111db\", \"Test case 1 failed\"\n assert decimal_to_binary(32) == \"db100000db\", \"Test case 2 failed\"\n assert decimal_to_binary(0) == \"db0db\", \"Test case 3 failed\"\n assert decimal_to_binary(1) == \"db1db\", \"Test case 4 failed\"\n print(\"All test cases passed!\")\n\ncheck_function()\n```"}
{"task_id": "HumanEval/80", "solution": "```\npython\ndef is_happy(s):\n \"\"\"You are given a string s.\n Your task is to check if the string is happy or not.\n A string is happy if its length is at least 3 and every 3 consecutive letters are distinct\n For example:\n is_happy(a) => False\n is_happy(aa) => False\n is_happy(abcd) => True\n is_happy(aabb) => False\n is_happy(adb) => True\n is_happy(xyy) => False\n \"\"\"\n if len(s) < 3:\n return False\n \n for i in range(len(s) - 2):\n if s[i] == s[i+1] or s[i] == s[i+2] or s[i+1] == s[i+2]:\n return False\n \n return True\n\n# Test cases\nprint(is_happy(\"a\")) # Output: False\nprint(is_happy(\"aa\")) # Output: False\nprint(is_happy(\"abcd\")) # Output: True\nprint(is_happy(\"aabb\")) # Output: False\nprint(is_happy(\"adb\")) # Output: True\nprint(is_happy(\"xyy\")) # Output: False\n```"}
{"task_id": "HumanEval/81", "solution": "```\npython\ndef numerical_letter_grade(grades):\n letter_grades = []\n for gpa in grades:\n if gpa == 4.0:\n letter_grades.append('A+')\n elif gpa > 3.7:\n letter_grades.append('A')\n elif gpa > 3.3:\n letter_grades.append('A-')\n elif gpa > 3.0:\n letter_grades.append('B+')\n elif gpa > 2.7:\n letter_grades.append('B')\n elif gpa > 2.3:\n letter_grades.append('B-')\n elif gpa > 2.0:\n letter_grades.append('C+')\n elif gpa > 1.7:\n letter_grades.append('C')\n elif gpa > 1.3:\n letter_grades.append('C-')\n elif gpa > 1.0:\n letter_grades.append('D+')\n elif gpa > 0.7:\n letter_grades.append('D')\n elif gpa > 0.0:\n letter_grades.append('D-')\n else:\n letter_grades.append('E')\n return letter_grades\n\n# Example usage\nprint(numerical_letter_grade([4.0, 3, 1.7, 2, 3.5])) # Output: ['A+', 'B', 'C-', 'C', 'A-']\n```"}
{"task_id": "HumanEval/82", "solution": "```\npython\ndef prime_length(string):\n \"\"\"Write a function that takes a string and returns True if the string\n length is a prime number or False otherwise\n Examples\n prime_length('Hello') == True\n prime_length('abcdcba') == True\n prime_length('kittens') == True\n prime_length('orange') == False\n \"\"\"\n n = len(string)\n if n <= 1:\n return False\n for i in range(2, int(n**0.5) + 1):\n if n % i == 0:\n return False\n return True\n\n# Test cases\nprint(prime_length('Hello')) # Expected output: True\nprint(prime_length('abcdcba')) # Expected output: True\nprint(prime_length('kittens')) # Expected output: True\nprint(prime_length('orange')) # Expected output: False\n```"}
{"task_id": "HumanEval/83", "solution": "```\npython\ndef starts_one_ends(n):\n \"\"\"\n Given a positive integer n, return the count of the numbers of n-digit\n positive integers that start or end with 1.\n \"\"\"\n if n == 1:\n return 1 # Only '1' is the number that starts and ends with 1\n else:\n # For n > 1, calculate the count\n # Numbers starting with 1: 1xxxx... (n-1 digits)\n # Numbers ending with 1 but not starting with 1: xxxx...1 (n-1 digits) - 1 (to avoid double counting '1xxxx...1')\n return 2 * (10 ** (n - 1)) - 10 ** (n - 2)\n\n# Example usage:\nprint(starts_one_ends(2)) # Output: 19\nprint(starts_one_ends(3)) # Output: 180\n```"}
{"task_id": "HumanEval/84", "solution": "```\npython\ndef solve(N):\n \"\"\"Given a positive integer N, return the total sum of its digits in binary.\n \n Example\n For N = 1000, the sum of digits will be 1 the output should be \"1\".\n For N = 150, the sum of digits will be 6 the output should be \"110\".\n For N = 147, the sum of digits will be 12 the output should be \"1100\".\n \n Variables:\n @N integer\n Constraints: 0 \u2264 N \u2264 10000.\n Output:\n a string of binary number\n \"\"\"\n # Calculate the sum of digits of N\n digit_sum = sum(int(digit) for digit in str(N))\n \n # Convert the sum to binary and return it as a string\n return bin(digit_sum)[2:]\n```"}
{"task_id": "HumanEval/85", "solution": "```\npython\ndef add(lst):\n \"\"\"Given a non-empty list of integers lst. add the even elements that are at odd indices.\n\n Examples:\n add([4, 2, 6, 7]) ==> 2 \n \"\"\"\n return sum(x for i, x in enumerate(lst) if i % 2 == 1 and x % 2 == 0)\n```"}
{"task_id": "HumanEval/86", "solution": "```\npython\ndef anti_shuffle(s):\n \"\"\"\n Write a function that takes a string and returns an ordered version of it.\n Ordered version of string, is a string where all words (separated by space)\n are replaced by a new word where all the characters arranged in\n ascending order based on ascii value.\n Note: You should keep the order of words and blank spaces in the sentence.\n\n For example:\n anti_shuffle('Hi') returns 'Hi'\n anti_shuffle('hello') returns 'ehllo'\n anti_shuffle('Hello World!!!') returns 'Hello !!!Wdlor'\n \"\"\"\n # Split the string into words\n words = s.split()\n \n # Process each word to sort its characters\n sorted_words = [''.join(sorted(word)) for word in words]\n \n # Join the sorted words back into a single string with spaces\n return ' '.join(sorted_words)\n\n# Test cases\nprint(anti_shuffle('Hi')) # Output: 'Hi'\nprint(anti_shuffle('hello')) # Output: 'ehllo'\nprint(anti_shuffle('Hello World!!!')) # Output: 'Hello !!!Wdlor'\n```"}
{"task_id": "HumanEval/87", "solution": "```\npython\ndef get_row(lst, x):\n result = []\n for i, row in enumerate(lst):\n for j, value in enumerate(row[::-1]): # Reverse the row to sort by columns in descending order later\n if value == x:\n result.append((i, len(row) - 1 - j)) # Adjust column index due to reversal\n return sorted(result, key=lambda item: (item[0], -item[1])) # Sort by rows ascending and columns descending\n\n# Test cases\nprint(get_row([\n [1,2,3,4,5,6],\n [1,2,3,4,1,6],\n [1,2,3,4,5,1]\n], 1)) # Expected: [(0, 0), (1, 4), (1, 0), (2, 5), (2, 0)]\n\nprint(get_row([], 1)) # Expected: []\n\nprint(get_row([[], [1], [1, 2, 3]], 3)) # Expected: [(2, 2)]\n```"}
{"task_id": "HumanEval/88", "solution": "```\npython\ndef sort_array(array):\n if not array:\n return []\n \n sorted_array = sorted(array)\n if (array[0] + array[-1]) % 2 == 0:\n sorted_array.reverse()\n \n return sorted_array\n\n# Test cases\nprint(sort_array([])) # Output: []\nprint(sort_array([5])) # Output: [5]\nprint(sort_array([2, 4, 3, 0, 1, 5])) # Output: [0, 1, 2, 3, 4, 5]\nprint(sort_array([2, 4, 3, 0, 1, 5, 6])) # Output: [6, 5, 4, 3, 2, 1, 0]\n```"}
{"task_id": "HumanEval/89", "solution": "```\npython\ndef encrypt(s):\n \"\"\"Create a function encrypt that takes a string as an argument and\n returns a string encrypted with the alphabet being rotated. \n The alphabet should be rotated in a manner such that the letters \n shift down by two multiplied to two places.\n For example:\n encrypt('hi') returns 'lm'\n encrypt('asdfghjkl') returns 'ewhjklnop'\n encrypt('gf') returns 'kj'\n encrypt('et') returns 'ix'\n \"\"\"\n result = []\n for char in s:\n if char.isalpha():\n shift = (2 * 2) % 26\n if char.islower():\n result.append(chr((ord(char) - ord('a') + shift) % 26 + ord('a')))\n else:\n result.append(chr((ord(char) - ord('A') + shift) % 26 + ord('A')))\n else:\n result.append(char)\n return ''.join(result)\n\n# Test cases\nprint(encrypt('hi')) # Output: 'lm'\nprint(encrypt('asdfghjkl')) # Output: 'ewhjklnop'\nprint(encrypt('gf')) # Output: 'kj'\nprint(encrypt('et')) # Output: 'ix'\n```"}
{"task_id": "HumanEval/90", "solution": "```\npython\ndef next_smallest(lst):\n if len(lst) < 2:\n return None\n \n unique_elements = list(set(lst))\n if len(unique_elements) < 2:\n return None\n \n unique_elements.sort()\n return unique_elements[1]\n\n# Test cases\nprint(next_smallest([1, 2, 3, 4, 5])) # Output: 2\nprint(next_smallest([5, 1, 4, 3, 2])) # Output: 2\nprint(next_smallest([])) # Output: None\nprint(next_smallest([1, 1])) # Output: None\n```"}
{"task_id": "HumanEval/91", "solution": "```\npython\nimport re\n\ndef is_bored(S):\n \"\"\"\n You'll be given a string of words, and your task is to count the number\n of boredoms. A boredom is a sentence that starts with the word \"I\".\n Sentences are delimited by '.', '?' or '!'.\n \n For example:\n >>> is_bored(\"Hello world\")\n 0\n >>> is_bored(\"The sky is blue. The sun is shining. I love this weather\")\n 1\n \"\"\"\n # Split the string into sentences using regex to match '.', '?' or '!'\n sentences = re.split(r'[.?!]\\s*', S)\n # Count the number of sentences that start with \"I\"\n boredom_count = sum(sentence.startswith('I') for sentence in sentences if sentence)\n return boredom_count\n\n# Test cases\nprint(is_bored(\"Hello world\")) # Expected output: 0\nprint(is_bored(\"The sky is blue. The sun is shining. I love this weather\")) # Expected output: 1\n```"}
{"task_id": "HumanEval/92", "solution": "```\npython\ndef any_int(x, y, z):\n # Check if all numbers are integers\n if not all(isinstance(i, int) for i in [x, y, z]):\n return False\n \n # Check if any number is equal to the sum of the other two\n if x == y + z or y == x + z or z == x + y:\n return True\n \n return False\n\n# Test cases\nprint(any_int(5, 2, 7)) # \u279e True\nprint(any_int(3, 2, 2)) # \u279e False\nprint(any_int(3, -2, 1)) # \u279e True\nprint(any_int(3.6, -2.2, 2)) # \u279e False\n```"}
{"task_id": "HumanEval/93", "solution": "```\npython\ndef encode(message):\n \"\"\"\n Write a function that takes a message, and encodes in such a \n way that it swaps case of all letters, replaces all vowels in \n the message with the letter that appears 2 places ahead of that \n vowel in the english alphabet. \n Assume only letters. \n \n Examples:\n >>> encode('test')\n 'TGST'\n >>> encode('This is a message')\n 'tHKS KS C MGSSCGG'\n \"\"\"\n vowels = \"aeiou\"\n shifted_vowels = {v: chr((ord(v) - 97 + 2) % 26 + 97) for v in vowels}\n shifted_vowels.update({v.upper(): chr((ord(v.upper()) - 65 + 2) % 26 + 65) for v in vowels})\n \n def swap_case_and_shift(c):\n if c.isalpha():\n if c.lower() in vowels:\n return shifted_vowels[c]\n else:\n return c.swapcase()\n else:\n return c\n \n return ''.join(swap_case_and_shift(char) for char in message)\n\n# Test cases\nprint(encode('test')) # Output: 'TGST'\nprint(encode('This is a message')) # Output: 'tHKS KS C MGSSCGG'\n```"}
{"task_id": "HumanEval/94", "solution": "```\npython\ndef is_prime(n):\n \"\"\"Check if a number is prime.\"\"\"\n if n <= 1:\n return False\n for i in range(2, int(n**0.5) + 1):\n if n % i == 0:\n return False\n return True\n\ndef skjkasdkd(lst):\n \"\"\"Find the largest prime value and return the sum of its digits.\"\"\"\n max_prime = 0\n for num in lst:\n if is_prime(num) and num > max_prime:\n max_prime = num\n \n # Calculate the sum of digits of the largest prime number\n digit_sum = sum(int(digit) for digit in str(max_prime))\n return digit_sum\n\n# Test cases\nprint(skjkasdkd([0,3,2,1,3,5,7,4,5,5,5,2,181,32,4,32,3,2,32,324,4,3])) # Output: 10\nprint(skjkasdkd([1,0,1,8,2,4597,2,1,3,40,1,2,1,2,4,2,5,1])) # Output: 25\nprint(skjkasdkd([1,3,1,32,5107,34,83278,109,163,23,2323,32,30,1,9,3])) # Output: 13\nprint(skjkasdkd([0,724,32,71,99,32,6,0,5,91,83,0,5,6])) # Output: 11\nprint(skjkasdkd([0,81,12,3,1,21])) # Output: 3\nprint(skjkasdkd([0,8,1,2,1,7])) # Output: 7\n```"}
{"task_id": "HumanEval/95", "solution": "```\npython\ndef check_dict_case(dict):\n if not dict:\n return False\n\n lower_case = upper_case = None\n\n for key in dict.keys():\n if not isinstance(key, str):\n return False\n\n if lower_case is None and upper_case is None:\n lower_case = key.islower()\n upper_case = key.isupper()\n elif (lower_case and not key.islower()) or (upper_case and not key.isupper()):\n return False\n\n return True\n```"}
{"task_id": "HumanEval/96", "solution": "```\npython\ndef is_prime(num):\n \"\"\"Helper function to check if a number is prime.\"\"\"\n if num <= 1:\n return False\n for i in range(2, int(num**0.5) + 1):\n if num % i == 0:\n return False\n return True\n\ndef count_up_to(n):\n \"\"\"Function that returns an array of the first n prime numbers less than n.\"\"\"\n primes = []\n num = 2\n while len(primes) < n and num < n:\n if is_prime(num):\n primes.append(num)\n num += 1\n return primes\n\n# Test cases\nprint(count_up_to(5)) # Output: [2, 3]\nprint(count_up_to(11)) # Output: [2, 3, 5, 7]\nprint(count_up_to(0)) # Output: []\nprint(count_up_to(20)) # Output: [2, 3, 5, 7, 11, 13, 17, 19]\nprint(count_up_to(1)) # Output: []\nprint(count_up_to(18)) # Output: [2, 3, 5, 7, 11, 13, 17]\n```"}
{"task_id": "HumanEval/97", "solution": "```\npython\ndef multiply(a, b):\n \"\"\"Complete the function that takes two integers and returns \n the product of their unit digits.\n Assume the input is always valid.\n Examples:\n multiply(148, 412) should return 16.\n multiply(19, 28) should return 72.\n multiply(2020, 1851) should return 0.\n multiply(14,-15) should return 20.\n \"\"\"\n # Extract the unit digits of both numbers\n unit_digit_a = abs(a) % 10\n unit_digit_b = abs(b) % 10\n \n # Return the product of the unit digits\n return unit_digit_a * unit_digit_b\n\n# Test cases\nprint(multiply(148, 412)) # Expected output: 16\nprint(multiply(19, 28)) # Expected output: 72\nprint(multiply(2020, 1851))# Expected output: 0\nprint(multiply(14, -15)) # Expected output: 20\n```"}
{"task_id": "HumanEval/98", "solution": "```\npython\ndef count_upper(s):\n \"\"\"\n Given a string s, count the number of uppercase vowels in even indices.\n \n For example:\n count_upper('aBCdEf') returns 1\n count_upper('abcdefg') returns 0\n count_upper('dBBE') returns 0\n \"\"\"\n # Define the set of uppercase vowels\n uppercase_vowels = {'A', 'E', 'I', 'O', 'U'}\n \n # Initialize a counter for uppercase vowels at even indices\n count = 0\n \n # Iterate over the string, considering only even indices\n for i in range(0, len(s), 2):\n if s[i] in uppercase_vowels:\n count += 1\n \n return count\n\n# Test cases to verify the correctness of the function\nassert count_upper('aBCdEf') == 1\nassert count_upper('abcdefg') == 0\nassert count_upper('dBBE') == 0\n```"}
{"task_id": "HumanEval/99", "solution": "```\npython\ndef closest_integer(value):\n \"\"\"\n Create a function that takes a value (string) representing a number\n and returns the closest integer to it. If the number is equidistant\n from two integers, round it away from zero.\n\n Examples\n >>> closest_integer(\"10\")\n 10\n >>> closest_integer(\"15.3\")\n 15\n\n Note:\n Rounding away from zero means that if the given number is equidistant\n from two integers, the one you should return is the one that is the\n farthest from zero. For example closest_integer(\"14.5\") should\n return 15 and closest_integer(\"-14.5\") should return -15.\n \"\"\"\n num = float(value)\n if abs(num - round(num)) == 0.5:\n return int(num + (num > 0))\n else:\n return round(num)\n\n# Test cases\nprint(closest_integer(\"10\")) # Output: 10\nprint(closest_integer(\"15.3\")) # Output: 15\nprint(closest_integer(\"14.5\")) # Output: 15\nprint(closest_integer(\"-14.5\")) # Output: -15\n```"}
{"task_id": "HumanEval/100", "solution": "```\npython\ndef make_a_pile(n):\n \"\"\"\n Given a positive integer n, you have to make a pile of n levels of stones.\n The first level has n stones.\n The number of stones in the next level is:\n - the next odd number if n is odd.\n - the next even number if n is even.\n Return the number of stones in each level in a list, where element at index\n i represents the number of stones in the level (i+1).\n\n Examples:\n >>> make_a_pile(3)\n [3, 5, 7]\n \"\"\"\n pile = []\n current_stones = n\n for _ in range(n):\n pile.append(current_stones)\n if n % 2 == 0: # If n is even\n current_stones += 2 # Next even number\n else: # If n is odd\n current_stones += 2 # Next odd number\n return pile\n\n# Check function to verify the correctness of the solution\ndef check_solution():\n assert make_a_pile(3) == [3, 5, 7], \"Test case 1 failed\"\n assert make_a_pile(4) == [4, 6, 8, 10], \"Test case 2 failed\"\n assert make_a_pile(1) == [1], \"Test case 3 failed\"\n print(\"All test cases passed!\")\n\ncheck_solution()\n```"}
{"task_id": "HumanEval/101", "solution": "```\npython\ndef words_string(s):\n \"\"\"\n You will be given a string of words separated by commas or spaces. Your task is\n to split the string into words and return an array of the words.\n \n For example:\n words_string(\"Hi, my name is John\") == [\"Hi\", \"my\", \"name\", \"is\", \"John\"]\n words_string(\"One, two, three, four, five, six\") == [\"One\", \"two\", \"three\", \"four\", \"five\", \"six\"]\n \"\"\"\n # Split the string by either comma or space and return the result\n return s.replace(',', ' ').split()\n```"}
{"task_id": "HumanEval/102", "solution": "```\npython\ndef choose_num(x, y):\n \"\"\"This function takes two positive numbers x and y and returns the\n biggest even integer number that is in the range [x, y] inclusive. If \n there's no such number, then the function should return -1.\n\n For example:\n choose_num(12, 15) = 14\n choose_num(13, 12) = -1\n \"\"\"\n if x > y:\n return -1\n # Start from y and go down to x, looking for the first even number\n for num in range(y, x - 1, -1):\n if num % 2 == 0:\n return num\n return -1\n\n# Test cases\nprint(choose_num(12, 15)) # Expected output: 14\nprint(choose_num(13, 12)) # Expected output: -1\n```"}
{"task_id": "HumanEval/103", "solution": "```\npython\ndef rounded_avg(n, m):\n if n > m:\n return -1\n total = sum(range(n, m + 1))\n count = m - n + 1\n average = round(total / count)\n return bin(average)\n\n# Test cases\nprint(rounded_avg(1, 5)) # Output: \"0b11\"\nprint(rounded_avg(7, 5)) # Output: -1\nprint(rounded_avg(10, 20)) # Output: \"0b1111\"\nprint(rounded_avg(20, 33)) # Output: \"0b11010\"\n```"}
{"task_id": "HumanEval/104", "solution": "```\npython\ndef unique_digits(x):\n \"\"\"Given a list of positive integers x. return a sorted list of all \n elements that hasn't any even digit.\n\n Note: Returned list should be sorted in increasing order.\n \n For example:\n >>> unique_digits([15, 33, 1422, 1])\n [1, 15, 33]\n >>> unique_digits([152, 323, 1422, 10])\n []\n \"\"\"\n def has_no_even_digit(num):\n return all(int(digit) % 2 != 0 for digit in str(num))\n \n result = [num for num in x if has_no_even_digit(num)]\n return sorted(result)\n\n# Test cases\nprint(unique_digits([15, 33, 1422, 1])) # Output: [1, 15, 33]\nprint(unique_digits([152, 323, 1422, 10])) # Output: []\n```"}
{"task_id": "HumanEval/105", "solution": "```\npython\ndef by_length(arr):\n # Define the mapping from digits to their names\n digit_to_name = {\n 1: \"One\", 2: \"Two\", 3: \"Three\", 4: \"Four\",\n 5: \"Five\", 6: \"Six\", 7: \"Seven\", 8: \"Eight\", 9: \"Nine\"\n }\n \n # Filter out numbers that are not between 1 and 9\n filtered_arr = [num for num in arr if 1 <= num <= 9]\n \n # Sort the filtered array\n sorted_arr = sorted(filtered_arr)\n \n # Reverse the sorted array\n reversed_arr = sorted_arr[::-1]\n \n # Replace each digit with its corresponding name\n result = [digit_to_name[num] for num in reversed_arr]\n \n return result\n\n# Example usage:\narr = [2, 1, 1, 4, 5, 8, 2, 3]\nprint(by_length(arr)) # Output: [\"Eight\", \"Five\", \"Four\", \"Three\", \"Two\", \"Two\", \"One\", \"One\"]\n\narr = []\nprint(by_length(arr)) # Output: []\n\narr = [1, -1, 55]\nprint(by_length(arr)) # Output: ['One']\n```"}
{"task_id": "HumanEval/106", "solution": "```\npython\ndef f(n):\n def factorial(x):\n if x == 0 or x == 1:\n return 1\n else:\n return x * factorial(x - 1)\n \n def sum_to_i(i):\n return i * (i + 1) // 2\n \n result = []\n for i in range(1, n + 1):\n if i % 2 == 0:\n result.append(factorial(i))\n else:\n result.append(sum_to_i(i))\n \n return result\n\n# Test the function\nprint(f(5)) # Output: [1, 2, 6, 24, 15]\n```"}
{"task_id": "HumanEval/107", "solution": "```\npython\ndef is_palindrome(num):\n return str(num) == str(num)[::-1]\n\ndef even_odd_palindrome(n):\n even_count = 0\n odd_count = 0\n\n for i in range(1, n + 1):\n if is_palindrome(i):\n if i % 2 == 0:\n even_count += 1\n else:\n odd_count += 1\n\n return (even_count, odd_count)\n\n# Example usage:\nprint(even_odd_palindrome(3)) # Output: (1, 2)\nprint(even_odd_palindrome(12)) # Output: (4, 6)\n```"}
{"task_id": "HumanEval/108", "solution": "```\npython\ndef count_nums(arr):\n def sum_of_digits(n):\n if n >= 0:\n return sum(int(digit) for digit in str(n))\n else:\n digits = [int(d) for d in str(n)[1:]]\n digits[0] *= -1\n return sum(digits)\n\n count = 0\n for num in arr:\n if sum_of_digits(num) > 0:\n count += 1\n return count\n\n# Test cases\nassert count_nums([]) == 0\nassert count_nums([-1, 11, -11]) == 1\nassert count_nums([1, 1, 2]) == 3\n```"}
{"task_id": "HumanEval/109", "solution": "```\npython\ndef move_one_ball(arr):\n if not arr:\n return True\n \n n = len(arr)\n sorted_arr = sorted(arr)\n \n for i in range(n):\n if arr == sorted_arr:\n return True\n arr.insert(0, arr.pop())\n \n return False\n\n# Test cases\nprint(move_one_ball([3, 4, 5, 1, 2])) # Output: True\nprint(move_one_ball([3, 5, 4, 1, 2])) # Output: False\n```"}
{"task_id": "HumanEval/110", "solution": "```\npython\ndef exchange(lst1, lst2):\n \"\"\"In this problem, you will implement a function that takes two lists of numbers,\n and determines whether it is possible to perform an exchange of elements\n between them to make lst1 a list of only even numbers.\n There is no limit on the number of exchanged elements between lst1 and lst2.\n If it is possible to exchange elements between the lst1 and lst2 to make\n all the elements of lst1 to be even, return \"YES\".\n Otherwise, return \"NO\".\n For example:\n exchange([1, 2, 3, 4], [1, 2, 3, 4]) => \"YES\"\n exchange([1, 2, 3, 4], [1, 5, 3, 4]) => \"NO\"\n It is assumed that the input lists will be non-empty.\n \"\"\"\n # Count the number of odd elements in lst1\n odd_count = sum(1 for x in lst1 if x % 2 != 0)\n \n # Count the number of even elements in lst2\n even_count_in_lst2 = sum(1 for x in lst2 if x % 2 == 0)\n \n # If there are enough even elements in lst2 to exchange with all odd elements in lst1, return \"YES\"\n if even_count_in_lst2 >= odd_count:\n return \"YES\"\n else:\n return \"NO\"\n\n# Test cases\nprint(exchange([1, 2, 3, 4], [1, 2, 3, 4])) # Output: \"YES\"\nprint(exchange([1, 2, 3, 4], [1, 5, 3, 4])) # Output: \"NO\"\n```"}
{"task_id": "HumanEval/111", "solution": "```\npython\nfrom collections import Counter\n\ndef histogram(test):\n \"\"\"Given a string representing a space separated lowercase letters, return a dictionary\n of the letter with the most repetition and containing the corresponding count.\n If several letters have the same occurrence, return all of them.\n \n Example:\n histogram('a b c') == {'a': 1, 'b': 1, 'c': 1}\n histogram('a b b a') == {'a': 2, 'b': 2}\n histogram('a b c a b') == {'a': 2, 'b': 2}\n histogram('b b b b a') == {'b': 4}\n histogram('') == {}\n\n \"\"\"\n # Split the input string into individual letters\n letters = test.split()\n \n # Count the occurrences of each letter\n letter_counts = Counter(letters)\n \n if not letter_counts:\n return {}\n \n # Find the maximum occurrence count\n max_count = max(letter_counts.values())\n \n # Filter the dictionary to include only letters with the maximum count\n result = {letter: count for letter, count in letter_counts.items() if count == max_count}\n \n return result\n\n# Test cases\nprint(histogram('a b c')) # {'a': 1, 'b': 1, 'c': 1}\nprint(histogram('a b b a')) # {'a': 2, 'b': 2}\nprint(histogram('a b c a b')) # {'a': 2, 'b': 2}\nprint(histogram('b b b b a')) # {'b': 4}\nprint(histogram('')) # {}\n```"}
{"task_id": "HumanEval/112", "solution": "```\npython\ndef reverse_delete(s, c):\n # Remove characters from s that are in c\n result = ''.join([char for char in s if char not in c])\n \n # Check if the resulting string is a palindrome\n is_palindrome = result == result[::-1]\n \n return (result, is_palindrome)\n\n# Test cases\nprint(reverse_delete(\"abcde\", \"ae\")) # ('bcd', False)\nprint(reverse_delete(\"abcdef\", \"b\")) # ('acdef', False)\nprint(reverse_delete(\"abcdedcba\", \"ab\")) # ('cdedc', True)\n```"}
{"task_id": "HumanEval/113", "solution": "```\npython\ndef odd_count(lst):\n \"\"\"Given a list of strings, where each string consists of only digits, return a list.\n Each element i of the output should be \"the number of odd elements in the\n string i of the input.\" where all the i's should be replaced by the number\n of odd digits in the i'th string of the input.\n\n >>> odd_count(['1234567'])\n [\"the number of odd elements 4n the str4ng 4 of the 4nput.\"]\n >>> odd_count(['3',\"11111111\"])\n [\"the number of odd elements 1n the str1ng 1 of the 1nput.\",\n \"the number of odd elements 8n the str8ng 8 of the 8nput.\"]\n \"\"\"\n result = []\n for s in lst:\n count = sum(1 for char in s if int(char) % 2 != 0)\n output = f\"the number of odd elements {count}n the str{count}ng {count} of the {count}nput.\"\n result.append(output)\n return result\n\n# Test cases\nprint(odd_count(['1234567'])) # [\"the number of odd elements 4n the str4ng 4 of the 4nput.\"]\nprint(odd_count(['3', \"11111111\"])) # [\"the number of odd elements 1n the str1ng 1 of the 1nput.\", \"the number of odd elements 8n the str8ng 8 of the 8nput.\"]\n```"}
{"task_id": "HumanEval/114", "solution": "```\npython\ndef minSubArraySum(nums):\n \"\"\"\n Given an array of integers nums, find the minimum sum of any non-empty sub-array\n of nums.\n Example\n minSubArraySum([2, 3, 4, 1, 2, 4]) == 1\n minSubArraySum([-1, -2, -3]) == -6\n \"\"\"\n if not nums:\n return 0\n \n min_sum = float('inf')\n current_sum = 0\n \n for num in nums:\n current_sum = min(num, current_sum + num)\n min_sum = min(min_sum, current_sum)\n \n return min_sum\n\n# Test cases\nprint(minSubArraySum([2, 3, 4, 1, 2, 4])) # Output: 1\nprint(minSubArraySum([-1, -2, -3])) # Output: -6\n```"}
{"task_id": "HumanEval/115", "solution": "```\npython\nimport math\n\ndef max_fill(grid, capacity):\n total_water = sum(sum(row) for row in grid)\n return math.ceil(total_water / capacity)\n\n# Example usage:\ngrid1 = [[0,0,1,0], [0,1,0,0], [1,1,1,1]]\nbucket_capacity1 = 1\nprint(max_fill(grid1, bucket_capacity1)) # Output: 6\n\ngrid2 = [[0,0,1,1], [0,0,0,0], [1,1,1,1], [0,1,1,1]]\nbucket_capacity2 = 2\nprint(max_fill(grid2, bucket_capacity2)) # Output: 5\n\ngrid3 = [[0,0,0], [0,0,0]]\nbucket_capacity3 = 5\nprint(max_fill(grid3, bucket_capacity3)) # Output: 0\n```"}
{"task_id": "HumanEval/116", "solution": "```\npython\ndef sort_array(arr):\n return sorted(arr, key=lambda x: (bin(x).count('1'), x))\n\n# Test cases\nprint(sort_array([1, 5, 2, 3, 4])) # Output: [1, 2, 3, 4, 5]\nprint(sort_array([-2, -3, -4, -5, -6])) # Output: [-6, -5, -4, -3, -2]\nprint(sort_array([1, 0, 2, 3, 4])) # Output: [0, 1, 2, 3, 4]\n```"}
{"task_id": "HumanEval/117", "solution": "```\npython\ndef select_words(s, n):\n \"\"\"Given a string s and a natural number n, you have been tasked to implement \n a function that returns a list of all words from string s that contain exactly \n n consonants, in order these words appear in the string s.\n If the string s is empty then the function should return an empty list.\n Note: you may assume the input string contains only letters and spaces.\n Examples:\n select_words(\"Mary had a little lamb\", 4) ==> [\"little\"]\n select_words(\"Mary had a little lamb\", 3) ==> [\"Mary\", \"lamb\"]\n select_words(\"simple white space\", 2) ==> []\n select_words(\"Hello world\", 4) ==> [\"world\"]\n select_words(\"Uncle sam\", 3) ==> [\"Uncle\"]\n \"\"\"\n # Define vowels for comparison\n vowels = 'aeiouAEIOU'\n # Split the string into words\n words = s.split()\n # Initialize an empty list to store the result\n result = []\n \n # Iterate over each word in the list\n for word in words:\n # Count the number of consonants in the current word\n consonant_count = sum(1 for char in word if char.isalpha() and char not in vowels)\n # If the count matches n, add the word to the result list\n if consonant_count == n:\n result.append(word)\n \n return result\n\n# Test cases\nprint(select_words(\"Mary had a little lamb\", 4)) # [\"little\"]\nprint(select_words(\"Mary had a little lamb\", 3)) # [\"Mary\", \"lamb\"]\nprint(select_words(\"simple white space\", 2)) # []\nprint(select_words(\"Hello world\", 4)) # [\"world\"]\nprint(select_words(\"Uncle sam\", 3)) # [\"Uncle\"]\n```"}
{"task_id": "HumanEval/118", "solution": "```\npython\ndef get_closest_vowel(word):\n vowels = \"aeiouAEIOU\"\n for i in range(len(word) - 2, 0, -1):\n if word[i] in vowels and word[i-1] not in vowels and word[i+1] not in vowels:\n return word[i]\n return \"\"\n\n# Test cases\nprint(get_closest_vowel(\"yogurt\")) # Output: \"u\"\nprint(get_closest_vowel(\"FULL\")) # Output: \"U\"\nprint(get_closest_vowel(\"quick\")) # Output: \"\"\nprint(get_closest_vowel(\"ab\")) # Output: \"\"\n```"}
{"task_id": "HumanEval/119", "solution": "```\npython\ndef match_parens(lst):\n def is_balanced(s):\n balance = 0\n for char in s:\n if char == '(':\n balance += 1\n else:\n balance -= 1\n if balance < 0:\n return False\n return balance == 0\n\n first_order = lst[0] + lst[1]\n second_order = lst[1] + lst[0]\n return 'Yes' if is_balanced(first_order) or is_balanced(second_order) else 'No'\n\n# Test cases\nprint(match_parens(['()(', ')'])) # Output: 'Yes'\nprint(match_parens([')', ')'])) # Output: 'No'\n```"}
{"task_id": "HumanEval/120", "solution": "```\npython\ndef maximum(arr, k):\n # Sort the array in descending order\n arr.sort(reverse=True)\n # Return the first k elements of the sorted array\n return arr[:k]\n\n# Test cases\nprint(maximum([-3, -4, 5], 3)) # Output: [-4, -3, 5]\nprint(maximum([4, -4, 4], 2)) # Output: [4, 4]\nprint(maximum([-3, 2, 1, 2, -1, -2, 1], 1)) # Output: [2]\n```"}
{"task_id": "HumanEval/121", "solution": "```\npython\ndef solution(lst):\n \"\"\"Given a non-empty list of integers, return the sum of all of the odd elements that are in even positions.\n \n\n Examples\n solution([5, 8, 7, 1]) ==> 12\n solution([3, 3, 3, 3, 3]) ==> 9\n solution([30, 13, 24, 321]) ==>0\n \"\"\"\n return sum(x for i, x in enumerate(lst) if i % 2 == 1 and x % 2 == 1)\n```"}
{"task_id": "HumanEval/122", "solution": "```\npython\ndef add_elements(arr, k):\n \"\"\"\n Given a non-empty array of integers arr and an integer k, return\n the sum of the elements with at most two digits from the first k elements of arr.\n\n Example:\n\n Input: arr = [111,21,3,4000,5,6,7,8,9], k = 4\n Output: 24 # sum of 21 + 3\n\n Constraints:\n 1. 1 <= len(arr) <= 100\n 2. 1 <= k <= len(arr)\n \"\"\"\n return sum(x for x in arr[:k] if -99 <= x <= 99)\n\n# Test the function\narr = [111, 21, 3, 4000, 5, 6, 7, 8, 9]\nk = 4\nprint(add_elements(arr, k)) # Output: 24\n```"}
{"task_id": "HumanEval/123", "solution": "```\npython\ndef get_odd_collatz(n):\n \"\"\"\n Given a positive integer n, return a sorted list that has the odd numbers in collatz sequence.\n\n The Collatz conjecture is a conjecture in mathematics that concerns a sequence defined\n as follows: start with any positive integer n. Then each term is obtained from the \n previous term as follows: if the previous term is even, the next term is one half of \n the previous term. If the previous term is odd, the next term is 3 times the previous\n term plus 1. The conjecture is that no matter what value of n, the sequence will always reach 1.\n\n Note: \n 1. Collatz(1) is [1].\n 2. returned list sorted in increasing order.\n\n For example:\n get_odd_collatz(5) returns [1, 5] # The collatz sequence for 5 is [5, 16, 8, 4, 2, 1], so the odd numbers are only 1, and 5.\n \"\"\"\n if n <= 0:\n raise ValueError(\"Input must be a positive integer\")\n \n collatz_sequence = []\n while n != 1:\n collatz_sequence.append(n)\n if n % 2 == 0:\n n = n // 2\n else:\n n = 3 * n + 1\n \n # Add the final number 1 to the sequence\n collatz_sequence.append(1)\n \n # Filter out the odd numbers and sort them\n odd_numbers = sorted([num for num in collatz_sequence if num % 2 != 0])\n \n return odd_numbers\n\n# Example usage:\nprint(get_odd_collatz(5)) # Output: [1, 5]\n```"}
{"task_id": "HumanEval/124", "solution": "```\npython\nfrom datetime import datetime\n\ndef valid_date(date):\n \"\"\"You have to write a function which validates a given date string and\n returns True if the date is valid otherwise False.\n The date is valid if all of the following rules are satisfied:\n 1. The date string is not empty.\n 2. The number of days is not less than 1 or higher than 31 days for months 1,3,5,7,8,10,12. And the number of days is not less than 1 or higher than 30 days for months 4,6,9,11. And, the number of days is not less than 1 or higher than 29 for the month 2.\n 3. The months should not be less than 1 or higher than 12.\n 4. The date should be in the format: mm-dd-yyyy\n\n for example: \n valid_date('03-11-2000') => True\n\n valid_date('15-01-2012') => False\n\n valid_date('04-0-2040') => False\n\n valid_date('06-04-2020') => True\n\n valid_date('06/04/2020') => False\n \"\"\"\n if not date:\n return False\n \n try:\n month, day, year = map(int, date.split('-'))\n except ValueError:\n return False\n \n if month < 1 or month > 12:\n return False\n \n if day < 1:\n return False\n \n if month in [4, 6, 9, 11] and day > 30:\n return False\n elif month == 2 and day > 29:\n return False\n elif month in [1, 3, 5, 7, 8, 10, 12] and day > 31:\n return False\n \n try:\n datetime(year, month, day)\n except ValueError:\n return False\n \n return True\n\n# Test cases\nprint(valid_date('03-11-2000')) # True\nprint(valid_date('15-01-2012')) # False\nprint(valid_date('04-0-2040')) # False\nprint(valid_date('06-04-2020')) # True\nprint(valid_date('06/04/2020')) # False\n```"}
{"task_id": "HumanEval/125", "solution": "```\npython\ndef split_words(txt):\n # Check for whitespace and split if present\n if ' ' in txt:\n return txt.split()\n # Check for commas and split if present\n elif ',' in txt:\n return txt.split(',')\n else:\n # Count the number of lowercase letters with odd order in the alphabet\n count = 0\n for char in txt:\n if char.islower() and (ord(char) - ord('a')) % 2 == 1:\n count += 1\n return count\n\n# Test cases\nprint(split_words(\"Hello world!\")) # \u279e [\"Hello\", \"world!\"]\nprint(split_words(\"Hello,world!\")) # \u279e [\"Hello\", \"world!\"]\nprint(split_words(\"abcdef\")) # \u279e 3\n```"}
{"task_id": "HumanEval/126", "solution": "```\npython\ndef is_sorted(lst):\n # Check if the list is empty or has one element, which is trivially sorted\n if len(lst) <= 1:\n return True\n \n # Initialize a variable to keep track of the previous number\n prev = lst[0]\n \n # Iterate through the list starting from the second element\n for num in lst[1:]:\n # Check if the current number is less than the previous one (not sorted)\n if num < prev:\n return False\n # Check for more than one duplicate of the same number\n elif num == prev:\n return False\n # Update the previous number to the current one\n prev = num\n \n # If no issues were found, the list is sorted\n return True\n\n# Test cases\nprint(is_sorted([5])) # \u279e True\nprint(is_sorted([1, 2, 3, 4, 5])) # \u279e True\nprint(is_sorted([1, 3, 2, 4, 5])) # \u279e False\nprint(is_sorted([1, 2, 3, 4, 5, 6])) # \u279e True\nprint(is_sorted([1, 2, 3, 4, 5, 6, 7])) # \u279e True\nprint(is_sorted([1, 3, 2, 4, 5, 6, 7])) # \u279e False\nprint(is_sorted([1, 2, 2, 3, 3, 4])) # \u279e True\nprint(is_sorted([1, 2, 2, 2, 3, 4])) # \u279e False\n```"}
{"task_id": "HumanEval/127", "solution": "```\npython\ndef is_prime(n):\n \"\"\"Helper function to check if a number is prime.\"\"\"\n if n <= 1:\n return False\n for i in range(2, int(n**0.5) + 1):\n if n % i == 0:\n return False\n return True\n\ndef intersection(interval1, interval2):\n \"\"\"Determine if the length of the intersection of two intervals is a prime number.\"\"\"\n start = max(interval1[0], interval2[0])\n end = min(interval1[1], interval2[1])\n \n if start > end:\n return \"NO\"\n \n length_of_intersection = end - start + 1\n return \"YES\" if is_prime(length_of_intersection) else \"NO\"\n\n# Test cases\nprint(intersection((1, 2), (2, 3))) # Output: \"NO\"\nprint(intersection((-1, 1), (0, 4))) # Output: \"NO\"\nprint(intersection((-3, -1), (-5, 5))) # Output: \"YES\"\n```"}
{"task_id": "HumanEval/128", "solution": "```\npython\ndef prod_signs(arr):\n if not arr:\n return None\n \n product_of_signs = 1\n sum_of_magnitudes = 0\n \n for num in arr:\n if num == 0:\n return 0\n elif num < 0:\n product_of_signs *= -1\n \n sum_of_magnitudes += abs(num)\n \n return sum_of_magnitudes * product_of_signs\n\n# Test cases\nprint(prod_signs([1, 2, 2, -4])) # Output: -9\nprint(prod_signs([0, 1])) # Output: 0\nprint(prod_signs([])) # Output: None\n```"}
{"task_id": "HumanEval/129", "solution": "```\npython\nfrom typing import List\n\ndef minPath(grid: List[List[int]], k: int) -> List[int]:\n N = len(grid)\n directions = [(0, 1), (1, 0), (-1, 0), (0, -1)]\n \n def dfs(x, y, path):\n if len(path) == k:\n paths.append(path[:])\n return\n for dx, dy in directions:\n nx, ny = x + dx, y + dy\n if 0 <= nx < N and 0 <= ny < N:\n dfs(nx, ny, path + [grid[nx][ny]])\n \n paths = []\n for i in range(N):\n for j in range(N):\n dfs(i, j, [grid[i][j]])\n \n return min(paths)\n\n# Example usage\nprint(minPath([[1,2,3], [4,5,6], [7,8,9]], 3)) # Output: [1, 2, 1]\nprint(minPath([[5,9,3], [4,1,6], [7,8,2]], 1)) # Output: [1]\n```"}
{"task_id": "HumanEval/130", "solution": "```\npython\ndef tri(n):\n if n == 0:\n return [1]\n elif n == 1:\n return [1, 3]\n \n tribonacci = [1, 3, 2] # Starting with the first three numbers of the Tribonacci sequence\n \n for i in range(3, n + 1):\n if i % 2 == 0:\n tribonacci.append(1 + i / 2)\n else:\n next_value = tribonacci[i - 1] + tribonacci[i - 2] + tribonacci[i - 3]\n tribonacci.append(next_value)\n \n return tribonacci\n\n# Example usage\nprint(tri(3)) # Output: [1, 3, 2, 8]\n```"}
{"task_id": "HumanEval/131", "solution": "```\npython\ndef digits(n):\n \"\"\"Given a positive integer n, return the product of the odd digits.\n Return 0 if all digits are even.\n For example:\n digits(1) == 1\n digits(4) == 0\n digits(235) == 15\n \"\"\"\n product = 1\n has_odd = False\n for digit in str(n):\n int_digit = int(digit)\n if int_digit % 2 == 1:\n product *= int_digit\n has_odd = True\n return product if has_odd else 0\n\n# Test cases\nprint(digits(1)) # Output: 1\nprint(digits(4)) # Output: 0\nprint(digits(235)) # Output: 15\n```"}
{"task_id": "HumanEval/132", "solution": "```\npython\ndef is_nested(string):\n stack = []\n nested = False\n \n for char in string:\n if char == '[':\n stack.append(char)\n elif char == ']' and stack:\n stack.pop()\n # If the stack is not empty after popping, it means there's a nested structure.\n if stack:\n nested = True\n \n return nested and not stack\n\n# Test cases\nprint(is_nested('[[]]')) # \u279e True\nprint(is_nested('[]]]]]]][[[[[]')) # \u279e False\nprint(is_nested('[][]')) # \u279e False\nprint(is_nested('[]')) # \u279e False\nprint(is_nested('[[][]]')) # \u279e True\nprint(is_nested('[[]][[')) # \u279e True\n```"}
{"task_id": "HumanEval/133", "solution": "```\npython\nimport math\n\ndef sum_squares(lst):\n \"\"\"You are given a list of numbers.\n You need to return the sum of squared numbers in the given list,\n round each element in the list to the upper int(Ceiling) first.\n Examples:\n For lst = [1,2,3] the output should be 14\n For lst = [1,4,9] the output should be 98\n For lst = [1,3,5,7] the output should be 84\n For lst = [1.4,4.2,0] the output should be 29\n For lst = [-2.4,1,1] the output should be 6\n \n\n \"\"\"\n return sum(math.ceil(num) ** 2 for num in lst)\n\n# Test cases\nprint(sum_squares([1,2,3])) # Output: 14\nprint(sum_squares([1,4,9])) # Output: 98\nprint(sum_squares([1,3,5,7])) # Output: 84\nprint(sum_squares([1.4,4.2,0])) # Output: 29\nprint(sum_squares([-2.4,1,1])) # Output: 6\n```"}
{"task_id": "HumanEval/134", "solution": "```\npython\nimport re\n\ndef check_if_last_char_is_a_letter(txt):\n # Check if the last character is an alphabetical letter and not part of a word\n return bool(re.search(r'\\b[a-zA-Z]$', txt))\n\n# Test cases\nprint(check_if_last_char_is_a_letter(\"apple pie\")) # \u279e False\nprint(check_if_last_char_is_a_letter(\"apple pi e\")) # \u279e True\nprint(check_if_last_char_is_a_letter(\"apple pi e \")) # \u279e False\nprint(check_if_last_char_is_a_letter(\"\")) # \u279e False\n```"}
{"task_id": "HumanEval/135", "solution": "```\npython\ndef can_arrange(arr):\n \"\"\"Create a function which returns the largest index of an element which\n is not greater than or equal to the element immediately preceding it. If\n no such element exists then return -1. The given array will not contain\n duplicate values.\n\n Examples:\n can_arrange([1,2,4,3,5]) = 3\n can_arrange([1,2,3]) = -1\n \"\"\"\n for i in range(len(arr) - 1, 0, -1):\n if arr[i] < arr[i - 1]:\n return i\n return -1\n\n# Test cases\nprint(can_arrange([1, 2, 4, 3, 5])) # Expected output: 3\nprint(can_arrange([1, 2, 3])) # Expected output: -1\n```"}
{"task_id": "HumanEval/136", "solution": "```\npython\ndef largest_smallest_integers(lst):\n negative_ints = [x for x in lst if x < 0]\n positive_ints = [x for x in lst if x > 0]\n\n largest_negative = max(negative_ints) if negative_ints else None\n smallest_positive = min(positive_ints) if positive_ints else None\n\n return (largest_negative, smallest_positive)\n\n# Test cases\nprint(largest_smallest_integers([2, 4, 1, 3, 5, 7])) # Output: (None, 1)\nprint(largest_smallest_integers([])) # Output: (None, None)\nprint(largest_smallest_integers([0])) # Output: (None, None)\n```"}
{"task_id": "HumanEval/137", "solution": "```\npython\ndef compare_one(a, b):\n # Helper function to convert string to float if necessary\n def to_float(val):\n if isinstance(val, str):\n val = val.replace(',', '.')\n return float(val)\n return val\n \n # Convert both values to floats for comparison\n a_float = to_float(a)\n b_float = to_float(b)\n \n # Compare the float values\n if a_float > b_float:\n return a\n elif b_float > a_float:\n return b\n else:\n return None\n\n# Test cases\nprint(compare_one(1, 2.5)) # \u279e 2.5\nprint(compare_one(1, \"2,3\")) # \u279e \"2,3\"\nprint(compare_one(\"5,1\", \"6\")) # \u279e \"6\"\nprint(compare_one(\"1\", 1)) # \u279e None\n```"}
{"task_id": "HumanEval/138", "solution": "```\npython\ndef is_equal_to_sum_even(n):\n \"\"\"Evaluate whether the given number n can be written as the sum of exactly 4 positive even numbers\n Example\n is_equal_to_sum_even(4) == False\n is_equal_to_sum_even(6) == False\n is_equal_to_sum_even(8) == True\n \"\"\"\n # Since the smallest sum of 4 positive even numbers is 2+2+2+2=8, any number less than 8 cannot be expressed as such.\n if n < 8:\n return False\n # If n is even and greater than or equal to 8, it can always be expressed as the sum of 4 even numbers.\n return n % 2 == 0\n\n# Test cases\nprint(is_equal_to_sum_even(4)) # Expected output: False\nprint(is_equal_to_sum_even(6)) # Expected output: False\nprint(is_equal_to_sum_even(8)) # Expected output: True\n```"}
{"task_id": "HumanEval/139", "solution": "```\npython\ndef brazilian_factorial(n):\n \"\"\"The Brazilian factorial is defined as:\n brazilian_factorial(n) = n! * (n-1)! * (n-2)! * ... * 1!\n where n > 0\n\n For example:\n >>> special_factorial(4)\n 288\n\n The function will receive an integer as input and should return the special\n factorial of this integer.\n \"\"\"\n result = 1\n for i in range(1, n + 1):\n factorial = 1\n for j in range(1, i + 1):\n factorial *= j\n result *= factorial\n return result\n\n# Check function to verify the correctness of the solution\ndef check_brazilian_factorial():\n assert brazilian_factorial(4) == 288, \"Test case 1 failed\"\n assert brazilian_factorial(5) == 34560, \"Test case 2 failed\"\n assert brazilian_factorial(6) == 24883200, \"Test case 3 failed\"\n print(\"All test cases passed!\")\n\n# Run the check function\ncheck_brazilian_factorial()\n```"}
{"task_id": "HumanEval/140", "solution": "```\npython\ndef fix_spaces(text):\n \"\"\"\n Given a string text, replace all spaces in it with underscores, \n and if a string has more than 2 consecutive spaces, \n then replace all consecutive spaces with - \n \n fix_spaces(\"Example\") == \"Example\"\n fix_spaces(\"Example 1\") == \"Example_1\"\n fix_spaces(\" Example 2\") == \"_Example_2\"\n fix_spaces(\" Example 3\") == \"_Example-3\"\n \"\"\"\n result = []\n space_count = 0\n\n for char in text:\n if char == ' ':\n space_count += 1\n else:\n if space_count > 2:\n result.append('-')\n elif space_count > 0:\n result.extend(['_'] * space_count)\n result.append(char)\n space_count = 0\n\n # Handle trailing spaces\n if space_count > 2:\n result.append('-')\n elif space_count > 0:\n result.extend(['_'] * space_count)\n\n return ''.join(result)\n\n# Test cases\nprint(fix_spaces(\"Example\")) # Output: \"Example\"\nprint(fix_spaces(\"Example 1\")) # Output: \"Example_1\"\nprint(fix_spaces(\" Example 2\")) # Output: \"_Example_2\"\nprint(fix_spaces(\" Example 3\")) # Output: \"_Example-3\"\n```"}
{"task_id": "HumanEval/141", "solution": "```\npython\nimport re\n\ndef file_name_check(file_name):\n \"\"\"Create a function which takes a string representing a file's name, and returns\n 'Yes' if the the file's name is valid, and returns 'No' otherwise.\n A file's name is considered to be valid if and only if all the following conditions \n are met:\n - There should not be more than three digits ('0'-'9') in the file's name.\n - The file's name contains exactly one dot '.'\n - The substring before the dot should not be empty, and it starts with a letter from \n the latin alphapet ('a'-'z' and 'A'-'Z').\n - The substring after the dot should be one of these: ['txt', 'exe', 'dll']\n Examples:\n file_name_check(\"example.txt\") # => 'Yes'\n file_name_check(\"1example.dll\") # => 'No' (the name should start with a latin alphapet letter)\n \"\"\"\n # Regular expression to match the file name criteria\n pattern = r'^[a-zA-Z][^\\d]*\\d{0,3}[^\\d]*\\.(txt|exe|dll)$'\n \n # Check if the file name matches the pattern\n if re.match(pattern, file_name):\n return 'Yes'\n else:\n return 'No'\n\n# Test cases\nprint(file_name_check(\"example.txt\")) # => 'Yes'\nprint(file_name_check(\"1example.dll\")) # => 'No' (the name should start with a latin alphapet letter)\nprint(file_name_check(\"file1234.txt\")) # => 'No' (more than three digits)\nprint(file_name_check(\".txt\")) # => 'No' (empty substring before the dot)\nprint(file_name_check(\"example.doc\")) # => 'No' (invalid extension)\n```"}
{"task_id": "HumanEval/142", "solution": "```\npython\ndef sum_squares(lst):\n total_sum = 0\n for index, value in enumerate(lst):\n if index % 3 == 0:\n total_sum += value ** 2\n elif index % 4 == 0 and index % 3 != 0:\n total_sum += value ** 3\n else:\n total_sum += value\n return total_sum\n\n# Test cases\nprint(sum_squares([1, 2, 3])) # Output should be 6\nprint(sum_squares([])) # Output should be 0\nprint(sum_squares([-1, -5, 2, -1, -5])) # Output should be -126\n```"}
{"task_id": "HumanEval/143", "solution": "```\npython\ndef is_prime(n):\n \"\"\"Check if a number is prime.\"\"\"\n if n <= 1:\n return False\n for i in range(2, int(n**0.5) + 1):\n if n % i == 0:\n return False\n return True\n\ndef words_in_sentence(sentence):\n \"\"\"\n You are given a string representing a sentence,\n the sentence contains some words separated by a space,\n and you have to return a string that contains the words from the original sentence,\n whose lengths are prime numbers,\n the order of the words in the new string should be the same as the original one.\n\n Example 1:\n Input: sentence = \"This is a test\"\n Output: \"is\"\n\n Example 2:\n Input: sentence = \"lets go for swimming\"\n Output: \"go for\"\n\n Constraints:\n * 1 <= len(sentence) <= 100\n * sentence contains only letters\n \"\"\"\n words = sentence.split()\n prime_length_words = [word for word in words if is_prime(len(word))]\n return ' '.join(prime_length_words)\n\n# Check function to verify the correctness of the solution\ndef check():\n assert words_in_sentence(\"This is a test\") == \"is\"\n assert words_in_sentence(\"lets go for swimming\") == \"go for\"\n print(\"All tests passed!\")\n\ncheck()\n```"}
{"task_id": "HumanEval/144", "solution": "```\npython\ndef simplify(x, n):\n # Split the fractions into numerator and denominator\n x_num, x_den = map(int, x.split('/'))\n n_num, n_den = map(int, n.split('/'))\n \n # Calculate the product of the numerators and denominators\n product_num = x_num * n_num\n product_den = x_den * n_den\n \n # Check if the product is a whole number by seeing if the numerator is divisible by the denominator\n return product_num % product_den == 0\n\n# Test cases\nprint(simplify(\"1/5\", \"5/1\")) # Expected output: True\nprint(simplify(\"1/6\", \"2/1\")) # Expected output: False\nprint(simplify(\"7/10\", \"10/2\")) # Expected output: False\n```"}
{"task_id": "HumanEval/145", "solution": "```\npython\ndef order_by_points(nums):\n def digit_sum(n):\n return sum(int(digit) for digit in str(abs(n)))\n \n return sorted(nums, key=lambda x: (digit_sum(x), nums.index(x)))\n\n# Test cases\nprint(order_by_points([1, 11, -1, -11, -12])) # Output: [-1, -11, 1, -12, 11]\nprint(order_by_points([])) # Output: []\n```"}
{"task_id": "HumanEval/146", "solution": "```\npython\ndef specialFilter(nums):\n def is_odd_and_greater_than_10(num):\n if num <= 10:\n return False\n str_num = str(abs(num))\n return int(str_num[0]) % 2 == 1 and int(str_num[-1]) % 2 == 1\n\n count = sum(is_odd_and_greater_than_10(num) for num in nums)\n return count\n\n# Test cases\nprint(specialFilter([15, -73, 14, -15])) # Output: 1\nprint(specialFilter([33, -2, -3, 45, 21, 109])) # Output: 2\n```"}
{"task_id": "HumanEval/147", "solution": "```\npython\ndef get_max_triples(n):\n def calculate_a(i):\n return i * i - i + 1\n\n a = [calculate_a(i) for i in range(1, n + 1)]\n \n count = 0\n for i in range(n):\n for j in range(i + 1, n):\n for k in range(j + 1, n):\n if (a[i] + a[j] + a[k]) % 3 == 0:\n count += 1\n \n return count\n\n# Example usage\nn = 5\nprint(get_max_triples(n)) # Output: 1\n```"}
{"task_id": "HumanEval/148", "solution": "```\npython\ndef bf(planet1, planet2):\n planets = [\"Mercury\", \"Venus\", \"Earth\", \"Mars\", \"Jupiter\", \"Saturn\", \"Uranus\", \"Neptune\"]\n if planet1 not in planets or planet2 not in planets:\n return ()\n \n index1, index2 = planets.index(planet1), planets.index(planet2)\n \n if index1 > index2:\n index1, index2 = index2, index1\n \n return tuple(planets[index1 + 1:index2])\n\n# Test cases\nprint(bf(\"Jupiter\", \"Neptune\")) # Output: (\"Saturn\", \"Uranus\")\nprint(bf(\"Earth\", \"Mercury\")) # Output: (\"Venus\")\nprint(bf(\"Mercury\", \"Uranus\")) # Output: (\"Venus\", \"Earth\", \"Mars\", \"Jupiter\", \"Saturn\")\n```"}
{"task_id": "HumanEval/149", "solution": "```\npython\ndef sorted_list_sum(lst):\n # Filter out strings with odd lengths\n even_length_lst = [word for word in lst if len(word) % 2 == 0]\n \n # Sort the list by length, and then alphabetically for words of the same length\n even_length_lst.sort(key=lambda x: (len(x), x))\n \n return even_length_lst\n\n# Test cases\nassert sorted_list_sum([\"aa\", \"a\", \"aaa\"]) == [\"aa\"]\nassert sorted_list_sum([\"ab\", \"a\", \"aaa\", \"cd\"]) == [\"ab\", \"cd\"]\n```"}
{"task_id": "HumanEval/150", "solution": "```\npython\ndef is_prime(num):\n \"\"\"Helper function to check if a number is prime.\"\"\"\n if num <= 1:\n return False\n for i in range(2, int(num**0.5) + 1):\n if num % i == 0:\n return False\n return True\n\ndef x_or_y(n, x, y):\n \"\"\"A simple program which should return the value of x if n is \n a prime number and should return the value of y otherwise.\n\n Examples:\n for x_or_y(7, 34, 12) == 34\n for x_or_y(15, 8, 5) == 5\n \n \"\"\"\n return x if is_prime(n) else y\n\n# Check function to verify the correctness of the solution\ndef check():\n assert x_or_y(7, 34, 12) == 34, \"Test case 1 failed\"\n assert x_or_y(15, 8, 5) == 5, \"Test case 2 failed\"\n assert x_or_y(2, 10, 3) == 10, \"Test case 3 failed\"\n assert x_or_y(4, 7, 2) == 2, \"Test case 4 failed\"\n print(\"All test cases passed!\")\n\ncheck()\n```"}
{"task_id": "HumanEval/151", "solution": "```\npython\ndef double_the_difference(lst):\n # Filter out negative numbers and non-integers\n filtered_nums = [num for num in lst if num >= 0 and isinstance(num, int)]\n \n # Filter out even numbers\n odd_nums = [num for num in filtered_nums if num % 2 != 0]\n \n # Calculate the sum of squares of the odd numbers\n result = sum([num ** 2 for num in odd_nums])\n \n return result\n\n# Test cases\nprint(double_the_difference([1, 3, 2, 0])) # Output: 10\nprint(double_the_difference([-1, -2, 0])) # Output: 0\nprint(double_the_difference([9, -2])) # Output: 81\nprint(double_the_difference([0])) # Output: 0\nprint(double_the_difference([])) # Output: 0\n```"}
{"task_id": "HumanEval/152", "solution": "```\npython\ndef compare(game, guess):\n # Initialize an empty list to store the differences\n differences = []\n \n # Iterate through each match and its corresponding guess\n for i in range(len(game)):\n # Calculate the absolute difference between the game score and the guess\n diff = abs(game[i] - guess[i])\n # Append the difference to the list\n differences.append(diff)\n \n # Return the list of differences\n return differences\n\n# Test cases\nprint(compare([1,2,3,4,5,1],[1,2,3,4,2,-2])) # Output: [0,0,0,0,3,3]\nprint(compare([0,5,0,0,0,4],[4,1,1,0,0,-2])) # Output: [4,4,1,0,0,6]\n```"}
{"task_id": "HumanEval/153", "solution": "```\npython\ndef Strongest_Extension(class_name, extensions):\n def calculate_strength(extension):\n CAP = sum(1 for char in extension if char.isupper())\n SM = sum(1 for char in extension if char.islower())\n return CAP - SM\n\n strongest_extension = max(extensions, key=calculate_strength)\n return f\"{class_name}.{strongest_extension}\"\n```"}
{"task_id": "HumanEval/154", "solution": "```\npython\ndef cycpattern_check(a, b):\n \"\"\"You are given 2 words. You need to return True if the second word or any of its rotations is a substring in the first word\n cycpattern_check(\"abcd\",\"abd\") => False\n cycpattern_check(\"hello\",\"ell\") => True\n cycpattern_check(\"whassup\",\"psus\") => False\n cycpattern_check(\"abab\",\"baa\") => True\n cycpattern_check(\"efef\",\"eeff\") => False\n cycpattern_check(\"himenss\",\"simen\") => True\n\n \"\"\"\n if b in a:\n return True\n for i in range(1, len(b)):\n rotated_b = b[i:] + b[:i]\n if rotated_b in a:\n return True\n return False\n\n# Test cases\nprint(cycpattern_check(\"abcd\", \"abd\")) # => False\nprint(cycpattern_check(\"hello\", \"ell\")) # => True\nprint(cycpattern_check(\"whassup\", \"psus\")) # => False\nprint(cycpattern_check(\"abab\", \"baa\")) # => True\nprint(cycpattern_check(\"efef\", \"eeff\")) # => False\nprint(cycpattern_check(\"himenss\", \"simen\")) # => True\n```"}
{"task_id": "HumanEval/155", "solution": "```\npython\ndef even_odd_count(num):\n \"\"\"Given an integer. return a tuple that has the number of even and odd digits respectively.\n\n Example:\n even_odd_count(-12) ==> (1, 1)\n even_odd_count(123) ==> (1, 2)\n \"\"\"\n # Convert the number to its absolute value and then to a string\n num_str = str(abs(num))\n \n # Initialize counters for even and odd digits\n even_count = 0\n odd_count = 0\n \n # Iterate through each character in the string representation of the number\n for char in num_str:\n digit = int(char)\n \n # Check if the digit is even or odd and update the respective counter\n if digit % 2 == 0:\n even_count += 1\n else:\n odd_count += 1\n \n # Return a tuple containing the counts of even and odd digits\n return (even_count, odd_count)\n\n# Example usage:\nprint(even_odd_count(-12)) # Output: (1, 1)\nprint(even_odd_count(123)) # Output: (1, 2)\n```"}
{"task_id": "HumanEval/156", "solution": "```\npython\ndef int_to_mini_roman(number):\n \"\"\"\n Given a positive integer, obtain its roman numeral equivalent as a string,\n and return it in lowercase.\n Restrictions: 1 <= num <= 1000\n\n Examples:\n >>> int_to_mini_roman(19) == 'xix'\n >>> int_to_mini_roman(152) == 'clii'\n >>> int_to_mini_roman(426) == 'cdxxvi'\n \"\"\"\n val = [\n 1000, 900, 500, 400,\n 100, 90, 50, 40,\n 10, 9, 5, 4,\n 1\n ]\n syms = [\n \"m\", \"cm\", \"d\", \"cd\",\n \"c\", \"xc\", \"l\", \"xl\",\n \"x\", \"ix\", \"v\", \"iv\",\n \"i\"\n ]\n roman_numeral = ''\n i = 0\n while number > 0:\n for _ in range(number // val[i]):\n roman_numeral += syms[i]\n number -= val[i]\n i += 1\n return roman_numeral\n\n# Check function to verify the correctness of the solution\ndef check():\n assert int_to_mini_roman(19) == 'xix'\n assert int_to_mini_roman(152) == 'clii'\n assert int_to_mini_roman(426) == 'cdxxvi'\n print(\"All tests passed!\")\n\ncheck()\n```"}
{"task_id": "HumanEval/157", "solution": "```\npython\ndef right_angle_triangle(a, b, c):\n # Sort the sides to ensure the longest side is last (hypotenuse)\n sides = sorted([a, b, c])\n # Check if the Pythagorean theorem holds for these sides\n return sides[0]**2 + sides[1]**2 == sides[2]**2\n\n# Test cases\nprint(right_angle_triangle(3, 4, 5)) # Expected output: True\nprint(right_angle_triangle(1, 2, 3)) # Expected output: False\n```"}
{"task_id": "HumanEval/158", "solution": "```\npython\ndef find_max(words):\n \"\"\"Write a function that accepts a list of strings.\n The list contains different words. Return the word with maximum number\n of unique characters. If multiple strings have maximum number of unique\n characters, return the one which comes first in lexicographical order.\n\n find_max([\"name\", \"of\", \"string\"]) == \"string\"\n find_max([\"name\", \"enam\", \"game\"]) == \"enam\"\n find_max([\"aaaaaaa\", \"bb\" ,\"cc\"]) == \"aaaaaaa\"\n \"\"\"\n if not words:\n return \"\"\n\n # Sort the list lexicographically first to ensure that if there are multiple\n # words with the same number of unique characters, the one that comes first\n # in lexicographical order is returned.\n words.sort()\n\n max_unique_chars = 0\n max_word = \"\"\n for word in words:\n unique_chars = len(set(word))\n if unique_chars > max_unique_chars:\n max_unique_chars = unique_chars\n max_word = word\n\n return max_word\n\n# Test cases\nprint(find_max([\"name\", \"of\", \"string\"])) # Output: \"string\"\nprint(find_max([\"name\", \"enam\", \"game\"])) # Output: \"enam\"\nprint(find_max([\"aaaaaaa\", \"bb\" ,\"cc\"])) # Output: \"aaaaaaa\"\n```"}
{"task_id": "HumanEval/159", "solution": "```\npython\ndef eat(number, need, remaining):\n \"\"\"\n You're a hungry rabbit, and you already have eaten a certain number of carrots,\n but now you need to eat more carrots to complete the day's meals.\n you should return an array of [ total number of eaten carrots after your meals,\n the number of carrots left after your meals ]\n if there are not enough remaining carrots, you will eat all remaining carrots, but will still be hungry.\n \n Example:\n * eat(5, 6, 10) -> [11, 4]\n * eat(4, 8, 9) -> [12, 1]\n * eat(1, 10, 10) -> [11, 0]\n * eat(2, 11, 5) -> [7, 0]\n \n Variables:\n @number : integer\n the number of carrots that you have eaten.\n @need : integer\n the number of carrots that you need to eat.\n @remaining : integer\n the number of remaining carrots thet exist in stock\n \n Constrain:\n * 0 <= number <= 1000\n * 0 <= need <= 1000\n * 0 <= remaining <= 1000\n\n Have fun :)\n \"\"\"\n if need <= remaining:\n return [number + need, remaining - need]\n else:\n return [number + remaining, 0]\n\n# Test cases\nprint(eat(5, 6, 10)) # Output: [11, 4]\nprint(eat(4, 8, 9)) # Output: [12, 1]\nprint(eat(1, 10, 10)) # Output: [11, 0]\nprint(eat(2, 11, 5)) # Output: [7, 0]\n```"}
{"task_id": "HumanEval/160", "solution": "```\npython\ndef do_algebra(operator, operand):\n # Initialize the result with the first operand\n result = operand[0]\n \n # Iterate through the operators and operands to build and evaluate the expression\n for i in range(len(operator)):\n if operator[i] == '+':\n result += operand[i + 1]\n elif operator[i] == '-':\n result -= operand[i + 1]\n elif operator[i] == '*':\n result *= operand[i + 1]\n elif operator[i] == '//':\n result //= operand[i + 1]\n elif operator[i] == '**':\n result **= operand[i + 1]\n \n return result\n\n# Example usage:\noperators = ['+', '*', '-']\noperands = [2, 3, 4, 5]\nprint(do_algebra(operators, operands)) # Output should be 9\n```"}
{"task_id": "HumanEval/161", "solution": "```\npython\ndef solve(s):\n # Check if the string contains any letters\n contains_letter = any(char.isalpha() for char in s)\n \n if contains_letter:\n # Reverse the case of each letter\n return ''.join(char.swapcase() if char.isalpha() else char for char in s)\n else:\n # Reverse the entire string if no letters are present\n return s[::-1]\n\n# Test cases\nprint(solve(\"1234\")) # Output: \"4321\"\nprint(solve(\"ab\")) # Output: \"AB\"\nprint(solve(\"#a@C\")) # Output: \"#A@c\"\n```"}
{"task_id": "HumanEval/162", "solution": "```\npython\nimport hashlib\n\ndef string_to_md5(text):\n \"\"\"\n Given a string 'text', return its md5 hash equivalent string.\n If 'text' is an empty string, return None.\n\n >>> string_to_md5('Hello world') == '3e25960a79dbc69b674cd4ec67a72c62'\n \"\"\"\n if not text:\n return None\n return hashlib.md5(text.encode()).hexdigest()\n```"}
{"task_id": "HumanEval/163", "solution": "```\npython\ndef generate_integers(a, b):\n \"\"\"\n Given two positive integers a and b, return the even digits between a\n and b, in ascending order.\n\n For example:\n generate_integers(2, 8) => [2, 4, 6, 8]\n generate_integers(8, 2) => [2, 4, 6, 8]\n generate_integers(10, 14) => []\n \"\"\"\n # Ensure a is less than b for the range function\n if a > b:\n a, b = b, a\n \n # Generate and return the list of even numbers between a and b\n return [num for num in range(a, b + 1) if num % 2 == 0]\n```"}
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment