Skip to content

Instantly share code, notes, and snippets.

@eruo005-dev

eruo005-dev/phi-4-14b-Q4_K_M-mbpp.tmp.log

Created May 29, 2026 05:34
Show Gist options

  • Select an option

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

Select an option

Learn more about clone URLs
Save eruo005-dev/85202d74545936709e9af2e92ffbeb24 to your computer and use it in GitHub Desktop.
Download ZIP
runlocalai_evalplus_phi-4-14b-Q4_K_M-mbpp
Raw
phi-4-14b-Q4_K_M-mbpp.tmp.log
=== runlocalai MBPP+ run ===
model: phi-4-14b (Phi-4 14B)
quant: Q4_K_M
runtime: ollama-0.24
hardware: rtx-3080-16gb-mobile
dataset: mbpp
num_ctx: 8192
samples: .humaneval-runs\phi-4-14b-Q4_K_M-mbpp-1780014239543.jsonl
raw: .humaneval-runs\phi-4-14b-Q4_K_M-mbpp-1780014239543.raw.jsonl
started: 2026-05-29T00:23:59.542Z
finished: 2026-05-29T05:34:32.995Z
wall: 310.6 min
pass@1: 0.603
score: 60.3/100
reproduce: pnpm tsx scripts/run-humaneval-plus.ts --slug phi-4-14b --quant Q4_K_M --runtime ollama-0.24 --hardware rtx-3080-16gb-mobile --endpoint http://localhost:11434/v1 --model-name phi4:14b --dataset mbpp --num-ctx 8192 --python python --parallel 4 --notes "First-party MBPP+ on RTX 3080 Laptop 16GB via Ollama 0.24. Windows-safe scoring via scripts/evalplus_score_windows.py."
=== generation stdout follows ===
Dataset: mbpp | tasks: 378 | resume: 0 done
Samples: .humaneval-runs\phi-4-14b-Q4_K_M-mbpp-1780014239543.jsonl
Raw: .humaneval-runs\phi-4-14b-Q4_K_M-mbpp-1780014239543.raw.jsonl
[ 1/378] generate Mbpp/2
wrote 488 chars in 9.0s | ETA 56.4 min
[ 2/378] generate Mbpp/3
wrote 517 chars in 13.2s | ETA 69.6 min
[ 3/378] generate Mbpp/4
wrote 469 chars in 13.5s | ETA 74.3 min
[ 4/378] generate Mbpp/6
wrote 250 chars in 15.3s | ETA 79.4 min
[ 5/378] generate Mbpp/7
wrote 518 chars in 9.9s | ETA 75.7 min
[ 6/378] generate Mbpp/8
wrote 335 chars in 14.7s | ETA 78.1 min
[ 7/378] generate Mbpp/9
wrote 325 chars in 12.2s | ETA 77.6 min
[ 8/378] generate Mbpp/11
wrote 747 chars in 11.6s | ETA 76.6 min
[ 9/378] generate Mbpp/12
wrote 429 chars in 17.6s | ETA 79.9 min
[ 10/378] generate Mbpp/14
wrote 674 chars in 14.2s | ETA 80.4 min
[ 11/378] generate Mbpp/16
wrote 660 chars in 18.9s | ETA 83.4 min
[ 12/378] generate Mbpp/17
wrote 344 chars in 11.7s | ETA 82.2 min
[ 13/378] generate Mbpp/18
wrote 636 chars in 11.9s | ETA 81.2 min
[ 14/378] generate Mbpp/19
wrote 357 chars in 12.4s | ETA 80.6 min
[ 15/378] generate Mbpp/20
wrote 863 chars in 17.6s | ETA 82.1 min
[ 16/378] generate Mbpp/56
wrote 435 chars in 12.1s | ETA 81.3 min
[ 17/378] generate Mbpp/57
wrote 368 chars in 15.2s | ETA 81.7 min
[ 18/378] generate Mbpp/58
wrote 749 chars in 18.8s | ETA 83.2 min
[ 19/378] generate Mbpp/59
wrote 819 chars in 38.2s | ETA 90.6 min
[ 20/378] generate Mbpp/61
wrote 645 chars in 30.3s | ETA 94.9 min
[ 21/378] generate Mbpp/62
wrote 427 chars in 25.4s | ETA 97.3 min
[ 22/378] generate Mbpp/63
wrote 490 chars in 29.4s | ETA 100.6 min
[ 23/378] generate Mbpp/64
wrote 438 chars in 37.5s | ETA 105.6 min
[ 24/378] generate Mbpp/65
wrote 655 chars in 35.4s | ETA 109.6 min
[ 25/378] generate Mbpp/66
wrote 320 chars in 23.5s | ETA 110.5 min
[ 26/378] generate Mbpp/67
wrote 760 chars in 63.0s | ETA 120.1 min
[ 27/378] generate Mbpp/68
wrote 934 chars in 25.6s | ETA 120.9 min
[ 28/378] generate Mbpp/69
wrote 875 chars in 55.5s | ETA 127.8 min
[ 29/378] generate Mbpp/70
wrote 595 chars in 25.8s | ETA 128.2 min
[ 30/378] generate Mbpp/71
wrote 646 chars in 48.1s | ETA 132.9 min
[ 31/378] generate Mbpp/72
wrote 146 chars in 49.1s | ETA 137.4 min
[ 32/378] generate Mbpp/74
wrote 957 chars in 54.6s | ETA 142.6 min
[ 33/378] generate Mbpp/75
wrote 564 chars in 48.8s | ETA 146.3 min
[ 34/378] generate Mbpp/77
wrote 882 chars in 45.1s | ETA 149.2 min
[ 35/378] generate Mbpp/79
wrote 387 chars in 23.0s | ETA 148.3 min
[ 36/378] generate Mbpp/80
wrote 264 chars in 42.3s | ETA 150.5 min
[ 37/378] generate Mbpp/82
wrote 333 chars in 24.3s | ETA 149.7 min
[ 38/378] generate Mbpp/84
wrote 302 chars in 12.6s | ETA 147.2 min
[ 39/378] generate Mbpp/85
wrote 341 chars in 27.5s | ETA 147.0 min
[ 40/378] generate Mbpp/86
wrote 242 chars in 43.0s | ETA 149.0 min
[ 41/378] generate Mbpp/87
wrote 683 chars in 57.2s | ETA 152.7 min
[ 42/378] generate Mbpp/88
wrote 446 chars in 37.4s | ETA 153.6 min
[ 43/378] generate Mbpp/89
wrote 439 chars in 12.9s | ETA 151.3 min
[ 44/378] generate Mbpp/90
wrote 524 chars in 24.0s | ETA 150.5 min
[ 45/378] generate Mbpp/91
wrote 636 chars in 43.6s | ETA 152.0 min
[ 46/378] generate Mbpp/92
wrote 947 chars in 54.2s | ETA 154.8 min
[ 47/378] generate Mbpp/93
wrote 464 chars in 40.2s | ETA 155.8 min
[ 48/378] generate Mbpp/94
wrote 242 chars in 27.2s | ETA 155.2 min
[ 49/378] generate Mbpp/95
wrote 648 chars in 31.9s | ETA 155.1 min
[ 50/378] generate Mbpp/96
wrote 588 chars in 48.8s | ETA 156.9 min
[ 51/378] generate Mbpp/97
wrote 746 chars in 43.7s | ETA 158.0 min
[ 52/378] generate Mbpp/98
wrote 595 chars in 46.4s | ETA 159.4 min
[ 53/378] generate Mbpp/99
wrote 554 chars in 44.9s | ETA 160.5 min
[ 54/378] generate Mbpp/100
wrote 553 chars in 19.1s | ETA 158.9 min
[ 55/378] generate Mbpp/101
wrote 456 chars in 19.1s | ETA 157.4 min
[ 56/378] generate Mbpp/102
wrote 547 chars in 30.0s | ETA 157.0 min
[ 57/378] generate Mbpp/103
wrote 928 chars in 72.2s | ETA 160.6 min
[ 58/378] generate Mbpp/104
wrote 389 chars in 31.3s | ETA 160.2 min
[ 59/378] generate Mbpp/105
wrote 262 chars in 32.4s | ETA 159.9 min
[ 60/378] generate Mbpp/106
wrote 235 chars in 47.6s | ETA 160.9 min
[ 61/378] generate Mbpp/108
wrote 226 chars in 29.1s | ETA 160.3 min
[ 62/378] generate Mbpp/109
wrote 542 chars in 53.5s | ETA 161.8 min
[ 63/378] generate Mbpp/111
wrote 610 chars in 45.3s | ETA 162.5 min
[ 64/378] generate Mbpp/113
wrote 582 chars in 50.1s | ETA 163.5 min
[ 65/378] generate Mbpp/116
wrote 518 chars in 34.0s | ETA 163.2 min
[ 66/378] generate Mbpp/118
wrote 427 chars in 31.8s | ETA 162.8 min
[ 67/378] generate Mbpp/119
wrote 643 chars in 50.4s | ETA 163.7 min
[ 68/378] generate Mbpp/120
wrote 686 chars in 61.3s | ETA 165.4 min
[ 69/378] generate Mbpp/123
wrote 838 chars in 53.7s | ETA 166.5 min
[ 70/378] generate Mbpp/124
wrote 542 chars in 46.0s | ETA 167.0 min
[ 71/378] generate Mbpp/125
wrote 487 chars in 66.8s | ETA 168.9 min
[ 72/378] generate Mbpp/126
wrote 1194 chars in 62.2s | ETA 170.4 min
[ 73/378] generate Mbpp/127
wrote 297 chars in 12.8s | ETA 168.4 min
[ 74/378] generate Mbpp/128
wrote 612 chars in 30.2s | ETA 167.7 min
[ 75/378] generate Mbpp/129
wrote 1122 chars in 63.4s | ETA 169.2 min
[ 76/378] generate Mbpp/130
wrote 550 chars in 46.1s | ETA 169.5 min
[ 77/378] generate Mbpp/131
wrote 1099 chars in 52.1s | ETA 170.1 min
[ 78/378] generate Mbpp/132
wrote 285 chars in 41.0s | ETA 170.0 min
[ 79/378] generate Mbpp/133
wrote 499 chars in 28.3s | ETA 169.1 min
[ 80/378] generate Mbpp/135
wrote 238 chars in 42.6s | ETA 169.0 min
[ 81/378] generate Mbpp/137
wrote 515 chars in 51.0s | ETA 169.5 min
[ 82/378] generate Mbpp/138
wrote 1857 chars in 86.9s | ETA 172.1 min
[ 83/378] generate Mbpp/139
wrote 280 chars in 50.0s | ETA 172.4 min
[ 84/378] generate Mbpp/140
wrote 433 chars in 48.0s | ETA 172.6 min
[ 85/378] generate Mbpp/141
wrote 851 chars in 29.0s | ETA 171.6 min
[ 86/378] generate Mbpp/142
wrote 773 chars in 39.9s | ETA 171.3 min
[ 87/378] generate Mbpp/145
wrote 351 chars in 51.7s | ETA 171.7 min
[ 88/378] generate Mbpp/160
wrote 604 chars in 65.4s | ETA 172.7 min
[ 89/378] generate Mbpp/161
wrote 693 chars in 62.8s | ETA 173.6 min
[ 90/378] generate Mbpp/162
wrote 410 chars in 41.0s | ETA 173.2 min
[ 91/378] generate Mbpp/165
wrote 489 chars in 36.3s | ETA 172.7 min
[ 92/378] generate Mbpp/166
wrote 377 chars in 64.4s | ETA 173.5 min
[ 93/378] generate Mbpp/167
wrote 536 chars in 58.1s | ETA 174.0 min
[ 94/378] generate Mbpp/168
wrote 330 chars in 44.3s | ETA 173.8 min
[ 95/378] generate Mbpp/170
wrote 895 chars in 53.9s | ETA 174.0 min
[ 96/378] generate Mbpp/171
wrote 336 chars in 37.5s | ETA 173.5 min
[ 97/378] generate Mbpp/172
wrote 682 chars in 46.7s | ETA 173.3 min
[ 98/378] generate Mbpp/222
wrote 485 chars in 51.5s | ETA 173.4 min
[ 99/378] generate Mbpp/223
wrote 1441 chars in 76.6s | ETA 174.6 min
[100/378] generate Mbpp/224
wrote 851 chars in 57.2s | ETA 174.9 min
[101/378] generate Mbpp/226
wrote 489 chars in 29.6s | ETA 173.9 min
[102/378] generate Mbpp/227
wrote 579 chars in 22.7s | ETA 172.6 min
[103/378] generate Mbpp/230
wrote 501 chars in 37.3s | ETA 172.0 min
[104/378] generate Mbpp/232
wrote 476 chars in 41.8s | ETA 171.5 min
[105/378] generate Mbpp/233
wrote 11 chars in 43.4s | ETA 171.2 min
[106/378] generate Mbpp/234
wrote 241 chars in 34.4s | ETA 170.4 min
[107/378] generate Mbpp/235
wrote 532 chars in 58.2s | ETA 170.6 min
[108/378] generate Mbpp/237
wrote 885 chars in 42.5s | ETA 170.2 min
[109/378] generate Mbpp/238
wrote 235 chars in 48.9s | ETA 170.0 min
[110/378] generate Mbpp/239
wrote 1051 chars in 68.5s | ETA 170.6 min
[111/378] generate Mbpp/240
wrote 605 chars in 34.0s | ETA 169.8 min
[112/378] generate Mbpp/242
wrote 308 chars in 31.3s | ETA 168.9 min
[113/378] generate Mbpp/244
wrote 400 chars in 29.4s | ETA 168.0 min
[114/378] generate Mbpp/245
wrote 1066 chars in 49.2s | ETA 167.7 min
[115/378] generate Mbpp/247
wrote 786 chars in 81.0s | ETA 168.7 min
[116/378] generate Mbpp/250
wrote 349 chars in 32.1s | ETA 167.9 min
[117/378] generate Mbpp/251
wrote 589 chars in 31.3s | ETA 167.0 min
[118/378] generate Mbpp/252
wrote 502 chars in 44.8s | ETA 166.6 min
[119/378] generate Mbpp/253
wrote 618 chars in 31.9s | ETA 165.7 min
[120/378] generate Mbpp/255
wrote 497 chars in 27.4s | ETA 164.6 min
[121/378] generate Mbpp/256
wrote 888 chars in 62.8s | ETA 164.9 min
[122/378] generate Mbpp/257
wrote 378 chars in 26.6s | ETA 163.8 min
[123/378] generate Mbpp/259
wrote 876 chars in 46.0s | ETA 163.4 min
[124/378] generate Mbpp/260
wrote 680 chars in 65.6s | ETA 163.7 min
[125/378] generate Mbpp/261
wrote 1026 chars in 44.8s | ETA 163.3 min
[126/378] generate Mbpp/262
wrote 587 chars in 33.8s | ETA 162.5 min
[127/378] generate Mbpp/264
wrote 499 chars in 37.1s | ETA 161.8 min
[128/378] generate Mbpp/265
wrote 734 chars in 42.4s | ETA 161.3 min
[129/378] generate Mbpp/266
wrote 699 chars in 51.1s | ETA 161.0 min
[130/378] generate Mbpp/267
wrote 630 chars in 39.7s | ETA 160.4 min
[131/378] generate Mbpp/268
wrote 439 chars in 51.8s | ETA 160.2 min
[132/378] generate Mbpp/269
wrote 377 chars in 38.7s | ETA 159.5 min
[133/378] generate Mbpp/270
wrote 598 chars in 48.2s | ETA 159.1 min
[134/378] generate Mbpp/271
wrote 636 chars in 43.2s | ETA 158.6 min
[135/378] generate Mbpp/272
wrote 491 chars in 36.6s | ETA 157.9 min
[136/378] generate Mbpp/273
wrote 640 chars in 29.1s | ETA 157.0 min
[137/378] generate Mbpp/274
wrote 359 chars in 64.8s | ETA 157.1 min
[138/378] generate Mbpp/276
wrote 385 chars in 45.8s | ETA 156.6 min
[139/378] generate Mbpp/277
wrote 483 chars in 54.3s | ETA 156.4 min
[140/378] generate Mbpp/278
wrote 481 chars in 31.5s | ETA 155.5 min
[141/378] generate Mbpp/279
wrote 271 chars in 38.1s | ETA 154.8 min
[142/378] generate Mbpp/280
wrote 599 chars in 38.6s | ETA 154.2 min
[143/378] generate Mbpp/281
wrote 422 chars in 25.6s | ETA 153.1 min
[144/378] generate Mbpp/282
wrote 627 chars in 36.9s | ETA 152.4 min
[145/378] generate Mbpp/283
wrote 841 chars in 46.0s | ETA 152.0 min
[146/378] generate Mbpp/284
wrote 417 chars in 27.6s | ETA 151.0 min
[147/378] generate Mbpp/285
wrote 595 chars in 55.7s | ETA 150.8 min
[148/378] generate Mbpp/286
wrote 1474 chars in 91.3s | ETA 151.5 min
[149/378] generate Mbpp/287
wrote 703 chars in 45.6s | ETA 151.0 min
[150/378] generate Mbpp/290
wrote 477 chars in 49.0s | ETA 150.6 min
[151/378] generate Mbpp/292
wrote 557 chars in 36.7s | ETA 149.8 min
[152/378] generate Mbpp/293
wrote 608 chars in 59.3s | ETA 149.7 min
[153/378] generate Mbpp/294
wrote 829 chars in 55.1s | ETA 149.4 min
[154/378] generate Mbpp/296
wrote 1579 chars in 86.5s | ETA 149.8 min
[155/378] generate Mbpp/297
wrote 650 chars in 37.3s | ETA 149.1 min
[156/378] generate Mbpp/299
wrote 1094 chars in 63.2s | ETA 149.0 min
[157/378] generate Mbpp/300
wrote 130 chars in 66.4s | ETA 148.9 min
[158/378] generate Mbpp/301
wrote 505 chars in 41.1s | ETA 148.3 min
[159/378] generate Mbpp/305
wrote 620 chars in 32.6s | ETA 147.4 min
[160/378] generate Mbpp/306
wrote 692 chars in 82.6s | ETA 147.7 min
[161/378] generate Mbpp/308
wrote 530 chars in 43.6s | ETA 147.1 min
[162/378] generate Mbpp/309
wrote 327 chars in 14.8s | ETA 145.8 min
[163/378] generate Mbpp/310
wrote 266 chars in 32.7s | ETA 145.0 min
[164/378] generate Mbpp/311
wrote 582 chars in 50.3s | ETA 144.5 min
[165/378] generate Mbpp/312
wrote 409 chars in 37.4s | ETA 143.8 min
[166/378] generate Mbpp/388
wrote 511 chars in 18.6s | ETA 142.6 min
[167/378] generate Mbpp/389
wrote 701 chars in 31.7s | ETA 141.8 min
[168/378] generate Mbpp/390
wrote 390 chars in 37.7s | ETA 141.1 min
[169/378] generate Mbpp/391
wrote 640 chars in 42.9s | ETA 140.4 min
[170/378] generate Mbpp/392
wrote 342 chars in 49.5s | ETA 140.0 min
[171/378] generate Mbpp/394
wrote 548 chars in 46.4s | ETA 139.4 min
[172/378] generate Mbpp/395
wrote 504 chars in 36.3s | ETA 138.6 min
[173/378] generate Mbpp/397
wrote 683 chars in 41.1s | ETA 138.0 min
[174/378] generate Mbpp/398
wrote 530 chars in 54.0s | ETA 137.6 min
[175/378] generate Mbpp/404
wrote 279 chars in 13.7s | ETA 136.4 min
[176/378] generate Mbpp/405
wrote 354 chars in 26.3s | ETA 135.4 min
[177/378] generate Mbpp/406
wrote 748 chars in 51.6s | ETA 135.0 min
[178/378] generate Mbpp/409
wrote 796 chars in 37.2s | ETA 134.3 min
[179/378] generate Mbpp/410
wrote 308 chars in 36.0s | ETA 133.5 min
[180/378] generate Mbpp/412
wrote 353 chars in 27.5s | ETA 132.6 min
[181/378] generate Mbpp/413
wrote 483 chars in 61.1s | ETA 132.3 min
[182/378] generate Mbpp/414
wrote 542 chars in 42.6s | ETA 131.7 min
[183/378] generate Mbpp/415
wrote 904 chars in 74.3s | ETA 131.6 min
[184/378] generate Mbpp/418
wrote 727 chars in 38.8s | ETA 130.9 min
[185/378] generate Mbpp/419
wrote 642 chars in 37.8s | ETA 130.2 min
[186/378] generate Mbpp/420
wrote 723 chars in 48.0s | ETA 129.7 min
[187/378] generate Mbpp/421
wrote 487 chars in 31.4s | ETA 128.8 min
[188/378] generate Mbpp/422
wrote 549 chars in 40.6s | ETA 128.1 min
[189/378] generate Mbpp/424
wrote 409 chars in 35.0s | ETA 127.4 min
[190/378] generate Mbpp/425
wrote 643 chars in 55.5s | ETA 127.0 min
[191/378] generate Mbpp/426
wrote 482 chars in 28.9s | ETA 126.1 min
[192/378] generate Mbpp/427
wrote 448 chars in 42.1s | ETA 125.4 min
[193/378] generate Mbpp/428
wrote 811 chars in 55.3s | ETA 125.0 min
[194/378] generate Mbpp/429
wrote 962 chars in 51.9s | ETA 124.5 min
[195/378] generate Mbpp/430
wrote 702 chars in 88.4s | ETA 124.6 min
[196/378] generate Mbpp/432
wrote 385 chars in 54.9s | ETA 124.1 min
[197/378] generate Mbpp/433
wrote 440 chars in 36.9s | ETA 123.4 min
[198/378] generate Mbpp/435
wrote 512 chars in 32.2s | ETA 122.6 min
[199/378] generate Mbpp/436
wrote 351 chars in 25.3s | ETA 121.6 min
[200/378] generate Mbpp/437
wrote 482 chars in 39.4s | ETA 120.9 min
[201/378] generate Mbpp/439
wrote 568 chars in 34.4s | ETA 120.2 min
[202/378] generate Mbpp/440
wrote 641 chars in 54.4s | ETA 119.7 min
[203/378] generate Mbpp/441
wrote 495 chars in 31.4s | ETA 118.9 min
[204/378] generate Mbpp/445
wrote 880 chars in 58.2s | ETA 118.4 min
[205/378] generate Mbpp/446
wrote 715 chars in 45.9s | ETA 117.8 min
[206/378] generate Mbpp/447
wrote 372 chars in 41.9s | ETA 117.2 min
[207/378] generate Mbpp/448
wrote 560 chars in 53.6s | ETA 116.7 min
[208/378] generate Mbpp/450
wrote 463 chars in 31.6s | ETA 115.9 min
[209/378] generate Mbpp/451
wrote 436 chars in 35.5s | ETA 115.1 min
[210/378] generate Mbpp/453
wrote 654 chars in 45.4s | ETA 114.5 min
[211/378] generate Mbpp/454
wrote 559 chars in 55.2s | ETA 114.0 min
[212/378] generate Mbpp/455
wrote 1071 chars in 47.0s | ETA 113.4 min
[213/378] generate Mbpp/456
wrote 314 chars in 25.2s | ETA 112.5 min
[214/378] generate Mbpp/457
wrote 804 chars in 35.6s | ETA 111.7 min
[215/378] generate Mbpp/458
wrote 280 chars in 11.9s | ETA 110.7 min
[216/378] generate Mbpp/459
wrote 996 chars in 39.0s | ETA 110.0 min
[217/378] generate Mbpp/460
wrote 486 chars in 42.0s | ETA 109.3 min
[218/378] generate Mbpp/462
wrote 559 chars in 38.2s | ETA 108.6 min
[219/378] generate Mbpp/463
wrote 769 chars in 64.3s | ETA 108.2 min
[220/378] generate Mbpp/465
wrote 783 chars in 47.5s | ETA 107.6 min
[221/378] generate Mbpp/468
wrote 592 chars in 59.5s | ETA 107.2 min
[222/378] generate Mbpp/470
wrote 811 chars in 49.7s | ETA 106.6 min
[223/378] generate Mbpp/471
wrote 622 chars in 46.8s | ETA 106.0 min
[224/378] generate Mbpp/472
wrote 931 chars in 44.9s | ETA 105.3 min
[225/378] generate Mbpp/473
wrote 596 chars in 45.9s | ETA 104.7 min
[226/378] generate Mbpp/474
wrote 474 chars in 40.5s | ETA 104.0 min
[227/378] generate Mbpp/475
wrote 696 chars in 50.8s | ETA 103.4 min
[228/378] generate Mbpp/476
wrote 526 chars in 37.7s | ETA 102.7 min
[229/378] generate Mbpp/477
wrote 232 chars in 9.8s | ETA 101.7 min
[230/378] generate Mbpp/478
wrote 402 chars in 30.6s | ETA 100.9 min
[231/378] generate Mbpp/479
wrote 891 chars in 41.8s | ETA 100.2 min
[232/378] generate Mbpp/554
wrote 482 chars in 27.0s | ETA 99.4 min
[233/378] generate Mbpp/555
wrote 584 chars in 91.7s | ETA 99.2 min
[234/378] generate Mbpp/556
wrote 482 chars in 55.3s | ETA 98.7 min
[235/378] generate Mbpp/557
wrote 502 chars in 62.0s | ETA 98.2 min
[236/378] generate Mbpp/558
wrote 779 chars in 64.7s | ETA 97.8 min
[237/378] generate Mbpp/559
wrote 602 chars in 56.9s | ETA 97.2 min
[238/378] generate Mbpp/560
wrote 592 chars in 52.2s | ETA 96.7 min
[239/378] generate Mbpp/562
wrote 631 chars in 36.2s | ETA 95.9 min
[240/378] generate Mbpp/563
wrote 496 chars in 45.1s | ETA 95.3 min
[241/378] generate Mbpp/564
wrote 995 chars in 61.2s | ETA 94.8 min
[242/378] generate Mbpp/565
wrote 283 chars in 24.9s | ETA 93.9 min
[243/378] generate Mbpp/566
wrote 556 chars in 52.5s | ETA 93.3 min
[244/378] generate Mbpp/567
wrote 426 chars in 48.2s | ETA 92.7 min
[245/378] generate Mbpp/568
wrote 333 chars in 59.1s | ETA 92.2 min
[246/378] generate Mbpp/569
wrote 372 chars in 66.2s | ETA 91.7 min
[247/378] generate Mbpp/572
wrote 643 chars in 52.0s | ETA 91.1 min
[248/378] generate Mbpp/573
wrote 362 chars in 36.6s | ETA 90.3 min
[249/378] generate Mbpp/576
wrote 967 chars in 63.9s | ETA 89.8 min
[250/378] generate Mbpp/577
wrote 862 chars in 75.3s | ETA 89.4 min
[251/378] generate Mbpp/578
wrote 878 chars in 60.8s | ETA 88.9 min
[252/378] generate Mbpp/579
wrote 440 chars in 65.3s | ETA 88.4 min
[253/378] generate Mbpp/580
wrote 609 chars in 59.5s | ETA 87.8 min
[254/378] generate Mbpp/581
wrote 11 chars in 61.2s | ETA 87.3 min
[255/378] generate Mbpp/583
wrote 403 chars in 61.6s | ETA 86.7 min
[256/378] generate Mbpp/585
wrote 617 chars in 38.2s | ETA 86.0 min
[257/378] generate Mbpp/586
wrote 655 chars in 54.4s | ETA 85.4 min
[258/378] generate Mbpp/587
wrote 326 chars in 39.1s | ETA 84.7 min
[259/378] generate Mbpp/588
wrote 654 chars in 49.5s | ETA 84.0 min
[260/378] generate Mbpp/589
wrote 832 chars in 60.5s | ETA 83.4 min
[261/378] generate Mbpp/590
wrote 11 chars in 64.9s | ETA 82.9 min
[262/378] generate Mbpp/591
wrote 431 chars in 40.3s | ETA 82.2 min
[263/378] generate Mbpp/592
wrote 563 chars in 78.9s | ETA 81.7 min
[264/378] generate Mbpp/593
wrote 720 chars in 35.2s | ETA 81.0 min
[265/378] generate Mbpp/594
wrote 664 chars in 54.6s | ETA 80.3 min
[266/378] generate Mbpp/596
wrote 264 chars in 47.0s | ETA 79.7 min
[267/378] generate Mbpp/597
wrote 526 chars in 71.4s | ETA 79.1 min
[268/378] generate Mbpp/598
wrote 935 chars in 73.9s | ETA 78.6 min
[269/378] generate Mbpp/599
wrote 599 chars in 51.4s | ETA 78.0 min
[270/378] generate Mbpp/600
wrote 280 chars in 28.7s | ETA 77.2 min
[271/378] generate Mbpp/602
wrote 416 chars in 53.4s | ETA 76.5 min
[272/378] generate Mbpp/603
wrote 1349 chars in 51.8s | ETA 75.9 min
[273/378] generate Mbpp/604
wrote 627 chars in 39.2s | ETA 75.1 min
[274/378] generate Mbpp/605
wrote 578 chars in 85.9s | ETA 74.7 min
[275/378] generate Mbpp/606
wrote 229 chars in 52.4s | ETA 74.0 min
[276/378] generate Mbpp/607
wrote 820 chars in 123.6s | ETA 73.8 min
[277/378] generate Mbpp/608
wrote 634 chars in 113.7s | ETA 73.5 min
[278/378] generate Mbpp/610
wrote 566 chars in 51.5s | ETA 72.8 min
[279/378] generate Mbpp/611
wrote 515 chars in 50.2s | ETA 72.1 min
[280/378] generate Mbpp/612
wrote 976 chars in 47.5s | ETA 71.4 min
[281/378] generate Mbpp/614
wrote 450 chars in 42.4s | ETA 70.7 min
[282/378] generate Mbpp/615
wrote 861 chars in 45.8s | ETA 70.0 min
[283/378] generate Mbpp/616
wrote 632 chars in 55.6s | ETA 69.3 min
[284/378] generate Mbpp/618
wrote 762 chars in 55.9s | ETA 68.7 min
[285/378] generate Mbpp/619
wrote 557 chars in 53.2s | ETA 68.0 min
[286/378] generate Mbpp/620
wrote 476 chars in 76.0s | ETA 67.4 min
[287/378] generate Mbpp/622
wrote 1530 chars in 105.5s | ETA 67.0 min
[288/378] generate Mbpp/623
wrote 386 chars in 65.2s | ETA 66.4 min
[289/378] generate Mbpp/624
wrote 274 chars in 25.1s | ETA 65.5 min
[290/378] generate Mbpp/626
wrote 1102 chars in 81.8s | ETA 65.0 min
[291/378] generate Mbpp/628
wrote 370 chars in 29.8s | ETA 64.2 min
[292/378] generate Mbpp/629
wrote 632 chars in 47.2s | ETA 63.5 min
[293/378] generate Mbpp/630
wrote 684 chars in 69.1s | ETA 62.8 min
[294/378] generate Mbpp/631
wrote 463 chars in 43.2s | ETA 62.1 min
[295/378] generate Mbpp/632
wrote 599 chars in 43.1s | ETA 61.4 min
[296/378] generate Mbpp/633
wrote 358 chars in 44.6s | ETA 60.6 min
[297/378] generate Mbpp/635
wrote 439 chars in 76.1s | ETA 60.0 min
[298/378] generate Mbpp/637
wrote 580 chars in 47.5s | ETA 59.3 min
[299/378] generate Mbpp/638
wrote 927 chars in 75.1s | ETA 58.7 min
[300/378] generate Mbpp/639
wrote 709 chars in 45.0s | ETA 58.0 min
[301/378] generate Mbpp/641
wrote 242 chars in 49.8s | ETA 57.2 min
[302/378] generate Mbpp/643
wrote 446 chars in 54.6s | ETA 56.5 min
[303/378] generate Mbpp/644
wrote 749 chars in 55.0s | ETA 55.8 min
[304/378] generate Mbpp/720
wrote 538 chars in 54.3s | ETA 55.1 min
[305/378] generate Mbpp/721
wrote 964 chars in 99.5s | ETA 54.6 min
[306/378] generate Mbpp/722
wrote 684 chars in 43.4s | ETA 53.8 min
[307/378] generate Mbpp/723
wrote 787 chars in 42.8s | ETA 53.1 min
[308/378] generate Mbpp/724
wrote 779 chars in 49.1s | ETA 52.4 min
[309/378] generate Mbpp/725
wrote 436 chars in 43.7s | ETA 51.6 min
[310/378] generate Mbpp/726
wrote 536 chars in 49.9s | ETA 50.9 min
[311/378] generate Mbpp/728
wrote 623 chars in 54.1s | ETA 50.2 min
[312/378] generate Mbpp/730
wrote 641 chars in 40.6s | ETA 49.4 min
[313/378] generate Mbpp/731
wrote 262 chars in 40.0s | ETA 48.6 min
[314/378] generate Mbpp/732
wrote 542 chars in 32.1s | ETA 47.8 min
[315/378] generate Mbpp/733
wrote 788 chars in 46.4s | ETA 47.1 min
[316/378] generate Mbpp/734
wrote 427 chars in 42.0s | ETA 46.3 min
[317/378] generate Mbpp/735
wrote 748 chars in 88.0s | ETA 45.7 min
[318/378] generate Mbpp/736
wrote 586 chars in 54.8s | ETA 45.0 min
[319/378] generate Mbpp/737
wrote 469 chars in 42.7s | ETA 44.3 min
[320/378] generate Mbpp/739
wrote 685 chars in 84.6s | ETA 43.6 min
[321/378] generate Mbpp/740
wrote 550 chars in 51.9s | ETA 42.9 min
[322/378] generate Mbpp/741
wrote 551 chars in 28.1s | ETA 42.1 min
[323/378] generate Mbpp/742
wrote 11 chars in 37.9s | ETA 41.3 min
[324/378] generate Mbpp/743
wrote 589 chars in 69.4s | ETA 40.6 min
[325/378] generate Mbpp/744
wrote 294 chars in 35.3s | ETA 39.9 min
[326/378] generate Mbpp/745
wrote 351 chars in 44.1s | ETA 39.1 min
[327/378] generate Mbpp/748
wrote 962 chars in 60.6s | ETA 38.4 min
[328/378] generate Mbpp/749
wrote 639 chars in 39.7s | ETA 37.6 min
[329/378] generate Mbpp/750
wrote 461 chars in 39.5s | ETA 36.9 min
[330/378] generate Mbpp/751
wrote 774 chars in 67.5s | ETA 36.2 min
[331/378] generate Mbpp/752
wrote 705 chars in 75.8s | ETA 35.5 min
[332/378] generate Mbpp/753
wrote 567 chars in 40.1s | ETA 34.7 min
[333/378] generate Mbpp/754
wrote 783 chars in 49.6s | ETA 34.0 min
[334/378] generate Mbpp/755
wrote 401 chars in 35.6s | ETA 33.2 min
[335/378] generate Mbpp/757
wrote 647 chars in 67.7s | ETA 32.5 min
[336/378] generate Mbpp/758
wrote 902 chars in 52.3s | ETA 31.7 min
[337/378] generate Mbpp/759
wrote 521 chars in 64.8s | ETA 31.0 min
[338/378] generate Mbpp/760
wrote 680 chars in 40.7s | ETA 30.3 min
[339/378] generate Mbpp/762
wrote 523 chars in 31.7s | ETA 29.5 min
[340/378] generate Mbpp/763
wrote 360 chars in 51.6s | ETA 28.7 min
[341/378] generate Mbpp/764
wrote 490 chars in 34.3s | ETA 28.0 min
[342/378] generate Mbpp/765
wrote 304 chars in 82.0s | ETA 27.3 min
[343/378] generate Mbpp/766
wrote 719 chars in 44.7s | ETA 26.5 min
[344/378] generate Mbpp/767
wrote 942 chars in 61.4s | ETA 25.8 min
[345/378] generate Mbpp/769
wrote 563 chars in 53.1s | ETA 25.0 min
[346/378] generate Mbpp/770
wrote 595 chars in 53.7s | ETA 24.3 min
[347/378] generate Mbpp/771
wrote 715 chars in 33.0s | ETA 23.5 min
[348/378] generate Mbpp/772
wrote 564 chars in 34.5s | ETA 22.7 min
[349/378] generate Mbpp/773
wrote 638 chars in 64.3s | ETA 22.0 min
[350/378] generate Mbpp/775
wrote 609 chars in 60.9s | ETA 21.3 min
[351/378] generate Mbpp/777
wrote 409 chars in 63.0s | ETA 20.5 min
[352/378] generate Mbpp/778
wrote 453 chars in 66.3s | ETA 19.8 min
[353/378] generate Mbpp/780
wrote 566 chars in 42.0s | ETA 19.0 min
[354/378] generate Mbpp/781
wrote 588 chars in 53.9s | ETA 18.3 min
[355/378] generate Mbpp/782
wrote 586 chars in 74.9s | ETA 17.5 min
[356/378] generate Mbpp/784
wrote 967 chars in 66.0s | ETA 16.8 min
[357/378] generate Mbpp/785
wrote 1073 chars in 94.3s | ETA 16.1 min
[358/378] generate Mbpp/786
wrote 596 chars in 98.9s | ETA 15.4 min
[359/378] generate Mbpp/787
wrote 573 chars in 54.0s | ETA 14.6 min
[360/378] generate Mbpp/788
wrote 720 chars in 45.1s | ETA 13.8 min
[361/378] generate Mbpp/790
wrote 372 chars in 51.2s | ETA 13.1 min
[362/378] generate Mbpp/791
wrote 190 chars in 54.6s | ETA 12.3 min
[363/378] generate Mbpp/792
wrote 657 chars in 64.5s | ETA 11.6 min
[364/378] generate Mbpp/793
wrote 751 chars in 52.8s | ETA 10.8 min
[365/378] generate Mbpp/794
wrote 530 chars in 64.7s | ETA 10.0 min
[366/378] generate Mbpp/796
wrote 312 chars in 51.0s | ETA 9.3 min
[367/378] generate Mbpp/797
wrote 608 chars in 80.0s | ETA 8.5 min
[368/378] generate Mbpp/798
wrote 243 chars in 54.6s | ETA 7.7 min
[369/378] generate Mbpp/799
wrote 586 chars in 85.1s | ETA 7.0 min
[370/378] generate Mbpp/800
wrote 332 chars in 53.3s | ETA 6.2 min
[371/378] generate Mbpp/801
wrote 546 chars in 90.5s | ETA 5.4 min
[372/378] generate Mbpp/803
wrote 671 chars in 70.7s | ETA 4.7 min
[373/378] generate Mbpp/804
wrote 476 chars in 71.1s | ETA 3.9 min
[374/378] generate Mbpp/805
wrote 793 chars in 63.5s | ETA 3.1 min
[375/378] generate Mbpp/806
wrote 903 chars in 47.6s | ETA 2.3 min
[376/378] generate Mbpp/807
wrote 359 chars in 44.0s | ETA 1.6 min
[377/378] generate Mbpp/808
wrote 305 chars in 48.5s | ETA 0.8 min
[378/378] generate Mbpp/809
wrote 856 chars in 84.5s | ETA 0.0 min
Done: .humaneval-runs\phi-4-14b-Q4_K_M-mbpp-1780014239543.jsonl
=== generation stderr follows ===
=== scorer stdout follows ===
Load from ground-truth from C:\Users\eruo0\AppData\Local\evalplus\evalplus\Cache\92743def42b30b354a30898e4fa33fb0.pkl
Reading samples...
mbpp (base tests)
pass@1: 0.704
mbpp+ (base + extra tests)
pass@1: 0.603
=== scorer stderr follows ===
0it [00:00, ?it/s] 1it [00:00, 9.46it/s] 80it [00:00, 457.45it/s] 127it [00:00, 361.29it/s] 378it [00:00, 928.91it/s]
0%| | 0/378 [00:00<?, ?it/s] 0%| | 1/378 [00:13<1:25:53, 13.67s/it] 1%| | 2/378 [00:13<36:16, 5.79s/it] 1%| | 3/378 [00:15<23:00, 3.68s/it] 1%|1 | 4/378 [00:15<14:17, 2.29s/it] 1%|1 | 5/378 [00:23<26:52, 4.32s/it] 2%|1 | 6/378 [00:23<18:11, 2.93s/it] 2%|1 | 7/378 [00:24<14:31, 2.35s/it] 2%|2 | 8/378 [00:24<10:14, 1.66s/it] 2%|2 | 9/378 [00:32<21:14, 3.45s/it] 3%|2 | 11/378 [00:33<12:41, 2.08s/it] 3%|3 | 12/378 [00:33<09:45, 1.60s/it] 3%|3 | 13/378 [00:40<19:10, 3.15s/it] 4%|3 | 15/378 [00:41<12:15, 2.03s/it] 4%|4 | 17/378 [00:49<16:45, 2.78s/it] 5%|5 | 19/378 [00:51<11:58, 2.00s/it] 6%|5 | 21/378 [00:58<15:10, 2.55s/it] 6%|6 | 23/378 [00:59<11:09, 1.89s/it] 7%|6 | 25/378 [01:06<14:16, 2.43s/it] 7%|7 | 27/378 [01:07<10:36, 1.81s/it] 7%|7 | 28/378 [01:07<08:45, 1.50s/it] 8%|7 | 29/378 [01:14<14:43, 2.53s/it] 8%|8 | 31/378 [01:14<10:06, 1.75s/it] 9%|8 | 33/378 [01:21<13:14, 2.30s/it] 9%|9 | 35/378 [01:22<09:29, 1.66s/it] 10%|9 | 37/378 [01:29<12:30, 2.20s/it] 10%|# | 38/378 [01:29<10:38, 1.88s/it] 10%|# | 39/378 [01:29<08:44, 1.55s/it] 11%|# | 41/378 [01:36<12:27, 2.22s/it] 11%|#1 | 42/378 [01:36<10:21, 1.85s/it] 11%|#1 | 43/378 [01:37<08:24, 1.50s/it] 12%|#1 | 45/378 [01:44<12:29, 2.25s/it] 12%|#2 | 46/378 [01:44<10:18, 1.86s/it] 12%|#2 | 47/378 [01:44<08:10, 1.48s/it] 13%|#2 | 49/378 [01:51<12:23, 2.26s/it] 13%|#3 | 50/378 [01:52<10:07, 1.85s/it] 13%|#3 | 51/378 [01:52<08:02, 1.47s/it] 14%|#4 | 53/378 [01:59<12:09, 2.24s/it] 14%|#4 | 54/378 [01:59<09:46, 1.81s/it] 15%|#4 | 55/378 [01:59<07:50, 1.46s/it] 15%|#5 | 57/378 [02:06<11:53, 2.22s/it] 15%|#5 | 58/378 [02:06<09:30, 1.78s/it] 16%|#5 | 59/378 [02:07<07:48, 1.47s/it] 16%|#6 | 61/378 [02:13<11:48, 2.23s/it] 16%|#6 | 62/378 [02:14<09:21, 1.78s/it] 17%|#6 | 63/378 [02:14<07:34, 1.44s/it] 17%|#7 | 65/378 [02:21<11:55, 2.29s/it] 17%|#7 | 66/378 [02:21<09:26, 1.82s/it] 18%|#7 | 67/378 [02:22<07:40, 1.48s/it] 18%|#8 | 69/378 [02:29<12:03, 2.34s/it] 19%|#8 | 70/378 [02:29<09:47, 1.91s/it] 19%|#9 | 72/378 [02:31<08:08, 1.60s/it] 19%|#9 | 73/378 [02:37<12:09, 2.39s/it] 20%|#9 | 74/378 [02:37<09:44, 1.92s/it] 20%|## | 76/378 [02:39<08:04, 1.60s/it] 20%|## | 77/378 [02:44<11:41, 2.33s/it] 21%|## | 78/378 [02:45<09:24, 1.88s/it] 21%|##1 | 80/378 [02:47<08:13, 1.65s/it] 21%|##1 | 81/378 [02:52<11:52, 2.40s/it] 22%|##1 | 82/378 [02:53<09:23, 1.90s/it] 22%|##2 | 84/378 [02:55<07:37, 1.56s/it] 22%|##2 | 85/378 [03:00<11:18, 2.32s/it] 23%|##2 | 86/378 [03:00<09:01, 1.85s/it] 23%|##3 | 88/378 [03:02<07:35, 1.57s/it] 24%|##3 | 89/378 [03:08<11:57, 2.48s/it] 24%|##3 | 90/378 [03:08<09:29, 1.98s/it] 24%|##4 | 91/378 [03:10<08:23, 1.76s/it] 24%|##4 | 92/378 [03:11<07:28, 1.57s/it] 25%|##4 | 93/378 [03:15<11:33, 2.43s/it] 25%|##4 | 94/378 [03:16<08:41, 1.84s/it] 25%|##5 | 95/378 [03:17<07:54, 1.68s/it] 25%|##5 | 96/378 [03:18<07:09, 1.52s/it] 26%|##5 | 97/378 [03:23<11:44, 2.51s/it] 26%|##5 | 98/378 [03:23<08:33, 1.83s/it] 26%|##6 | 99/378 [03:24<07:46, 1.67s/it] 26%|##6 | 100/378 [03:26<06:57, 1.50s/it] 27%|##6 | 101/378 [03:31<11:39, 2.53s/it] 27%|##6 | 102/378 [03:31<08:26, 1.83s/it] 27%|##7 | 103/378 [03:32<07:34, 1.65s/it] 28%|##7 | 104/378 [03:33<06:47, 1.49s/it] 28%|##7 | 105/378 [03:38<11:26, 2.51s/it] 28%|##8 | 106/378 [03:38<08:10, 1.80s/it] 28%|##8 | 107/378 [03:39<07:31, 1.67s/it] 29%|##8 | 108/378 [03:41<06:49, 1.52s/it] 29%|##8 | 109/378 [03:46<11:48, 2.63s/it] 29%|##9 | 110/378 [03:46<08:24, 1.88s/it] 29%|##9 | 111/378 [03:56<18:34, 4.17s/it] 30%|### | 115/378 [03:56<07:10, 1.64s/it] 31%|### | 116/378 [03:57<06:41, 1.53s/it] 31%|### | 117/378 [04:02<10:00, 2.30s/it] 31%|###1 | 119/378 [04:05<07:56, 1.84s/it] 32%|###1 | 120/378 [04:11<11:40, 2.72s/it] 32%|###2 | 122/378 [04:12<08:40, 2.03s/it] 33%|###2 | 123/378 [04:19<12:40, 2.98s/it] 33%|###3 | 125/378 [04:21<09:29, 2.25s/it] 33%|###3 | 126/378 [04:21<07:47, 1.85s/it] 34%|###3 | 127/378 [04:27<11:32, 2.76s/it] 34%|###4 | 129/378 [04:29<08:52, 2.14s/it] 34%|###4 | 130/378 [04:31<08:35, 2.08s/it] 35%|###4 | 131/378 [04:36<11:17, 2.74s/it] 35%|###4 | 132/378 [04:36<08:29, 2.07s/it] 35%|###5 | 133/378 [04:39<08:41, 2.13s/it] 35%|###5 | 134/378 [04:45<13:11, 3.24s/it] 36%|###5 | 136/378 [04:47<09:16, 2.30s/it] 36%|###6 | 137/378 [04:50<10:02, 2.50s/it] 37%|###6 | 138/378 [04:53<10:24, 2.60s/it] 37%|###7 | 140/378 [04:55<07:51, 1.98s/it] 37%|###7 | 141/378 [04:58<08:56, 2.27s/it] 38%|###7 | 142/378 [05:02<09:44, 2.48s/it] 38%|###8 | 144/378 [05:04<07:17, 1.87s/it] 38%|###8 | 145/378 [05:07<08:12, 2.11s/it] 39%|###8 | 146/378 [05:10<09:07, 2.36s/it] 39%|###9 | 148/378 [05:12<06:56, 1.81s/it] 39%|###9 | 149/378 [05:14<07:41, 2.02s/it] 40%|###9 | 150/378 [05:18<08:40, 2.28s/it] 40%|#### | 152/378 [05:20<06:46, 1.80s/it] 40%|#### | 153/378 [05:23<07:33, 2.01s/it] 41%|#### | 154/378 [05:26<08:35, 2.30s/it] 41%|####1 | 156/378 [05:28<06:41, 1.81s/it] 42%|####1 | 157/378 [05:31<07:53, 2.14s/it] 42%|####1 | 158/378 [05:35<09:01, 2.46s/it] 42%|####2 | 160/378 [05:37<06:48, 1.87s/it] 43%|####2 | 161/378 [05:39<07:25, 2.05s/it] 43%|####2 | 162/378 [05:43<08:33, 2.38s/it] 43%|####3 | 164/378 [05:45<06:40, 1.87s/it] 44%|####3 | 165/378 [05:48<07:20, 2.07s/it] 44%|####3 | 166/378 [05:51<08:44, 2.47s/it] 44%|####4 | 168/378 [05:54<07:12, 2.06s/it] 45%|####4 | 169/378 [05:57<07:45, 2.23s/it] 45%|####4 | 170/378 [06:01<09:18, 2.69s/it] 46%|####5 | 172/378 [06:04<07:05, 2.06s/it] 46%|####5 | 173/378 [06:06<07:29, 2.19s/it] 46%|####6 | 174/378 [06:10<08:59, 2.65s/it] 47%|####6 | 176/378 [06:13<07:08, 2.12s/it] 47%|####6 | 177/378 [06:16<07:32, 2.25s/it] 47%|####7 | 178/378 [06:20<08:56, 2.68s/it] 48%|####7 | 180/378 [06:23<07:13, 2.19s/it] 48%|####7 | 181/378 [06:26<07:37, 2.32s/it] 48%|####8 | 182/378 [06:29<08:32, 2.61s/it] 49%|####8 | 184/378 [06:32<07:10, 2.22s/it] 49%|####8 | 185/378 [06:35<07:23, 2.30s/it] 49%|####9 | 186/378 [06:39<08:29, 2.65s/it] 50%|####9 | 188/378 [06:42<06:47, 2.14s/it] 50%|##### | 189/378 [06:44<06:43, 2.14s/it] 50%|##### | 190/378 [06:47<07:50, 2.50s/it] 51%|##### | 192/378 [06:50<06:27, 2.08s/it] 51%|#####1 | 193/378 [06:52<06:32, 2.12s/it] 51%|#####1 | 194/378 [06:56<07:36, 2.48s/it] 52%|#####1 | 196/378 [06:59<06:15, 2.06s/it] 52%|#####2 | 197/378 [07:01<06:17, 2.09s/it] 52%|#####2 | 198/378 [07:05<07:11, 2.40s/it] 53%|#####2 | 200/378 [07:08<06:02, 2.03s/it] 53%|#####3 | 201/378 [07:10<06:02, 2.05s/it] 53%|#####3 | 202/378 [07:13<07:01, 2.40s/it] 54%|#####3 | 204/378 [07:16<05:52, 2.03s/it] 54%|#####4 | 205/378 [07:18<05:50, 2.02s/it] 54%|#####4 | 206/378 [07:21<06:42, 2.34s/it] 55%|#####5 | 208/378 [07:25<05:41, 2.01s/it] 55%|#####5 | 209/378 [07:27<05:40, 2.02s/it] 56%|#####5 | 210/378 [07:30<06:29, 2.32s/it] 56%|#####6 | 212/378 [07:33<05:33, 2.01s/it] 56%|#####6 | 213/378 [07:35<05:34, 2.03s/it] 57%|#####6 | 214/378 [07:38<06:22, 2.33s/it] 57%|#####7 | 216/378 [07:44<06:52, 2.55s/it] 57%|#####7 | 217/378 [07:47<07:16, 2.71s/it] 58%|#####7 | 219/378 [07:54<07:39, 2.89s/it] 58%|#####8 | 220/378 [07:57<07:43, 2.93s/it] 59%|#####8 | 222/378 [08:02<07:27, 2.87s/it] 59%|#####8 | 223/378 [08:05<07:33, 2.93s/it] 60%|#####9 | 225/378 [08:11<07:36, 2.98s/it] 60%|#####9 | 226/378 [08:14<07:31, 2.97s/it] 60%|###### | 228/378 [08:21<07:37, 3.05s/it] 61%|###### | 229/378 [08:24<07:49, 3.15s/it] 61%|######1 | 231/378 [08:31<07:46, 3.17s/it] 61%|######1 | 232/378 [08:34<07:47, 3.20s/it] 62%|######1 | 234/378 [08:40<07:22, 3.07s/it] 62%|######2 | 235/378 [08:52<11:54, 5.00s/it] 63%|######2 | 238/378 [08:53<06:35, 2.82s/it] 63%|######3 | 239/378 [09:02<09:06, 3.93s/it] 64%|######3 | 241/378 [09:02<05:55, 2.60s/it] 64%|######4 | 242/378 [09:03<05:04, 2.24s/it] 64%|######4 | 243/378 [09:11<07:47, 3.46s/it] 65%|######4 | 245/378 [09:11<04:47, 2.16s/it] 65%|######5 | 246/378 [09:12<04:10, 1.89s/it] 65%|######5 | 247/378 [09:19<07:05, 3.25s/it] 66%|######5 | 249/378 [09:20<04:15, 1.98s/it] 66%|######6 | 250/378 [09:21<03:48, 1.78s/it] 66%|######6 | 251/378 [09:28<06:35, 3.11s/it] 67%|######6 | 253/378 [09:28<03:55, 1.88s/it] 67%|######7 | 254/378 [09:29<03:33, 1.72s/it] 67%|######7 | 255/378 [09:37<06:36, 3.22s/it] 68%|######7 | 257/378 [09:38<03:56, 1.95s/it] 68%|######8 | 258/378 [09:39<03:28, 1.74s/it] 69%|######8 | 259/378 [09:46<06:09, 3.11s/it] 69%|######9 | 261/378 [09:46<03:39, 1.87s/it] 69%|######9 | 262/378 [09:47<03:12, 1.66s/it] 70%|######9 | 263/378 [09:55<06:05, 3.18s/it] 70%|######9 | 264/378 [09:55<04:33, 2.40s/it] 70%|####### | 265/378 [09:56<03:46, 2.00s/it] 70%|####### | 266/378 [09:59<04:04, 2.18s/it] 71%|####### | 267/378 [10:03<05:12, 2.82s/it] 71%|####### | 268/378 [10:03<03:44, 2.04s/it] 71%|#######1 | 269/378 [10:04<03:06, 1.71s/it] 71%|#######1 | 270/378 [10:07<03:40, 2.04s/it] 72%|#######1 | 271/378 [10:11<04:54, 2.76s/it] 72%|#######1 | 272/378 [10:12<03:30, 1.98s/it] 72%|#######2 | 273/378 [10:13<03:00, 1.72s/it] 72%|#######2 | 274/378 [10:16<03:52, 2.23s/it] 73%|#######2 | 275/378 [10:20<04:57, 2.88s/it] 73%|#######3 | 276/378 [10:21<03:30, 2.07s/it] 73%|#######3 | 277/378 [10:22<03:01, 1.80s/it] 74%|#######3 | 278/378 [10:25<03:40, 2.20s/it] 74%|#######3 | 279/378 [10:30<04:56, 2.99s/it] 74%|#######4 | 280/378 [10:30<03:28, 2.13s/it] 74%|#######4 | 281/378 [10:31<03:03, 1.89s/it] 75%|#######4 | 282/378 [10:34<03:16, 2.04s/it] 75%|#######4 | 283/378 [10:37<04:03, 2.56s/it] 75%|#######5 | 284/378 [10:38<03:02, 1.94s/it] 75%|#######5 | 285/378 [10:39<02:33, 1.65s/it] 76%|#######5 | 286/378 [10:42<03:13, 2.10s/it] 76%|#######5 | 287/378 [10:47<04:23, 2.89s/it] 76%|#######6 | 289/378 [10:48<02:48, 1.90s/it] 77%|#######6 | 290/378 [10:51<03:04, 2.09s/it] 77%|#######6 | 291/378 [10:55<03:41, 2.54s/it] 78%|#######7 | 293/378 [10:57<02:44, 1.94s/it] 78%|#######7 | 294/378 [10:59<02:40, 1.91s/it] 78%|#######8 | 295/378 [11:03<03:25, 2.48s/it] 79%|#######8 | 297/378 [11:05<02:35, 1.92s/it] 79%|#######8 | 298/378 [11:07<02:27, 1.85s/it] 79%|#######9 | 299/378 [11:11<03:10, 2.42s/it] 80%|#######9 | 301/378 [11:13<02:27, 1.92s/it] 80%|#######9 | 302/378 [11:15<02:20, 1.85s/it] 80%|######## | 303/378 [11:19<02:55, 2.34s/it] 81%|######## | 305/378 [11:21<02:18, 1.90s/it] 81%|######## | 306/378 [11:23<02:12, 1.84s/it] 81%|########1 | 307/378 [11:27<02:48, 2.38s/it] 82%|########1 | 309/378 [11:30<02:11, 1.91s/it] 82%|########2 | 310/378 [11:31<02:02, 1.80s/it] 82%|########2 | 311/378 [11:35<02:32, 2.28s/it] 83%|########2 | 313/378 [11:37<01:59, 1.83s/it] 83%|########3 | 314/378 [11:38<01:48, 1.70s/it] 83%|########3 | 315/378 [11:42<02:20, 2.24s/it] 84%|########3 | 316/378 [11:42<01:44, 1.69s/it] 84%|########3 | 317/378 [11:45<01:54, 1.87s/it] 84%|########4 | 318/378 [11:46<01:41, 1.69s/it] 84%|########4 | 319/378 [11:50<02:14, 2.27s/it] 85%|########4 | 320/378 [11:50<01:35, 1.65s/it] 85%|########4 | 321/378 [11:52<01:47, 1.89s/it] 85%|########5 | 322/378 [11:54<01:35, 1.70s/it] 85%|########5 | 323/378 [11:58<02:10, 2.38s/it] 86%|########5 | 324/378 [11:58<01:32, 1.71s/it] 86%|########5 | 325/378 [12:01<01:48, 2.05s/it] 86%|########6 | 326/378 [12:02<01:34, 1.82s/it] 87%|########6 | 327/378 [12:06<02:00, 2.37s/it] 87%|########7 | 329/378 [12:08<01:31, 1.86s/it] 87%|########7 | 330/378 [12:09<01:22, 1.72s/it] 88%|########7 | 331/378 [12:13<01:45, 2.24s/it] 88%|########8 | 333/378 [12:16<01:22, 1.83s/it] 88%|########8 | 334/378 [12:17<01:16, 1.73s/it] 89%|########8 | 335/378 [12:21<01:41, 2.36s/it] 89%|########9 | 337/378 [12:24<01:20, 1.97s/it] 89%|########9 | 338/378 [12:26<01:14, 1.87s/it] 90%|########9 | 339/378 [12:30<01:37, 2.50s/it] 90%|########9 | 340/378 [12:30<01:11, 1.87s/it] 90%|######### | 341/378 [12:33<01:18, 2.13s/it] 90%|######### | 342/378 [12:34<01:08, 1.91s/it] 91%|######### | 343/378 [12:38<01:27, 2.51s/it] 91%|#########1| 344/378 [12:38<01:01, 1.82s/it] 91%|#########1| 345/378 [12:41<01:09, 2.12s/it] 92%|#########1| 346/378 [12:43<00:59, 1.86s/it] 92%|#########1| 347/378 [12:47<01:18, 2.53s/it] 92%|#########2| 349/378 [12:50<00:59, 2.07s/it] 93%|#########2| 350/378 [12:51<00:52, 1.86s/it] 93%|#########2| 351/378 [12:55<01:05, 2.42s/it] 93%|#########3| 353/378 [12:58<00:50, 2.02s/it] 94%|#########3| 354/378 [13:03<01:06, 2.75s/it] 94%|#########4| 356/378 [13:06<00:49, 2.25s/it] 94%|#########4| 357/378 [13:11<00:59, 2.84s/it] 95%|#########4| 359/378 [13:14<00:44, 2.33s/it] 95%|#########5| 360/378 [13:19<00:51, 2.86s/it] 96%|#########5| 362/378 [13:22<00:37, 2.37s/it] 96%|#########6| 363/378 [13:25<00:37, 2.50s/it] 96%|#########6| 364/378 [13:28<00:36, 2.59s/it] 97%|#########6| 365/378 [13:32<00:37, 2.91s/it] 97%|#########6| 366/378 [13:34<00:34, 2.84s/it] 97%|#########7| 367/378 [13:37<00:30, 2.82s/it] 97%|#########7| 368/378 [13:48<00:50, 5.09s/it] 98%|#########7| 369/378 [13:53<00:45, 5.02s/it] 98%|#########7| 370/378 [13:53<00:29, 3.68s/it] 98%|#########8| 371/378 [13:57<00:26, 3.77s/it] 98%|#########8| 372/378 [14:00<00:20, 3.37s/it] 99%|#########8| 373/378 [14:05<00:19, 3.86s/it] 99%|#########8| 374/378 [14:05<00:11, 2.89s/it] 99%|#########9| 375/378 [14:07<00:07, 2.63s/it] 99%|#########9| 376/378 [14:09<00:04, 2.47s/it] 100%|#########9| 377/378 [14:14<00:03, 3.01s/it] 100%|##########| 378/378 [14:14<00:00, 2.28s/it] 100%|##########| 378/378 [14:14<00:00, 2.26s/it]
=== sanitized samples jsonl follows ===
{"task_id": "Mbpp/2", "solution": "def similar_elements(list1, list2):\n \"\"\"\n Find the shared elements from the given two lists.\n \n Parameters:\n - list1: First list of elements.\n - list2: Second list of elements.\n \n Returns:\n A set containing the shared elements between the two lists.\n \"\"\"\n # Convert both lists to sets\n set1 = set(list1)\n set2 = set(list2)\n \n # Find the intersection of the two sets\n shared_elements = set1.intersection(set2)\n \n return shared_elements"}
{"task_id": "Mbpp/3", "solution": "def is_not_prime(n):\n \"\"\"\n Determine if a number n is not a prime number.\n \n Args:\n n (int): The number to check.\n \n Returns:\n bool: True if n is not a prime number, False otherwise.\n \"\"\"\n # A prime number must be greater than 1\n if n <= 1:\n return True\n \n # Check for factors from 2 up to the square root of n\n for i in range(2, int(n**0.5) + 1):\n if n % i == 0:\n return True\n \n # If no factors were found, n is a prime number\n return False"}
{"task_id": "Mbpp/4", "solution": "import heapq\ndef heap_queue_largest(numbers, n):\n \"\"\"\n Find the n largest integers from a given list of numbers.\n \n Parameters:\n - numbers: List[int], the list of numbers to search through.\n - n: int, the number of largest integers to find.\n \n Returns:\n - List[int]: The n largest integers in descending order.\n \"\"\"\n # Use nlargest from heapq to get the n largest elements\n largest_n = heapq.nlargest(n, numbers)\n return largest_n"}
{"task_id": "Mbpp/6", "solution": "def differ_At_One_Bit_Pos(num1, num2):\n # Perform XOR to find differing bits\n xor_result = num1 ^ num2\n \n # Check if xor_result is a power of two (i.e., only one bit set)\n return xor_result != 0 and (xor_result & (xor_result - 1)) == 0"}
{"task_id": "Mbpp/7", "solution": "def find_char_long(input_string):\n \"\"\"\n Find all words in the input string that are at least 4 characters long.\n \n Parameters:\n - input_string (str): The string to search for words.\n \n Returns:\n - list: A list of words with a length of at least 4 characters.\n \"\"\"\n # Split the input string into words\n words = input_string.split()\n \n # Filter words that have a length of at least 4 characters\n long_words = [word for word in words if len(word) >= 4]\n \n return long_words"}
{"task_id": "Mbpp/8", "solution": "def square_nums(numbers):\n \"\"\"\n This function takes a list of numbers as input and returns a new list containing \n the squares of each number from the original list.\n \n :param numbers: List of integers or floats.\n :return: A list with the squares of the input numbers.\n \"\"\"\n return [num ** 2 for num in numbers]"}
{"task_id": "Mbpp/9", "solution": "def find_Rotations(s):\n # Concatenate the string with itself\n doubled_string = s + s\n \n # Iterate over possible rotations from 1 to len(s)\n for i in range(1, len(s) + 1):\n # Check if a rotation of length 'i' results in the original string\n if doubled_string[i:i+len(s)] == s:\n return i"}
{"task_id": "Mbpp/11", "solution": "def remove_occ(s, char):\n \"\"\"\n Remove the first and last occurrence of 'char' in the string 's'.\n \n Parameters:\n s (str): The input string.\n char (str): The character to be removed from the string.\n \n Returns:\n str: A new string with the first and last occurrences of 'char' removed.\n \"\"\"\n if not s or len(char) != 1:\n return s\n \n # Find the first occurrence\n first_index = s.find(char)\n if first_index == -1:\n return s\n \n # Find the last occurrence\n last_index = s.rfind(char)\n \n # Remove the first and last occurrences\n new_s = s[:first_index] + s[first_index+1:last_index] + s[last_index+1:]\n \n return new_s\n\n# Test case\nassert remove_occ(\"hello\", \"l\") == \"heo\""}
{"task_id": "Mbpp/12", "solution": "def sort_matrix(matrix):\n \"\"\"\n Sorts the given matrix in ascending order according to the sum of its rows.\n \n Parameters:\n matrix (list of lists): A 2D list where each sublist represents a row of the matrix.\n \n Returns:\n list of lists: The sorted matrix with rows ordered by their sums.\n \"\"\"\n # Sort the matrix using the sum of each row as the key\n return sorted(matrix, key=lambda row: sum(row))"}
{"task_id": "Mbpp/14", "solution": "def find_volume(base_length, triangle_height, prism_depth):\n \"\"\"\n Calculate the volume of a triangular prism.\n \n Parameters:\n - base_length: Length of the base of the triangular face.\n - triangle_height: Height of the triangular face.\n - prism_depth: Depth (or length) of the prism.\n \n Returns:\n - Volume of the triangular prism.\n \"\"\"\n # Calculate the area of the triangular base\n triangular_area = 0.5 * base_length * triangle_height\n \n # Calculate the volume of the prism\n volume = triangular_area * prism_depth\n \n return volume\n\n# Test case to verify the function works as expected\nassert find_volume(10, 8, 6) == 240"}
{"task_id": "Mbpp/16", "solution": "import re\ndef text_lowercase_underscore(s):\n \"\"\"\n Check if the input string contains sequences of lowercase letters joined with an underscore.\n \n Args:\n s (str): The input string to check.\n \n Returns:\n bool: True if the string matches the pattern, False otherwise.\n \"\"\"\n # Define a regular expression pattern for matching\n # one or more lowercase letters followed by an underscore,\n # repeated zero or more times, and ending with one or more lowercase letters.\n pattern = r'^[a-z]+(_[a-z]+)*$'\n \n # Use the fullmatch method to check if the entire string matches the pattern\n return bool(re.fullmatch(pattern, s))"}
{"task_id": "Mbpp/17", "solution": "def square_perimeter(side_length):\n \"\"\"\n Calculate the perimeter of a square given its side length.\n \n Parameters:\n side_length (float or int): The length of one side of the square.\n \n Returns:\n float: The perimeter of the square.\n \"\"\"\n # Perimeter of a square is 4 times the side length\n return 4 * side_length"}
{"task_id": "Mbpp/18", "solution": "def remove_dirty_chars(s1, s2):\n \"\"\"\n Remove characters from the first string (s1) which are present in the second string (s2).\n \n Parameters:\n s1 (str): The original string from which characters will be removed.\n s2 (str): The string containing characters to be removed from s1.\n\n Returns:\n str: A new string with specified characters removed.\n \"\"\"\n # Create a set of characters to remove for efficient lookup\n chars_to_remove = set(s2)\n \n # Use a list comprehension to filter out unwanted characters\n result = ''.join(char for char in s1 if char not in chars_to_remove)\n \n return result"}
{"task_id": "Mbpp/19", "solution": "def test_duplicate(arr):\n \"\"\"\n Check if the given list contains any duplicate elements.\n \n Parameters:\n arr (list): A list of integers.\n \n Returns:\n bool: True if there are duplicates, False otherwise.\n \"\"\"\n seen = set()\n for num in arr:\n if num in seen:\n return True\n seen.add(num)\n return False"}
{"task_id": "Mbpp/20", "solution": "def is_woodall(num):\n \"\"\"\n Check if the given number is a Woodall number.\n \n A Woodall number is of the form n * 2^n - 1 for some positive integer n.\n \n Args:\n num (int): The number to check.\n \n Returns:\n bool: True if the number is a Woodall number, False otherwise.\n \"\"\"\n # Start with n = 1 and incrementally test each value\n n = 1\n \n while True:\n woodall_number = n * (2 ** n) - 1\n \n # If we've exceeded or matched the given number, break out of the loop\n if woodall_number > num:\n break\n \n # Check if the current Woodall number matches the input number\n if woodall_number == num:\n return True\n \n # Increment n for the next iteration\n n += 1\n \n # If no matching Woodall number was found, return False\n return False"}
{"task_id": "Mbpp/56", "solution": "def reverse_number(n):\n \"\"\"Helper function to reverse the digits of a number.\"\"\"\n return int(str(n)[::-1])\ndef check(number):\n \"\"\"\n Check if a given number is one less than twice its reverse.\n \n Args:\n number (int): The number to be checked.\n \n Returns:\n bool: True if the condition is met, False otherwise.\n \"\"\"\n reversed_number = reverse_number(number)\n return number == 2 * reversed_number - 1"}
{"task_id": "Mbpp/57", "solution": "def find_Max_Num(digits):\n # Convert each digit to a string\n str_digits = [str(digit) for digit in digits]\n \n # Sort the string representations of the digits in descending order\n str_digits.sort(reverse=True)\n \n # Join them into one string and convert back to an integer\n largest_number = int(''.join(str_digits))\n \n return largest_number"}
{"task_id": "Mbpp/58", "solution": "def opposite_signs(a, b):\n \"\"\"\n Check whether the given two integers have opposite signs.\n \n Parameters:\n a (int): First integer\n b (int): Second integer\n \n Returns:\n bool: True if the integers have opposite signs, False otherwise.\n \"\"\"\n # Two numbers have opposite signs if their product is negative\n return (a < 0) != (b < 0)\n\n# Test cases to verify the function works as expected\nassert opposite_signs(1, -2) == True, \"Test case 1 failed\"\nassert opposite_signs(-3, 4) == True, \"Test case 2 failed\"\nassert opposite_signs(5, -6) == True, \"Test case 3 failed\"\nassert opposite_signs(-7, -8) == False, \"Test case 4 failed\"\nassert opposite_signs(9, 10) == False, \"Test case 5 failed\"\n\nprint(\"All test cases passed!\")"}
{"task_id": "Mbpp/59", "solution": "def is_octagonal(x):\n \"\"\"\n Check if a given number x is an octagonal number by solving\n the quadratic equation derived from O(n) = x for n.\n\n Parameters:\n x (int): The number to check.\n\n Returns:\n bool: True if x is an octagonal number, False otherwise.\n \"\"\"\n # Solve 3n^2 - 2n - x = 0 using the quadratic formula\n # a = 3, b = -2, c = -x\n a = 3\n b = -2\n c = -x\n\n # Calculate the discriminant\n discriminant = b**2 - 4 * a * c\n\n if discriminant < 0:\n return False\n\n # Calculate the two possible solutions for n\n sqrt_discriminant = discriminant**0.5\n n1 = (-b + sqrt_discriminant) / (2 * a)\n n2 = (-b - sqrt_discriminant) / (2 * a)\n\n # Check if either solution is a positive integer\n return n1.is_integer() and n1 > 0 or n2.is_integer() and n2 > 0"}
{"task_id": "Mbpp/61", "solution": "def count_substrings(s):\n def digit_sum(substring):\n return sum(int(char) for char in substring)\n \n n = len(s)\n count = 0\n \n # Iterate over all possible starting points of substrings\n for start in range(n):\n current_sum = 0\n \n # Iterate over all possible ending points of substrings\n for end in range(start, n):\n current_sum += int(s[end])\n \n # Check if the sum of digits equals the length of the substring\n if current_sum == (end - start + 1):\n count += 1\n \n return count\n\n# Test case\nassert count_substrings('112112') == 6"}
{"task_id": "Mbpp/62", "solution": "def smallest_num(numbers):\n \"\"\"\n This function takes a list of numbers as input and returns the smallest number.\n \n Parameters:\n numbers (list): A list of integers or floats.\n \n Returns:\n int/float: The smallest number in the list.\n \n Raises:\n ValueError: If the input list is empty.\n \"\"\"\n if not numbers:\n raise ValueError(\"The list cannot be empty.\")\n \n return min(numbers)"}
{"task_id": "Mbpp/63", "solution": "def max_difference(pairs):\n # Initialize a variable to keep track of the maximum difference found\n max_diff = 0\n \n # Iterate over each pair in the list\n for a, b in pairs:\n # Calculate the absolute difference between the two numbers in the current pair\n diff = abs(a - b)\n \n # Update max_diff if the current difference is greater than the previously recorded maximum\n if diff > max_diff:\n max_diff = diff\n \n return max_diff"}
{"task_id": "Mbpp/64", "solution": "def subject_marks(subjects):\n \"\"\"\n Sorts a list of tuples based on the second element (marks) in each tuple.\n \n Parameters:\n subjects (list of tuples): A list where each tuple contains a subject name and its corresponding marks.\n \n Returns:\n list: The sorted list of tuples by marks in ascending order.\n \"\"\"\n # Sort the list using the second item of each tuple\n return sorted(subjects, key=lambda x: x[1])"}
{"task_id": "Mbpp/65", "solution": "def recursive_list_sum(nested_list):\n \"\"\"\n This function takes a nested list as input and returns the sum of all its elements.\n \n Parameters:\n nested_list (list): A list that may contain integers or other lists\n \n Returns:\n int: The sum of all integer elements in the nested list\n \"\"\"\n total_sum = 0\n\n for element in nested_list:\n if isinstance(element, list):\n # If the element is a list, recursively call this function\n total_sum += recursive_list_sum(element)\n else:\n # Otherwise, add the element to the total sum\n total_sum += element\n \n return total_sum"}
{"task_id": "Mbpp/66", "solution": "def pos_count(lst):\n \"\"\"\n Count the number of positive numbers in a list.\n\n Parameters:\n lst (list): A list of integers.\n\n Returns:\n int: The count of positive numbers in the list.\n \"\"\"\n # Use a generator expression to filter and count positive numbers\n return sum(1 for num in lst if num > 0)"}
{"task_id": "Mbpp/67", "solution": "def bell_number(n):\n \"\"\"\n Calculate the n-th Bell number.\n \n Parameters:\n n (int): The index of the Bell number to calculate.\n \n Returns:\n int: The n-th Bell number.\n \"\"\"\n # Create a 2D list to store intermediate results\n bell = [[0 for i in range(n+1)] for j in range(n+1)]\n \n # Base case: B_0 is 1\n bell[0][0] = 1\n \n # Fill the Bell triangle\n for i in range(1, n+1):\n # Explicitly set the first value of each row\n bell[i][0] = bell[i-1][i-1]\n \n # Fill the rest of the values using the recursive relation\n for j in range(1, i+1):\n bell[i][j] = bell[i-1][j-1] + bell[i][j-1]\n \n # The Bell number B_n is the first element of the nth row\n return bell[n][0]"}
{"task_id": "Mbpp/68", "solution": "def is_monotonic(arr):\n \"\"\"\n Check whether the given array is monotonic.\n \n An array is monotonic if it is either entirely non-increasing or non-decreasing.\n \n Parameters:\n arr (list): The list of integers to check for monotonicity.\n \n Returns:\n bool: True if the array is monotonic, False otherwise.\n \"\"\"\n # Check if the array has less than 2 elements\n if len(arr) < 2:\n return True\n \n # Determine if the array is non-decreasing or non-increasing\n increasing = decreasing = True\n \n for i in range(1, len(arr)):\n if arr[i] > arr[i - 1]:\n decreasing = False\n elif arr[i] < arr[i - 1]:\n increasing = False\n \n # If the array is neither increasing nor decreasing, return False\n if not increasing and not decreasing:\n return False\n \n return True\n\n# Test case\nassert is_monotonic([6, 5, 4, 4]) == True"}
{"task_id": "Mbpp/69", "solution": "def is_sublist(main_list, sub_list):\n \"\"\"\n Check if sub_list is a sublist of main_list.\n \n Parameters:\n - main_list: List where we need to check for the presence of sub_list.\n - sub_list: List that needs to be checked as a sublist within main_list.\n\n Returns:\n - True if sub_list is a sublist of main_list, False otherwise.\n \"\"\"\n # Lengths of both lists\n len_main = len(main_list)\n len_sub = len(sub_list)\n\n # If the sub_list is longer than the main_list, it can't be a sublist\n if len_sub > len_main:\n return False\n\n # Iterate over the main list to find a starting point for comparison\n for i in range(len_main - len_sub + 1):\n # Check if the slice of main_list matches sub_list\n if main_list[i:i+len_sub] == sub_list:\n return True\n \n # If no match is found, return False\n return False"}
{"task_id": "Mbpp/70", "solution": "def get_equal(tuples_list):\n \"\"\"\n Check if all tuples in the list have the same length.\n \n Parameters:\n tuples_list (list of tuple): A list containing tuples.\n \n Returns:\n bool: True if all tuples have the same length, False otherwise.\n \"\"\"\n # Get the length of the first tuple\n if not tuples_list:\n return True # An empty list is considered to have equal lengths\n \n first_length = len(tuples_list[0])\n \n # Check each tuple in the list\n for t in tuples_list:\n if len(t) != first_length:\n return False\n \n return True"}
{"task_id": "Mbpp/71", "solution": "def comb_sort(arr):\n def getNextGap(gap):\n # Shrink gap by Shrink factor\n gap = (gap * 10) // 13\n if gap < 1:\n return 1\n return gap\n\n n = len(arr)\n gap = n\n swapped = True\n\n while gap != 1 or swapped:\n # Find next gap\n gap = getNextGap(gap)\n\n # Initialize swapped as false so that we can check if swap happened or not\n swapped = False\n\n for i in range(0, n - gap):\n # Compare elements with current gap\n if arr[i] > arr[i + gap]:\n arr[i], arr[i + gap] = arr[i + gap], arr[i]\n swapped = True\n\n return arr"}
{"task_id": "Mbpp/72", "solution": "def dif_Square(n):\n # If n is odd or a multiple of 4, it can be expressed as the difference of two squares.\n return n % 2 != 0 or n % 4 == 0"}
{"task_id": "Mbpp/74", "solution": "def is_samepatterns(seq1, seq2):\n \"\"\"\n Check if two sequences follow the same pattern.\n \n Args:\n seq1 (list): First list of elements.\n seq2 (list): Second list of elements to compare with the first one.\n \n Returns:\n bool: True if both lists follow the same sequence pattern, False otherwise.\n \"\"\"\n # Check if lengths are different\n if len(seq1) != len(seq2):\n return False\n \n # Create a mapping from seq1 to seq2 and vice versa\n map_seq1_to_seq2 = {}\n map_seq2_to_seq1 = {}\n \n for item1, item2 in zip(seq1, seq2):\n # Check if there's an inconsistency in the mapping\n if (item1 in map_seq1_to_seq2 and map_seq1_to_seq2[item1] != item2) or \\\n (item2 in map_seq2_to_seq1 and map_seq2_to_seq1[item2] != item1):\n return False\n \n # Create a new mapping\n map_seq1_to_seq2[item1] = item2\n map_seq2_to_seq1[item2] = item1\n \n return True"}
{"task_id": "Mbpp/75", "solution": "def find_tuples(tuples_list, k):\n \"\"\"\n This function takes a list of tuples and an integer k.\n It returns a new list containing only those tuples where every element is divisible by k.\n\n :param tuples_list: List of tuples to be checked\n :param k: The divisor\n :return: A list of tuples with all elements divisible by k\n \"\"\"\n result = []\n \n for tup in tuples_list:\n # Check if all elements in the tuple are divisible by k\n if all(element % k == 0 for element in tup):\n result.append(tup)\n \n return result"}
{"task_id": "Mbpp/77", "solution": "def is_divisible_by_11(n):\n \"\"\"\n Check if a number n is divisible by 11.\n \n Args:\n n (int): The number to check.\n \n Returns:\n bool: True if n is divisible by 11, False otherwise.\n \"\"\"\n # Convert the number to string for easy digit manipulation\n num_str = str(n)\n \n # Initialize sums for alternating digits\n odd_sum = 0\n even_sum = 0\n \n # Iterate over each character in the string representation of the number\n for i, char in enumerate(num_str):\n digit = int(char)\n \n if (i + 1) % 2 == 0:\n even_sum += digit\n else:\n odd_sum += digit\n \n # Calculate the difference between the sums\n diff = abs(odd_sum - even_sum)\n \n # A number is divisible by 11 if this difference is a multiple of 11\n return diff % 11 == 0\n\n# Test case\nassert is_divisible_by_11(12345) == False"}
{"task_id": "Mbpp/79", "solution": "def word_len(word):\n \"\"\"\n Check whether the length of the word is odd or not.\n \n Parameters:\n word (str): The input string whose length is to be checked.\n \n Returns:\n bool: False if the length is even, True if the length is odd.\n \"\"\"\n # Calculate the length of the word\n length = len(word)\n \n # Check if the length is odd\n return length % 2 != 0"}
{"task_id": "Mbpp/80", "solution": "def tetrahedral_number(n):\n \"\"\"\n Calculate the nth tetrahedral number.\n \n Parameters:\n n (int): The position in the sequence of tetrahedral numbers.\n \n Returns:\n int: The nth tetrahedral number.\n \"\"\"\n return n * (n + 1) * (n + 2) // 6"}
{"task_id": "Mbpp/82", "solution": "import math\ndef volume_sphere(radius):\n \"\"\"\n Calculate the volume of a sphere given its radius.\n \n Parameters:\n radius (float): The radius of the sphere.\n \n Returns:\n float: The volume of the sphere.\n \"\"\"\n # Volume formula for a sphere: V = 4/3 * \u03c0 * r^3\n return (4.0 / 3.0) * math.pi * (radius ** 3)"}
{"task_id": "Mbpp/84", "solution": "def sequence(n):\n if n < 1:\n raise ValueError(\"n must be a positive integer.\")\n \n # Initialize the sequence with base cases\n seq = [0] * (n + 1)\n seq[1], seq[2] = 1, 1\n \n for i in range(3, n + 1):\n seq[i] = seq[seq[i - 1]] + seq[i - seq[i - 1]]\n \n return seq[n]"}
{"task_id": "Mbpp/85", "solution": "import math\ndef surfacearea_sphere(radius):\n \"\"\"\n Calculate the surface area of a sphere given its radius.\n \n Parameters:\n radius (float): The radius of the sphere.\n \n Returns:\n float: The surface area of the sphere.\n \"\"\"\n # Surface area formula for a sphere is 4 * pi * r^2\n return 4 * math.pi * radius ** 2"}
{"task_id": "Mbpp/86", "solution": "def centered_hexagonal_number(n):\n \"\"\"\n Calculate the nth centered hexagonal number.\n \n :param n: The position in the sequence (1-based index).\n :return: The nth centered hexagonal number.\n \"\"\"\n return 3 * n * (n - 1) + 1"}
{"task_id": "Mbpp/87", "solution": "def merge_dictionaries_three(dict1, dict2, dict3):\n \"\"\"\n Merges three dictionaries into one.\n \n In case of key conflicts, the value from the last dictionary with that key is used.\n \n Args:\n - dict1: First dictionary to merge.\n - dict2: Second dictionary to merge.\n - dict3: Third dictionary to merge.\n \n Returns:\n A single merged dictionary.\n \"\"\"\n # Start by copying all items from the first dictionary\n merged_dict = dict1.copy()\n \n # Update with items from the second dictionary\n merged_dict.update(dict2)\n \n # Finally, update with items from the third dictionary\n merged_dict.update(dict3)\n \n return merged_dict"}
{"task_id": "Mbpp/88", "solution": "def freq_count(lst):\n \"\"\"\n Calculate the frequency of each element in the given list.\n \n Parameters:\n lst (list): A list of integers or other hashable items.\n \n Returns:\n dict: A dictionary with elements as keys and their frequencies as values.\n \"\"\"\n frequency = {}\n for item in lst:\n if item in frequency:\n frequency[item] += 1\n else:\n frequency[item] = 1\n return frequency"}
{"task_id": "Mbpp/89", "solution": "def closest_smaller_number(n):\n \"\"\"\n This function finds the closest smaller number than the given integer `n`.\n \n Parameters:\n n (int): The input number for which we need to find the closest smaller number.\n \n Returns:\n int: The closest smaller number than `n`. If no such number exists, returns None.\n \"\"\"\n if n <= 0:\n return None\n return n - 1\n\n# Test case\nassert closest_smaller_number(11) == 10"}
{"task_id": "Mbpp/90", "solution": "def len_longest_word(words):\n \"\"\"\n This function takes a list of words and returns the length of the longest word.\n \n :param words: List of strings\n :return: Integer representing the length of the longest word\n \"\"\"\n if not words:\n return 0\n \n max_length = 0\n for word in words:\n if len(word) > max_length:\n max_length = len(word)\n \n return max_length\n\n# Test case to verify the function works as expected\nassert len_longest_word([\"python\", \"PHP\", \"bigdata\"]) == 7"}
{"task_id": "Mbpp/91", "solution": "def find_substring(string_list, substring):\n \"\"\"\n Check if a substring is present as a part of any string in the provided list.\n \n Parameters:\n - string_list: List[str] : A list of strings to search through.\n - substring: str : The substring to look for within the list elements.\n\n Returns:\n - bool : True if the substring is found, False otherwise.\n \"\"\"\n # Iterate over each string in the list\n for s in string_list:\n # Check if the current string contains the substring\n if substring in s:\n return True\n # If no string contained the substring, return False\n return False"}
{"task_id": "Mbpp/92", "solution": "def is_undulating(number):\n \"\"\"\n Check whether the given number is undulating or not.\n \n Args:\n number (int): The number to check.\n \n Returns:\n bool: True if the number is undulating, False otherwise.\n \"\"\"\n # Convert the number to a string for easy manipulation\n num_str = str(number)\n \n # An undulating number must have at least 3 digits\n if len(num_str) < 3:\n return False\n \n # Extract the first two digits\n first_digit, second_digit = num_str[0], num_str[1]\n \n # The first two digits must be different\n if first_digit == second_digit:\n return False\n \n # Check the repeating pattern of the first two digits throughout the number\n for i in range(2, len(num_str)):\n if (i % 2 == 0 and num_str[i] != first_digit) or (i % 2 == 1 and num_str[i] != second_digit):\n return False\n \n # If all checks pass, it's an undulating number\n return True"}
{"task_id": "Mbpp/93", "solution": "def power(a, b):\n \"\"\"\n Calculate the value of 'a' raised to the power 'b'.\n \n Parameters:\n a (int or float): The base number.\n b (int): The exponent (must be a non-negative integer).\n \n Returns:\n int or float: The result of a^b.\n \"\"\"\n # Base case: any number to the power of 0 is 1\n if b == 0:\n return 1\n \n # Recursive case: multiply 'a' by the result of 'a' raised to the power 'b-1'\n return a * power(a, b - 1)"}
{"task_id": "Mbpp/94", "solution": "def index_minimum(tuples_list):\n # Find the tuple with the smallest second value using min function and key parameter\n min_tuple = min(tuples_list, key=lambda x: x[1])\n # Return the first element of that tuple\n return min_tuple[0]"}
{"task_id": "Mbpp/95", "solution": "def Find_Min_Length(list_of_lists):\n \"\"\"\n This function takes a list of lists and returns the length of the shortest list.\n \n Parameters:\n list_of_lists (list): A list containing other lists as elements.\n \n Returns:\n int: The length of the smallest list in the input list of lists.\n \"\"\"\n # Initialize min_length with a large number\n min_length = float('inf')\n \n # Iterate over each sublist in the list of lists\n for sublist in list_of_lists:\n # Update min_length if the current sublist is shorter\n if len(sublist) < min_length:\n min_length = len(sublist)\n \n return min_length"}
{"task_id": "Mbpp/96", "solution": "def divisor(n):\n \"\"\"\n Calculate the number of divisors of a given integer n.\n \n Args:\n n (int): The integer to find divisors for.\n \n Returns:\n int: The number of divisors of n.\n \"\"\"\n if n < 1:\n return 0\n \n count = 0\n # Iterate from 1 to the square root of n\n for i in range(1, int(n**0.5) + 1):\n if n % i == 0:\n # If divisors are equal, count only one\n if i * i == n:\n count += 1\n else:\n # Otherwise count both i and n/i\n count += 2\n \n return count"}
{"task_id": "Mbpp/97", "solution": "def frequency_lists(list_of_lists):\n \"\"\"\n This function takes a list of lists and returns a dictionary with the frequency \n of each element in the flattened list.\n \n :param list_of_lists: List[List[int]] - A list containing sublists of integers.\n :return: Dict[int, int] - A dictionary where keys are elements from the list and values are their frequencies.\n \"\"\"\n # Flatten the list of lists\n flat_list = [item for sublist in list_of_lists for item in sublist]\n \n # Create a frequency dictionary\n frequency_dict = {}\n for element in flat_list:\n if element in frequency_dict:\n frequency_dict[element] += 1\n else:\n frequency_dict[element] = 1\n \n return frequency_dict"}
{"task_id": "Mbpp/98", "solution": "import math\ndef multiply_num(numbers):\n \"\"\"\n Multiplies all numbers in the input tuple and divides the product by the length of the tuple.\n \n Parameters:\n numbers (tuple): A tuple containing numeric values.\n \n Returns:\n float: The result of multiplying all numbers and dividing by the length of the tuple.\n \"\"\"\n # Initialize the product to 1\n product = 1\n \n # Multiply each number in the tuple\n for num in numbers:\n product *= num\n \n # Divide the product by the length of the tuple\n result = product / len(numbers)\n \n return result"}
{"task_id": "Mbpp/99", "solution": "def decimal_to_binary(n):\n # Handle the special case where n is 0\n if n == 0:\n return '0'\n \n # Initialize an empty list to store binary digits\n binary_digits = []\n \n # Convert the number to binary using division by 2\n while n > 0:\n remainder = n % 2\n binary_digits.append(str(remainder))\n n = n // 2\n \n # The binary digits are collected in reverse order, so we need to reverse them\n binary_digits.reverse()\n \n # Join the list into a string and return it\n return ''.join(binary_digits)"}
{"task_id": "Mbpp/100", "solution": "def next_smallest_palindrome(n):\n \"\"\"\n This function finds the next smallest palindrome greater than or equal to the given integer n.\n\n :param n: An integer for which we need to find the next smallest palindrome.\n :return: The next smallest palindrome as an integer.\n \"\"\"\n\n def is_palindrome(x):\n \"\"\"Check if a number x is a palindrome.\"\"\"\n return str(x) == str(x)[::-1]\n\n # Start checking from the next number\n candidate = n + 1\n\n while not is_palindrome(candidate):\n candidate += 1\n\n return candidate"}
{"task_id": "Mbpp/101", "solution": "def kth_element(arr, k):\n \"\"\"\n This function returns the k-th smallest element in a given array using 1-based indexing.\n \n Parameters:\n arr (list): A list of integers.\n k (int): The position (1-based) of the element to find.\n\n Returns:\n int: The k-th smallest element in the array.\n \"\"\"\n # Sort the array\n sorted_arr = sorted(arr)\n \n # Return the k-1 indexed element from the sorted array\n return sorted_arr[k - 1]"}
{"task_id": "Mbpp/102", "solution": "def snake_to_camel(snake_str):\n \"\"\"\n Convert a snake_case string to CamelCase.\n \n Parameters:\n snake_str (str): A string in snake_case format.\n \n Returns:\n str: The converted string in CamelCase format.\n \"\"\"\n # Split the string into words using underscore as delimiter\n components = snake_str.split('_')\n \n # Capitalize the first letter of each word except the first one\n # and join them together to form a camel case string\n return components[0] + ''.join(word.capitalize() for word in components[1:])"}
{"task_id": "Mbpp/103", "solution": "def eulerian_num(n, m):\n \"\"\"\n Calculate the Eulerian number a(n, m).\n \n Parameters:\n n (int): The length of the permutation.\n m (int): The number of ascents in the permutation.\n\n Returns:\n int: The Eulerian number a(n, m).\n \"\"\"\n # Create a 2D list to store computed values\n eulerian = [[0] * (m + 1) for _ in range(n + 1)]\n \n # Base case: There's one way to arrange 1 element with 0 ascents\n eulerian[1][0] = 1\n \n # Fill the table using a dynamic programming approach\n for i in range(2, n + 1):\n for j in range(m + 1):\n if j == 0:\n # Only one way to have zero ascents: all elements are decreasing\n eulerian[i][j] = eulerian[i - 1][i - 2]\n else:\n # Use the recurrence relation\n eulerian[i][j] = (j + 1) * eulerian[i - 1][j] + (i - j) * eulerian[i - 1][j - 1]\n \n return eulerian[n][m]"}
{"task_id": "Mbpp/104", "solution": "def sort_sublists(list_of_lists):\n \"\"\"\n Sorts each sublist within a list of lists.\n \n Parameters:\n list_of_lists (list): A list containing sublists of strings to be sorted.\n \n Returns:\n list: A new list with each sublist sorted in ascending order.\n \"\"\"\n # Use a list comprehension to sort each sublist\n return [sorted(sublist) for sublist in list_of_lists]"}
{"task_id": "Mbpp/105", "solution": "def count(bool_list):\n \"\"\"\n Count the number of True booleans in the given list.\n \n Parameters:\n bool_list (list): A list containing boolean values.\n \n Returns:\n int: The count of True values in the list.\n \"\"\"\n return sum(bool_list)"}
{"task_id": "Mbpp/106", "solution": "def add_lists(lst, tpl):\n # Convert the tuple to a list to allow appending\n combined_list = list(tpl) + lst\n \n # Convert the combined list back to a tuple\n result_tuple = tuple(combined_list)\n \n return result_tuple"}
{"task_id": "Mbpp/108", "solution": "def merge_sorted_list(list1, list2, list3):\n # Combine all three lists into one\n combined_list = list1 + list2 + list3\n \n # Sort the combined list\n sorted_list = sorted(combined_list)\n \n return sorted_list"}
{"task_id": "Mbpp/109", "solution": "def odd_Equivalent(binary_string, num_rotations):\n n = len(binary_string)\n seen_odd_values = set()\n \n for i in range(num_rotations):\n # Rotate the binary string by i positions\n rotated_binary = binary_string[i:] + binary_string[:i]\n \n # Convert the rotated binary to a decimal number\n decimal_value = int(rotated_binary, 2)\n \n # Check if the decimal value is odd\n if decimal_value % 2 == 1:\n seen_odd_values.add(decimal_value)\n \n return len(seen_odd_values)"}
{"task_id": "Mbpp/111", "solution": "def common_in_nested_lists(nested_lists):\n \"\"\"\n Find the common elements in given nested lists.\n\n Parameters:\n nested_lists (list of list): A list containing multiple sublists with integers.\n\n Returns:\n set: A set containing the common elements across all sublists.\n \"\"\"\n if not nested_lists:\n return set()\n\n # Start by converting the first sublist to a set\n common_elements = set(nested_lists[0])\n\n # Intersect this set with each of the other sublists\n for sublist in nested_lists[1:]:\n common_elements.intersection_update(sublist)\n\n return common_elements"}
{"task_id": "Mbpp/113", "solution": "import re\ndef check_integer(s):\n \"\"\"\n Check if the provided string s represents an integer.\n \n Parameters:\n s (str): The string to be checked.\n \n Returns:\n bool: True if the string is a valid representation of an integer, False otherwise.\n \"\"\"\n # Regular expression pattern for matching integers\n # This pattern matches optional leading '+' or '-' followed by one or more digits\n integer_pattern = re.compile(r'^[+-]?\\d+$')\n \n # Use fullmatch to ensure the entire string conforms to the pattern\n return bool(integer_pattern.fullmatch(s))"}
{"task_id": "Mbpp/116", "solution": "def tuple_to_int(t):\n \"\"\"\n Convert a tuple of positive integers into a single integer.\n\n Parameters:\n t (tuple): A tuple containing positive integers.\n\n Returns:\n int: An integer formed by concatenating the numbers in the tuple.\n \n Example:\n >>> assert tuple_to_int((1, 2, 3)) == 123\n \"\"\"\n # Use map to convert each element of the tuple to a string,\n # then join them together into one string, and finally convert that string back to an integer.\n return int(''.join(map(str, t)))"}
{"task_id": "Mbpp/118", "solution": "def string_to_list(input_string):\n \"\"\"\n Convert a string into a list of strings split on the space character.\n \n Parameters:\n input_string (str): A string that needs to be split into a list of substrings.\n \n Returns:\n list: A list of substrings obtained by splitting the input string on spaces.\n \"\"\"\n # Split the input string on spaces and return the resulting list\n return input_string.split()"}
{"task_id": "Mbpp/119", "solution": "def search(nums):\n \"\"\"\n Find the element that appears only once in a sorted array.\n \n :param nums: List[int] - A list of integers where every element appears twice except for one.\n :return: int - The single element that appears only once.\n \"\"\"\n left, right = 0, len(nums) - 1\n \n while left < right:\n mid = (left + right) // 2\n \n # Ensure the mid is even to pair with mid+1\n if mid % 2 == 1:\n mid -= 1\n \n # Check if the pair is valid\n if nums[mid] == nums[mid + 1]:\n left = mid + 2\n else:\n right = mid\n \n return nums[left]"}
{"task_id": "Mbpp/120", "solution": "def max_product_tuple(tuples):\n max_abs_product = float('-inf')\n \n # Iterate over each pair of tuples\n for i in range(len(tuples)):\n for j in range(i + 1, len(tuples)):\n a, b = tuples[i]\n c, d = tuples[j]\n \n # Calculate all possible products between the two tuples\n product1 = a * c\n product2 = a * d\n product3 = b * c\n product4 = b * d\n \n # Update max_abs_product with the maximum absolute value of these products\n max_abs_product = max(max_abs_product, abs(product1), abs(product2), abs(product3), abs(product4))\n \n return max_abs_product"}
{"task_id": "Mbpp/123", "solution": "def proper_divisors(n):\n \"\"\"Return the list of proper divisors of n.\"\"\"\n divisors = [1]\n for i in range(2, int(n**0.5) + 1):\n if n % i == 0:\n divisors.append(i)\n if i != n // i:\n divisors.append(n // i)\n return divisors\ndef sum_of_divisors(n):\n \"\"\"Return the sum of proper divisors of n.\"\"\"\n return sum(proper_divisors(n))\ndef is_amicable(a, b):\n \"\"\"Check if a and b are amicable numbers.\"\"\"\n return sum_of_divisors(a) == b and sum_of_divisors(b) == a\ndef amicable_numbers_sum(limit):\n \"\"\"Return the sum of all amicable numbers under the given limit.\"\"\"\n amicable_sum = 0\n for num in range(2, limit):\n partner = sum_of_divisors(num)\n if partner > num and is_amicable(num, partner):\n amicable_sum += num + partner\n return amicable_sum"}
{"task_id": "Mbpp/124", "solution": "import math\ndef angle_complex(real, imag):\n \"\"\"\n Calculate the angle (in radians) of a complex number given its real and imaginary parts.\n \n Parameters:\n - real: The real part of the complex number.\n - imag: The imaginary part of the complex number.\n \n Returns:\n - The angle in radians.\n \"\"\"\n # Create a complex number from the real and imaginary parts\n complex_number = complex(real, imag)\n \n # Use math.atan2 to calculate the angle (argument) of the complex number\n return math.atan2(imag, real)"}
{"task_id": "Mbpp/125", "solution": "def find_length(s: str) -> int:\n # Convert '0' to +1 and '1' to -1\n transformed = [1 if char == '0' else -1 for char in s]\n \n max_diff = 0\n current_sum = 0\n \n for value in transformed:\n current_sum += value\n \n # Reset the current sum if it becomes negative\n if current_sum < 0:\n current_sum = 0\n \n # Update the maximum difference found so far\n max_diff = max(max_diff, current_sum)\n \n return max_diff"}
{"task_id": "Mbpp/126", "solution": "def gcd(a, b):\n \"\"\"Compute the greatest common divisor of a and b.\"\"\"\n while b:\n a, b = b, a % b\n return a\n\ndef sum_of_common_divisors(x, y):\n \"\"\"\n Calculate the sum of all common divisors of two numbers x and y.\n \n Args:\n x (int): First number\n y (int): Second number\n \n Returns:\n int: Sum of all common divisors of x and y\n \"\"\"\n # Find the greatest common divisor of x and y\n gcd_value = gcd(x, y)\n \n # Find all divisors of the gcd_value\n divisors = []\n for i in range(1, int(gcd_value**0.5) + 1):\n if gcd_value % i == 0:\n divisors.append(i)\n if i != gcd_value // i: # Avoid adding the square root twice if it's a perfect square\n divisors.append(gcd_value // i)\n \n # Return the sum of all common divisors\n return sum(divisors)\n\n# Test cases to verify the function works as expected\nassert sum_of_common_divisors(10, 15) == 6, \"Test case 1 failed\"\nassert sum_of_common_divisors(12, 18) == 13, \"Test case 2 failed\" # Common divisors are 1, 2, 3, 6\nassert sum_of_common_divisors(7, 5) == 1, \"Test case 3 failed\" # Only common divisor is 1\n\nprint(\"All test cases passed!\")"}
{"task_id": "Mbpp/127", "solution": "def multiply_int(a: int, b: int) -> int:\n \"\"\"\n Multiplies two integers and returns the result.\n\n Parameters:\n a (int): The first integer to be multiplied.\n b (int): The second integer to be multiplied.\n\n Returns:\n int: The product of the two integers.\n \"\"\"\n return a * b"}
{"task_id": "Mbpp/128", "solution": "def long_words(n, sentence):\n \"\"\"\n Find words in a given sentence that are longer than n characters.\n \n Parameters:\n n (int): The minimum length for the words to be included in the result.\n sentence (str): A string containing multiple words separated by spaces.\n\n Returns:\n list: A list of words from the sentence that have more than n characters.\n \"\"\"\n # Split the sentence into individual words\n words = sentence.split()\n \n # Filter and collect words longer than n characters\n long_words_list = [word for word in words if len(word) > n]\n \n return long_words_list"}
{"task_id": "Mbpp/129", "solution": "def is_magic_square(matrix):\n \"\"\"\n Determine if a given matrix is a magic square.\n \n Args:\n - matrix (list of list of int): The matrix to check.\n \n Returns:\n - bool: True if the matrix is a magic square, False otherwise.\n \"\"\"\n n = len(matrix)\n \n # Check if all rows have the same sum\n row_sums = [sum(row) for row in matrix]\n if len(set(row_sums)) != 1:\n return False\n \n # Check if all columns have the same sum\n col_sums = [sum(matrix[i][j] for i in range(n)) for j in range(n)]\n if len(set(col_sums)) != 1:\n return False\n \n # Check if both diagonals have the same sum\n diag1_sum = sum(matrix[i][i] for i in range(n))\n diag2_sum = sum(matrix[i][n - 1 - i] for i in range(n))\n \n if diag1_sum != diag2_sum or diag1_sum != row_sums[0]:\n return False\n \n return True\ndef magic_square_test(matrix):\n \"\"\"\n Test function to check if a matrix is a magic square.\n \n Args:\n - matrix (list of list of int): The matrix to test.\n \n Returns:\n - bool: Result of the test.\n \"\"\"\n return is_magic_square(matrix)"}
{"task_id": "Mbpp/130", "solution": "def max_occurrences(lst):\n # Dictionary to store the frequency of each element\n frequency = {}\n \n # Count the occurrences of each element in the list\n for item in lst:\n if item in frequency:\n frequency[item] += 1\n else:\n frequency[item] = 1\n \n # Find the element with the maximum frequency\n max_count = 0\n max_item = None\n \n for key, value in frequency.items():\n if value > max_count:\n max_count = value\n max_item = key\n \n return max_item"}
{"task_id": "Mbpp/131", "solution": "def reverse_vowels(s):\n \"\"\"\n Reverse only the vowels in a given string.\n \n Args:\n s (str): The input string where vowels need to be reversed.\n \n Returns:\n str: A new string with vowels reversed.\n \"\"\"\n # Define what characters are considered vowels\n vowels = set(\"aeiouAEIOU\")\n \n # Convert the string into a list of characters for easy manipulation\n s_list = list(s)\n \n # Initialize two pointers, one at the start and one at the end of the list\n left, right = 0, len(s) - 1\n \n while left < right:\n # Move the left pointer to the next vowel\n if s_list[left] not in vowels:\n left += 1\n # Move the right pointer to the previous vowel\n elif s_list[right] not in vowels:\n right -= 1\n else:\n # Swap the vowels at the two pointers\n s_list[left], s_list[right] = s_list[right], s_list[left]\n # Move both pointers towards the center\n left += 1\n right -= 1\n \n # Join the list back into a string and return it\n return ''.join(s_list)"}
{"task_id": "Mbpp/132", "solution": "def tup_string(t):\n \"\"\"\n Convert a tuple of characters into a single string.\n \n Parameters:\n t (tuple): A tuple containing individual character strings.\n \n Returns:\n str: A concatenated string formed from the elements of the tuple.\n \"\"\"\n return ''.join(t)"}
{"task_id": "Mbpp/133", "solution": "def sum_negative_numbers(numbers):\n \"\"\"\n Calculate the sum of all negative numbers in a given list.\n \n Parameters:\n numbers (list): A list of integers or floats.\n \n Returns:\n int: The sum of all negative numbers in the list.\n \"\"\"\n # Use a generator expression to filter and sum negative numbers\n return sum(num for num in numbers if num < 0)\n\n# Test case\nassert sum_negative_numbers([2, 4, -6, -9, 11, -12, 14, -5, 17]) == -32\n\nprint(\"The function works correctly.\")"}
{"task_id": "Mbpp/135", "solution": "def hexagonal_num(n):\n \"\"\"\n Calculate the nth hexagonal number.\n \n Parameters:\n n (int): The position in the hexagonal number sequence.\n \n Returns:\n int: The nth hexagonal number.\n \"\"\"\n return n * (2 * n - 1)"}
{"task_id": "Mbpp/137", "solution": "import math\ndef zero_count(arr):\n # Count the number of zeros in the array\n zero_count = sum(1 for x in arr if x == 0)\n \n # Count the number of non-zeros in the array\n non_zero_count = len(arr) - zero_count\n \n # If there are no non-zero elements, return 0 to avoid division by zero\n if non_zero_count == 0:\n return float('inf') # or some other representation for undefined ratio\n \n # Calculate and return the ratio of zeroes to non-zeroes\n return zero_count / non_zero_count"}
{"task_id": "Mbpp/138", "solution": "def is_sum_of_powers_of_two(n):\n \"\"\"\n Check whether the given number n can be represented as the sum of non-zero powers of 2.\n \n Args:\n n (int): The number to check.\n \n Returns:\n bool: True if n can be represented as such a sum, False otherwise.\n \"\"\"\n # A number can be expressed as a sum of distinct powers of 2\n # if and only if it has no zero bits in its binary representation,\n # except for the leading bit (which is always non-zero).\n \n # Check if n is positive\n if n <= 0:\n return False\n \n # Use bitwise AND to check if there are any zero bits in the binary representation of n.\n # If n & (n - 1) == 0, then n is a power of 2 or zero.\n # We need to ensure that all bits except possibly one are set to 1.\n \n # Count the number of 1s in the binary representation of n\n count_ones = 0\n temp_n = n\n \n while temp_n > 0:\n if temp_n & 1 == 1:\n count_ones += 1\n temp_n >>= 1\n \n # If there are no zero bits (except possibly the leading bit), then it can be represented as a sum of distinct powers of 2.\n return count_ones == n.bit_length()\n\n# Test cases\nassert is_sum_of_powers_of_two(10) == True, \"Test case 1 failed\"\nassert is_sum_of_powers_of_two(7) == True, \"Test case 2 failed\" # 7 = 4 + 2 + 1\nassert is_sum_of_powers_of_two(8) == True, \"Test case 3 failed\" # 8 = 2^3\nassert is_sum_of_powers_of_two(6) == True, \"Test case 4 failed\" # 6 = 4 + 2\nassert is_sum_of_powers_of_two(5) == True, \"Test case 5 failed\" # 5 = 4 + 1\nassert is_sum_of_powers_of_two(3) == True, \"Test case 6 failed\" # 3 = 2 + 1\nassert is_sum_of_powers_of_two(1) == True, \"Test case 7 failed\" # 1 = 2^0\nassert is_sum_of_powers_of_two(0) == False, \"Test case 8 failed\"\nassert is_sum_of_powers_of_two(-5) == False, \"Test case 9 failed\"\n\nprint(\"All test cases passed!\")"}
{"task_id": "Mbpp/139", "solution": "import math\ndef circle_circumference(radius):\n \"\"\"\n Calculate the circumference of a circle given its radius.\n \n Parameters:\n radius (float): The radius of the circle.\n\n Returns:\n float: The circumference of the circle.\n \"\"\"\n return 2 * math.pi * radius"}
{"task_id": "Mbpp/140", "solution": "def extract_singly(list_of_lists):\n \"\"\"\n Flattens a list of lists into a single set of numbers.\n \n Parameters:\n - list_of_lists: A list containing tuples or lists of numbers.\n \n Returns:\n - A set containing all the unique numbers from the input list of lists.\n \"\"\"\n # Use a set comprehension to flatten and collect unique elements\n return {element for sublist in list_of_lists for element in sublist}"}
{"task_id": "Mbpp/141", "solution": "def pancake_sort(arr):\n def flip(sub_arr, k):\n \"\"\"Helper function to reverse the first k elements of sub_arr.\"\"\"\n return sub_arr[:k][::-1] + sub_arr[k:]\n\n sorted_arr = []\n while arr:\n # Find the index of the maximum element in the current array\n max_index = arr.index(max(arr))\n \n # If the maximum element is not already at its correct position\n if max_index != len(arr) - 1:\n # Flip the array to bring the maximum element to the front\n if max_index != 0:\n arr = flip(arr, max_index + 1)\n \n # Flip it again to move the maximum element to its correct position\n arr = flip(arr, len(arr))\n \n # Remove the last element and add it to the sorted array\n sorted_arr.append(arr.pop())\n \n return sorted_arr"}
{"task_id": "Mbpp/142", "solution": "def count_samepair(list1, list2, list3):\n \"\"\"\n Count the number of items that are identical in the same position across three lists.\n \n Parameters:\n - list1: First list of integers.\n - list2: Second list of integers.\n - list3: Third list of integers.\n \n Returns:\n - An integer representing the count of identical items at the same positions.\n \"\"\"\n # Initialize a counter for identical items\n count = 0\n \n # Iterate over the indices of the lists (assuming all lists are of the same length)\n for i in range(min(len(list1), len(list2), len(list3))):\n # Check if the elements at the current index are the same across all three lists\n if list1[i] == list2[i] == list3[i]:\n count += 1\n \n return count"}
{"task_id": "Mbpp/145", "solution": "def max_Abs_Diff(arr):\n if not arr:\n return 0 # Return 0 for empty arrays as there are no elements to compare\n \n min_val = float('inf')\n max_val = float('-inf')\n \n for num in arr:\n if num < min_val:\n min_val = num\n if num > max_val:\n max_val = num\n \n return max_val - min_val"}
{"task_id": "Mbpp/160", "solution": "def extended_gcd(a, b):\n \"\"\" Returns a tuple (g, x, y) such that a*x + b*y = g = gcd(a, b) \"\"\"\n if a == 0:\n return b, 0, 1\n else:\n g, x1, y1 = extended_gcd(b % a, a)\n x = y1 - (b // a) * x1\n y = x1\n return g, x, y\ndef find_solution(a, b, n):\n \"\"\" Returns integers x and y such that ax + by = n, or None if no solution exists \"\"\"\n gcd, x, y = extended_gcd(a, b)\n \n # Check if a solution exists\n if n % gcd != 0:\n return None\n \n # Scale the solution to get the desired result\n x *= n // gcd\n y *= n // gcd\n \n return (x, y)"}
{"task_id": "Mbpp/161", "solution": "def remove_elements(original_list, elements_to_remove):\n \"\"\"\n Remove all elements from original_list that are present in elements_to_remove.\n \n Parameters:\n - original_list: List of integers to filter.\n - elements_to_remove: List of integers to be removed from the original list.\n \n Returns:\n - A new list containing only those elements from original_list \n which are not in elements_to_remove.\n \"\"\"\n # Use a set for faster lookup times\n remove_set = set(elements_to_remove)\n \n # Create a new list with elements that are not in the remove_set\n result = [element for element in original_list if element not in remove_set]\n \n return result"}
{"task_id": "Mbpp/162", "solution": "def sum_series(n):\n \"\"\"\n Calculate the sum of the series: n + (n-2) + (n-4) + ... \n until the term becomes less than or equal to 0.\n \n Parameters:\n n (int): The starting number of the series.\n\n Returns:\n int: The sum of the series.\n \"\"\"\n total_sum = 0\n for i in range(n // 2 + 1):\n term = n - 2 * i\n if term > 0:\n total_sum += term\n return total_sum"}
{"task_id": "Mbpp/165", "solution": "def count_char_position(s):\n # Convert the input string to lowercase for case insensitivity\n s = s.lower()\n \n # Initialize a counter for characters at their alphabet position\n count = 0\n \n # Iterate over each character and its index in the string\n for i, char in enumerate(s):\n # Check if the character is an alphabet and matches its position (1-based)\n if 'a' <= char <= 'z' and ord(char) - ord('a') == i:\n count += 1\n \n return count"}
{"task_id": "Mbpp/166", "solution": "def find_even_pair(lst):\n # Count even and odd numbers in the list\n even_count = sum(1 for x in lst if x % 2 == 0)\n odd_count = len(lst) - even_count\n \n # Calculate combinations of pairs\n even_pairs = (even_count * (even_count - 1)) // 2\n odd_pairs = (odd_count * (odd_count - 1)) // 2\n \n # Total pairs with even XOR\n return even_pairs + odd_pairs"}
{"task_id": "Mbpp/167", "solution": "def next_power_of_2(n):\n \"\"\"\n Find the smallest power of 2 that is greater than or equal to n.\n \n Parameters:\n n (int): A non-negative integer\n \n Returns:\n int: The smallest power of 2 >= n\n \"\"\"\n if n < 0:\n raise ValueError(\"Input must be a non-negative integer\")\n \n # Special case for n = 0\n if n == 0:\n return 1\n\n # Find the next power of 2 greater than or equal to n\n power = 1\n while power < n:\n power <<= 1 # Equivalent to multiplying by 2\n \n return power"}
{"task_id": "Mbpp/168", "solution": "def frequency(lst, num):\n \"\"\"\n Count the number of occurrences of 'num' in the list 'lst'.\n \n Parameters:\n lst (list): A list of numbers.\n num (int or float): The number whose occurrences need to be counted.\n \n Returns:\n int: The count of occurrences of 'num' in 'lst'.\n \"\"\"\n return lst.count(num)"}
{"task_id": "Mbpp/170", "solution": "def sum_range_list(numbers, start_index, end_index):\n \"\"\"\n Calculate the sum of elements in the list 'numbers' from index 'start_index'\n (inclusive) to 'end_index' (exclusive).\n\n Parameters:\n - numbers: List[int] - A list of integers.\n - start_index: int - The starting index for summation (inclusive).\n - end_index: int - The ending index for summation (exclusive).\n\n Returns:\n - int: Sum of the elements within the specified range.\n \n Raises:\n - ValueError: If indices are out of bounds or if start_index is greater than end_index.\n \"\"\"\n # Check if indices are valid\n if not (0 <= start_index < len(numbers)) or not (start_index < end_index <= len(numbers)):\n raise ValueError(\"Invalid range specified by the indices.\")\n \n # Calculate and return the sum of elements in the specified range\n return sum(numbers[start_index:end_index])"}
{"task_id": "Mbpp/171", "solution": "def perimeter_pentagon(side_length):\n \"\"\"\n Calculate the perimeter of a regular pentagon.\n \n Parameters:\n - side_length: The length of one side of the pentagon.\n \n Returns:\n - The perimeter of the pentagon.\n \"\"\"\n # A regular pentagon has 5 sides, so multiply the side length by 5\n return 5 * side_length"}
{"task_id": "Mbpp/172", "solution": "def count_occurrence(s):\n \"\"\"\n Count the number of occurrences of the substring 'std' in the given string s.\n \n Parameters:\n s (str): The input string where we want to find occurrences of 'std'.\n \n Returns:\n int: The number of times 'std' appears in the string.\n \"\"\"\n # Initialize a counter for occurrences\n count = 0\n \n # Loop through the string, checking each substring of length 3\n for i in range(len(s) - 2):\n if s[i:i+3] == 'std':\n count += 1\n \n return count\n\n# Test case to verify the function works as expected\nassert count_occurrence(\"letstdlenstdporstd\") == 3\n\nprint(\"The test passed successfully!\")"}
{"task_id": "Mbpp/222", "solution": "def check_type(tpl):\n \"\"\"\n Check if all elements in the tuple have the same data type.\n \n Parameters:\n tpl (tuple): A tuple containing elements of any data types.\n \n Returns:\n bool: True if all elements are of the same type, False otherwise.\n \"\"\"\n # Use a set to store unique types found in the tuple\n types = {type(element) for element in tpl}\n \n # If there's only one unique type, return True; otherwise, return False\n return len(types) == 1"}
{"task_id": "Mbpp/223", "solution": "def is_majority(arr, n, elem):\n \"\"\"\n Determines if 'elem' is the majority element in the sorted array 'arr'.\n \n Parameters:\n arr (list): A sorted list of integers.\n n (int): The length of the array.\n elem (int): The element to check for majority status.\n\n Returns:\n bool: True if 'elem' is a majority element, False otherwise.\n \"\"\"\n # Binary search to find the first occurrence of elem\n left = 0\n right = n - 1\n first_occurrence = -1\n\n while left <= right:\n mid = (left + right) // 2\n if arr[mid] == elem:\n first_occurrence = mid\n right = mid - 1 # Look on the left side for earlier occurrence\n elif arr[mid] < elem:\n left = mid + 1\n else:\n right = mid - 1\n\n # If element is not found, return False\n if first_occurrence == -1:\n return False\n\n # Binary search to find the last occurrence of elem\n left = 0\n right = n - 1\n last_occurrence = -1\n\n while left <= right:\n mid = (left + right) // 2\n if arr[mid] == elem:\n last_occurrence = mid\n left = mid + 1 # Look on the right side for later occurrence\n elif arr[mid] < elem:\n left = mid + 1\n else:\n right = mid - 1\n\n # Calculate the number of occurrences\n count = last_occurrence - first_occurrence + 1\n\n # Check if it is a majority element\n return count > n // 2"}
{"task_id": "Mbpp/224", "solution": "def count_set_bits(n):\n \"\"\"\n Count the number of set bits (1s) in the binary representation of an integer.\n \n Parameters:\n n (int): A non-negative integer whose set bits are to be counted.\n \n Returns:\n int: The number of set bits in the binary representation of n.\n \"\"\"\n count = 0\n while n:\n # Use bitwise AND operation with 1 to check if the least significant bit is set\n count += n & 1\n # Right shift n by 1 to process the next bit\n n >>= 1\n return count\n\n# Test cases\nassert count_set_bits(2) == 1, \"Test case failed for input 2\"\nassert count_set_bits(0) == 0, \"Test case failed for input 0\"\nassert count_set_bits(15) == 4, \"Test case failed for input 15\" # Binary: 1111\nassert count_set_bits(7) == 3, \"Test case failed for input 7\" # Binary: 0111\n\nprint(\"All test cases passed!\")"}
{"task_id": "Mbpp/226", "solution": "def odd_values_string(s):\n \"\"\"\n This function removes characters which have odd index values from the given string.\n \n Parameters:\n s (str): The input string from which to remove characters with odd indices.\n \n Returns:\n str: A new string containing only characters at even indices of the original string.\n \"\"\"\n # Using list comprehension to select characters at even indices\n result = ''.join([s[i] for i in range(len(s)) if i % 2 == 0])\n return result"}
{"task_id": "Mbpp/227", "solution": "def min_of_three(a, b, c):\n \"\"\"\n This function takes three numerical arguments and returns the smallest one.\n\n Parameters:\n a (int/float): The first number.\n b (int/float): The second number.\n c (int/float): The third number.\n\n Returns:\n int/float: The minimum of the three numbers.\n \"\"\"\n # Compare the first two numbers and find the smaller one\n if a < b:\n min_ab = a\n else:\n min_ab = b\n \n # Now compare the smaller of the first two with the third number\n if min_ab < c:\n return min_ab\n else:\n return c"}
{"task_id": "Mbpp/230", "solution": "def replace_blank(input_string, char):\n \"\"\"\n Replaces all blank spaces in the input_string with the specified character.\n \n Parameters:\n - input_string (str): The original string containing spaces to be replaced.\n - char (str): The character that will replace each space in the input_string.\n \n Returns:\n - str: A new string with all spaces replaced by the given character.\n \"\"\"\n # Replace spaces with the specified character\n return input_string.replace(' ', char)"}
{"task_id": "Mbpp/232", "solution": "def larg_nnum(lst, n):\n \"\"\"\n Returns a list of the n largest numbers from the given list.\n \n Parameters:\n lst (list): A list of integers or floats.\n n (int): The number of largest elements to return.\n \n Returns:\n list: A list containing the n largest items from the input list.\n \"\"\"\n # Sort the list in descending order\n sorted_lst = sorted(lst, reverse=True)\n # Return the first n elements from the sorted list\n return sorted_lst[:n]"}
{"task_id": "Mbpp/233", "solution": "import math"}
{"task_id": "Mbpp/234", "solution": "def volume_cube(side_length):\n \"\"\"\n Calculate the volume of a cube.\n\n Parameters:\n side_length (float or int): The length of a side of the cube.\n\n Returns:\n float: The volume of the cube.\n \"\"\"\n return side_length ** 3"}
{"task_id": "Mbpp/235", "solution": "def even_bit_set_number(n):\n \"\"\"\n This function takes an integer n and sets all its even-positioned bits to 1.\n \n Args:\n n (int): The input integer whose even bits are to be set.\n \n Returns:\n int: The integer with all even bits set to 1.\n \"\"\"\n # Create a mask where all even bits are set to 1\n # For example, for an 8-bit number, the mask would be 0b10101010 (170 in decimal)\n mask = 0xAAAAAAAA\n \n # Use bitwise OR to set all even bits of n to 1\n result = n | mask\n \n return result"}
{"task_id": "Mbpp/237", "solution": "def check_occurrences(tuples_list):\n \"\"\"\n This function takes in a list of tuples and returns a dictionary mapping each unique tuple \n to the number of times it occurs in the list. It considers (a, b) and (b, a) as the same tuple.\n \n :param tuples_list: List of tuples\n :return: Dictionary with normalized tuples as keys and their counts as values\n \"\"\"\n from collections import defaultdict\n\n # Create a default dictionary to store occurrences\n occurrence_dict = defaultdict(int)\n\n for a, b in tuples_list:\n # Normalize the tuple by sorting it\n normalized_tuple = tuple(sorted((a, b)))\n # Increment the count of this normalized tuple\n occurrence_dict[normalized_tuple] += 1\n\n return dict(occurrence_dict)\n\n\n# Test case\nassert check_occurrences([(3, 1), (1, 3), (2, 5), (5, 2), (6, 3)]) == {(1, 3): 2, (2, 5): 2, (3, 6): 1}"}
{"task_id": "Mbpp/238", "solution": "def number_of_substrings(s):\n \"\"\"\n Calculate the number of non-empty substrings in the given string.\n \n :param s: Input string\n :return: Number of non-empty substrings\n \"\"\"\n n = len(s)\n return (n * (n + 1)) // 2"}
{"task_id": "Mbpp/239", "solution": "def get_total_number_of_sequences(m, n):\n # Memoization dictionary\n memo = {}\n\n def count_sequences(current_length, current_value):\n # Base case: if the sequence length is 1, return 1 (valid sequence)\n if current_length == 1:\n return 1\n \n # Check if result is already computed\n if (current_length, current_value) in memo:\n return memo[(current_length, current_value)]\n \n total_sequences = 0\n next_value = 2 * current_value\n \n # Explore all possible next values\n while next_value <= m:\n total_sequences += count_sequences(current_length - 1, next_value)\n next_value += 1\n \n # Store the result in memo dictionary\n memo[(current_length, current_value)] = total_sequences\n return total_sequences\n\n # Start counting sequences from each possible starting number\n total_count = 0\n for start in range(1, m + 1):\n total_count += count_sequences(n - 1, start)\n \n return total_count"}
{"task_id": "Mbpp/240", "solution": "def replace_list(list1, list2):\n \"\"\"\n Replaces the last element of the first list with all elements from the second list.\n\n Parameters:\n - list1: The first list whose last element will be replaced.\n - list2: The second list whose elements will replace the last element of the first list.\n\n Returns:\n A new list with the modification applied.\n \"\"\"\n # Check if list1 is not empty to avoid IndexError\n if list1:\n # Remove the last element from list1\n list1.pop()\n # Extend list1 with all elements from list2\n list1.extend(list2)\n \n return list1"}
{"task_id": "Mbpp/242", "solution": "def count_charac(s):\n \"\"\"\n This function takes a string as input and returns the total number of characters in it.\n \n Parameters:\n s (str): The input string whose characters are to be counted.\n \n Returns:\n int: Total number of characters in the input string.\n \"\"\"\n return len(s)"}
{"task_id": "Mbpp/244", "solution": "import math\ndef next_Perfect_Square(n):\n \"\"\"\n Find the next perfect square greater than the given number n.\n \n Parameters:\n n (int): A non-negative integer\n \n Returns:\n int: The smallest perfect square greater than n\n \"\"\"\n # Calculate the ceiling of the square root of n\n root = math.ceil(math.sqrt(n))\n \n # Return the next perfect square\n return root * root"}
{"task_id": "Mbpp/245", "solution": "def max_sum_bitonic_subsequence(arr):\n n = len(arr)\n \n # Arrays to store the increasing and decreasing subsequences sums\n inc = [0] * n\n dec = [0] * n\n \n # Initialize both arrays with the values of arr\n for i in range(n):\n inc[i] = arr[i]\n dec[i] = arr[i]\n \n # Fill the inc array to store maximum sum of increasing subsequence ending at each index\n for i in range(1, n):\n for j in range(i):\n if arr[i] > arr[j]:\n inc[i] = max(inc[i], inc[j] + arr[i])\n \n # Fill the dec array to store maximum sum of decreasing subsequence starting from each index\n for i in range(n-2, -1, -1):\n for j in range(n-1, i, -1):\n if arr[i] > arr[j]:\n dec[i] = max(dec[i], dec[j] + arr[i])\n \n # Find the maximum sum of bitonic subsequence\n max_sum = float('-inf')\n for i in range(n):\n max_sum = max(max_sum, inc[i] + dec[i] - arr[i])\n \n return max_sum\n\n# Test case\nassert max_sum_bitonic_subsequence([1, 15, 51, 45, 33, 100, 12, 18, 9]) == 194"}
{"task_id": "Mbpp/247", "solution": "def lps(s: str) -> int:\n n = len(s)\n \n # Create a 2D table to store results of subproblems\n dp = [[0] * n for _ in range(n)]\n \n # Every single character is a palindrome of length 1\n for i in range(n):\n dp[i][i] = 1\n \n # Build the table. The outer loop is for substrings of increasing lengths.\n for cl in range(2, n + 1): # cl is the current length of substring\n for i in range(n - cl + 1):\n j = i + cl - 1\n \n if s[i] == s[j] and cl == 2:\n dp[i][j] = 2\n elif s[i] == s[j]:\n dp[i][j] = dp[i + 1][j - 1] + 2\n else:\n dp[i][j] = max(dp[i][j - 1], dp[i + 1][j])\n \n # The result is in the top right corner of the table\n return dp[0][n - 1]"}
{"task_id": "Mbpp/250", "solution": "def count_X(tpl, element):\n \"\"\"\n Counts the number of times 'element' appears in the tuple 'tpl'.\n\n Parameters:\n tpl (tuple): A tuple containing elements.\n element: An element whose occurrences need to be counted in the tuple.\n\n Returns:\n int: The number of times 'element' occurs in 'tpl'.\n \"\"\"\n return tpl.count(element)"}
{"task_id": "Mbpp/251", "solution": "def insert_element(original_list, element):\n \"\"\"\n Inserts the given element before each element in the original list.\n \n Parameters:\n - original_list: List of elements where the new element will be inserted.\n - element: The element to insert before each element in the original list.\n \n Returns:\n A new list with the specified element inserted before each item from the original list.\n \"\"\"\n result = []\n for item in original_list:\n # Insert the element before each item\n result.append(element)\n result.append(item)\n return result"}
{"task_id": "Mbpp/252", "solution": "import cmath\ndef convert(complex_number):\n \"\"\"\n Convert a complex number to polar coordinates.\n \n Parameters:\n complex_number (complex): A complex number to be converted.\n \n Returns:\n tuple: A tuple containing the magnitude and the angle in radians.\n \"\"\"\n # Calculate the magnitude using the absolute value\n magnitude = abs(complex_number)\n \n # Calculate the phase angle using cmath.phase\n angle = cmath.phase(complex_number)\n \n return (magnitude, angle)"}
{"task_id": "Mbpp/253", "solution": "def count_integer(lst):\n \"\"\"\n This function takes a list as input and returns the number of integer elements in it.\n \n Parameters:\n lst (list): A list containing various data types.\n\n Returns:\n int: The count of integer elements in the list.\n \"\"\"\n # Initialize a counter for integers\n integer_count = 0\n \n # Iterate over each element in the list\n for item in lst:\n # Check if the current item is an instance of int\n if isinstance(item, int):\n # Increment the counter if it's an integer\n integer_count += 1\n \n return integer_count"}
{"task_id": "Mbpp/255", "solution": "from itertools import product\ndef combinations_colors(colors, n):\n \"\"\"\n Generate all combinations (with repetition) of the elements in 'colors' of length 'n'.\n \n Parameters:\n colors (list): A list of strings representing colors.\n n (int): The length of each combination tuple.\n\n Returns:\n list: A list containing tuples, each representing a combination.\n \"\"\"\n # Use itertools.product to generate combinations with repetition\n return list(product(colors, repeat=n))"}
{"task_id": "Mbpp/256", "solution": "def is_prime(n):\n \"\"\"Check if a number is a prime.\"\"\"\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\ndef count_primes_less_than(n):\n \"\"\"Return the number of prime numbers less than a given non-negative number.\"\"\"\n if n <= 2:\n return 0\n \n # Use Sieve of Eratosthenes to find all primes less than n\n is_prime = [True] * n\n p = 2\n while (p * p < n):\n if is_prime[p]:\n for i in range(p * p, n, p):\n is_prime[i] = False\n p += 1\n \n # Count primes\n prime_count = sum(1 for i in range(2, n) if is_prime[i])\n return prime_count\n\n# Test the function with an assertion\nassert count_primes_less_than(5) == 2"}
{"task_id": "Mbpp/257", "solution": "def swap_numbers(a, b):\n \"\"\"\n This function takes two numbers as input and returns a tuple with the second number first,\n followed by the first number.\n \n Parameters:\n a (int/float): The first number.\n b (int/float): The second number.\n \n Returns:\n tuple: A tuple containing the second number followed by the first number.\n \"\"\"\n return (b, a)"}
{"task_id": "Mbpp/259", "solution": "def maximize_elements(tuple_list1, tuple_list2):\n \"\"\"\n This function takes two lists of tuples and returns a new list of tuples.\n Each tuple in the resulting list is formed by taking the maximum element \n from each position (first or second) between corresponding tuples from the input lists.\n\n :param tuple_list1: List of tuples\n :param tuple_list2: List of tuples\n :return: A new list of tuples with maximized elements\n \"\"\"\n # Ensure both lists have the same length\n if len(tuple_list1) != len(tuple_list2):\n raise ValueError(\"Both input lists must have the same number of tuples.\")\n \n result = []\n for t1, t2 in zip(tuple_list1, tuple_list2):\n # Create a new tuple with maximized elements from both tuples\n max_tuple = (max(t1[0], t2[0]), max(t1[1], t2[1]))\n result.append(max_tuple)\n \n return result"}
{"task_id": "Mbpp/260", "solution": "def is_prime(num):\n \"\"\"Check if a number is prime.\"\"\"\n if num <= 1:\n return False\n if num <= 3:\n return True\n if num % 2 == 0 or num % 3 == 0:\n return False\n i = 5\n while i * i <= num:\n if num % i == 0 or num % (i + 2) == 0:\n return False\n i += 6\n return True\n\ndef newman_shanks_williams(n):\n \"\"\"Find the nth NSW prime number.\"\"\"\n a, b = 1, 1\n count = 0\n \n while True:\n if is_prime(a):\n count += 1\n if count == n:\n return a\n \n # Generate the next NSW number\n a, b = 2 * a + b, a\n\n# Example usage\nassert newman_shanks_williams(3) == 7"}
{"task_id": "Mbpp/261", "solution": "def division_elements(tuple1, tuple2):\n \"\"\"\n Perform element-wise division between two tuples.\n \n Args:\n - tuple1: A tuple of numbers.\n - tuple2: A tuple of numbers with the same length as tuple1.\n \n Returns:\n - A new tuple containing the results of the division.\n \n Raises:\n - ValueError: If the lengths of the tuples are not equal or if any element in tuple2 is zero.\n \"\"\"\n # Check if both tuples have the same length\n if len(tuple1) != len(tuple2):\n raise ValueError(\"Tuples must be of the same length.\")\n \n # Initialize an empty list to store division results\n result = []\n \n # Iterate over pairs of elements from both tuples\n for a, b in zip(tuple1, tuple2):\n # Check if the divisor is zero\n if b == 0:\n raise ValueError(\"Division by zero is not allowed.\")\n \n # Perform division and append to results list\n result.append(a / b)\n \n # Convert the result list back into a tuple\n return tuple(result)"}
{"task_id": "Mbpp/262", "solution": "def split_two_parts(lst, L):\n \"\"\"\n Splits the given list into two parts where the length of the first part is L.\n \n Parameters:\n lst (list): The list to be split.\n L (int): The desired length of the first part.\n \n Returns:\n tuple: A tuple containing the two resulting lists.\n \"\"\"\n # Ensure that L is a valid index\n if not 0 <= L <= len(lst):\n raise ValueError(\"L must be between 0 and the length of the list.\")\n \n # Split the list into two parts\n first_part = lst[:L]\n second_part = lst[L:]\n \n return (first_part, second_part)"}
{"task_id": "Mbpp/264", "solution": "def dog_age(human_years):\n \"\"\"\n Calculate a dog's age in dog years.\n \n Parameters:\n human_years (int): The age of the dog in human years.\n \n Returns:\n int: The equivalent age in dog years.\n \"\"\"\n if human_years <= 0:\n return 0\n elif human_years == 1:\n return 15\n elif human_years == 2:\n return 25\n else:\n # First two years are 15 and 10 dog years respectively, then each year is 4 dog years.\n return 25 + (human_years - 2) * 4"}
{"task_id": "Mbpp/265", "solution": "def list_split(lst, n):\n \"\"\"\n Splits a list into sublists every nth element.\n\n Parameters:\n lst (list): The input list to be split.\n n (int): The interval at which to split the list.\n\n Returns:\n list: A list of lists where each sublist contains elements from the original\n list taken every nth position starting from 0, 1, ..., n-1 respectively.\n \"\"\"\n # Initialize a list to hold the resulting sublists\n result = [[] for _ in range(n)]\n \n # Iterate over the input list with index and element\n for i, item in enumerate(lst):\n # Determine which sublist to append the current element to\n sublist_index = i % n\n result[sublist_index].append(item)\n \n return result"}
{"task_id": "Mbpp/266", "solution": "def lateralsurface_cube(side_length):\n \"\"\"\n Calculate the lateral surface area of a cube.\n \n The lateral surface area of a cube is the sum of the areas of the four vertical faces.\n Each face has an area equal to side_length squared. Therefore, the lateral surface area\n is 4 times the area of one face.\n\n Parameters:\n - side_length (float or int): The length of a side of the cube.\n\n Returns:\n - float: The lateral surface area of the cube.\n \"\"\"\n # Calculate the area of one face\n face_area = side_length ** 2\n \n # There are four faces contributing to the lateral surface area\n lateral_surface_area = 4 * face_area\n \n return lateral_surface_area"}
{"task_id": "Mbpp/267", "solution": "def square_sum(n):\n \"\"\"\n Calculate the sum of the squares of the first n odd natural numbers.\n\n Parameters:\n n (int): The number of initial odd natural numbers to consider.\n\n Returns:\n int: The sum of the squares of these numbers.\n \"\"\"\n # Initialize the sum to 0\n total_sum = 0\n \n # Loop through the first n odd numbers\n for i in range(n):\n # Calculate the current odd number (2*i + 1)\n odd_number = 2 * i + 1\n \n # Add its square to the total sum\n total_sum += odd_number ** 2\n\n return total_sum\n\n# Test case\nassert square_sum(2) == 10, \"Test case failed!\""}
{"task_id": "Mbpp/268", "solution": "def find_star_num(n):\n \"\"\"\n Calculate the n'th star number.\n \n A star number is defined as:\n S_n = 6 * (n * (n - 1) / 2) + 1\n \n Args:\n n (int): The position in the sequence of star numbers.\n \n Returns:\n int: The n'th star number.\n \"\"\"\n if n < 1:\n raise ValueError(\"n must be a positive integer.\")\n \n # Calculate the nth star number using the formula\n return 6 * (n * (n - 1) // 2) + 1"}
{"task_id": "Mbpp/269", "solution": "def ascii_value(char):\n \"\"\"\n This function takes a single character as input and returns its ASCII value.\n \n Parameters:\n char (str): A string containing exactly one character.\n \n Returns:\n int: The ASCII value of the given character.\n \"\"\"\n if len(char) != 1:\n raise ValueError(\"Input must be a single character.\")\n \n return ord(char)"}
{"task_id": "Mbpp/270", "solution": "def sum_even_and_even_index(lst):\n \"\"\"\n This function calculates the sum of even numbers located at even indices in a list.\n \n Parameters:\n lst (list): A list of integers.\n\n Returns:\n int: The sum of even numbers at even positions.\n \"\"\"\n # Initialize the sum to zero\n total_sum = 0\n \n # Iterate over the list using enumerate to get both index and value\n for index, value in enumerate(lst):\n # Check if the index is even and the value is even\n if index % 2 == 0 and value % 2 == 0:\n total_sum += value\n \n return total_sum"}
{"task_id": "Mbpp/271", "solution": "def even_Power_Sum(n):\n \"\"\"\n Calculate the sum of the first n even natural numbers raised to the fifth power.\n \n Parameters:\n n (int): The number of even natural numbers to consider.\n \n Returns:\n int: The sum of the first n even natural numbers each raised to the fifth power.\n \"\"\"\n # Initialize the sum\n total_sum = 0\n \n # Loop through the first n even numbers\n for i in range(1, n + 1):\n # Calculate the ith even number (2 * i)\n even_number = 2 * i\n \n # Raise it to the fifth power and add to the sum\n total_sum += even_number ** 5\n \n return total_sum"}
{"task_id": "Mbpp/272", "solution": "def rear_extract(tuples_list):\n \"\"\"\n This function takes a list of tuples as input and returns a list containing \n the last element of each tuple.\n \n Parameters:\n tuples_list (list): A list of tuples where each tuple contains at least one element.\n \n Returns:\n list: A list containing the rear elements from each tuple in the input list.\n \"\"\"\n # Using list comprehension to extract the last element from each tuple\n return [tup[-1] for tup in tuples_list]"}
{"task_id": "Mbpp/273", "solution": "def subtract_elements(tuple1, tuple2):\n \"\"\"\n Subtracts elements of the second tuple from the first tuple element-wise.\n \n Parameters:\n tuple1 (tuple): The first tuple.\n tuple2 (tuple): The second tuple.\n \n Returns:\n tuple: A new tuple containing the results of the subtraction.\n \n Raises:\n ValueError: If the tuples are not of equal length.\n \"\"\"\n if len(tuple1) != len(tuple2):\n raise ValueError(\"Tuples must be of the same length\")\n \n result = tuple(a - b for a, b in zip(tuple1, tuple2))\n return result\n\n# Test case\nassert subtract_elements((10, 4, 5), (2, 5, 18)) == (8, -1, -13)"}
{"task_id": "Mbpp/274", "solution": "def even_binomial_Coeff_Sum(n):\n from math import comb\n \n # Calculate 2^n\n total_sum = 2 ** n\n \n # If n is odd, add the middle term C(n, n//2) once\n if n % 2 == 1:\n middle_term = comb(n, n // 2)\n even_index_sum = (total_sum + middle_term) // 2\n else:\n even_index_sum = total_sum // 2\n \n return even_index_sum"}
{"task_id": "Mbpp/276", "solution": "import math\ndef volume_cylinder(radius, height):\n \"\"\"\n Calculate the volume of a cylinder.\n \n Parameters:\n radius (float): The radius of the base of the cylinder.\n height (float): The height of the cylinder.\n \n Returns:\n float: The volume of the cylinder.\n \"\"\"\n # Volume formula for a cylinder: V = \u03c0 * r^2 * h\n return math.pi * radius ** 2 * height"}
{"task_id": "Mbpp/277", "solution": "def dict_filter(input_dict, n):\n \"\"\"\n Filters the input dictionary to include only entries with values >= n.\n\n Parameters:\n - input_dict (dict): A dictionary with string keys and integer values.\n - n (int): The threshold value for filtering.\n\n Returns:\n - dict: A new dictionary containing only the filtered key-value pairs.\n \"\"\"\n # Use a dictionary comprehension to filter entries\n return {key: value for key, value in input_dict.items() if value >= n}"}
{"task_id": "Mbpp/278", "solution": "def count_first_elements(tpl):\n \"\"\"\n This function counts the number of elements in the tuple before the first occurrence \n of a nested tuple element.\n \n Parameters:\n tpl (tuple): The input tuple which may contain other tuples as elements.\n\n Returns:\n int: The number of elements before the first tuple element.\n \"\"\"\n count = 0\n for element in tpl:\n if isinstance(element, tuple):\n return count\n count += 1\n return count"}
{"task_id": "Mbpp/279", "solution": "def is_num_decagonal(n):\n \"\"\"\n Calculate the nth decagonal number using the formula:\n D_n = 4n^2 - 3n\n\n Parameters:\n n (int): The position of the decagonal number to find.\n\n Returns:\n int: The nth decagonal number.\n \"\"\"\n return 4 * n**2 - 3 * n"}
{"task_id": "Mbpp/280", "solution": "def sequential_search(arr, element):\n \"\"\"\n This function takes an array and an element as input.\n It returns a tuple containing:\n - A boolean indicating if the element is found in the array.\n - The index position of the element if it's found, otherwise -1.\n\n Parameters:\n arr (list): The list to search within.\n element: The element to search for.\n\n Returns:\n tuple: (bool, int) where bool indicates presence and int is the index or -1.\n \"\"\"\n for index, value in enumerate(arr):\n if value == element:\n return (True, index)\n return (False, -1)"}
{"task_id": "Mbpp/281", "solution": "def all_unique(lst):\n \"\"\"\n Check if all elements in the list are unique.\n \n Parameters:\n lst (list): The list of elements to check for uniqueness.\n \n Returns:\n bool: True if all elements are unique, False otherwise.\n \"\"\"\n # Use a set to track seen elements\n seen = set()\n for element in lst:\n if element in seen:\n return False\n seen.add(element)\n return True"}
{"task_id": "Mbpp/282", "solution": "def sub_list(list1, list2):\n \"\"\"\n Subtract elements of list2 from list1 element-wise.\n \n Parameters:\n - list1: List of numbers (integers or floats).\n - list2: List of numbers (integers or floats) with the same length as list1.\n\n Returns:\n - A new list containing the result of subtracting each element in list2 from the corresponding element in list1.\n \n Raises:\n - ValueError: If the input lists are not of equal length.\n \"\"\"\n if len(list1) != len(list2):\n raise ValueError(\"Both lists must have the same number of elements.\")\n \n return [a - b for a, b in zip(list1, list2)]"}
{"task_id": "Mbpp/283", "solution": "def validate(n):\n \"\"\"\n Check whether the frequency of each digit in the integer n is less than or equal to the digit itself.\n \n Args:\n n (int): The input integer to be validated.\n \n Returns:\n bool: True if the condition holds for all digits, False otherwise.\n \"\"\"\n # Convert the integer to a string to iterate over its digits\n str_n = str(n)\n \n # Create a dictionary to store the frequency of each digit\n freq = {}\n \n # Count the frequency of each digit in the number\n for digit in str_n:\n if digit in freq:\n freq[digit] += 1\n else:\n freq[digit] = 1\n \n # Check if the frequency of each digit is less than or equal to the digit itself\n for digit, count in freq.items():\n if int(digit) < count:\n return False\n \n return True"}
{"task_id": "Mbpp/284", "solution": "def check_element(lst, element):\n \"\"\"\n Check if all elements in the list are equal to the specified element.\n \n Parameters:\n lst (list): The list of elements to be checked.\n element: The element to compare against each item in the list.\n \n Returns:\n bool: True if all items in the list are equal to the given element, False otherwise.\n \"\"\"\n return all(item == element for item in lst)"}
{"task_id": "Mbpp/285", "solution": "import re\ndef text_match_two_three(text):\n \"\"\"\n Check whether the input string contains the 'a' character followed by \n exactly two or three 'b' characters.\n \n Parameters:\n text (str): The input string to be checked.\n \n Returns:\n bool: True if the pattern is found, False otherwise.\n \"\"\"\n # Define a regular expression pattern for 'a' followed by 2 or 3 'b's\n pattern = r'a[b]{2,3}'\n \n # Use re.search to find the pattern in the text\n match = re.search(pattern, text)\n \n # Return True if a match is found, otherwise False\n return bool(match)"}
{"task_id": "Mbpp/286", "solution": "def max_sub_array_sum_repeated(arr, k, n):\n # Helper function to find maximum sum of a contiguous subarray using Kadane's algorithm\n def kadane(a):\n max_ending_here = max_so_far = a[0]\n for x in a[1:]:\n max_ending_here = max(x, max_ending_here + x)\n max_so_far = max(max_so_far, max_ending_here)\n return max_so_far\n\n # Edge case: if the array is empty\n if n == 0:\n return 0\n\n # Step 1: Find maximum subarray sum in a single instance of arr using Kadane's algorithm\n max_kadane = kadane(arr)\n\n # Step 2: Calculate prefix and suffix sums\n max_prefix_sum = float('-inf')\n current_prefix_sum = 0\n for i in range(n):\n current_prefix_sum += arr[i]\n max_prefix_sum = max(max_prefix_sum, current_prefix_sum)\n\n max_suffix_sum = float('-inf')\n current_suffix_sum = 0\n for i in range(n - 1, -1, -1):\n current_suffix_sum += arr[i]\n max_suffix_sum = max(max_suffix_sum, current_suffix_sum)\n\n # Step 3: Calculate total sum of the array\n total_sum = sum(arr)\n\n # If all numbers are negative, return the maximum element\n if max_kadane < 0:\n return max_kadane\n\n # Step 4: Consider cases based on k\n result = max_kadane\n if k == 1:\n return result\n\n # Case when total_sum is positive, we can add it multiple times\n if total_sum > 0:\n result = max(result, max_prefix_sum + (k - 2) * total_sum + max_suffix_sum)\n\n return result"}
{"task_id": "Mbpp/287", "solution": "def square_sum(n):\n \"\"\"\n Calculate the sum of squares of the first n even natural numbers.\n \n Parameters:\n n (int): The number of initial even natural numbers to consider.\n \n Returns:\n int: The sum of squares of the first n even natural numbers.\n \"\"\"\n # Initialize the sum\n total_sum = 0\n \n # Loop through the first n even numbers\n for i in range(1, n + 1):\n # Calculate the ith even number (2 * i)\n even_number = 2 * i\n \n # Add its square to the total sum\n total_sum += even_number ** 2\n \n return total_sum\n\n# Test case\nassert square_sum(2) == 20, \"Test case failed!\"\n\n# Example usage\nprint(square_sum(2)) # Output: 20"}
{"task_id": "Mbpp/290", "solution": "def max_length(list_of_lists):\n \"\"\"\n This function takes a list of lists and returns a tuple containing:\n - The length of the longest list.\n - The first list encountered with this maximum length.\n\n :param list_of_lists: List[List[Any]]\n :return: Tuple[int, List[Any]]\n \"\"\"\n max_len = 0\n max_list = []\n\n for lst in list_of_lists:\n if len(lst) > max_len:\n max_len = len(lst)\n max_list = lst\n\n return max_len, max_list"}
{"task_id": "Mbpp/292", "solution": "def find(dividend, divisor):\n \"\"\"\n Calculate the quotient of two numbers (rounded down to the nearest integer).\n\n Parameters:\n dividend (int or float): The number to be divided.\n divisor (int or float): The number by which to divide.\n\n Returns:\n int: The quotient rounded down to the nearest integer.\n \n Raises:\n ValueError: If the divisor is zero.\n \"\"\"\n if divisor == 0:\n raise ValueError(\"The divisor cannot be zero.\")\n \n # Use floor division to get the quotient rounded down\n return dividend // divisor"}
{"task_id": "Mbpp/293", "solution": "import math\ndef otherside_rightangle(side1, side2):\n # Determine which is the larger side\n if side1 > side2:\n hypotenuse = side1\n other_side = side2\n else:\n hypotenuse = side2\n other_side = side1\n \n # Check if one of the sides is the hypotenuse\n if hypotenuse**2 == other_side**2 + (side1 + side2 - hypotenuse)**2:\n # The third side is calculated using Pythagorean theorem\n return math.sqrt(hypotenuse**2 - other_side**2)\n \n # If neither of the given sides is the hypotenuse, calculate the hypotenuse\n return math.sqrt(side1**2 + side2**2)"}
{"task_id": "Mbpp/294", "solution": "def max_val(heterogeneous_list):\n # Initialize variables to store the maximum value found\n max_value = None\n \n for item in heterogeneous_list:\n if isinstance(item, (int, float)):\n # If the current item is a number, compare it with the current max_value\n if max_value is None or item > max_value:\n max_value = item\n elif isinstance(item, str):\n # If the current item is a string, convert it to a numeric value if possible\n try:\n num_value = float(item)\n if max_value is None or num_value > max_value:\n max_value = num_value\n except ValueError:\n # If conversion fails, skip this item as we are only interested in numbers\n continue\n \n return max_value"}
{"task_id": "Mbpp/296", "solution": "def merge_and_count(arr, temp_arr, left, mid, right):\n i = left # Starting index for left subarray\n j = mid + 1 # Starting index for right subarray\n k = left # Starting index to be sorted\n inv_count = 0\n\n # Conditions are checked to ensure that i doesn't exceed mid and j doesn't exceed right\n while i <= mid and j <= right:\n if arr[i] <= arr[j]:\n temp_arr[k] = arr[i]\n i += 1\n else:\n # There are mid - i inversions, because all elements left to i in the left subarray\n # are greater than arr[j]\n temp_arr[k] = arr[j]\n inv_count += (mid-i + 1)\n j += 1\n k += 1\n\n # Copy the remaining elements of left subarray, if any\n while i <= mid:\n temp_arr[k] = arr[i]\n i += 1\n k += 1\n\n # Copy the remaining elements of right subarray, if any\n while j <= right:\n temp_arr[k] = arr[j]\n j += 1\n k += 1\n\n # Copy the sorted subarray into Original array\n for i in range(left, right + 1):\n arr[i] = temp_arr[i]\n\n return inv_count\ndef merge_sort_and_count(arr, temp_arr, left, right):\n inv_count = 0\n if left < right:\n mid = (left + right)//2\n\n inv_count += merge_sort_and_count(arr, temp_arr, left, mid)\n inv_count += merge_sort_and_count(arr, temp_arr, mid + 1, right)\n\n inv_count += merge_and_count(arr, temp_arr, left, mid, right)\n\n return inv_count\ndef get_Inv_Count(arr):\n n = len(arr)\n temp_arr = [0]*n\n return merge_sort_and_count(arr, temp_arr, 0, n-1)"}
{"task_id": "Mbpp/297", "solution": "def flatten_list(nested_list):\n \"\"\"\n Flattens a given nested list structure into a single list of elements.\n \n Parameters:\n nested_list (list): A list which may contain other lists as its elements.\n\n Returns:\n list: A flattened version of the input list with all nested elements extracted.\n \"\"\"\n flat_list = []\n \n for element in nested_list:\n if isinstance(element, list):\n # Recursively flatten the sublist\n flat_list.extend(flatten_list(element))\n else:\n # Append non-list elements directly to the result\n flat_list.append(element)\n \n return flat_list"}
{"task_id": "Mbpp/299", "solution": "def max_aggregate(scores):\n \"\"\"\n Calculate the maximum aggregate score from a list of (name, score) tuples.\n \n Args:\n scores (list of tuples): A list where each tuple contains a name (str) and a score (int).\n \n Returns:\n tuple: A tuple containing the name with the highest total score and that score.\n \"\"\"\n # Dictionary to store cumulative scores for each person\n aggregate_scores = {}\n \n # Iterate over each (name, score) tuple in the list\n for name, score in scores:\n if name in aggregate_scores:\n # If the name is already in the dictionary, add the score to their total\n aggregate_scores[name] += score\n else:\n # Otherwise, initialize their total with the current score\n aggregate_scores[name] = score\n \n # Find the person with the maximum aggregate score\n max_name = None\n max_score = float('-inf')\n \n for name, total in aggregate_scores.items():\n if total > max_score:\n max_score = total\n max_name = name\n \n return (max_name, max_score)"}
{"task_id": "Mbpp/300", "solution": "import math\ndef count_binary_seq(n):\n # Calculate the central binomial coefficient (2n choose n)\n return math.comb(2 * n, n)"}
{"task_id": "Mbpp/301", "solution": "def dict_depth(d, level=1):\n \"\"\"\n Calculate the depth of a nested dictionary.\n \n Parameters:\n d (dict): The dictionary whose depth is to be calculated.\n level (int): The current depth level during recursion. Default is 1.\n \n Returns:\n int: The maximum depth of the dictionary.\n \"\"\"\n if not isinstance(d, dict) or not d:\n return level\n \n # Recursively find the maximum depth among all values\n return max(dict_depth(value, level + 1) for value in d.values())"}
{"task_id": "Mbpp/305", "solution": "def start_with_p(words):\n \"\"\"\n This function takes a list of words and returns two words that start with the letter 'p'.\n \n :param words: List of strings\n :return: A tuple containing two words starting with 'p'\n \"\"\"\n # Filter words that start with 'p' or 'P'\n p_words = [word for word in words if word.lower().startswith('p')]\n \n # Assert there are exactly two such words\n assert len(p_words) == 2, \"There must be exactly two words starting with 'p'\"\n \n return tuple(p_words)\n\n# Test the function\nassert start_with_p([\"Python PHP\", \"Java JavaScript\", \"c c++\"]) == ('Python', 'PHP')"}
{"task_id": "Mbpp/306", "solution": "def max_sum_increasing_subseq(arr, n, i, k):\n # Step 1: Calculate maximum sum of increasing subsequences ending at each index up to i\n max_sums = [0] * n\n for idx in range(n):\n max_sums[idx] = arr[idx]\n \n for j in range(1, i + 1):\n for l in range(j):\n if arr[l] < arr[j]:\n max_sums[j] = max(max_sums[j], max_sums[l] + arr[j])\n \n # Step 2: Find the maximum sum of increasing subsequence ending at any index up to i\n # and can be extended by including element at index k\n result = float('-inf')\n for j in range(i + 1):\n if arr[j] < arr[k]:\n result = max(result, max_sums[j] + arr[k])\n \n return result"}
{"task_id": "Mbpp/308", "solution": "def large_product(list1, list2, n):\n # Create a list to store all possible products\n products = []\n \n # Iterate over each element in the first list\n for num1 in list1:\n # Iterate over each element in the second list\n for num2 in list2:\n # Calculate the product and add it to the products list\n products.append(num1 * num2)\n \n # Sort the products list in descending order\n products.sort(reverse=True)\n \n # Return the first n largest products\n return products[:n]"}
{"task_id": "Mbpp/309", "solution": "def maximum(a, b):\n \"\"\"\n This function takes two numbers as input and returns the larger one.\n\n Parameters:\n a (int or float): The first number.\n b (int or float): The second number.\n\n Returns:\n int or float: The maximum of the two numbers.\n \"\"\"\n if a > b:\n return a\n else:\n return b"}
{"task_id": "Mbpp/310", "solution": "def string_to_tuple(s):\n \"\"\"\n Convert a given string to a tuple of characters.\n \n Parameters:\n s (str): The input string to be converted.\n \n Returns:\n tuple: A tuple containing each character from the input string.\n \"\"\"\n return tuple(s)"}
{"task_id": "Mbpp/311", "solution": "def set_left_most_unset_bit(n):\n \"\"\"\n Set the leftmost unset bit in the binary representation of n.\n \n Args:\n n (int): A non-negative integer whose leftmost unset bit is to be set.\n \n Returns:\n int: The new integer with the leftmost unset bit set.\n \"\"\"\n # If all bits are set, return n as it is\n if n & (n + 1) == 0:\n return n\n \n # Find the position of the leftmost unset bit\n mask = ~n\n pos = 0\n while mask & (1 << pos):\n pos += 1\n \n # Set the leftmost unset bit\n result = n | (1 << pos)\n \n return result"}
{"task_id": "Mbpp/312", "solution": "import math\ndef volume_cone(radius, height):\n \"\"\"\n Calculate the volume of a cone given its radius and height.\n \n Parameters:\n - radius (float): The radius of the base of the cone.\n - height (float): The height of the cone.\n \n Returns:\n - float: The volume of the cone.\n \"\"\"\n # Volume formula for a cone: V = (1/3) * \u03c0 * r^2 * h\n return (1/3) * math.pi * radius**2 * height"}
{"task_id": "Mbpp/388", "solution": "def highest_power_of_2(n):\n \"\"\"\n This function finds the highest power of 2 that is less than or equal to a given number n.\n\n Parameters:\n n (int): The upper limit integer.\n\n Returns:\n int: The highest power of 2 less than or equal to n.\n \"\"\"\n # Initialize the result as 1, which is 2^0\n result = 1\n \n # Keep multiplying by 2 until the next power exceeds n\n while result * 2 <= n:\n result *= 2\n \n return result\n\n# Test case\nassert highest_power_of_2(10) == 8"}
{"task_id": "Mbpp/389", "solution": "def find_lucas(n):\n \"\"\"\n Calculate the nth Lucas number.\n\n The Lucas numbers are similar to Fibonacci numbers, but start with 2 and 1 instead of 0 and 1.\n The sequence is defined as:\n L(0) = 2, L(1) = 1\n L(n) = L(n-1) + L(n-2) for n > 1\n\n Args:\n n (int): The position in the Lucas sequence to find.\n\n Returns:\n int: The nth Lucas number.\n \"\"\"\n if n == 0:\n return 2\n elif n == 1:\n return 1\n \n # Initialize the first two Lucas numbers\n lucas_0, lucas_1 = 2, 1\n\n # Compute the nth Lucas number iteratively\n for _ in range(2, n + 1):\n lucas_n = lucas_0 + lucas_1\n lucas_0, lucas_1 = lucas_1, lucas_n\n \n return lucas_n"}
{"task_id": "Mbpp/390", "solution": "def add_string(lst, fmt):\n \"\"\"\n Apply a given format string to all of the elements in a list.\n \n Parameters:\n lst (list): A list of elements to be formatted.\n fmt (str): A format string with placeholders for each element.\n \n Returns:\n list: A new list where each element is formatted according to the format string.\n \"\"\"\n return [fmt.format(i) for i in lst]"}
{"task_id": "Mbpp/391", "solution": "def convert_list_dictionary(ids, names, scores):\n \"\"\"\n Convert three lists into a list of nested dictionaries.\n \n Parameters:\n ids (list): List of student IDs.\n names (list): List of student names.\n scores (list): List of student scores.\n \n Returns:\n list: A list of dictionaries where each dictionary represents\n a student with their ID, name, and score in nested format.\n \"\"\"\n result = []\n for id_, name, score in zip(ids, names, scores):\n # Create a nested dictionary for each student\n student_dict = {id_: {name: score}}\n result.append(student_dict)\n return result"}
{"task_id": "Mbpp/392", "solution": "def get_max_sum(n):\n # Create a list to store results of subproblems\n dp = [0] * (n + 1)\n \n # Base case: f(0) and f(1) are 0 and 1 respectively\n for i in range(2, n + 1):\n # Calculate the maximum sum using the given equation\n dp[i] = max(i, dp[i // 2] + dp[i // 3] + dp[i // 4] + dp[i // 5])\n \n return dp[n]"}
{"task_id": "Mbpp/394", "solution": "def check_distinct(tpl):\n \"\"\"\n Check if the given tuple contains no duplicates.\n \n Parameters:\n tpl (tuple): The input tuple to be checked for duplicates.\n \n Returns:\n bool: True if there are no duplicates, False otherwise.\n \"\"\"\n # Convert the tuple into a set. Sets automatically remove duplicate elements.\n unique_elements = set(tpl)\n \n # Compare the length of the original tuple and the set\n # If they are equal, it means there were no duplicates in the tuple\n return len(unique_elements) == len(tpl)"}
{"task_id": "Mbpp/395", "solution": "def first_non_repeating_character(s):\n # Create a dictionary to count occurrences of each character\n char_count = {}\n \n # Count each character in the string\n for char in s:\n if char in char_count:\n char_count[char] += 1\n else:\n char_count[char] = 1\n \n # Find the first non-repeating character\n for char in s:\n if char_count[char] == 1:\n return char\n \n # Return None if there is no non-repeating character\n return None"}
{"task_id": "Mbpp/397", "solution": "def median_of_three(a, b, c):\n \"\"\"\n This function takes three numbers as input and returns their median.\n \n Parameters:\n a (float): The first number.\n b (float): The second number.\n c (float): The third number.\n \n Returns:\n float: The median of the three numbers.\n \"\"\"\n # Create a list of the three numbers\n numbers = [a, b, c]\n \n # Sort the list in ascending order\n sorted_numbers = sorted(numbers)\n \n # Return the middle element (median) from the sorted list\n return sorted_numbers[1]\n\n# Test case to verify the function works correctly\nassert median_of_three(25, 55, 65) == 55.0\n\nprint(\"The function passed the test case.\")"}
{"task_id": "Mbpp/398", "solution": "def sum_of_digits(numbers):\n \"\"\"\n Compute the sum of digits of each number in the given list.\n\n Parameters:\n numbers (list): A list of integers.\n\n Returns:\n int: The sum of all digits from all numbers in the list.\n \"\"\"\n total_sum = 0\n \n for number in numbers:\n # Convert the number to a string to iterate over its digits\n for digit in str(number):\n # Add each digit (converted back to an integer) to the total sum\n total_sum += int(digit)\n \n return total_sum"}
{"task_id": "Mbpp/404", "solution": "def minimum(a, b):\n \"\"\"\n This function returns the smaller of two numbers.\n\n Parameters:\n a (int or float): The first number.\n b (int or float): The second number.\n\n Returns:\n int or float: The smaller of the two numbers.\n \"\"\"\n return a if a < b else b"}
{"task_id": "Mbpp/405", "solution": "def check_tuplex(tpl, element):\n \"\"\"\n Check whether an element exists within a tuple.\n \n Parameters:\n tpl (tuple): The tuple in which to search for the element.\n element: The element to search for within the tuple.\n \n Returns:\n bool: True if the element is found in the tuple, False otherwise.\n \"\"\"\n return element in tpl"}
{"task_id": "Mbpp/406", "solution": "def find_parity(n):\n \"\"\"\n Determine if the parity of the number of 1s in the binary representation of n is odd.\n \n Parameters:\n n (int): The integer to check.\n \n Returns:\n bool: True if the number of 1s is odd, False otherwise.\n \"\"\"\n # Initialize a counter for the number of 1s\n count_ones = 0\n \n # Loop until n becomes zero\n while n > 0:\n # Increment the counter if the least significant bit is 1\n if n & 1:\n count_ones += 1\n \n # Right shift n by one bit to check the next bit\n n >>= 1\n \n # Check if the number of 1s is odd\n return count_ones % 2 == 1\n\n# Test case\nassert find_parity(12) == False, \"Test case failed!\"\n\nprint(\"All test cases passed!\")"}
{"task_id": "Mbpp/409", "solution": "def min_product_tuple(tuples_list):\n \"\"\"\n This function takes a list of tuples, where each tuple contains two integers.\n It computes the product of the integers in each tuple and returns the minimum product found.\n \n :param tuples_list: List of tuples containing pairs of integers\n :return: The minimum product from all tuple pairs\n \"\"\"\n # Initialize min_product with a large number to ensure any product will be smaller\n min_product = float('inf')\n \n # Iterate over each tuple in the list\n for a, b in tuples_list:\n # Calculate the product of the current tuple\n product = a * b\n \n # Update min_product if the current product is smaller\n if product < min_product:\n min_product = product\n \n return min_product"}
{"task_id": "Mbpp/410", "solution": "def min_val(heterogeneous_list):\n # Filter the list to include only numeric types (int, float)\n numeric_values = [item for item in heterogeneous_list if isinstance(item, (int, float))]\n \n # Return the minimum value from the filtered list\n return min(numeric_values) if numeric_values else None"}
{"task_id": "Mbpp/412", "solution": "def remove_odd(numbers):\n \"\"\"\n Remove odd numbers from a given list of integers.\n \n Parameters:\n numbers (list): A list of integers.\n \n Returns:\n list: A list containing only the even numbers from the input list.\n \"\"\"\n # Use a list comprehension to filter out odd numbers\n return [num for num in numbers if num % 2 == 0]"}
{"task_id": "Mbpp/413", "solution": "def extract_nth_element(tuples_list, n):\n \"\"\"\n Extracts the nth element from each tuple in the provided list of tuples.\n \n Parameters:\n - tuples_list: List[Tuple] : A list containing tuples.\n - n: int : The index of the element to be extracted from each tuple.\n\n Returns:\n - List[Any] : A list containing the nth elements from each tuple.\n \"\"\"\n # Use a list comprehension to extract the nth element from each tuple\n return [t[n] for t in tuples_list]"}
{"task_id": "Mbpp/414", "solution": "def overlapping(seq1, seq2):\n \"\"\"\n Check whether any value in seq1 exists in seq2.\n \n Parameters:\n - seq1: A sequence (e.g., list, tuple) of elements.\n - seq2: Another sequence (e.g., list, tuple) of elements.\n \n Returns:\n - True if there is at least one common element between the sequences.\n - False otherwise.\n \"\"\"\n # Convert both sequences to sets for efficient lookup\n set1 = set(seq1)\n set2 = set(seq2)\n \n # Check for intersection between the two sets\n return not set1.isdisjoint(set2)"}
{"task_id": "Mbpp/415", "solution": "def max_Product(arr):\n if len(arr) < 2:\n raise ValueError(\"Array must contain at least two elements.\")\n \n # Initialize variables to store the largest and smallest numbers\n max1 = max2 = float('-inf')\n min1 = min2 = float('inf')\n \n for num in arr:\n # Update the largest numbers\n if num > max1:\n max2 = max1\n max1 = num\n elif num > max2:\n max2 = num\n \n # Update the smallest numbers\n if num < min1:\n min2 = min1\n min1 = num\n elif num < min2:\n min2 = num\n \n # Calculate the products of the two largest and two smallest numbers\n product_max_pair = max1 * max2\n product_min_pair = min1 * min2\n \n # Return the pair with the highest product\n if product_max_pair > product_min_pair:\n return (max1, max2)\n else:\n return (min1, min2)"}
{"task_id": "Mbpp/418", "solution": "def Find_Max(lst):\n \"\"\"\n This function takes a list of lists as input and returns the sublist \n with the maximum length.\n \n Parameters:\n lst (list): A list containing sublists of varying lengths.\n \n Returns:\n list: The sublist with the maximum length.\n \"\"\"\n # Initialize variable to keep track of the longest sublist\n max_length_sublist = []\n \n # Iterate over each sublist in the input list\n for sublist in lst:\n # Check if the current sublist is longer than the currently known longest sublist\n if len(sublist) > len(max_length_sublist):\n # Update the longest sublist found so far\n max_length_sublist = sublist\n \n return max_length_sublist"}
{"task_id": "Mbpp/419", "solution": "def round_and_sum(numbers):\n \"\"\"\n Rounds each number in the list to the nearest integer,\n calculates their sum, and then multiplies this sum by \n the length of the list.\n \n Parameters:\n numbers (list): A list of floating-point numbers.\n\n Returns:\n int: The total sum multiplied by the length of the list.\n \"\"\"\n # Round each number in the list\n rounded_numbers = [round(num) for num in numbers]\n \n # Calculate the sum of the rounded numbers\n total_sum = sum(rounded_numbers)\n \n # Multiply the sum by the length of the original list\n result = total_sum * len(numbers)\n \n return result"}
{"task_id": "Mbpp/420", "solution": "def cube_sum(n):\n \"\"\"\n Calculate the cube sum of the first n even natural numbers.\n \n Parameters:\n n (int): The number of initial even natural numbers to consider.\n \n Returns:\n int: The cube sum of the first n even natural numbers.\n \"\"\"\n # Initialize the sum\n total_sum = 0\n \n # Loop through the first n even numbers\n for i in range(1, n + 1):\n # Calculate the ith even number (2 * i)\n even_number = 2 * i\n \n # Add its cube to the total sum\n total_sum += even_number ** 3\n \n return total_sum\n\n# Test the function with an assertion\nassert cube_sum(2) == 72, \"The test case failed!\"\n\n# Example usage:\nprint(cube_sum(2)) # Output should be 72"}
{"task_id": "Mbpp/421", "solution": "def concatenate_tuple(tpl):\n \"\"\"\n Concatenates each element of a tuple into a single string separated by hyphens.\n \n Parameters:\n tpl (tuple): A tuple containing elements to be concatenated.\n \n Returns:\n str: A string with all elements from the tuple joined by hyphens.\n \"\"\"\n # Convert all elements in the tuple to strings\n str_elements = map(str, tpl)\n # Join them using a hyphen as the delimiter\n result = '-'.join(str_elements)\n return result"}
{"task_id": "Mbpp/422", "solution": "def find_Average_Of_Cube(n):\n \"\"\"\n Calculate the average of the cubes of the first n natural numbers.\n \n Parameters:\n n (int): The number of initial natural numbers to consider.\n \n Returns:\n float: The average of the cubes of the first n natural numbers.\n \"\"\"\n if n <= 0:\n return 0.0\n \n # Calculate the sum of cubes of the first n natural numbers\n sum_of_cubes = sum(i**3 for i in range(1, n + 1))\n \n # Calculate the average\n average_of_cubes = sum_of_cubes / n\n \n return average_of_cubes"}
{"task_id": "Mbpp/424", "solution": "def extract_rear(tpl):\n \"\"\"\n Extracts the last character from each string in the given tuple.\n\n Parameters:\n tpl (tuple): A tuple of strings.\n\n Returns:\n list: A list containing the last character of each string.\n \"\"\"\n # Use a list comprehension to iterate over each element in the tuple\n # and extract the last character using negative indexing [-1]\n return [s[-1] for s in tpl]"}
{"task_id": "Mbpp/425", "solution": "def count_element_in_list(lst, element):\n \"\"\"\n Count the number of sublists in 'lst' that contain the specified 'element'.\n \n Parameters:\n lst (list): A list of lists.\n element: The element to search for within the sublists.\n \n Returns:\n int: The count of sublists containing the element.\n \"\"\"\n # Initialize a counter\n count = 0\n \n # Iterate over each sublist in the main list\n for sublist in lst:\n # Check if the element is in the current sublist\n if element in sublist:\n # Increment the counter if the element is found\n count += 1\n \n return count"}
{"task_id": "Mbpp/426", "solution": "def filter_odd_numbers(numbers):\n \"\"\"\n Filters out the odd numbers from a given list of integers.\n \n Parameters:\n numbers (list): A list of integers.\n \n Returns:\n list: A list containing only the odd numbers from the input list.\n \"\"\"\n # Use a list comprehension to filter odd numbers\n return [num for num in numbers if num % 2 != 0]\n\n# Test the function with an assertion\nassert filter_odd_numbers([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]) == [1, 3, 5, 7, 9]"}
{"task_id": "Mbpp/427", "solution": "def change_date_format(date_str):\n \"\"\"\n Convert a date string from yyyy-mm-dd format to dd-mm-yyyy format.\n\n Parameters:\n date_str (str): A date in the format 'yyyy-mm-dd'.\n\n Returns:\n str: The date in the format 'dd-mm-yyyy'.\n \"\"\"\n # Split the input date string by '-'\n year, month, day = date_str.split('-')\n \n # Reformat to dd-mm-yyyy\n new_date_format = f\"{day}-{month}-{year}\"\n \n return new_date_format"}
{"task_id": "Mbpp/428", "solution": "def shell_sort(arr):\n n = len(arr)\n \n # Start with a big gap, then reduce the gap\n gap = n // 2\n \n # Do a gapped insertion sort for this gap size.\n while gap > 0:\n # Perform a gapped insertion sort for this gap size.\n for i in range(gap, n):\n # Save arr[i] in temp and make a hole at position i\n temp = arr[i]\n \n # Shift earlier gap-sorted elements up until the correct location for arr[i] is found\n j = i\n while j >= gap and arr[j - gap] > temp:\n arr[j] = arr[j - gap]\n j -= gap\n \n # Put temp (the original arr[i]) in its correct location\n arr[j] = temp\n \n # Reduce the gap for the next element\n gap //= 2\n \n return arr"}
{"task_id": "Mbpp/429", "solution": "def and_tuples(tuple1, tuple2):\n \"\"\"\n This function takes two tuples of equal length and returns a new tuple.\n Each element in the returned tuple is the difference in indices where \n elements from the first tuple are greater than or equal to those in the second tuple.\n\n Parameters:\n - tuple1: A tuple of integers.\n - tuple2: A tuple of integers, must be the same length as tuple1.\n\n Returns:\n - A tuple containing the elementwise differences based on the described condition.\n \"\"\"\n \n # Ensure both tuples are of the same length\n if len(tuple1) != len(tuple2):\n raise ValueError(\"Both tuples must have the same length.\")\n \n result = []\n \n for i in range(len(tuple1)):\n count = 0\n for j in range(len(tuple2)):\n if tuple1[i] >= tuple2[j]:\n count += 1\n result.append(count - 1) # Subtract 1 to get the zero-based index difference\n \n return tuple(result)"}
{"task_id": "Mbpp/430", "solution": "def parabola_directrix(x1, y1, x2, y2, x3, y3):\n # Solve for coefficients a, b, c using the system of equations:\n # y1 = ax1^2 + bx1 + c\n # y2 = ax2^2 + bx2 + c\n # y3 = ax3^2 + bx3 + c\n\n # Create matrices to solve the linear system\n A = [\n [x1**2, x1, 1],\n [x2**2, x2, 1],\n [x3**2, x3, 1]\n ]\n \n B = [y1, y2, y3]\n\n # Solve for a, b, c using numpy's linear algebra solver\n import numpy as np\n coefficients = np.linalg.solve(A, B)\n a, b, c = coefficients\n\n # Calculate the vertex (h, k)\n h = -b / (2 * a)\n k = c - (b**2) / (4 * a)\n\n # Calculate the directrix y = k - 1/(4a)\n directrix_y = k - (1 / (4 * a))\n\n return directrix_y"}
{"task_id": "Mbpp/432", "solution": "def median_trapezium(base1, base2):\n \"\"\"\n Calculate the median length of a trapezium given its two bases.\n \n Parameters:\n - base1: Length of one of the parallel sides (bases) of the trapezium.\n - base2: Length of the other parallel side (base) of the trapezium.\n \n Returns:\n - The length of the median of the trapezium.\n \"\"\"\n return (base1 + base2) / 2"}
{"task_id": "Mbpp/433", "solution": "def check_greater(arr, num):\n \"\"\"\n Check if the given number is greater than all elements in the array.\n \n Parameters:\n arr (list): A list of numbers.\n num (int or float): The number to compare against each element in the list.\n \n Returns:\n bool: True if num is greater than every element in arr, False otherwise.\n \"\"\"\n for element in arr:\n if num <= element:\n return False\n return True"}
{"task_id": "Mbpp/435", "solution": "def last_digit(number):\n \"\"\"\n This function takes an integer and returns its last digit.\n \n Parameters:\n number (int): The input number from which the last digit is extracted.\n \n Returns:\n int: The last digit of the given number.\n \"\"\"\n # Convert the number to a string, get the last character, and convert it back to an integer\n return abs(number) % 10\n\n# Test case to verify the function works as expected\nassert last_digit(123) == 3\n\nprint(\"The function passed the test case.\")"}
{"task_id": "Mbpp/436", "solution": "def neg_nos(numbers):\n \"\"\"\n This function takes a list of numbers and returns a new list containing only the negative numbers.\n \n Parameters:\n numbers (list): A list of integers or floats.\n \n Returns:\n list: A list containing only the negative numbers from the input list.\n \"\"\"\n return [num for num in numbers if num < 0]"}
{"task_id": "Mbpp/437", "solution": "def remove_odd(s):\n \"\"\"\n This function takes a string 's' as input and returns a new string \n containing only the characters at even indices of the original string.\n \n Parameters:\n s (str): The input string from which to remove odd-indexed characters.\n \n Returns:\n str: A new string with characters at even indices.\n \"\"\"\n # Using list comprehension to select characters at even indices\n return ''.join([s[i] for i in range(len(s)) if i % 2 == 0])"}
{"task_id": "Mbpp/439", "solution": "def multiple_to_single(int_list):\n \"\"\"\n Joins a list of integers into a single integer.\n \n Parameters:\n int_list (list): A list of integers to be joined.\n \n Returns:\n int: A single integer formed by concatenating the input integers.\n \"\"\"\n # Convert each integer in the list to a string\n str_ints = [str(num) for num in int_list]\n \n # Join all strings together into one long string\n combined_str = ''.join(str_ints)\n \n # Convert the combined string back to an integer\n result = int(combined_str)\n \n return result"}
{"task_id": "Mbpp/440", "solution": "import re\ndef find_adverb_position(sentence):\n # Define a regular expression pattern for adverbs.\n # Adverbs often end with 'ly', but this is not always true. \n # This regex will capture words ending with 'ly' as potential adverbs.\n adverb_pattern = r'\\b\\w+ly\\b'\n \n # Use the re.finditer method to find all matches of the pattern in the sentence\n for match in re.finditer(adverb_pattern, sentence):\n start_pos = match.start()\n end_pos = match.end()\n adverb = match.group()\n \n # Return the first found adverb and its positions (start and end)\n return (start_pos, end_pos, adverb)"}
{"task_id": "Mbpp/441", "solution": "def surface_area_cube(side_length):\n \"\"\"\n Calculate the surface area of a cube with a given side length.\n \n Parameters:\n side_length (int): The length of one side of the cube.\n \n Returns:\n int: The total surface area of the cube.\n \"\"\"\n # A cube has 6 faces, and each face is a square with an area equal to side_length squared\n return 6 * (side_length ** 2)\n\n# Test case\nassert surface_area_cube(5) == 150\n\nprint(\"The function works correctly for the test case.\")"}
{"task_id": "Mbpp/445", "solution": "def index_multiplication(tuple1, tuple2):\n \"\"\"\n Perform index-wise multiplication of elements in two tuples.\n \n Args:\n - tuple1: A tuple containing tuples as its elements.\n - tuple2: Another tuple containing tuples as its elements.\n \n Returns:\n - A new tuple with the results of element-wise multiplication.\n \"\"\"\n # Ensure both input tuples have the same length\n if len(tuple1) != len(tuple2):\n raise ValueError(\"Both tuples must have the same number of elements.\")\n \n result = []\n for t1, t2 in zip(tuple1, tuple2):\n # Ensure each inner tuple has the same length\n if len(t1) != len(t2):\n raise ValueError(\"Inner tuples must have the same number of elements.\")\n \n multiplied_tuple = tuple(a * b for a, b in zip(t1, t2))\n result.append(multiplied_tuple)\n \n return tuple(result)"}
{"task_id": "Mbpp/446", "solution": "def count_occurrence(tpl, lst):\n \"\"\"\n Count the occurrence of all elements of `lst` in `tpl`.\n\n Parameters:\n tpl (tuple): A tuple containing various elements.\n lst (list): A list of elements to be counted within the tuple.\n\n Returns:\n int: The total number of occurrences of any element from `lst` in `tpl`.\n \"\"\"\n # Initialize a counter\n count = 0\n \n # Iterate over each element in the tuple\n for item in tpl:\n # If the current item is in the list, increment the counter\n if item in lst:\n count += 1\n \n return count\n\n# Test case to verify the function works as expected\nassert count_occurrence(('a', 'a', 'c', 'b', 'd'), ['a', 'b']) == 3"}
{"task_id": "Mbpp/447", "solution": "def cube_nums(numbers):\n \"\"\"\n This function takes a list of numbers and returns a list of their cubes.\n \n Parameters:\n numbers (list): A list of integers or floats.\n \n Returns:\n list: A list containing the cubes of the input numbers.\n \"\"\"\n # Use a list comprehension to compute the cube of each number\n return [num ** 3 for num in numbers]"}
{"task_id": "Mbpp/448", "solution": "def perrin_number(n):\n \"\"\"Calculate the nth Perrin number.\"\"\"\n if n == 0:\n return 3\n elif n == 1:\n return 0\n elif n == 2:\n return 2\n \n # Initialize the first three numbers of the sequence\n a, b, c = 3, 0, 2\n \n # Calculate up to the nth Perrin number\n for _ in range(3, n + 1):\n a, b, c = b, c, a + b\n \n return c\ndef cal_sum(n):\n \"\"\"Calculate the sum of Perrin numbers from P(0) to P(n).\"\"\"\n total_sum = 0\n for i in range(n + 1):\n total_sum += perrin_number(i)\n return total_sum"}
{"task_id": "Mbpp/450", "solution": "def extract_string(strings, size):\n \"\"\"\n Extract strings from the list that have exactly the specified length.\n\n Parameters:\n - strings (list): A list of string values.\n - size (int): The exact length of strings to be extracted.\n\n Returns:\n - list: A list containing strings with the specified length.\n \"\"\"\n # Use a list comprehension to filter out strings that match the desired length\n return [s for s in strings if len(s) == size]"}
{"task_id": "Mbpp/451", "solution": "def remove_whitespaces(s):\n \"\"\"\n This function removes all whitespace characters from the input string `s`.\n \n Parameters:\n s (str): The input string from which whitespaces are to be removed.\n \n Returns:\n str: A new string with all whitespace characters removed.\n \"\"\"\n # Use a generator expression to filter out any character that is not a space\n return ''.join(char for char in s if not char.isspace())"}
{"task_id": "Mbpp/453", "solution": "def sum_of_factors(n):\n \"\"\"\n Calculate the sum of all even factors of a given number n.\n \n Parameters:\n n (int): The number for which we want to find the sum of even factors.\n \n Returns:\n int: The sum of all even factors of n.\n \"\"\"\n # Initialize sum\n sum_even_factors = 0\n \n # Iterate over possible factors from 1 to n\n for i in range(1, n + 1):\n # Check if i is a factor of n\n if n % i == 0:\n # Check if the factor is even\n if i % 2 == 0:\n sum_even_factors += i\n \n return sum_even_factors\n\n# Test case\nassert sum_of_factors(18) == 26, \"Test case failed!\""}
{"task_id": "Mbpp/454", "solution": "import re\ndef text_match_wordz(text):\n \"\"\"\n This function checks if there is any word in the input text that contains the letter 'z'.\n \n Args:\n text (str): The string to be checked.\n \n Returns:\n bool: True if at least one word containing 'z' is found, False otherwise.\n \"\"\"\n # Regular expression pattern to find words containing 'z'\n pattern = r'\\b\\w*z\\w*\\b'\n \n # Search for the pattern in the text\n match = re.search(pattern, text)\n \n # Return True if a match is found, else return False\n return bool(match)"}
{"task_id": "Mbpp/455", "solution": "def check_monthnumber(month_number):\n \"\"\"\n Check if the given month number contains 31 days.\n\n Parameters:\n month_number (int): The month number (1-12)\n\n Returns:\n bool: True if the month has 31 days, False otherwise.\n \"\"\"\n # List of months that have 31 days\n months_with_31_days = [1, 3, 5, 7, 8, 10, 12]\n \n # Check if the given month number is in the list\n return month_number in months_with_31_days\n\n# Test case to verify the function works correctly for May (month number 5)\nassert check_monthnumber(5) == True\n\n# Additional test cases\nassert check_monthnumber(1) == True # January has 31 days\nassert check_monthnumber(2) == False # February does not have 31 days\nassert check_monthnumber(4) == False # April does not have 31 days\nassert check_monthnumber(6) == False # June does not have 31 days\nassert check_monthnumber(9) == False # September does not have 31 days\nassert check_monthnumber(11) == False# November does not have 31 days\nassert check_monthnumber(12) == True # December has 31 days\n\nprint(\"All test cases passed!\")"}
{"task_id": "Mbpp/456", "solution": "def reverse_string_list(strings):\n \"\"\"\n Reverses each string in the provided list of strings.\n \n Parameters:\n strings (list): A list of strings to be reversed.\n \n Returns:\n list: A new list containing the reversed versions of the input strings.\n \"\"\"\n return [s[::-1] for s in strings]"}
{"task_id": "Mbpp/457", "solution": "def Find_Min(list_of_lists):\n \"\"\"\n This function takes a list of lists and returns the sublist with the minimum length.\n \n Parameters:\n list_of_lists (list): A list containing sublists.\n \n Returns:\n list: The sublist with the minimum length.\n \"\"\"\n # Initialize the minimum length to a large number\n min_length = float('inf')\n # Variable to store the sublist with the minimum length\n min_list = None\n \n # Iterate over each sublist in the list of lists\n for sublist in list_of_lists:\n # Check if the current sublist is shorter than the known minimum\n if len(sublist) < min_length:\n # Update the minimum length and the corresponding sublist\n min_length = len(sublist)\n min_list = sublist\n \n return min_list"}
{"task_id": "Mbpp/458", "solution": "def rectangle_area(length, width):\n \"\"\"\n Calculate the area of a rectangle.\n\n Parameters:\n length (float): The length of the rectangle.\n width (float): The width of the rectangle.\n\n Returns:\n float: The area of the rectangle.\n \"\"\"\n return length * width"}
{"task_id": "Mbpp/459", "solution": "def remove_uppercase(s):\n \"\"\"\n This function removes all uppercase substrings from the input string.\n \n Parameters:\n s (str): The input string containing both uppercase and lowercase characters.\n \n Returns:\n str: A new string with all uppercase substrings removed.\n \"\"\"\n # Initialize an empty list to store the result\n result = []\n \n # Iterate over each character in the string\n i = 0\n while i < len(s):\n # Check if the current character is lowercase\n if s[i].islower():\n # If it's lowercase, add it to the result\n result.append(s[i])\n # Move to the next character\n i += 1\n else:\n # If it's uppercase, find the end of this uppercase substring\n start = i\n while i < len(s) and s[i].isupper():\n i += 1\n # Skip all characters in this uppercase substring\n \n # Join the list into a string and return\n return ''.join(result)"}
{"task_id": "Mbpp/460", "solution": "def Extract(list_of_lists):\n \"\"\"\n This function takes a list of sublists and returns a new list containing \n the first element of each sublist.\n \n Parameters:\n - list_of_lists: A list where each element is a sublist (list).\n \n Returns:\n - A list containing the first element from each sublist in the input list.\n \"\"\"\n # Use a list comprehension to extract the first element of each sublist\n return [sublist[0] for sublist in list_of_lists if sublist]"}
{"task_id": "Mbpp/462", "solution": "from itertools import chain, combinations\ndef combinations_list(elements):\n \"\"\"\n Generate all possible combinations of the elements in the input list.\n \n Args:\n elements (list): A list of elements to generate combinations from.\n\n Returns:\n list: A list containing all possible combinations of the input elements,\n including the empty combination.\n \"\"\"\n # Use chain and combinations from itertools to generate all combinations\n return list(chain.from_iterable(combinations(elements, r) for r in range(len(elements) + 1)))"}
{"task_id": "Mbpp/463", "solution": "def max_subarray_product(nums):\n if not nums:\n return 0\n\n # Initialize variables to track the maximum and minimum products up to the current position.\n max_prod = min_prod = result = nums[0]\n\n for num in nums[1:]:\n # If the current number is negative, swap max and min because multiplying by a negative flips signs\n if num < 0:\n max_prod, min_prod = min_prod, max_prod\n\n # Calculate the maximum product up to the current position\n max_prod = max(num, max_prod * num)\n \n # Calculate the minimum product up to the current position\n min_prod = min(num, min_prod * num)\n\n # Update the result with the maximum product found so far\n result = max(result, max_prod)\n\n return result"}
{"task_id": "Mbpp/465", "solution": "def drop_empty(d):\n \"\"\"\n Remove keys with 'empty' values from the dictionary.\n \n An 'empty' value is defined as:\n - None\n - Empty string ''\n - Zero-length collections (e.g., [], {}, set())\n \n Parameters:\n d (dict): The input dictionary to process.\n\n Returns:\n dict: A new dictionary with empty items removed.\n \"\"\"\n # Define what constitutes an 'empty' value\n def is_empty(value):\n if value is None:\n return True\n if isinstance(value, str) and not value:\n return True\n if isinstance(value, (list, tuple, set, dict)) and not value:\n return True\n return False\n\n # Use dictionary comprehension to filter out empty items\n return {k: v for k, v in d.items() if not is_empty(v)}"}
{"task_id": "Mbpp/468", "solution": "def max_product(nums):\n if not nums:\n return 0\n\n # Initialize dp with the same values as nums, because each number itself is an increasing subsequence.\n dp = nums[:]\n \n for i in range(len(nums)):\n for j in range(i):\n # Check if we can form an increasing subsequence ending at index i\n if nums[i] > nums[j]:\n # Update the product at dp[i]\n dp[i] = max(dp[i], dp[j] * nums[i])\n \n # The answer is the maximum value in dp, which represents the maximum product of any increasing subsequence.\n return max(dp)"}
{"task_id": "Mbpp/470", "solution": "def add_pairwise(input_tuple):\n \"\"\"\n This function takes a tuple of numbers and returns a new tuple where each element is \n the sum of two consecutive elements from the original tuple.\n \n :param input_tuple: A tuple of integers or floats.\n :return: A tuple containing the pairwise sums of neighboring elements.\n \"\"\"\n # Initialize an empty list to store the results\n result = []\n \n # Iterate over the indices of the tuple, stopping one element before the last\n for i in range(len(input_tuple) - 1):\n # Add the current element and the next element\n pairwise_sum = input_tuple[i] + input_tuple[i + 1]\n # Append the result to the list\n result.append(pairwise_sum)\n \n # Convert the list back into a tuple before returning\n return tuple(result)"}
{"task_id": "Mbpp/471", "solution": "def find_remainder(arr, n):\n \"\"\"\n Calculate the product of all elements in the array `arr` and return the remainder when divided by `n`.\n \n Parameters:\n arr (list): A list of integers.\n n (int): The modulus value.\n\n Returns:\n int: The remainder of the product of the array's elements modulo `n`.\n \"\"\"\n # Initialize the result as 1 (multiplicative identity)\n result = 1\n \n # Iterate over each element in the array\n for num in arr:\n # Multiply the current number with the result and take modulo n to prevent overflow\n result = (result * num) % n\n \n return result"}
{"task_id": "Mbpp/472", "solution": "def check_consecutive(lst):\n \"\"\"\n Check if the given list contains consecutive numbers.\n \n Parameters:\n lst (list): A list of integers.\n \n Returns:\n bool: True if the list contains consecutive numbers, False otherwise.\n \"\"\"\n # Sort the list to ensure order\n sorted_lst = sorted(lst)\n \n # Check if each element is exactly 1 more than the previous one\n for i in range(1, len(sorted_lst)):\n if sorted_lst[i] != sorted_lst[i - 1] + 1:\n return False\n \n return True\n\n# Test cases\nassert check_consecutive([1, 2, 3, 4, 5]) == True\nassert check_consecutive([10, 11, 12, 13, 14]) == True\nassert check_consecutive([5, 6, 7, 8, 10]) == False\nassert check_consecutive([]) == True # An empty list can be considered as having consecutive numbers (trivially true)\nassert check_consecutive([1]) == True # A single element is trivially consecutive\n\nprint(\"All test cases passed!\")"}
{"task_id": "Mbpp/473", "solution": "def tuple_intersection(list1, list2):\n \"\"\"\n Find the intersection of tuples from two lists irrespective of their order.\n \n Args:\n - list1: A list of tuples.\n - list2: Another list of tuples.\n \n Returns:\n - A set containing tuples that are present in both lists, with elements sorted within each tuple.\n \"\"\"\n # Convert each tuple to a sorted tuple so that (a, b) and (b, a) are considered the same\n set1 = {tuple(sorted(t)) for t in list1}\n set2 = {tuple(sorted(t)) for t in list2}\n \n # Find intersection of both sets\n return set1.intersection(set2)"}
{"task_id": "Mbpp/474", "solution": "def replace_char(s, old_char, new_char):\n \"\"\"\n Replace all occurrences of old_char with new_char in the string s.\n \n Parameters:\n s (str): The original string.\n old_char (str): The character to be replaced.\n new_char (str): The character to replace with.\n \n Returns:\n str: A new string with all instances of old_char replaced by new_char.\n \"\"\"\n # Use the str.replace() method to replace characters\n return s.replace(old_char, new_char)"}
{"task_id": "Mbpp/475", "solution": "def sort_counter(subject_scores):\n \"\"\"\n Sorts a dictionary by its values in descending order.\n \n Parameters:\n subject_scores (dict): A dictionary with subjects as keys and scores as values.\n \n Returns:\n list: A list of tuples, each containing a key-value pair from the dictionary,\n sorted by value in descending order.\n \"\"\"\n # Use the sorted function to sort the dictionary items\n # The key parameter is set to a lambda function that returns the second element (value) of each item\n # reverse=True sorts the list in descending order\n sorted_items = sorted(subject_scores.items(), key=lambda item: item[1], reverse=True)\n \n return sorted_items"}
{"task_id": "Mbpp/476", "solution": "def big_sum(arr):\n \"\"\"\n This function takes an array of numbers as input and returns the sum \n of the largest and smallest values in the array.\n \n Parameters:\n arr (list): A list of integers or floats.\n\n Returns:\n int/float: The sum of the maximum and minimum values in the list.\n \"\"\"\n if not arr: # Check for an empty list\n raise ValueError(\"The input array must contain at least one element.\")\n \n max_value = max(arr)\n min_value = min(arr)\n \n return max_value + min_value"}
{"task_id": "Mbpp/477", "solution": "def is_lower(s: str) -> str:\n \"\"\"\n Convert the input string to lowercase.\n\n Parameters:\n s (str): The string to be converted.\n\n Returns:\n str: The lowercase version of the input string.\n \"\"\"\n return s.lower()"}
{"task_id": "Mbpp/478", "solution": "def remove_lowercase(s):\n \"\"\"\n Remove all lowercase substrings from the given string.\n \n Parameters:\n s (str): The input string from which lowercase characters are to be removed.\n \n Returns:\n str: A new string with all lowercase characters removed.\n \"\"\"\n # Use list comprehension to filter out lowercase letters\n return ''.join(char for char in s if not char.islower())"}
{"task_id": "Mbpp/479", "solution": "def first_digit(number):\n \"\"\"\n This function takes an integer or float and returns its first digit.\n \n Parameters:\n number (int/float): The input number whose first digit is to be found.\n \n Returns:\n int: The first digit of the given number.\n \"\"\"\n # Convert the number to a string\n num_str = str(abs(number))\n \n # Iterate over each character in the string representation\n for char in num_str:\n if char.isdigit():\n return int(char)\n \n # If no digits are found, which shouldn't happen with valid input,\n # return None or raise an error. Here we assume valid input.\n return None\n\n# Test cases to verify the function works as expected\nassert first_digit(123) == 1\nassert first_digit(-4567) == 4\nassert first_digit(0) == 0\nassert first_digit(987654321) == 9\nassert first_digit(-0.00123) == 1\n\nprint(\"All test cases passed!\")"}
{"task_id": "Mbpp/554", "solution": "def split(numbers):\n \"\"\"\n This function takes a list of integers and returns a new list containing only the odd numbers.\n \n Parameters:\n numbers (list): A list of integers.\n \n Returns:\n list: A list containing only the odd integers from the input list.\n \"\"\"\n # Use a list comprehension to filter out even numbers\n return [num for num in numbers if num % 2 != 0]\n\n# Test case as per the problem statement\nassert split([1, 2, 3, 4, 5, 6]) == [1, 3, 5]"}
{"task_id": "Mbpp/555", "solution": "def difference(n):\n \"\"\"\n Calculate the difference between the sum of cubes of the first n natural numbers \n and the sum of the first n natural numbers.\n \n Parameters:\n n (int): The number of first natural numbers to consider.\n \n Returns:\n int: The calculated difference.\n \"\"\"\n # Sum of the first n natural numbers\n sum_of_numbers = n * (n + 1) // 2\n \n # Sum of cubes of the first n natural numbers\n sum_of_cubes = (n * (n + 1) // 2) ** 2\n \n # Calculate the difference\n result = sum_of_cubes - sum_of_numbers\n \n return result"}
{"task_id": "Mbpp/556", "solution": "def find_odd_pairs(arr, n):\n # Count of numbers with even and odd values\n even_count = 0\n odd_count = 0\n \n # Traverse through the array to count evens and odds\n for num in arr:\n if num % 2 == 0:\n even_count += 1\n else:\n odd_count += 1\n \n # The number of pairs with an odd XOR is the product of the counts of even and odd numbers\n return even_count * odd_count\n\n# Test case\nassert find_odd_pairs([5, 4, 7, 2, 1], 5) == 6"}
{"task_id": "Mbpp/557", "solution": "def toggle_string(s):\n \"\"\"\n Toggles the case of each character in the input string.\n \n Parameters:\n s (str): The input string whose characters' cases are to be toggled.\n \n Returns:\n str: A new string with all characters' cases toggled.\n \"\"\"\n # Use a list comprehension to toggle the case of each character\n toggled = [char.lower() if char.isupper() else char.upper() for char in s]\n # Join the list back into a single string and return it\n return ''.join(toggled)"}
{"task_id": "Mbpp/558", "solution": "def digit_distance_nums(a, b):\n \"\"\"\n Calculate the sum of the per-digit difference between two integers.\n \n Args:\n a (int): The first integer.\n b (int): The second integer.\n \n Returns:\n int: The sum of the absolute differences of corresponding digits.\n \"\"\"\n # Convert numbers to strings for easy digit manipulation\n str_a = str(a)\n str_b = str(b)\n \n # Pad the shorter string with leading zeros\n max_length = max(len(str_a), len(str_b))\n str_a = str_a.zfill(max_length)\n str_b = str_b.zfill(max_length)\n \n # Calculate the sum of per-digit differences\n total_difference = 0\n for digit_a, digit_b in zip(str_a, str_b):\n total_difference += abs(int(digit_a) - int(digit_b))\n \n return total_difference"}
{"task_id": "Mbpp/559", "solution": "def max_sub_array_sum(arr):\n # Initialize variables to store the maximum sum found so far and the current sum\n max_so_far = float('-inf')\n current_max = 0\n\n for num in arr:\n # Update the current maximum sum by including the current number\n current_max += num\n \n # If the current maximum is greater than the maximum so far, update it\n if current_max > max_so_far:\n max_so_far = current_max\n \n # If the current maximum drops below zero, reset it to zero\n if current_max < 0:\n current_max = 0\n\n return max_so_far"}
{"task_id": "Mbpp/560", "solution": "def union_elements(tuple1, tuple2):\n \"\"\"\n This function takes two tuples as input and returns their union in sorted order.\n \n Parameters:\n tuple1 (tuple): The first tuple.\n tuple2 (tuple): The second tuple.\n \n Returns:\n tuple: A tuple containing the union of elements from both input tuples, sorted in ascending order.\n \"\"\"\n # Convert both tuples to sets to find their union\n set_union = set(tuple1).union(set(tuple2))\n \n # Convert the resulting set back to a tuple and sort it\n result_tuple = tuple(sorted(set_union))\n \n return result_tuple"}
{"task_id": "Mbpp/562", "solution": "def Find_Max_Length(list_of_lists):\n \"\"\"\n This function takes a list of lists and returns the length of the longest sublist.\n \n Parameters:\n list_of_lists (list): A list containing sublists of varying lengths.\n \n Returns:\n int: The length of the longest sublist.\n \"\"\"\n # Initialize max_length to 0\n max_length = 0\n \n # Iterate over each sublist in the list_of_lists\n for sublist in list_of_lists:\n # Update max_length if the current sublist is longer than the previous max_length\n if len(sublist) > max_length:\n max_length = len(sublist)\n \n return max_length"}
{"task_id": "Mbpp/563", "solution": "import re\ndef extract_values(input_string):\n \"\"\"\n Extracts values between double quotation marks from the input string.\n \n Args:\n - input_string (str): A string containing values within double quotes.\n \n Returns:\n - List[str]: A list of strings extracted from within the double quotes.\n \"\"\"\n # Use regular expression to find all occurrences of text within double quotes\n pattern = r'\"(.*?)\"'\n matches = re.findall(pattern, input_string)\n \n return matches"}
{"task_id": "Mbpp/564", "solution": "def count_pairs(lst):\n \"\"\"\n This function takes a list of integers and returns the number of unordered pairs (i, j) such that i != j.\n \n :param lst: List[int] - A list of integers\n :return: int - The number of unordered pairs with unequal elements\n \"\"\"\n # Dictionary to count occurrences of each element in the list\n frequency = {}\n \n for num in lst:\n if num in frequency:\n frequency[num] += 1\n else:\n frequency[num] = 1\n \n total_pairs = 0\n unique_elements = len(frequency)\n \n # Calculate total possible pairs (unordered) from the list\n n = len(lst)\n total_possible_pairs = n * (n - 1) // 2\n \n # Subtract pairs where both elements are equal\n for count in frequency.values():\n if count > 1:\n total_possible_pairs -= count * (count - 1) // 2\n \n return total_possible_pairs\n\n# Test the function with the provided example\nassert count_pairs([1, 2, 1]) == 2\n\nprint(\"Test passed!\")"}
{"task_id": "Mbpp/565", "solution": "def split(s):\n \"\"\"\n Splits a given string into a list of its individual characters.\n \n Parameters:\n s (str): The string to be split.\n \n Returns:\n list: A list containing each character of the input string as an element.\n \"\"\"\n return [char for char in s]"}
{"task_id": "Mbpp/566", "solution": "def sum_digits(n):\n \"\"\"\n Calculate the sum of the digits of a non-negative integer.\n \n Parameters:\n n (int): A non-negative integer whose digits are to be summed.\n \n Returns:\n int: The sum of the digits of the input number.\n \"\"\"\n # Initialize the sum to 0\n total_sum = 0\n \n # Loop until all digits are processed\n while n > 0:\n # Extract the last digit and add it to the total sum\n total_sum += n % 10\n \n # Remove the last digit from the number\n n //= 10\n \n return total_sum"}
{"task_id": "Mbpp/567", "solution": "def issort_list(lst):\n \"\"\"\n Check if the specified list is sorted in non-decreasing order.\n \n Parameters:\n lst (list): The list to check for sorting.\n \n Returns:\n bool: True if the list is sorted, False otherwise.\n \"\"\"\n # Iterate through the list and compare each element with the next one\n for i in range(len(lst) - 1):\n if lst[i] > lst[i + 1]:\n return False\n return True"}
{"task_id": "Mbpp/568", "solution": "def empty_list(N):\n \"\"\"\n Create a list of N empty dictionaries.\n \n Parameters:\n N (int): The number of empty dictionaries to create in the list.\n \n Returns:\n list: A list containing N empty dictionaries.\n \"\"\"\n # Use a list comprehension to generate N empty dictionaries\n return [{} for _ in range(N)]"}
{"task_id": "Mbpp/569", "solution": "def sort_sublists(list_of_lists):\n \"\"\"\n Sorts each sublist within a list of lists.\n \n Parameters:\n list_of_lists (list): A list containing sublists of strings.\n \n Returns:\n list: A new list with each sublist sorted alphabetically.\n \"\"\"\n # Use a list comprehension to sort each sublist\n return [sorted(sublist) for sublist in list_of_lists]"}
{"task_id": "Mbpp/572", "solution": "def two_unique_nums(lst):\n \"\"\"\n Remove duplicates from the list and return numbers that appear exactly once.\n \n Parameters:\n lst (list): A list of integers.\n \n Returns:\n list: A list containing numbers that appear exactly once in the input list.\n \"\"\"\n # Create a dictionary to count occurrences of each number\n num_count = {}\n \n for num in lst:\n if num in num_count:\n num_count[num] += 1\n else:\n num_count[num] = 1\n \n # Collect numbers that appear exactly once\n unique_nums = [num for num, count in num_count.items() if count == 1]\n \n return unique_nums"}
{"task_id": "Mbpp/573", "solution": "def unique_product(numbers):\n # Use a set to find unique elements in the list\n unique_numbers = set(numbers)\n \n # Initialize the product variable to 1 (multiplicative identity)\n product = 1\n \n # Iterate over each unique number and multiply it with the product\n for num in unique_numbers:\n product *= num\n \n return product"}
{"task_id": "Mbpp/576", "solution": "def is_sublist(sublist, main_list):\n \"\"\"\n Check whether 'sublist' is a sublist of 'main_list'.\n \n Parameters:\n - sublist: List[int] - the list that might be a sublist.\n - main_list: List[int] - the list in which to check for the sublist.\n\n Returns:\n - bool: True if 'sublist' is a sublist of 'main_list', False otherwise.\n \"\"\"\n # Convert both lists to strings for easy comparison\n str_sublist = ','.join(map(str, sublist))\n str_main_list = ','.join(map(str, main_list))\n\n # Check if the string representation of the sublist is in the main list's string\n return str_sublist in str_main_list\n\n# Test cases with assertions\nassert is_sublist([1, 4, 3, 5], [1, 2]) == False\nassert is_sublist([1, 4], [1, 2, 3, 4, 5]) == True\nassert is_sublist([], [1, 2, 3]) == True # An empty list is a sublist of any list\nassert is_sublist([1, 2, 3], []) == False\nassert is_sublist([1, 2, 3], [1, 2, 3]) == True\n\nprint(\"All assertions passed.\")"}
{"task_id": "Mbpp/577", "solution": "def last_Digit_Factorial(n):\n \"\"\"\n This function returns the last digit of the factorial of a given number n.\n \n Args:\n n (int): A non-negative integer whose factorial's last digit is to be found.\n \n Returns:\n int: The last digit of n!\n \n Explanation:\n - For n >= 5, the factorial will always end in zero because it includes both\n 2 and 5 as factors. Hence, the last digit is 0.\n - For n < 5, we can compute the factorial directly and return its last digit.\n \"\"\"\n if n == 0:\n # The factorial of 0 is defined as 1\n return 1\n \n # If n >= 5, the last digit will always be 0\n if n >= 5:\n return 0\n\n # Calculate factorial for n < 5 directly\n factorial = 1\n for i in range(2, n + 1):\n factorial *= i\n \n # Return the last digit of the factorial\n return factorial % 10"}
{"task_id": "Mbpp/578", "solution": "def interleave_lists(list1, list2, list3):\n \"\"\"\n Interleaves three lists of the same length into a single flat list.\n \n Args:\n - list1: First list of integers.\n - list2: Second list of integers.\n - list3: Third list of integers.\n \n Returns:\n - A single list with elements interleaved from the input lists.\n \"\"\"\n # Ensure all lists are of the same length\n if not (len(list1) == len(list2) == len(list3)):\n raise ValueError(\"All lists must have the same length\")\n \n # Initialize an empty list to store the result\n interleaved_list = []\n \n # Iterate over the indices of the lists\n for i in range(len(list1)):\n # Append elements from each list in order\n interleaved_list.append(list1[i])\n interleaved_list.append(list2[i])\n interleaved_list.append(list3[i])\n \n return interleaved_list"}
{"task_id": "Mbpp/579", "solution": "def find_dissimilar(tuple1, tuple2):\n # Convert both tuples to sets for easy comparison\n set1 = set(tuple1)\n set2 = set(tuple2)\n\n # Find elements in set1 that are not in set2 and vice versa\n unique_to_set1 = set1 - set2\n unique_to_set2 = set2 - set1\n\n # Combine the unique elements from both sets into a tuple\n dissimilar_elements = tuple(sorted(unique_to_set1.union(unique_to_set2)))\n\n return dissimilar_elements"}
{"task_id": "Mbpp/580", "solution": "def extract_even(nested_tuple):\n def helper(tpl):\n result = []\n for item in tpl:\n if isinstance(item, int): # Check if the item is an integer\n if item % 2 == 0: # Check if it's even\n result.append(item)\n elif isinstance(item, tuple): # If the item is a tuple, recurse into it\n nested_result = helper(item)\n if nested_result: # Only add non-empty results to avoid empty tuples\n result.append(tuple(nested_result))\n return result\n\n return tuple(helper(nested_tuple))"}
{"task_id": "Mbpp/581", "solution": "import math"}
{"task_id": "Mbpp/583", "solution": "def catalan_number(n):\n if n == 0:\n return 1\n \n # Create an array to store the first n+1 Catalan numbers\n catalan = [0] * (n + 1)\n \n # Initialize the first value\n catalan[0] = 1\n \n # Fill the array using the recurrence relation\n for i in range(1, n + 1):\n for j in range(i):\n catalan[i] += catalan[j] * catalan[i - j - 1]\n \n return catalan[n]"}
{"task_id": "Mbpp/585", "solution": "def expensive_items(items, n):\n \"\"\"\n Find the n most expensive items from a list of dictionaries containing item names and prices.\n\n Parameters:\n - items (list): A list of dictionaries where each dictionary contains 'name' and 'price'.\n - n (int): The number of most expensive items to return.\n\n Returns:\n - list: A list of the n most expensive items sorted by price in descending order.\n \"\"\"\n # Sort the items based on the 'price' key in descending order\n sorted_items = sorted(items, key=lambda x: x['price'], reverse=True)\n \n # Return the top n items\n return sorted_items[:n]"}
{"task_id": "Mbpp/586", "solution": "def split_arr(lst, n):\n \"\"\"\n Splits the list at the nth element and moves the first part to the end.\n \n Parameters:\n lst (list): The input list to be manipulated.\n n (int): The index at which to split the list.\n \n Returns:\n list: The modified list with the first part moved to the end.\n \"\"\"\n # Ensure n is within the bounds of the list\n if not 0 <= n < len(lst):\n raise ValueError(\"n must be a valid index in the list\")\n \n # Split the list and rearrange\n return lst[n:] + lst[:n]\n\n# Test case to verify the function works as expected\nassert split_arr([12, 10, 5, 6, 52, 36], 2) == [5, 6, 52, 36, 12, 10]"}
{"task_id": "Mbpp/587", "solution": "def list_to_tuple(lst):\n \"\"\"\n Convert a list to a tuple.\n \n Parameters:\n lst (list): The list to be converted to a tuple.\n \n Returns:\n tuple: A tuple containing all elements of the input list.\n \"\"\"\n return tuple(lst)\n\n# Test case\nassert list_to_tuple([5, 10, 7, 4, 15, 3]) == (5, 10, 7, 4, 15, 3)"}
{"task_id": "Mbpp/588", "solution": "def big_diff(lst):\n \"\"\"\n This function takes a list of numbers as input and returns the difference \n between the largest and smallest number in the list.\n \n Parameters:\n lst (list): A list of integers or floats.\n\n Returns:\n int or float: The difference between the maximum and minimum values in the list.\n \"\"\"\n if not lst: # Check if the list is empty\n raise ValueError(\"The input list must contain at least one number.\")\n \n max_value = max(lst) # Find the largest value in the list\n min_value = min(lst) # Find the smallest value in the list\n \n return max_value - min_value # Return the difference"}
{"task_id": "Mbpp/589", "solution": "def perfect_squares(start, end):\n \"\"\"\n Find all perfect squares between start and end (inclusive).\n\n Parameters:\n - start: int, the starting number of the range.\n - end: int, the ending number of the range.\n\n Returns:\n - List[int]: A list of perfect squares within the given range.\n \"\"\"\n # Initialize an empty list to store perfect squares\n perfect_squares_list = []\n \n # Iterate over each number in the range from start to end (inclusive)\n for num in range(start, end + 1):\n # Calculate the square root of the current number\n sqrt_num = int(num ** 0.5)\n \n # Check if the square of the integer part of the square root equals the original number\n if sqrt_num * sqrt_num == num:\n perfect_squares_list.append(num)\n \n return perfect_squares_list"}
{"task_id": "Mbpp/590", "solution": "import math"}
{"task_id": "Mbpp/591", "solution": "def swap_List(lst):\n \"\"\"\n Interchange the first and last elements in a list.\n \n Parameters:\n lst (list): A list of elements\n \n Returns:\n list: A new list with the first and last elements swapped\n \"\"\"\n if len(lst) < 2:\n # If the list has fewer than two elements, return it as is\n return lst\n\n # Swap the first and last elements\n lst[0], lst[-1] = lst[-1], lst[0]\n \n return lst"}
{"task_id": "Mbpp/592", "solution": "def binomial_coefficient(n, k):\n \"\"\"Calculate the binomial coefficient C(n, k).\"\"\"\n if k < 0 or k > n:\n return 0\n if k == 0 or k == n:\n return 1\n # Use symmetry property: C(n, k) = C(n, n-k)\n k = min(k, n - k)\n c = 1\n for i in range(k):\n c = c * (n - i) // (i + 1)\n return c\ndef sum_Of_product(n):\n \"\"\"Calculate the sum of products of consecutive binomial coefficients.\"\"\"\n total_sum = 0\n for k in range(n):\n total_sum += binomial_coefficient(n, k) * binomial_coefficient(n, k + 1)\n return total_sum"}
{"task_id": "Mbpp/593", "solution": "def remove_zero_ip(ip_address):\n \"\"\"\n Remove leading zeroes from each segment of an IP address.\n\n Parameters:\n ip_address (str): The input IP address as a string.\n\n Returns:\n str: The IP address with leading zeroes removed.\n \"\"\"\n # Split the IP address into its segments\n segments = ip_address.split('.')\n \n # Convert each segment to an integer and back to a string to remove leading zeros\n cleaned_segments = [str(int(segment)) for segment in segments]\n \n # Join the cleaned segments back into a single string with dots\n cleaned_ip_address = '.'.join(cleaned_segments)\n \n return cleaned_ip_address\n\n# Test case\nassert remove_zero_ip(\"216.08.094.196\") == '216.8.94.196'"}
{"task_id": "Mbpp/594", "solution": "def diff_even_odd(lst):\n first_even = None\n first_odd = None\n \n for num in lst:\n if first_even is None and num % 2 == 0:\n first_even = num\n elif first_odd is None and num % 2 != 0:\n first_odd = num\n \n # If both first even and odd numbers are found, break the loop\n if first_even is not None and first_odd is not None:\n break\n \n # Check if both an even and an odd number were found\n if first_even is not None and first_odd is not None:\n return abs(first_even - first_odd)\n else:\n raise ValueError(\"The list must contain at least one even and one odd number.\")"}
{"task_id": "Mbpp/596", "solution": "import sys\ndef tuple_size(tpl):\n \"\"\"\n Calculate the size in bytes of the given tuple.\n \n Parameters:\n tpl (tuple): The tuple whose size is to be calculated.\n \n Returns:\n int: Size of the tuple in bytes.\n \"\"\"\n return sys.getsizeof(tpl)"}
{"task_id": "Mbpp/597", "solution": "def find_kth(arr1, arr2, k):\n # Base cases\n if len(arr1) == 0:\n return arr2[k]\n if len(arr2) == 0:\n return arr1[k]\n if k == 0:\n return min(arr1[0], arr2[0])\n \n # Calculate the indices to compare\n i = min(len(arr1) - 1, k // 2)\n j = min(len(arr2) - 1, k // 2)\n \n # Compare elements at these indices and reduce the problem size\n if arr1[i] > arr2[j]:\n return find_kth(arr1, arr2[j + 1:], k - (j + 1))\n else:\n return find_kth(arr1[i + 1:], arr2, k - (i + 1))"}
{"task_id": "Mbpp/598", "solution": "def armstrong_number(num):\n \"\"\"\n Check if the given number is an Armstrong number.\n \n An Armstrong number for a 3-digit number is one where the sum of the cubes \n of its digits equals the number itself. This function generalizes to n-digits.\n \n Args:\n num (int): The number to check.\n\n Returns:\n bool: True if the number is an Armstrong number, False otherwise.\n \"\"\"\n # Convert the number to a string to easily iterate over each digit\n str_num = str(num)\n # Calculate the length of the number (number of digits)\n n = len(str_num)\n \n # Initialize sum of powers\n sum_of_powers = 0\n \n # Iterate over each digit, convert it back to an integer, raise it to the power of n,\n # and add it to the sum_of_powers\n for digit in str_num:\n sum_of_powers += int(digit) ** n\n \n # Check if the calculated sum is equal to the original number\n return sum_of_powers == num"}
{"task_id": "Mbpp/599", "solution": "def sum_average(n):\n \"\"\"\n Calculate the sum and average of the first n natural numbers.\n \n Parameters:\n n (int): The number of initial natural numbers to consider.\n \n Returns:\n tuple: A tuple containing the sum and average of the first n natural numbers.\n \"\"\"\n # Calculate the sum using the formula for the sum of an arithmetic series\n total_sum = n * (n + 1) // 2\n \n # Calculate the average\n if n > 0:\n average = total_sum / n\n else:\n average = 0 # Handle the case where n is 0 to avoid division by zero\n \n return total_sum, average"}
{"task_id": "Mbpp/600", "solution": "def is_even(number):\n \"\"\"\n Check whether the given number is even.\n \n Parameters:\n number (int): The number to check.\n \n Returns:\n bool: True if the number is even, False otherwise.\n \"\"\"\n return number % 2 == 0\n\n# Test case\nassert is_even(1) == False"}
{"task_id": "Mbpp/602", "solution": "def first_repeated_char(s):\n \"\"\"\n This function finds the first repeated character in a given string.\n \n Parameters:\n s (str): The input string to search for the first repeated character.\n \n Returns:\n str: The first repeated character if found, otherwise None.\n \"\"\"\n seen = set()\n for char in s:\n if char in seen:\n return char\n seen.add(char)\n return None"}
{"task_id": "Mbpp/603", "solution": "def get_lucid(n):\n \"\"\"\n Generate all lucid (or lucky) numbers up to and including n.\n\n A lucid number is generated by a sieving process similar to the Sieve of Eratosthenes.\n Start with an infinite list of natural numbers beginning with 1. \n The first number in the list is considered \"lucky\" and is kept, while every second number\n (the one at index equal to the lucky number) is removed from the list. \n Repeat this process by considering the next number in the list as a new lucky number,\n removing every nth number where n is the value of that lucky number.\n \n Args:\n n (int): The upper limit for generating lucid numbers.\n\n Returns:\n List[int]: A list of all lucid numbers less than or equal to n.\n \"\"\"\n if n < 1:\n return []\n\n # Start with a list of natural numbers from 1 to n\n numbers = list(range(1, n + 1))\n \n index = 1 # Start with the first lucky number (index 0 is 1)\n \n while index < len(numbers):\n # The current lucky number\n step = numbers[index]\n \n # Remove every 'step'-th element starting from the next position after 'step'\n del numbers[index + step::step]\n \n # Move to the next index in the remaining list\n index += 1\n \n return numbers\n\n# Test case\nassert get_lucid(10) == [1, 2, 3, 5, 7]"}
{"task_id": "Mbpp/604", "solution": "def reverse_words(input_string):\n \"\"\"\n This function takes a string with words separated by spaces and \n returns a new string with the words in reverse order.\n \n Parameters:\n input_string (str): The string containing words to be reversed.\n \n Returns:\n str: A string with the words in reverse order.\n \"\"\"\n # Split the input string into a list of words\n words = input_string.split()\n \n # Reverse the list of words\n reversed_words = words[::-1]\n \n # Join the reversed list back into a single string separated by spaces\n result = ' '.join(reversed_words)\n \n return result"}
{"task_id": "Mbpp/605", "solution": "def prime_num(n):\n \"\"\"\n Check if the given integer n is a prime number.\n \n Parameters:\n n (int): The integer to be checked for primality.\n \n Returns:\n bool: True if n is a prime number, False otherwise.\n \"\"\"\n # A prime number is greater than 1\n if n <= 1:\n return False\n \n # Check from 2 to the square root of n\n # If n is divisible by any number in this range, it's not prime\n for i in range(2, int(n**0.5) + 1):\n if n % i == 0:\n return False\n \n # If no divisors were found, n is prime\n return True"}
{"task_id": "Mbpp/606", "solution": "import math\ndef radian_degree(degrees):\n \"\"\"\n Convert degrees to radians.\n \n Parameters:\n degrees (float): Angle in degrees\n \n Returns:\n float: Angle in radians\n \"\"\"\n return degrees * (math.pi / 180)"}
{"task_id": "Mbpp/607", "solution": "import re\ndef find_literals(text, pattern):\n \"\"\"\n Search for a regex pattern in a given text.\n \n Parameters:\n - text (str): The string to be searched.\n - pattern (str): The regex pattern to search for.\n \n Returns:\n - tuple: A tuple containing the matching substring and its start and end indices.\n If no match is found, returns None.\n \"\"\"\n # Compile the regex pattern\n regex = re.compile(pattern)\n \n # Search for the pattern in the text\n match = regex.search(text)\n \n if match:\n # Extract the matched substring and its start and end positions\n matched_substring = match.group()\n start_index = match.start()\n end_index = match.end()\n \n return (matched_substring, start_index, end_index)\n else:\n return None"}
{"task_id": "Mbpp/608", "solution": "def bell_Number(n):\n # Create a 2D list (triangle) initialized to zero\n bell = [[0 for i in range(n+1)] for j in range(n+1)]\n \n # The first Bell number is 1\n bell[0][0] = 1\n \n # Fill the Bell triangle\n for i in range(1, n+1):\n # Explicitly set the first value of each row\n bell[i][0] = bell[i-1][i-1]\n \n # Fill the rest of the values using the relation:\n # bell[i][j] = bell[i-1][j-1] + bell[i][j-1]\n for j in range(1, i+1):\n bell[i][j] = bell[i-1][j-1] + bell[i][j-1]\n \n # The nth Bell number is the first element of the nth row\n return bell[n][0]"}
{"task_id": "Mbpp/610", "solution": "def remove_kth_element(lst, k):\n \"\"\"\n Removes the k'th element from the given list.\n \n Parameters:\n lst (list): The original list from which to remove an element.\n k (int): The index of the element to be removed. Zero-based indexing is used.\n\n Returns:\n list: A new list with the k'th element removed.\n \"\"\"\n # Check if k is a valid index\n if 0 <= k < len(lst):\n # Remove the k'th element by slicing and concatenating parts of the list\n return lst[:k] + lst[k+1:]\n else:\n raise IndexError(\"Index out of range\")"}
{"task_id": "Mbpp/611", "solution": "def max_of_nth(matrix, n):\n \"\"\"\n Returns the maximum value in the nth column of a given matrix.\n \n :param matrix: List of lists where each sublist represents a row in the matrix.\n :param n: The index (0-based) of the column to find the maximum value from.\n :return: Maximum value found in the nth column.\n \"\"\"\n # Extract the nth column using list comprehension\n nth_column = [row[n] for row in matrix]\n \n # Return the maximum value in the extracted column\n return max(nth_column)"}
{"task_id": "Mbpp/612", "solution": "def merge(list_of_lists):\n \"\"\"\n Takes a list of lists, where each sublist has two elements,\n and returns a list of two lists. The first list contains all \n the first elements from the sublists, and the second list contains \n all the second elements.\n \n Parameters:\n list_of_lists (list): A list containing sublists with exactly two elements each.\n\n Returns:\n list: A list containing two lists - one for the first elements and one for the second elements.\n \"\"\"\n # Initialize two empty lists to hold the separated elements\n first_elements = []\n second_elements = []\n\n # Iterate over each sublist in the input list\n for sublist in list_of_lists:\n if len(sublist) == 2: # Ensure that each sublist has exactly two elements\n first_elements.append(sublist[0])\n second_elements.append(sublist[1])\n\n # Return a list containing both lists of separated elements\n return [first_elements, second_elements]"}
{"task_id": "Mbpp/614", "solution": "def cummulative_sum(tuple_list):\n \"\"\"\n Calculate the cumulative sum of all values in a list of tuples.\n \n Parameters:\n tuple_list (list): A list containing tuples with numeric values.\n \n Returns:\n int: The cumulative sum of all numbers in the tuples.\n \"\"\"\n total_sum = 0\n for tup in tuple_list:\n # Sum up each element in the current tuple and add to total_sum\n total_sum += sum(tup)\n return total_sum"}
{"task_id": "Mbpp/615", "solution": "def average_tuple(tuples):\n \"\"\"\n This function takes a tuple of tuples and returns the average value for each inner tuple as a list.\n \n Parameters:\n tuples (tuple): A tuple containing multiple tuples, where each inner tuple consists of numeric values.\n\n Returns:\n list: A list containing the average of each inner tuple.\n \"\"\"\n # Initialize an empty list to store the averages\n averages = []\n \n # Iterate over each tuple in the input tuple\n for t in tuples:\n # Calculate the sum of elements in the current tuple\n total_sum = sum(t)\n \n # Calculate the number of elements in the current tuple\n num_elements = len(t)\n \n # Compute the average and append it to the averages list\n average = total_sum / num_elements\n averages.append(average)\n \n return averages"}
{"task_id": "Mbpp/616", "solution": "def tuple_modulo(tuple1, tuple2):\n \"\"\"\n Perform element-wise modulo operation between two tuples.\n \n Parameters:\n - tuple1: A tuple of integers.\n - tuple2: A tuple of integers with the same length as tuple1.\n \n Returns:\n - A new tuple containing the results of element-wise modulo operations.\n \"\"\"\n # Ensure both tuples are of the same length\n if len(tuple1) != len(tuple2):\n raise ValueError(\"Both tuples must be of the same length.\")\n \n # Perform element-wise modulo and store in a list comprehension\n result = tuple(a % b for a, b in zip(tuple1, tuple2))\n \n return result"}
{"task_id": "Mbpp/618", "solution": "def div_list(list1, list2):\n \"\"\"\n Divides elements of list1 by corresponding elements in list2.\n \n Parameters:\n - list1: List of numbers (floats or integers).\n - list2: List of numbers (floats or integers) to divide by.\n \n Returns:\n - A new list containing the result of element-wise division.\n \n Raises:\n - ValueError: If the lists are not of the same length.\n - ZeroDivisionError: If any element in list2 is zero.\n \"\"\"\n if len(list1) != len(list2):\n raise ValueError(\"Both lists must have the same number of elements.\")\n \n result = []\n for a, b in zip(list1, list2):\n if b == 0:\n raise ZeroDivisionError(\"Cannot divide by zero.\")\n result.append(a / b)\n \n return result"}
{"task_id": "Mbpp/619", "solution": "def move_num(s):\n # Initialize two empty strings: one for non-numeric characters and one for numeric characters\n letters = ''\n digits = ''\n \n # Iterate over each character in the input string\n for char in s:\n if char.isdigit():\n # If the character is a digit, add it to the 'digits' string\n digits += char\n else:\n # Otherwise, add it to the 'letters' string\n letters += char\n \n # Concatenate the non-numeric and numeric parts and return the result\n return letters + digits"}
{"task_id": "Mbpp/620", "solution": "def largest_subset(nums):\n if not nums:\n return 0\n\n # Sort the numbers\n nums.sort()\n \n # Initialize dp array where each element is initially a subset of size 1 (itself)\n dp = [1] * len(nums)\n \n # Fill the dp array\n for i in range(1, len(nums)):\n for j in range(i):\n if nums[i] % nums[j] == 0:\n dp[i] = max(dp[i], dp[j] + 1)\n \n # The largest subset size will be the maximum value in dp\n return max(dp)"}
{"task_id": "Mbpp/622", "solution": "def get_median(list1, list2, n):\n if n <= 0:\n raise ValueError(\"Array sizes must be positive\")\n \n # Ensure that list1 is the smaller array for binary search\n if len(list1) > len(list2):\n return get_median(list2, list1, n)\n \n start = 0\n end = n - 1\n \n while start <= end:\n partition_list1 = (start + end) // 2\n partition_list2 = (n + start + end) // 2\n \n # Edge cases for partitions\n max_left_list1 = list1[partition_list1] if partition_list1 != -1 else float('-inf')\n min_right_list1 = list1[partition_list1 + 1] if partition_list1 + 1 < n else float('inf')\n \n max_left_list2 = list2[partition_list2] if partition_list2 != -1 else float('-inf')\n min_right_list2 = list2[partition_list2 + 1] if partition_list2 + 1 < n else float('inf')\n \n # Check if we have found the correct partition\n if max_left_list1 <= min_right_list2 and max_left_list2 <= min_right_list1:\n # If total number of elements is even\n if (n % 2 == 0):\n return (max(max_left_list1, max_left_list2) + min(min_right_list1, min_right_list2)) / 2.0\n else:\n return max(max_left_list1, max_left_list2)\n \n # Adjust the partition based on comparison\n elif max_left_list1 > min_right_list2:\n end = partition_list1 - 1\n else:\n start = partition_list1 + 1\n \n raise ValueError(\"Input arrays are not sorted or have different sizes\")"}
{"task_id": "Mbpp/623", "solution": "def nth_nums(numbers, n):\n \"\"\"\n Compute the n-th power of each number in a given list.\n \n Parameters:\n - numbers (list): A list of numerical values.\n - n (int): The power to which each number should be raised.\n \n Returns:\n - list: A new list containing each number from the input list raised to the n-th power.\n \"\"\"\n return [num ** n for num in numbers]"}
{"task_id": "Mbpp/624", "solution": "def is_upper(input_string):\n \"\"\"\n Convert the input string to uppercase.\n \n Parameters:\n input_string (str): The string to be converted to uppercase.\n \n Returns:\n str: The uppercase version of the input string.\n \"\"\"\n return input_string.upper()"}
{"task_id": "Mbpp/626", "solution": "def triangle_area(radius):\n \"\"\"\n Calculate the area of the largest triangle that can be inscribed in a semicircle with a given radius.\n \n Parameters:\n radius (float): The radius of the semicircle.\n \n Returns:\n float: The area of the largest inscribed triangle, or None if the radius is invalid.\n \"\"\"\n # Check for invalid input\n if radius <= 0:\n return None\n \n # For a semicircle with radius r, the diameter (hypotenuse) is 2r.\n # The largest triangle that can be inscribed in a semicircle is a right-angled triangle\n # with its hypotenuse as the diameter of the semicircle.\n \n # Using the properties of a right-angled triangle:\n # If the hypotenuse is 2r, then the maximum area occurs when the triangle is an isosceles right triangle.\n # The legs of this triangle will each be r * sqrt(2).\n \n # Area of a right triangle = (1/2) * base * height\n # Here, both base and height are equal to r * sqrt(2)\n # So, area = (1/2) * (r * sqrt(2)) * (r * sqrt(2))\n # Simplifying, area = (1/2) * 2 * r^2 = r^2\n \n return radius ** 2"}
{"task_id": "Mbpp/628", "solution": "def replace_spaces(input_string):\n \"\"\"\n Replaces all spaces in the input string with '%20'.\n \n Parameters:\n input_string (str): The original string containing spaces.\n \n Returns:\n str: A new string where each space is replaced by '%20'.\n \"\"\"\n # Use the built-in `replace` method to replace spaces\n return input_string.replace(' ', '%20')"}
{"task_id": "Mbpp/629", "solution": "def find_even_numbers(numbers):\n \"\"\"\n This function takes a list of numbers and returns a new list containing only the even numbers.\n \n Parameters:\n numbers (list): A list of integers.\n\n Returns:\n list: A list containing only the even numbers from the input list.\n \"\"\"\n # Use a list comprehension to filter out even numbers\n even_numbers = [num for num in numbers if num % 2 == 0]\n return even_numbers\n\n# Test the function with an assertion\nassert find_even_numbers([1, 2, 3, 4, 5]) == [2, 4], \"The function did not return the expected result.\"\n\nprint(\"Test passed! The function works as expected.\")"}
{"task_id": "Mbpp/630", "solution": "def get_coordinates(coord):\n \"\"\"\n Extracts all adjacent coordinates (including diagonals) for a given coordinate tuple.\n \n Parameters:\n coord (tuple): A tuple representing the x, y coordinates on a 2D grid.\n \n Returns:\n list: A list of lists where each sublist represents an adjacent coordinate.\n \"\"\"\n x, y = coord\n # Define all possible moves to get adjacent cells including diagonals\n directions = [\n (-1, -1), (-1, 0), (-1, 1),\n (0, -1), (0, 1),\n (1, -1), (1, 0), (1, 1)\n ]\n \n # Calculate adjacent coordinates\n adjacent_coords = [[x + dx, y + dy] for dx, dy in directions]\n \n return adjacent_coords"}
{"task_id": "Mbpp/631", "solution": "def replace_spaces(s):\n \"\"\"\n Replace all spaces in the given string with underscores,\n and all underscores with spaces.\n \n Args:\n s (str): The input string to be transformed.\n \n Returns:\n str: A new string with spaces replaced by underscores and vice versa.\n \"\"\"\n # Use a list comprehension to iterate over each character\n result = ''.join(['_' if char == ' ' else ' ' if char == '_' else char for char in s])\n return result"}
{"task_id": "Mbpp/632", "solution": "def move_zero(lst):\n \"\"\"\n Moves all zeroes in the given list to the end, preserving the order of non-zero elements.\n \n Parameters:\n lst (list): A list of integers which may contain zero or more zeroes.\n \n Returns:\n list: The modified list with all zeroes moved to the end.\n \"\"\"\n # Count the number of zeros\n zero_count = lst.count(0)\n \n # Create a new list excluding all zeros\n non_zero_list = [x for x in lst if x != 0]\n \n # Append the counted zeros at the end of the non-zero list\n result = non_zero_list + [0] * zero_count\n \n return result"}
{"task_id": "Mbpp/633", "solution": "def pair_xor_sum(arr, n):\n # Initialize sum to 0\n xor_sum = 0\n \n # Iterate over all pairs (i, j) where i < j\n for i in range(n):\n for j in range(i + 1, n):\n # Calculate XOR of the pair and add it to the sum\n xor_sum += arr[i] ^ arr[j]\n \n return xor_sum\n\n# Test case\nassert pair_xor_sum([5, 9, 7, 6], 4) == 47"}
{"task_id": "Mbpp/635", "solution": "def heap_sort(arr):\n \"\"\"\n Function to perform heap sort on a list.\n \n :param arr: List of elements to be sorted\n :return: Sorted list\n \"\"\"\n n = len(arr)\n\n # Build a maxheap\n for i in range(n // 2 - 1, -1, -1):\n heapify(arr, n, i)\n\n # Extract elements one by one from the heap\n for i in range(n-1, 0, -1):\n arr[i], arr[0] = arr[0], arr[i] # Swap\n heapify(arr, i, 0)\n \n return arr"}
{"task_id": "Mbpp/637", "solution": "def noprofit_noloss(cost_price, selling_price):\n \"\"\"\n Check whether the transaction results in no profit and no loss.\n\n Parameters:\n - cost_price (float): The original price of the item.\n - selling_price (float): The price at which the item is sold.\n\n Returns:\n - bool: True if there's no profit or loss, False otherwise.\n \"\"\"\n # Calculate the difference between selling price and cost price\n difference = selling_price - cost_price\n \n # Check if the difference is zero\n if difference == 0:\n return True\n else:\n return False"}
{"task_id": "Mbpp/638", "solution": "def wind_chill(wind_velocity, temperature):\n \"\"\"\n Calculate the wind chill index given the wind velocity in km/h and a temperature in celsius.\n \n Parameters:\n - wind_velocity: float, wind speed in kilometers per hour (km/h)\n - temperature: float, air temperature in degrees Celsius\n \n Returns:\n - int, wind chill index rounded to the nearest integer\n \"\"\"\n if wind_velocity < 4.8 or temperature > 10:\n # Wind chill is not defined for these conditions\n return round(temperature)\n\n # Convert wind velocity from km/h to m/s\n wind_speed_m_s = wind_velocity * 1000 / 3600\n\n # Calculate the wind chill index using the formula\n wind_chill_index = 13.12 + 0.6215 * temperature - 11.37 * (wind_speed_m_s ** 0.16) + \\\n 0.3965 * temperature * (wind_speed_m_s ** 0.16)\n\n # Return the result rounded to the nearest integer\n return round(wind_chill_index)"}
{"task_id": "Mbpp/639", "solution": "def sum_length_of_names(names):\n \"\"\"\n This function takes a list of names and returns the sum of the lengths \n of the names that do not start with a lowercase letter.\n \n Parameters:\n names (list): A list of strings representing names.\n \n Returns:\n int: The sum of the lengths of the valid names.\n \"\"\"\n # Filter out names starting with a lowercase letter\n filtered_names = [name for name in names if name[0].isupper()]\n \n # Calculate the total length of the remaining names\n total_length = sum(len(name) for name in filtered_names)\n \n return total_length\n\n# Test case\nassert sum_length_of_names(['sally', 'Dylan', 'rebecca', 'Diana', 'Joanne', 'keith']) == 16"}
{"task_id": "Mbpp/641", "solution": "def is_nonagonal(n):\n \"\"\"\n Calculate the nth nonagonal number.\n \n Args:\n n (int): The position in the sequence of nonagonal numbers.\n \n Returns:\n int: The nth nonagonal number.\n \"\"\"\n return (n * (7 * n - 5)) // 2"}
{"task_id": "Mbpp/643", "solution": "def text_match_wordz_middle(s):\n \"\"\"\n Check if the string s contains 'z' except at the start and end.\n \n Parameters:\n s (str): The input string to check.\n \n Returns:\n bool: True if 'z' is found in the middle of the word, False otherwise.\n \"\"\"\n # Remove leading and trailing whitespace\n s = s.strip()\n \n # Check if 'z' is present in the string excluding the first and last character\n return 'z' in s[1:-1]"}
{"task_id": "Mbpp/644", "solution": "def reverse_Array_Upto_K(arr, k):\n \"\"\"\n Reverses the elements of the array 'arr' up to the index 'k'.\n \n Parameters:\n arr (list): The list of integers to be partially reversed.\n k (int): The position up to which the array should be reversed.\n\n Returns:\n list: A new list with elements reversed up to the specified position.\n \"\"\"\n # Ensure that k is within the bounds of the array\n if k < 0 or k > len(arr):\n raise ValueError(\"k must be between 0 and the length of the array\")\n\n # Reverse the portion of the array from start to k (inclusive)\n reversed_part = arr[:k+1][::-1]\n \n # Concatenate the reversed part with the rest of the array\n result = reversed_part + arr[k+1:]\n \n return result"}
{"task_id": "Mbpp/720", "solution": "def add_dict_to_tuple(tpl, dct):\n \"\"\"\n Adds a dictionary to the end of a tuple and returns a new tuple.\n \n Parameters:\n tpl (tuple): The original tuple.\n dct (dict): The dictionary to be added to the tuple.\n \n Returns:\n tuple: A new tuple with the dictionary appended.\n \"\"\"\n # Convert the input tuple to a list to allow modification\n temp_list = list(tpl)\n # Append the dictionary to the list\n temp_list.append(dct)\n # Convert the list back to a tuple and return it\n return tuple(temp_list)"}
{"task_id": "Mbpp/721", "solution": "def maxAverageOfPath(matrix):\n n = len(matrix)\n \n # dp[i][j] will store the maximum sum of costs from (0, 0) to (i, j)\n dp = [[0] * n for _ in range(n)]\n \n # Initialize the starting point\n dp[0][0] = matrix[0][0]\n \n # Fill the first row (can only come from the left)\n for j in range(1, n):\n dp[0][j] = dp[0][j-1] + matrix[0][j]\n \n # Fill the first column (can only come from above)\n for i in range(1, n):\n dp[i][0] = dp[i-1][0] + matrix[i][0]\n \n # Fill the rest of the dp table\n for i in range(1, n):\n for j in range(1, n):\n dp[i][j] = max(dp[i-1][j], dp[i][j-1]) + matrix[i][j]\n \n # The maximum sum path ends at (n-1, n-1)\n max_sum = dp[n-1][n-1]\n \n # Number of cells in the longest path from (0, 0) to (n-1, n-1) is always 2*n - 1\n num_cells = 2 * n - 1\n \n # Calculate the maximum average\n max_average = max_sum / num_cells\n \n return max_average"}
{"task_id": "Mbpp/722", "solution": "def filter_data(students, min_height, min_weight):\n \"\"\"\n Filters students based on minimum height and weight.\n\n Parameters:\n - students: A dictionary with student names as keys and tuples of (height, weight) as values.\n - min_height: The minimal acceptable height.\n - min_weight: The minimal acceptable weight.\n\n Returns:\n - A dictionary containing only the students who meet or exceed both the minimum height and weight.\n \"\"\"\n filtered_students = {}\n \n for name, (height, weight) in students.items():\n if height >= min_height and weight >= min_weight:\n filtered_students[name] = (height, weight)\n \n return filtered_students"}
{"task_id": "Mbpp/723", "solution": "def count_same_pair(list1, list2):\n \"\"\"\n Counts the number of indices where the elements in both lists are equal.\n\n Parameters:\n list1 (list): The first list of integers.\n list2 (list): The second list of integers.\n\n Returns:\n int: The count of indices with the same values in both lists.\n \"\"\"\n # Ensure both lists have the same length\n if len(list1) != len(list2):\n raise ValueError(\"Both lists must be of the same length.\")\n \n # Initialize a counter for matching indices\n count = 0\n \n # Iterate over the indices and elements of the first list\n for i, value in enumerate(list1):\n # Check if the element at the current index is the same in both lists\n if value == list2[i]:\n count += 1\n \n return count"}
{"task_id": "Mbpp/724", "solution": "def power_base_sum(base, power):\n \"\"\"\n Calculate the sum of all digits of base raised to the specified power.\n \n Parameters:\n - base: The base number as an integer.\n - power: The exponent as an integer.\n \n Returns:\n - An integer representing the sum of the digits of base^power.\n \"\"\"\n # Compute base raised to the power\n result = base ** power\n \n # Convert the result to a string to iterate over each digit\n result_str = str(result)\n \n # Initialize the sum of digits\n digit_sum = 0\n \n # Iterate over each character in the string representation of the number\n for char in result_str:\n # Convert the character back to an integer and add it to the sum\n digit_sum += int(char)\n \n return digit_sum"}
{"task_id": "Mbpp/725", "solution": "import re\ndef extract_quotation(s):\n \"\"\"\n Extracts values between quotation marks from the given string.\n \n Parameters:\n s (str): Input string containing text with quoted segments.\n \n Returns:\n list: A list of strings found within quotation marks in the input string.\n \"\"\"\n # Use regular expression to find all substrings enclosed in double quotes\n matches = re.findall(r'\"(.*?)\"', s)\n return matches"}
{"task_id": "Mbpp/726", "solution": "def multiply_elements(t):\n \"\"\"\n This function takes a tuple of numbers (t_1,...,t_{N+1}) and returns a new tuple \n of length N where each element is the product of consecutive elements from the input tuple.\n \n Parameters:\n t (tuple): A tuple containing N+1 numerical elements.\n\n Returns:\n tuple: A tuple of length N with products of consecutive elements.\n \"\"\"\n # Using list comprehension to multiply consecutive elements\n result = tuple(t[i] * t[i + 1] for i in range(len(t) - 1))\n \n return result"}
{"task_id": "Mbpp/728", "solution": "def sum_list(list1, list2):\n \"\"\"\n Takes two lists of numbers and returns a new list containing the element-wise sums.\n \n Parameters:\n - list1: A list of numbers [a_1,...,a_n]\n - list2: A list of numbers [b_1,...,b_n]\n\n Returns:\n - A list where each element is the sum of the corresponding elements from list1 and list2.\n \"\"\"\n # Ensure both lists are of the same length\n if len(list1) != len(list2):\n raise ValueError(\"Both lists must have the same number of elements\")\n \n # Use a list comprehension to add corresponding elements\n return [a + b for a, b in zip(list1, list2)]"}
{"task_id": "Mbpp/730", "solution": "def consecutive_duplicates(lst):\n \"\"\"\n Remove consecutive duplicates from a given list.\n\n Parameters:\n lst (list): The input list with potential consecutive duplicates.\n\n Returns:\n list: A new list with consecutive duplicates removed.\n \"\"\"\n if not lst:\n return []\n\n # Initialize the result list with the first element\n result = [lst[0]]\n\n # Iterate over the list starting from the second element\n for i in range(1, len(lst)):\n # If the current element is different from the last added to result, append it\n if lst[i] != lst[i - 1]:\n result.append(lst[i])\n\n return result"}
{"task_id": "Mbpp/731", "solution": "import math\ndef lateralsurface_cone(r, h):\n # Calculate the slant height using the Pythagorean theorem\n l = math.sqrt(r**2 + h**2)\n \n # Calculate the lateral surface area\n lateral_surface_area = math.pi * r * l\n \n return lateral_surface_area"}
{"task_id": "Mbpp/732", "solution": "def replace_specialchar(input_string):\n \"\"\"\n Replaces all occurrences of spaces, commas, or dots with a colon.\n \n Parameters:\n input_string (str): The string to be processed.\n \n Returns:\n str: A new string with specified characters replaced by colons.\n \"\"\"\n # Define the characters to replace\n chars_to_replace = [' ', ',', '.']\n \n # Replace each character in the list with a colon\n for char in chars_to_replace:\n input_string = input_string.replace(char, ':')\n \n return input_string"}
{"task_id": "Mbpp/733", "solution": "def find_first_occurrence(arr, target):\n \"\"\"\n Find the index of the first occurrence of a given number in a sorted array.\n \n Parameters:\n arr (list): A list of integers sorted in non-decreasing order.\n target (int): The integer to find in the array.\n \n Returns:\n int: The index of the first occurrence of the target, or -1 if not found.\n \"\"\"\n left, right = 0, len(arr) - 1\n result = -1\n \n while left <= right:\n mid = (left + right) // 2\n \n # Check if we have found the target\n if arr[mid] == target:\n result = mid\n right = mid - 1 # Move left to find the first occurrence\n elif arr[mid] < target:\n left = mid + 1\n else:\n right = mid - 1\n \n return result"}
{"task_id": "Mbpp/734", "solution": "def sum_Of_Subarray_Prod(arr):\n n = len(arr)\n total_sum = 0\n \n # Iterate over each element as the starting point of the sublist\n for i in range(n):\n current_product = 1\n \n # Extend the sublist to include elements from the start index 'i' to end of the list\n for j in range(i, n):\n current_product *= arr[j]\n total_sum += current_product\n \n return total_sum"}
{"task_id": "Mbpp/735", "solution": "def toggle_middle_bits(n):\n # Edge case: if n has only one bit, return it as is\n if n == 0 or (n & (n - 1)) == 0:\n return n\n \n # Create a mask to isolate all bits except the first and last\n # Start with a number that has all bits set (e.g., for 32-bit: 0b111...111)\n all_ones = ~0\n \n # Clear the least significant bit (LSB)\n all_ones &= ~(1)\n \n # Find the position of the most significant bit (MSB)\n msb_pos = n.bit_length() - 1\n \n # Create a mask to keep only the MSB and LSB\n mask = (1 << msb_pos) | 1\n \n # Invert the mask to get all bits except MSB and LSB\n toggle_mask = ~mask & all_ones\n \n # Toggle the middle bits using XOR\n result = n ^ toggle_mask\n \n return result"}
{"task_id": "Mbpp/736", "solution": "def left_insertion(sorted_list, target):\n \"\"\"\n Find the left insertion point for a specified value in a sorted list.\n \n Parameters:\n - sorted_list: List of integers sorted in ascending order.\n - target: Integer value to insert into the sorted list.\n \n Returns:\n - The index where the target should be inserted to maintain sorted order.\n \"\"\"\n low, high = 0, len(sorted_list)\n \n while low < high:\n mid = (low + high) // 2\n if sorted_list[mid] < target:\n low = mid + 1\n else:\n high = mid\n \n return low"}
{"task_id": "Mbpp/737", "solution": "import re\ndef check_str(s):\n \"\"\"\n Check if the given string starts with a vowel using regex.\n \n Parameters:\n s (str): The input string to be checked.\n \n Returns:\n bool: True if the string starts with a vowel, False otherwise.\n \"\"\"\n # Define a regular expression pattern for strings starting with a vowel\n pattern = r'^[aeiouAEIOU]'\n \n # Use re.match to check if the string matches the pattern\n return bool(re.match(pattern, s))"}
{"task_id": "Mbpp/739", "solution": "def find_index(n):\n # Start by estimating the lower bound for k using the inequality:\n # 10^(n-1) <= k(k + 1)/2\n # This simplifies to solving: k^2 + k - 2*10^(n-1) >= 0\n # Using the quadratic formula, we estimate k as follows:\n \n import math\n \n # Calculate the lower bound for k using the quadratic formula\n lower_bound = int((math.sqrt(8 * (10**(n-1)) + 1) - 1) / 2)\n \n # Start checking from this estimated index\n k = lower_bound\n \n while True:\n triangular_number = k * (k + 1) // 2\n if len(str(triangular_number)) >= n:\n return k\n k += 1\n\n# Test the function with the given assertion\nassert find_index(2) == 4"}
{"task_id": "Mbpp/740", "solution": "def tuple_to_dict(tpl):\n \"\"\"\n Convert a tuple to a dictionary using adjacent elements as key-value pairs.\n \n Args:\n tpl (tuple): A tuple with an even number of elements.\n \n Returns:\n dict: A dictionary where each pair of adjacent elements in the tuple forms a key-value pair.\n \n Raises:\n ValueError: If the length of the tuple is not even.\n \"\"\"\n if len(tpl) % 2 != 0:\n raise ValueError(\"The tuple must have an even number of elements.\")\n \n return {tpl[i]: tpl[i + 1] for i in range(0, len(tpl), 2)}"}
{"task_id": "Mbpp/741", "solution": "def all_Characters_Same(s):\n \"\"\"\n Check whether all characters in the string s are the same.\n \n Parameters:\n s (str): The input string to be checked.\n \n Returns:\n bool: True if all characters are the same, False otherwise.\n \"\"\"\n # If the string is empty or has only one character, return True\n if len(s) <= 1:\n return True\n \n # Compare each character with the first character\n first_char = s[0]\n for char in s[1:]:\n if char != first_char:\n return False\n \n return True"}
{"task_id": "Mbpp/742", "solution": "import math"}
{"task_id": "Mbpp/743", "solution": "def rotate_right(lst, k):\n \"\"\"\n Rotates the given list `lst` to the right by `k` positions.\n \n Parameters:\n lst (list): The list to be rotated.\n k (int): The number of positions to rotate the list to the right.\n \n Returns:\n list: A new list that is rotated to the right by `k` positions.\n \"\"\"\n # Handle edge cases\n if not lst or k <= 0:\n return lst\n \n n = len(lst)\n # Normalize k in case it's larger than the length of the list\n k = k % n\n \n # Perform rotation\n rotated_list = lst[-k:] + lst[:-k]\n \n return rotated_list"}
{"task_id": "Mbpp/744", "solution": "def check_none(tpl):\n \"\"\"\n Check if the given tuple has any None value.\n \n Parameters:\n tpl (tuple): A tuple to be checked for None values.\n \n Returns:\n bool: True if there is at least one None value, False otherwise.\n \"\"\"\n return any(item is None for item in tpl)"}
{"task_id": "Mbpp/745", "solution": "def divisible_by_digits(startnum, endnum):\n def is_divisible(n):\n for digit in str(n):\n if digit == '0' or n % int(digit) != 0:\n return False\n return True\n\n result = []\n for number in range(startnum, endnum + 1):\n if is_divisible(number):\n result.append(number)\n \n return result"}
{"task_id": "Mbpp/748", "solution": "def capital_words_spaces(s):\n \"\"\"\n This function takes a string 's' as input and inserts spaces before each word that starts \n with an uppercase letter, except for the first character if it's uppercase.\n \n Args:\n s (str): The input string containing words starting with capital letters.\n\n Returns:\n str: A new string with spaces inserted before words starting with capital letters.\n \"\"\"\n # Initialize an empty list to store characters of the resulting string\n result = []\n \n # Iterate over each character in the string along with its index\n for i, char in enumerate(s):\n # If it's not the first character and is uppercase, add a space before it\n if i > 0 and char.isupper():\n result.append(' ')\n \n # Add the current character to the result list\n result.append(char)\n \n # Join all characters in the result list into a single string and return\n return ''.join(result)"}
{"task_id": "Mbpp/749", "solution": "def sort_numeric_strings(strings):\n \"\"\"\n Sorts a list of strings containing numeric values in ascending numerical order.\n \n Parameters:\n strings (list): A list of strings, where each string represents a number.\n \n Returns:\n list: The input list sorted based on their numeric value.\n \"\"\"\n # Convert the list of strings to integers for sorting\n numbers = [int(s) for s in strings]\n \n # Sort the list of integers\n numbers.sort()\n \n # Convert back to strings if needed, or return as is if integer output is acceptable\n sorted_strings = [str(n) for n in numbers]\n \n return sorted_strings"}
{"task_id": "Mbpp/750", "solution": "def add_tuple(lst, tpl):\n \"\"\"\n Adds elements from the tuple `tpl` to the end of the list `lst`.\n\n Parameters:\n lst (list): The list to which elements will be added.\n tpl (tuple): The tuple whose elements will be added to the list.\n\n Returns:\n list: A new list containing all elements of `lst` followed by all elements of `tpl`.\n \"\"\"\n # Convert the tuple into a list and concatenate it with the original list\n return lst + list(tpl)"}
{"task_id": "Mbpp/751", "solution": "def check_min_heap(arr):\n \"\"\"\n Check if the given array represents a min heap.\n \n :param arr: List[int] - The input list representing the binary tree.\n :return: bool - True if the list is a min-heap, False otherwise.\n \"\"\"\n n = len(arr)\n \n # Iterate over each non-leaf node\n for i in range((n - 2) // 2 + 1):\n left_child_index = 2 * i + 1\n right_child_index = 2 * i + 2\n \n # Check if the current node is greater than its left child\n if left_child_index < n and arr[i] > arr[left_child_index]:\n return False\n \n # Check if the current node is greater than its right child\n if right_child_index < n and arr[i] > arr[right_child_index]:\n return False\n \n return True"}
{"task_id": "Mbpp/752", "solution": "def jacobsthal_num(n):\n \"\"\"\n Compute the nth Jacobsthal number.\n \n Parameters:\n n (int): The position in the Jacobsthal sequence.\n\n Returns:\n int: The nth Jacobsthal number.\n \"\"\"\n if n == 0:\n return 0\n elif n == 1:\n return 1\n \n # Initialize the first two Jacobsthal numbers\n jacobsthal_prev2 = 0 # J(0)\n jacobsthal_prev1 = 1 # J(1)\n\n # Compute subsequent Jacobsthal numbers up to nth\n for i in range(2, n + 1):\n current_jacobsthal = jacobsthal_prev1 + 2 * jacobsthal_prev2\n # Update the previous two values\n jacobsthal_prev2 = jacobsthal_prev1\n jacobsthal_prev1 = current_jacobsthal\n\n return current_jacobsthal"}
{"task_id": "Mbpp/753", "solution": "def min_k(records, k):\n \"\"\"\n Find the minimum k records from a list of tuples based on the second element.\n \n Parameters:\n - records: List of tuples where each tuple contains a name and a score.\n - k: The number of minimum records to return.\n \n Returns:\n - A list containing the k tuples with the smallest scores.\n \"\"\"\n # Sort the records by the second element (score) in ascending order\n sorted_records = sorted(records, key=lambda x: x[1])\n \n # Return the first k elements from the sorted list\n return sorted_records[:k]"}
{"task_id": "Mbpp/754", "solution": "def extract_index_list(l1, l2, l3):\n \"\"\"\n This function takes three lists and returns a list of elements \n that are common to all three lists at the same index.\n \n :param l1: First list of integers\n :param l2: Second list of integers\n :param l3: Third list of integers\n :return: List of integers that are common in all three lists at the same index\n \"\"\"\n # Initialize an empty list to store common elements\n common_elements = []\n \n # Iterate over the indices of the shortest list to avoid IndexError\n for i in range(min(len(l1), len(l2), len(l3))):\n # Check if the element at the current index is the same in all three lists\n if l1[i] == l2[i] == l3[i]:\n common_elements.append(l1[i])\n \n return common_elements"}
{"task_id": "Mbpp/755", "solution": "def second_smallest(numbers):\n # Remove duplicates by converting the list to a set, then back to a sorted list\n unique_numbers = sorted(set(numbers))\n \n # Check if we have at least two distinct elements\n if len(unique_numbers) < 2:\n raise ValueError(\"The list must contain at least two distinct numbers.\")\n \n # Return the second smallest number\n return unique_numbers[1]"}
{"task_id": "Mbpp/757", "solution": "def count_reverse_pairs(words):\n from collections import defaultdict\n \n # Dictionary to store the frequency of each word\n word_count = defaultdict(int)\n \n # Variable to keep track of reverse pairs\n reverse_pair_count = 0\n \n for word in words:\n # Check if the reverse of the current word exists in the dictionary\n reverse_word = word[::-1]\n \n # If it does, add its count to the reverse pair count\n reverse_pair_count += word_count[reverse_word]\n \n # Increment the count of the current word in the dictionary\n word_count[word] += 1\n \n return reverse_pair_count"}
{"task_id": "Mbpp/758", "solution": "def unique_sublists(lst):\n \"\"\"\n Count occurrences of sublists in a given list.\n \n Args:\n lst (list): A list containing sublists.\n\n Returns:\n dict: A dictionary where each key is a tuple representing a sublist,\n and the value is the number of times that sublist appears in the input list.\n \"\"\"\n # Initialize an empty dictionary to store the counts\n count_dict = {}\n \n # Iterate over each sublist in the input list\n for sublst in lst:\n # Convert the sublist to a tuple (since lists are not hashable)\n sublst_tuple = tuple(sublst)\n \n # If the tuple is already in the dictionary, increment its count\n if sublst_tuple in count_dict:\n count_dict[sublst_tuple] += 1\n else:\n # Otherwise, add it to the dictionary with a count of 1\n count_dict[sublst_tuple] = 1\n \n return count_dict"}
{"task_id": "Mbpp/759", "solution": "import re\ndef is_decimal(s):\n \"\"\"\n Check if the input string s is a decimal number with exactly two decimal places.\n \n Args:\n s (str): The string to be checked.\n \n Returns:\n bool: True if s is a valid decimal number with two decimal places, False otherwise.\n \"\"\"\n # Regular expression pattern for matching a decimal number with exactly two decimal places\n pattern = r'^-?\\d+\\.\\d{2}$'\n \n # Use re.match to check if the string matches the pattern\n return bool(re.match(pattern, s))"}
{"task_id": "Mbpp/760", "solution": "def unique_element(numbers):\n \"\"\"\n Check whether a list of numbers contains only one distinct element or not.\n \n Parameters:\n numbers (list): A list of numbers.\n \n Returns:\n bool: True if all elements are the same, False otherwise.\n \"\"\"\n # Use a set to determine the number of unique elements\n return len(set(numbers)) == 1\n\n# Test cases\nassert unique_element([1, 1, 1]) == True\nassert unique_element([2, 2, 3]) == False\nassert unique_element([]) == True # An empty list can be considered as having one distinct element (none)\nassert unique_element([5]) == True # A single-element list is trivially all identical\n\nprint(\"All test cases passed!\")"}
{"task_id": "Mbpp/762", "solution": "def check_month_number(month):\n \"\"\"\n Check if the given month number contains 30 days.\n \n Parameters:\n month (int): Month number (1-12)\n \n Returns:\n bool: True if the month has 30 days, False otherwise.\n \"\"\"\n # Months with 30 days are April (4), June (6), September (9), and November (11).\n months_with_30_days = {4, 6, 9, 11}\n \n # Check if the given month is in the set of months with 30 days.\n return month in months_with_30_days\n\n# Test case\nassert check_month_number(6) == True"}
{"task_id": "Mbpp/763", "solution": "def find_min_diff(arr, n):\n # Step 1: Sort the array\n arr.sort()\n \n # Initialize minimum difference as infinity\n min_diff = float('inf')\n \n # Step 2 & 3: Calculate differences and find the minimum\n for i in range(n - 1):\n diff = arr[i + 1] - arr[i]\n if diff < min_diff:\n min_diff = diff\n \n return min_diff"}
{"task_id": "Mbpp/764", "solution": "def number_ctr(s):\n \"\"\"\n Count the number of digits in a given string.\n \n Parameters:\n s (str): The input string to be evaluated.\n \n Returns:\n int: The count of digit characters in the string.\n \"\"\"\n # Initialize a counter for digits\n digit_count = 0\n \n # Iterate over each character in the string\n for char in s:\n # Check if the character is a digit\n if char.isdigit():\n digit_count += 1\n \n return digit_count"}
{"task_id": "Mbpp/765", "solution": "def is_power_of_two(x):\n return (x & (x - 1)) == 0\n\ndef nth_polite_number(n):\n count = 0\n num = 1\n \n while count < n:\n if not is_power_of_two(num):\n count += 1\n num += 1\n \n return num - 1\n\n# Test the function with an example\nassert nth_polite_number(7) == 11"}
{"task_id": "Mbpp/766", "solution": "def pair_wise(lst):\n \"\"\"\n Returns a list of all pairs of consecutive items in the given list.\n \n Parameters:\n lst (list): A list of elements from which to form consecutive pairs.\n \n Returns:\n list: A list of tuples, where each tuple contains two consecutive elements from the input list.\n \"\"\"\n # Initialize an empty list to store the pairs\n result = []\n \n # Iterate over the list using index, stopping one element before the last\n for i in range(len(lst) - 1):\n # Create a pair (tuple) of the current element and the next element\n pair = (lst[i], lst[i + 1])\n \n # Append the pair to the result list\n result.append(pair)\n \n return result"}
{"task_id": "Mbpp/767", "solution": "def get_pairs_count(numbers, target_sum):\n # Dictionary to store the frequency of each number\n num_count = {}\n \n # Populate the dictionary with counts of each number\n for num in numbers:\n if num in num_count:\n num_count[num] += 1\n else:\n num_count[num] = 1\n \n pair_count = 0\n \n # Iterate through each unique number and calculate pairs\n for num in num_count:\n complement = target_sum - num\n \n # Check if the complement exists in the dictionary\n if complement in num_count:\n if num == complement:\n # If both numbers are the same, use combination formula nC2\n pair_count += (num_count[num] * (num_count[num] - 1)) // 2\n else:\n # Otherwise, multiply the counts of the two different numbers\n pair_count += num_count[num] * num_count[complement]\n \n return pair_count"}
{"task_id": "Mbpp/769", "solution": "def Diff(list1, list2):\n \"\"\"\n Compute the difference between two lists.\n \n Parameters:\n - list1: List of integers or other comparable items.\n - list2: List of integers or other comparable items.\n \n Returns:\n A new list containing elements from list1 that are not in list2.\n \"\"\"\n # Convert list2 to a set for O(1) average time complexity lookups\n set2 = set(list2)\n \n # Use a list comprehension to filter out elements present in set2\n difference = [item for item in list1 if item not in set2]\n \n return difference"}
{"task_id": "Mbpp/770", "solution": "def odd_num_sum(n):\n \"\"\"\n Calculate the sum of the fourth power of the first n odd natural numbers.\n \n Parameters:\n n (int): The number of initial odd natural numbers to consider.\n \n Returns:\n int: The sum of the fourth powers of these numbers.\n \"\"\"\n # Initialize the sum\n total_sum = 0\n \n # Loop through the first n odd numbers\n for i in range(n):\n # Calculate the ith odd number (1, 3, 5, ...)\n odd_number = 2 * i + 1\n \n # Add its fourth power to the total sum\n total_sum += odd_number ** 4\n \n return total_sum"}
{"task_id": "Mbpp/771", "solution": "def check_expression(expression):\n # Dictionary to hold matching pairs of brackets\n bracket_pairs = {\n ')': '(',\n ']': '[',\n '}': '{'\n }\n \n # Stack to keep track of opening brackets\n stack = []\n \n for char in expression:\n if char in bracket_pairs.values():\n # If it's an opening bracket, push onto the stack\n stack.append(char)\n elif char in bracket_pairs.keys():\n # If it's a closing bracket, check for balance\n if stack and stack[-1] == bracket_pairs[char]:\n stack.pop()\n else:\n return False\n \n # If stack is empty, all brackets were balanced\n return not stack"}
{"task_id": "Mbpp/772", "solution": "def remove_length(s, k):\n \"\"\"\n Remove all words of length k from the given string.\n\n Parameters:\n s (str): The input string.\n k (int): The length of words to be removed.\n\n Returns:\n str: A new string with all words of length k removed.\n \"\"\"\n # Split the string into a list of words\n words = s.split()\n \n # Filter out words that have length k\n filtered_words = [word for word in words if len(word) != k]\n \n # Join the remaining words back into a single string\n result = ' '.join(filtered_words)\n \n return result"}
{"task_id": "Mbpp/773", "solution": "def occurance_substring(main_string, sub_string):\n \"\"\"\n Find the first occurrence and position of a substring within a main string.\n \n Parameters:\n - main_string (str): The string to search within.\n - sub_string (str): The substring to find.\n\n Returns:\n - tuple: A tuple containing the substring, its starting index, and ending index if found.\n - None: If the substring is not found in the main string.\n \"\"\"\n start_index = main_string.find(sub_string)\n \n if start_index == -1:\n return None\n \n end_index = start_index + len(sub_string) - 1\n return (sub_string, start_index, end_index)"}
{"task_id": "Mbpp/775", "solution": "def odd_position(lst):\n \"\"\"\n Check if every element at an odd index in the list contains an odd number.\n \n Parameters:\n lst (list): A list of integers.\n \n Returns:\n bool: True if every element at an odd index is odd, False otherwise.\n \"\"\"\n # Iterate over indices and elements using enumerate\n for index, value in enumerate(lst):\n # Check if the index is odd\n if index % 2 != 0:\n # If the number at this odd index is not odd, return False\n if value % 2 == 0:\n return False\n # If all checks pass, return True\n return True"}
{"task_id": "Mbpp/777", "solution": "def find_sum(lst):\n # Create a dictionary to count occurrences of each element\n frequency = {}\n \n for num in lst:\n if num in frequency:\n frequency[num] += 1\n else:\n frequency[num] = 1\n \n # Calculate the sum of elements that appear only once\n non_repeated_sum = sum(num for num, count in frequency.items() if count == 1)\n \n return non_repeated_sum"}
{"task_id": "Mbpp/778", "solution": "def pack_consecutive_duplicates(lst):\n if not lst:\n return []\n \n packed_list = []\n current_sublist = [lst[0]]\n \n for element in lst[1:]:\n if element == current_sublist[-1]:\n current_sublist.append(element)\n else:\n packed_list.append(current_sublist)\n current_sublist = [element]\n \n # Append the last sublist\n packed_list.append(current_sublist)\n \n return packed_list"}
{"task_id": "Mbpp/780", "solution": "def find_combinations(tuples):\n result = []\n \n # Iterate over each pair of tuples\n for i in range(len(tuples)):\n for j in range(i + 1, len(tuples)):\n # Calculate the sum of elements from both tuples\n sum_tuple = (tuples[i][0] + tuples[j][0], tuples[i][1] + tuples[j][1])\n result.append(sum_tuple)\n \n # Also consider the reverse order\n sum_tuple_reverse = (tuples[j][0] + tuples[i][0], tuples[j][1] + tuples[i][1])\n result.append(sum_tuple_reverse)\n \n return result"}
{"task_id": "Mbpp/781", "solution": "def count_divisors(n):\n \"\"\"\n This function returns True if the count of divisors of n is even, otherwise False.\n \n Parameters:\n n (int): The integer to check for the number of divisors.\n \n Returns:\n bool: True if the count of divisors is even, False otherwise.\n \"\"\"\n # Initialize a counter for divisors\n divisor_count = 0\n \n # Iterate over possible divisors from 1 to n (inclusive)\n for i in range(1, n + 1):\n if n % i == 0:\n divisor_count += 1\n \n # Check if the count of divisors is even\n return divisor_count % 2 == 0"}
{"task_id": "Mbpp/782", "solution": "def odd_length_sum(arr):\n total_sum = 0\n n = len(arr)\n \n # Iterate over each possible starting point of subarrays\n for start in range(n):\n # Iterate over each possible ending point of subarrays\n for end in range(start, n):\n # Calculate the length of the current subarray\n length = end - start + 1\n \n # Check if the length is odd\n if length % 2 == 1:\n # Sum up the elements of this subarray and add to total_sum\n total_sum += sum(arr[start:end+1])\n \n return total_sum"}
{"task_id": "Mbpp/784", "solution": "def mul_even_odd(numbers):\n \"\"\"\n This function finds the product of the first even and odd numbers in a given list.\n \n Parameters:\n numbers (list): A list of integers.\n\n Returns:\n int: The product of the first even and odd numbers found in the list. \n If either is not found, returns None.\n \"\"\"\n first_even = None\n first_odd = None\n\n # Iterate through the list to find the first even and odd numbers\n for num in numbers:\n if first_even is None and num % 2 == 0:\n first_even = num\n elif first_odd is None and num % 2 != 0:\n first_odd = num\n \n # If both are found, no need to continue the loop\n if first_even is not None and first_odd is not None:\n break\n\n # Return the product of the first even and odd numbers if both are found\n if first_even is not None and first_odd is not None:\n return first_even * first_odd\n else:\n return None"}
{"task_id": "Mbpp/785", "solution": "def tuple_str_int(tuple_string):\n \"\"\"\n Convert a tuple represented as a string into an actual tuple of integers.\n \n Parameters:\n tuple_string (str): A string representation of a tuple, e.g., \"(7, 8, 9)\"\n \n Returns:\n tuple: A tuple containing the integer elements from the input string\n \"\"\"\n # Use eval to evaluate the string as a Python expression\n # Ensure that the input is safe by checking if it's properly formatted\n if isinstance(tuple_string, str) and tuple_string.startswith(\"(\") and tuple_string.endswith(\")\"):\n try:\n result = eval(tuple_string)\n # Check if the evaluated result is indeed a tuple\n if isinstance(result, tuple):\n return tuple(int(x) for x in result)\n else:\n raise ValueError(\"The input string does not represent a valid tuple.\")\n except (SyntaxError, NameError, TypeError):\n raise ValueError(\"Invalid format for tuple conversion.\")\n else:\n raise ValueError(\"Input must be a string representing a tuple.\")"}
{"task_id": "Mbpp/786", "solution": "def right_insertion(sorted_list, value):\n \"\"\"\n Find the right insertion point for a specified value in a sorted list.\n \n Parameters:\n - sorted_list: List of integers sorted in ascending order.\n - value: Integer to be inserted into the sorted list.\n \n Returns:\n - The index at which the value should be inserted to maintain sorted order.\n \"\"\"\n left, right = 0, len(sorted_list)\n \n while left < right:\n mid = (left + right) // 2\n if sorted_list[mid] <= value:\n left = mid + 1\n else:\n right = mid\n \n return left"}
{"task_id": "Mbpp/787", "solution": "import re\ndef text_match_three(text):\n \"\"\"\n This function checks if the input string contains an 'a'\n followed by exactly three 'b's.\n \n Parameters:\n text (str): The string to be checked.\n \n Returns:\n bool: True if the pattern is found, False otherwise.\n \"\"\"\n # Define a regular expression pattern for 'a' followed by exactly three 'b's\n pattern = r\"ab{3}\"\n \n # Use re.search to find the pattern in the text\n match = re.search(pattern, text)\n \n # Return True if the pattern is found, False otherwise\n return bool(match)"}
{"task_id": "Mbpp/788", "solution": "def create_new_tuple(string_list, single_string):\n \"\"\"\n Create a new tuple from the given list of strings and a single string.\n \n Parameters:\n - string_list: A list of strings.\n - single_string: A single string to be added to the tuple.\n \n Returns:\n - A tuple containing all elements from the list followed by the single string.\n \"\"\"\n # Combine the list with the single string into a new list\n combined_list = string_list + [single_string]\n \n # Convert the combined list into a tuple\n result_tuple = tuple(combined_list)\n \n return result_tuple\n\n# Test case to verify the function works as expected\nassert create_new_tuple([\"WEB\", \"is\"], \"best\") == ('WEB', 'is', 'best')"}
{"task_id": "Mbpp/790", "solution": "def even_position(lst):\n \"\"\"\n Check whether every even index contains even numbers in the given list.\n \n Parameters:\n lst (list): A list of integers.\n \n Returns:\n bool: True if every even index contains an even number, False otherwise.\n \"\"\"\n for i in range(0, len(lst), 2):\n if lst[i] % 2 != 0:\n return False\n return True"}
{"task_id": "Mbpp/791", "solution": "def remove_nested(input_tuple):\n # Use a generator expression to filter out nested tuples\n result = tuple(item for item in input_tuple if not isinstance(item, tuple))\n return result"}
{"task_id": "Mbpp/792", "solution": "def count_list(list_of_lists):\n \"\"\"\n Counts the number of lists in a given list of lists.\n \n Parameters:\n list_of_lists (list): A list containing other lists.\n \n Returns:\n int: The number of lists contained within the input list.\n \"\"\"\n # Check if the input is indeed a list\n if not isinstance(list_of_lists, list):\n raise ValueError(\"Input must be a list.\")\n \n # Initialize count to 0\n count = 0\n \n # Iterate over each element in the list\n for item in list_of_lists:\n # If the item is a list, increment the count\n if isinstance(item, list):\n count += 1\n \n return count"}
{"task_id": "Mbpp/793", "solution": "def last(arr, target):\n \"\"\"\n Find the last position of 'target' in a sorted array 'arr'.\n \n Parameters:\n arr (list): A list of integers sorted in non-decreasing order.\n target (int): The integer to find the last occurrence of in the array.\n \n Returns:\n int: The index of the last occurrence of 'target' in 'arr', or -1 if not found.\n \"\"\"\n left, right = 0, len(arr) - 1\n result = -1\n \n while left <= right:\n mid = (left + right) // 2\n \n if arr[mid] == target:\n result = mid\n left = mid + 1 # Move to the right half to find the last occurrence\n elif arr[mid] < target:\n left = mid + 1\n else:\n right = mid - 1\n \n return result"}
{"task_id": "Mbpp/794", "solution": "import re\ndef text_starta_endb(s):\n \"\"\"\n This function checks if the input string starts with 'a' and ends with 'b'.\n \n Parameters:\n s (str): The input string to be checked.\n \n Returns:\n bool: True if the string matches the pattern, False otherwise.\n \"\"\"\n # Define a regular expression pattern\n pattern = r'^a.*b$'\n \n # Use re.match to check if the string matches the pattern\n match = re.match(pattern, s)\n \n # Return True if there is a match, False otherwise\n return bool(match)"}
{"task_id": "Mbpp/796", "solution": "def return_sum(d):\n \"\"\"\n Calculate the sum of all values in the given dictionary.\n\n Parameters:\n d (dict): A dictionary with numeric values.\n\n Returns:\n int: The sum of all values in the dictionary.\n \"\"\"\n # Use the built-in `sum` function to calculate the total\n return sum(d.values())"}
{"task_id": "Mbpp/797", "solution": "def sum_in_range(l, r):\n \"\"\"\n Calculate the sum of all odd natural numbers within the range [l, r].\n \n Parameters:\n l (int): The lower bound of the range.\n r (int): The upper bound of the range.\n \n Returns:\n int: The sum of all odd natural numbers between l and r inclusive.\n \"\"\"\n # Initialize the sum to 0\n total_sum = 0\n \n # Iterate over each number in the range [l, r]\n for num in range(l, r + 1):\n # Check if the number is odd\n if num % 2 != 0:\n # Add it to the total sum\n total_sum += num\n \n return total_sum"}
{"task_id": "Mbpp/798", "solution": "def _sum(arr):\n \"\"\"\n Calculate the sum of all numbers in the given list.\n \n Parameters:\n arr (list): A list of integers or floats.\n \n Returns:\n int/float: The sum of the elements in the list.\n \"\"\"\n return sum(arr)"}
{"task_id": "Mbpp/799", "solution": "def left_rotate(n, d):\n \"\"\"\n Rotate the bits of a 32-bit integer n to the left by d positions.\n \n Parameters:\n n (int): A 32-bit integer.\n d (int): Number of positions to rotate to the left.\n \n Returns:\n int: The result after rotating n's bits to the left by d positions.\n \"\"\"\n # Ensure that we only consider the lower 32 bits of n\n n &= 0xFFFFFFFF\n \n # Calculate the number of effective rotations needed (d % 32)\n d = d % 32\n \n # Perform the rotation\n rotated_n = ((n << d) | (n >> (32 - d))) & 0xFFFFFFFF\n \n return rotated_n"}
{"task_id": "Mbpp/800", "solution": "def remove_all_spaces(s):\n \"\"\"\n Remove all whitespaces from a string.\n \n Parameters:\n s (str): The input string from which whitespaces are to be removed.\n \n Returns:\n str: A new string with all whitespace characters removed.\n \"\"\"\n # Use the replace method to remove spaces\n return s.replace(\" \", \"\")"}
{"task_id": "Mbpp/801", "solution": "def test_three_equal(a, b, c):\n \"\"\"\n This function takes three integers and returns the count of how many are equal.\n \n Parameters:\n a (int): First integer\n b (int): Second integer\n c (int): Third integer\n \n Returns:\n int: The number of integers that are equal among the three given numbers.\n \"\"\"\n # Create a set from the input numbers to remove duplicates\n unique_numbers = {a, b, c}\n \n # The count of equal numbers is 3 minus the size of the set (since all unique)\n return 3 - len(unique_numbers)"}
{"task_id": "Mbpp/803", "solution": "def is_perfect_square(n):\n \"\"\"\n Check whether the given number n is a perfect square.\n \n A perfect square is an integer that is the square of another integer.\n \n Parameters:\n n (int): The number to check.\n \n Returns:\n bool: True if n is a perfect square, False otherwise.\n \"\"\"\n if n < 0:\n return False\n # Use binary search to find the integer square root\n left, right = 0, n\n while left <= right:\n mid = (left + right) // 2\n squared = mid * mid\n if squared == n:\n return True\n elif squared < n:\n left = mid + 1\n else:\n right = mid - 1\n return False"}
{"task_id": "Mbpp/804", "solution": "def is_product_even(numbers):\n \"\"\"\n Check if the product of numbers in the list is even.\n\n Parameters:\n numbers (list): A list of integers.\n\n Returns:\n bool: True if the product is even, False otherwise.\n \"\"\"\n # Iterate through each number in the list\n for num in numbers:\n # If any number is even, the product will be even\n if num % 2 == 0:\n return True\n # If no even number is found, the product is odd\n return False"}
{"task_id": "Mbpp/805", "solution": "def max_sum_list(list_of_lists):\n \"\"\"\n This function takes a list of lists and returns the list with the highest sum of elements.\n \n Parameters:\n list_of_lists (list): A list containing sublists of integers.\n\n Returns:\n list: The sublist with the maximum sum of its elements.\n \"\"\"\n # Initialize variables to keep track of the maximum sum and corresponding list\n max_sum = float('-inf')\n max_list = []\n\n # Iterate over each list in the list_of_lists\n for lst in list_of_lists:\n # Calculate the sum of the current list\n current_sum = sum(lst)\n \n # Update max_sum and max_list if the current list has a higher sum\n if current_sum > max_sum:\n max_sum = current_sum\n max_list = lst\n\n return max_list"}
{"task_id": "Mbpp/806", "solution": "def max_run_uppercase(s):\n \"\"\"\n This function finds the maximum run of consecutive uppercase letters in a given string.\n\n Parameters:\n s (str): The input string to search for uppercase runs.\n\n Returns:\n int: The length of the longest sequence of consecutive uppercase characters.\n \"\"\"\n\n # Initialize variables to keep track of the current and maximum run lengths\n max_run = 0\n current_run = 0\n\n # Iterate over each character in the string\n for char in s:\n if char.isupper():\n # If the character is uppercase, increment the current run length\n current_run += 1\n # Update the maximum run length if the current run exceeds it\n max_run = max(max_run, current_run)\n else:\n # Reset the current run length to zero if a non-uppercase character is encountered\n current_run = 0\n\n return max_run"}
{"task_id": "Mbpp/807", "solution": "def first_odd(numbers):\n \"\"\"\n This function returns the first odd number from a list of numbers.\n \n Parameters:\n numbers (list): A list of integers.\n\n Returns:\n int: The first odd number found in the list, or None if no odd number is present.\n \"\"\"\n for num in numbers:\n if num % 2 != 0:\n return num\n return None"}
{"task_id": "Mbpp/808", "solution": "def check_K(tup, k):\n \"\"\"\n Check if the integer k is present in the given tuple.\n \n Parameters:\n tup (tuple): The tuple to search within.\n k (int): The integer to find in the tuple.\n \n Returns:\n bool: True if k is found in the tuple, False otherwise.\n \"\"\"\n return k in tup"}
{"task_id": "Mbpp/809", "solution": "def check_smaller(tuple1, tuple2):\n \"\"\"\n Check if each element of second tuple is smaller than its corresponding element in the first tuple.\n \n Parameters:\n - tuple1: A tuple of numbers.\n - tuple2: Another tuple of numbers with the same length as tuple1.\n\n Returns:\n - True if every element in tuple2 is smaller than the corresponding element in tuple1, False otherwise.\n \"\"\"\n # Check if both tuples have the same length\n if len(tuple1) != len(tuple2):\n raise ValueError(\"Both tuples must have the same length.\")\n \n # Iterate over pairs of elements from both tuples\n for a, b in zip(tuple1, tuple2):\n # If any element in tuple2 is not smaller than its corresponding element in tuple1, return False\n if b >= a:\n return False\n \n # If all checks pass, return True\n return True"}
=== raw completions jsonl follows ===
{"task_id": "Mbpp/2", "solution": "Certainly! Below is a self-contained Python script that defines a function to find shared elements between two lists. The function uses sets to efficiently determine the intersection of the two lists.\n\n```python\ndef similar_elements(list1, list2):\n \"\"\"\n Find the shared elements from the given two lists.\n \n Parameters:\n - list1: First list of elements.\n - list2: Second list of elements.\n \n Returns:\n A set containing the shared elements between the two lists.\n \"\"\"\n # Convert both lists to sets\n set1 = set(list1)\n set2 = set(list2)\n \n # Find the intersection of the two sets\n shared_elements = set1.intersection(set2)\n \n return shared_elements\n\n# Test case\nassert set(similar_elements((3, 4, 5, 6), (5, 7, 4, 10))) == set((4, 5))\n```\n\nThis script defines the `similar_elements` function and includes a test case to verify its correctness. The function converts both input lists into sets and then finds their intersection, which represents the shared elements."}
{"task_id": "Mbpp/3", "solution": "Certainly! Below is a self-contained Python script that defines a function `is_not_prime` to determine if a number is not prime. The function returns `True` for non-prime numbers and `False` for prime numbers.\n\n```python\ndef is_not_prime(n):\n \"\"\"\n Determine if a number n is not a prime number.\n \n Args:\n n (int): The number to check.\n \n Returns:\n bool: True if n is not a prime number, False otherwise.\n \"\"\"\n # A prime number must be greater than 1\n if n <= 1:\n return True\n \n # Check for factors from 2 up to the square root of n\n for i in range(2, int(n**0.5) + 1):\n if n % i == 0:\n return True\n \n # If no factors were found, n is a prime number\n return False\n\n# Test cases\nassert is_not_prime(2) == False\nassert is_not_prime(3) == False\nassert is_not_prime(4) == True\nassert is_not_prime(5) == False\nassert is_not_prime(1) == True\nassert is_not_prime(0) == True\nassert is_not_prime(-3) == True\n\nprint(\"All test cases passed!\")\n```\n\n### Explanation:\n- The function `is_not_prime` checks if a number `n` is not prime.\n- It first handles numbers less than or equal to 1, which are not considered prime.\n- For other numbers, it checks divisibility from 2 up to the square root of `n`. If any divisor is found, the number is not prime.\n- The function returns `True` if a non-prime condition is met and `False` otherwise.\n\nThis script includes test cases to verify the correctness of the implementation."}
{"task_id": "Mbpp/4", "solution": "Certainly! Below is a self-contained Python script that solves the problem of finding the `n` largest integers from a given list and returning them in descending order. The solution uses the `heapq` module to efficiently find the largest elements.\n\n```python\nimport heapq\n\ndef heap_queue_largest(numbers, n):\n \"\"\"\n Find the n largest integers from a given list of numbers.\n \n Parameters:\n - numbers: List[int], the list of numbers to search through.\n - n: int, the number of largest integers to find.\n \n Returns:\n - List[int]: The n largest integers in descending order.\n \"\"\"\n # Use nlargest from heapq to get the n largest elements\n largest_n = heapq.nlargest(n, numbers)\n return largest_n\n\n# Test case\nassert heap_queue_largest([25, 35, 22, 85, 14, 65, 75, 22, 58], 3) == [85, 75, 65]\n\nprint(\"Test passed!\")\n```\n\n### Explanation:\n\n- **`heapq.nlargest(n, iterable)`**: This function is used to find the `n` largest elements from an iterable. It uses a min-heap internally and is efficient for this purpose.\n \n- The function `heap_queue_largest` takes two parameters: `numbers`, which is the list of integers, and `n`, which specifies how many of the largest numbers to return.\n\n- After finding the `n` largest elements using `heapq.nlargest`, these are returned as they are already in descending order due to the nature of the function.\n\n- The test case checks if the function correctly returns `[85, 75, 65]` for the input list and `n = 3`.\n\nThis script should work efficiently even for larger lists due to the optimized heap operations."}
{"task_id": "Mbpp/6", "solution": "Certainly! To solve this problem, we need to determine if two integers differ by exactly one bit in their binary representation. Here's a step-by-step explanation and the corresponding Python function:\n\n1. **XOR Operation**: The XOR operation between two numbers will result in a number where each bit is set to 1 only if the bits at that position in the original numbers are different.\n\n2. **Check for Single Bit Difference**: After performing the XOR, we need to check if there's exactly one bit set to 1 in the resulting number. This can be done by checking if the result is a power of two (i.e., it has only one bit set).\n\n3. **Power of Two Check**: A number is a power of two if it is greater than zero and its binary representation contains exactly one '1'. This can be checked using the condition `(n & (n - 1)) == 0`.\n\nHere's the Python function implementing this logic:\n\n```python\ndef differ_At_One_Bit_Pos(num1, num2):\n # Perform XOR to find differing bits\n xor_result = num1 ^ num2\n \n # Check if xor_result is a power of two (i.e., only one bit set)\n return xor_result != 0 and (xor_result & (xor_result - 1)) == 0\n\n# Test case\nassert differ_At_One_Bit_Pos(13, 9) == True\n```\n\n### Explanation:\n\n- **XOR Calculation**: `num1 ^ num2` gives a number where bits are set to 1 only at positions where `num1` and `num2` differ.\n \n- **Power of Two Check**: `(xor_result & (xor_result - 1)) == 0` checks if there's exactly one '1' in the binary representation of `xor_result`. This works because subtracting 1 from a power of two flips all bits after the rightmost '1', and AND-ing it with the original number results in zero.\n\n- **Non-zero Check**: We also ensure `xor_result` is not zero, as zero would mean no differing bits, which doesn't satisfy the condition of differing at exactly one bit position."}
{"task_id": "Mbpp/7", "solution": "Certainly! Below is a self-contained Python script that defines the `find_char_long` function. This function takes a string as input and returns a list of words that are at least 4 characters long.\n\n```python\ndef find_char_long(input_string):\n \"\"\"\n Find all words in the input string that are at least 4 characters long.\n \n Parameters:\n - input_string (str): The string to search for words.\n \n Returns:\n - list: A list of words with a length of at least 4 characters.\n \"\"\"\n # Split the input string into words\n words = input_string.split()\n \n # Filter words that have a length of at least 4 characters\n long_words = [word for word in words if len(word) >= 4]\n \n return long_words\n\n# Test case to verify the function works as expected\nassert set(find_char_long('Please move back to stream')) == set(['Please', 'move', 'back', 'stream'])\n```\n\nThis script defines the `find_char_long` function, which splits the input string into words and filters out those that are at least 4 characters long. The test case ensures that the function behaves as expected by comparing its output to a predefined set of words."}
{"task_id": "Mbpp/8", "solution": "Certainly! Below is a self-contained Python script that defines the function `square_nums` to find squares of individual elements in a list. The function uses a list comprehension to compute the square of each element and returns the resulting list.\n\n```python\ndef square_nums(numbers):\n \"\"\"\n This function takes a list of numbers as input and returns a new list containing \n the squares of each number from the original list.\n \n :param numbers: List of integers or floats.\n :return: A list with the squares of the input numbers.\n \"\"\"\n return [num ** 2 for num in numbers]\n\n# Test case\nassert square_nums([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]) == [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]\n```\n\n### Explanation:\n- **Function Definition**: The function `square_nums` is defined to take a single parameter `numbers`, which is expected to be a list of integers or floats.\n- **List Comprehension**: Inside the function, a list comprehension `[num ** 2 for num in numbers]` iterates over each element `num` in the input list `numbers`. For each element, it computes its square (`num ** 2`) and collects these squared values into a new list.\n- **Return Statement**: The newly created list of squares is returned as the output of the function.\n- **Assertion Test**: An assertion test checks that calling `square_nums` with the input `[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]` returns the expected result `[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]`.\n\nThis script is self-contained and can be run in any Python environment to verify its correctness."}
{"task_id": "Mbpp/9", "solution": "```markdown\nTo solve this problem, we need to determine the smallest number of rotations needed for a given string to return to its original form. A rotation involves moving the last character of the string to the front.\n\nHere's how you can implement the function:\n\n```python\ndef find_Rotations(s):\n # Concatenate the string with itself\n doubled_string = s + s\n \n # Iterate over possible rotations from 1 to len(s)\n for i in range(1, len(s) + 1):\n # Check if a rotation of length 'i' results in the original string\n if doubled_string[i:i+len(s)] == s:\n return i\n\n# Test case\nassert find_Rotations(\"aaaa\") == 1\n```\n\n### Explanation:\n\n1. **Concatenate the String**: By concatenating `s` with itself (`doubled_string = s + s`), we create a string that contains all possible rotations of `s`.\n\n2. **Iterate Over Possible Rotations**: We loop from `1` to `len(s)` because any rotation greater than the length of the string would just repeat previous rotations.\n\n3. **Check for Original String**: For each possible rotation length `i`, we check if the substring starting at index `i` and spanning the length of `s` matches the original string `s`.\n\n4. **Return the Rotation Count**: The first match found gives us the minimum number of rotations needed to return to the original string.\n\nThis approach efficiently finds the smallest rotation count by leveraging the properties of string concatenation and slicing.\n```"}
{"task_id": "Mbpp/11", "solution": "Certainly! Below is a self-contained Python script that defines a function `remove_occ` which removes the first and last occurrences of a specified character from a given string. The function then checks if the result matches the expected output using an assertion.\n\n```python\ndef remove_occ(s, char):\n \"\"\"\n Remove the first and last occurrence of 'char' in the string 's'.\n \n Parameters:\n s (str): The input string.\n char (str): The character to be removed from the string.\n \n Returns:\n str: A new string with the first and last occurrences of 'char' removed.\n \"\"\"\n if not s or len(char) != 1:\n return s\n \n # Find the first occurrence\n first_index = s.find(char)\n if first_index == -1:\n return s\n \n # Find the last occurrence\n last_index = s.rfind(char)\n \n # Remove the first and last occurrences\n new_s = s[:first_index] + s[first_index+1:last_index] + s[last_index+1:]\n \n return new_s\n\n# Test case\nassert remove_occ(\"hello\", \"l\") == \"heo\"\n```\n\nThis script defines the `remove_occ` function, which uses string slicing to construct a new string with the specified character removed from both its first and last occurrences. The assertion at the end verifies that the function works as expected for the given test case."}
{"task_id": "Mbpp/12", "solution": "Certainly! Below is a self-contained Python script that defines the function `sort_matrix` to sort a given matrix in ascending order based on the sum of its rows. The function uses Python's built-in sorting capabilities with a custom key.\n\n```python\ndef sort_matrix(matrix):\n \"\"\"\n Sorts the given matrix in ascending order according to the sum of its rows.\n \n Parameters:\n matrix (list of lists): A 2D list where each sublist represents a row of the matrix.\n \n Returns:\n list of lists: The sorted matrix with rows ordered by their sums.\n \"\"\"\n # Sort the matrix using the sum of each row as the key\n return sorted(matrix, key=lambda row: sum(row))\n\n# Example usage and assertion to verify correctness\nassert sort_matrix([[1, 2, 3], [2, 4, 5], [1, 1, 1]]) == [[1, 1, 1], [1, 2, 3], [2, 4, 5]]\n\n# Additional test cases to ensure robustness\nassert sort_matrix([[10, 20], [30, 40], [5, 5]]) == [[5, 5], [10, 20], [30, 40]]\nassert sort_matrix([[], [1], [2, 3], [4, 5, 6]]) == [[], [1], [2, 3], [4, 5, 6]]\nassert sort_matrix([[0, 0, 0], [-1, -1, -1], [1, 1, 1]]) == [[-1, -1, -1], [0, 0, 0], [1, 1, 1]]\n\nprint(\"All test cases passed!\")\n```\n\n### Explanation:\n- The `sort_matrix` function takes a matrix (a list of lists) as input.\n- It uses the `sorted()` function with a lambda function as the key. This lambda calculates the sum of each row (`sum(row)`), which is used to determine the order of sorting.\n- The function returns the sorted matrix, where rows are ordered by their sums in ascending order.\n- Several test cases are included to verify that the function works correctly for different scenarios, including edge cases like empty rows and negative numbers."}
{"task_id": "Mbpp/14", "solution": "Certainly! Below is a self-contained Python script that defines a function to calculate the volume of a triangular prism. The function takes three parameters: the base length, height of the triangle, and the length (or depth) of the prism.\n\n```python\ndef find_volume(base_length, triangle_height, prism_depth):\n \"\"\"\n Calculate the volume of a triangular prism.\n \n Parameters:\n - base_length: Length of the base of the triangular face.\n - triangle_height: Height of the triangular face.\n - prism_depth: Depth (or length) of the prism.\n \n Returns:\n - Volume of the triangular prism.\n \"\"\"\n # Calculate the area of the triangular base\n triangular_area = 0.5 * base_length * triangle_height\n \n # Calculate the volume of the prism\n volume = triangular_area * prism_depth\n \n return volume\n\n# Test case to verify the function works as expected\nassert find_volume(10, 8, 6) == 240\n```\n\n### Explanation:\n- **Triangular Area Calculation**: The area of a triangle is calculated using the formula: \n \\[\n \\text{Area} = \\frac{1}{2} \\times \\text{base\\_length} \\times \\text{triangle\\_height}\n \\]\n- **Volume Calculation**: The volume of the prism is then found by multiplying the area of the triangular base by the depth (or length) of the prism:\n \\[\n \\text{Volume} = \\text{triangular\\_area} \\times \\text{prism\\_depth}\n \\]\n\nThe provided test case checks if the function correctly calculates a volume of `240` for a triangular prism with a base length of `10`, triangle height of `8`, and depth of `6`."}
{"task_id": "Mbpp/16", "solution": "Certainly! Below is a self-contained Python script that defines a function to check if an input string contains sequences of lowercase letters joined by underscores. The function returns `True` if the condition is met and `False` otherwise.\n\n```python\nimport re\n\ndef text_lowercase_underscore(s):\n \"\"\"\n Check if the input string contains sequences of lowercase letters joined with an underscore.\n \n Args:\n s (str): The input string to check.\n \n Returns:\n bool: True if the string matches the pattern, False otherwise.\n \"\"\"\n # Define a regular expression pattern for matching\n # one or more lowercase letters followed by an underscore,\n # repeated zero or more times, and ending with one or more lowercase letters.\n pattern = r'^[a-z]+(_[a-z]+)*$'\n \n # Use the fullmatch method to check if the entire string matches the pattern\n return bool(re.fullmatch(pattern, s))\n\n# Test case\nassert text_lowercase_underscore(\"aab_cbbbc\") == True\n\n# Additional test cases for verification\nprint(text_lowercase_underscore(\"hello_world\")) # Expected: True\nprint(text_lowercase_underscore(\"python3_is_fun\")) # Expected: False (contains a digit)\nprint(text_lowercase_underscore(\"this_is_a_test\")) # Expected: True\nprint(text_lowercase_underscore(\"no_underscores_here\")) # Expected: False (missing underscore)\nprint(text_lowercase_underscore(\"_leading_underscore\")) # Expected: False (leading underscore)\nprint(text_lowercase_underscore(\"trailing_underscore_\")) # Expected: False (trailing underscore)\n```\n\n### Explanation:\n- The function `text_lowercase_underscore` uses a regular expression to determine if the input string matches the desired pattern.\n- The pattern `^[a-z]+(_[a-z]+)*$` is explained as follows:\n - `^`: Asserts the start of the string.\n - `[a-z]+`: Matches one or more lowercase letters.\n - `(_[a-z]+)*`: Matches zero or more occurrences of an underscore followed by one or more lowercase letters.\n - `$`: Asserts the end of the string.\n- The `re.fullmatch` function checks if the entire string conforms to this pattern, returning a match object if it does and `None` otherwise. We convert this result to a boolean using `bool()`.\n- Additional test cases are provided to ensure the function behaves as expected in various scenarios."}
{"task_id": "Mbpp/17", "solution": "Certainly! Below is a self-contained Python script that defines a function to calculate the perimeter of a square given its side length. The script also includes an assertion to verify the correctness of the function.\n\n```python\ndef square_perimeter(side_length):\n \"\"\"\n Calculate the perimeter of a square given its side length.\n \n Parameters:\n side_length (float or int): The length of one side of the square.\n \n Returns:\n float: The perimeter of the square.\n \"\"\"\n # Perimeter of a square is 4 times the side length\n return 4 * side_length\n\n# Test case to verify the function works as expected\nassert square_perimeter(10) == 40, \"The test case failed!\"\n\nprint(\"All tests passed!\")\n```\n\n### Explanation:\n\n- **Function Definition**: The `square_perimeter` function takes one parameter, `side_length`, which represents the length of a side of the square.\n \n- **Calculation**: Since all sides of a square are equal, the perimeter is calculated as four times the side length.\n\n- **Assertion**: An assertion checks if calling `square_perimeter(10)` returns 40. If it does not, an error message \"The test case failed!\" will be displayed.\n\n- **Output**: If the assertion passes without any errors, \"All tests passed!\" is printed to indicate successful verification of the function's correctness."}
{"task_id": "Mbpp/18", "solution": "Certainly! Below is a self-contained Python script that defines and tests the `remove_dirty_chars` function as described:\n\n```markdown\n```python\ndef remove_dirty_chars(s1, s2):\n \"\"\"\n Remove characters from the first string (s1) which are present in the second string (s2).\n \n Parameters:\n s1 (str): The original string from which characters will be removed.\n s2 (str): The string containing characters to be removed from s1.\n\n Returns:\n str: A new string with specified characters removed.\n \"\"\"\n # Create a set of characters to remove for efficient lookup\n chars_to_remove = set(s2)\n \n # Use a list comprehension to filter out unwanted characters\n result = ''.join(char for char in s1 if char not in chars_to_remove)\n \n return result\n\n# Test the function with the provided assertion\nassert remove_dirty_chars(\"probasscurve\", \"pros\") == 'bacuve'\n\nprint(\"Test passed!\")\n```\n```\n\nThis script defines a function `remove_dirty_chars` that takes two strings as input. It uses a set for efficient membership testing to determine which characters from the first string should be removed based on their presence in the second string. The result is constructed using a list comprehension and then joined into a single string. Finally, it includes an assertion to verify that the function works correctly with the given example."}
{"task_id": "Mbpp/19", "solution": "Certainly! Below is a self-contained Python script that defines a function to check for duplicates in an array of integers. The function uses a set to track seen elements and returns `True` if any duplicate is found.\n\n```python\ndef test_duplicate(arr):\n \"\"\"\n Check if the given list contains any duplicate elements.\n \n Parameters:\n arr (list): A list of integers.\n \n Returns:\n bool: True if there are duplicates, False otherwise.\n \"\"\"\n seen = set()\n for num in arr:\n if num in seen:\n return True\n seen.add(num)\n return False\n\n# Test cases\nassert test_duplicate([1, 2, 3, 4, 5]) == False\nassert test_duplicate([1, 2, 3, 4, 5, 1]) == True\nassert test_duplicate([]) == False\nassert test_duplicate([7, 7, 7, 7]) == True\nassert test_duplicate([10, -1, 0, 10]) == True\n\nprint(\"All tests passed.\")\n```\n\nThis script includes a function `test_duplicate` that iterates over the list and uses a set to keep track of elements that have already been encountered. If an element is found in the set, it indicates a duplicate, and the function returns `True`. Otherwise, it adds the element to the set and continues. The test cases at the end verify the correctness of the function."}
{"task_id": "Mbpp/20", "solution": "Certainly! A Woodall number is defined as a number of the form \\( n \\times 2^n - 1 \\), where \\( n \\) is a positive integer. To determine if a given number is a Woodall number, we need to find an integer \\( n \\) such that this equation holds true.\n\nHere's a Python function to check if a given number is a Woodall number:\n\n```python\ndef is_woodall(num):\n \"\"\"\n Check if the given number is a Woodall number.\n \n A Woodall number is of the form n * 2^n - 1 for some positive integer n.\n \n Args:\n num (int): The number to check.\n \n Returns:\n bool: True if the number is a Woodall number, False otherwise.\n \"\"\"\n # Start with n = 1 and incrementally test each value\n n = 1\n \n while True:\n woodall_number = n * (2 ** n) - 1\n \n # If we've exceeded or matched the given number, break out of the loop\n if woodall_number > num:\n break\n \n # Check if the current Woodall number matches the input number\n if woodall_number == num:\n return True\n \n # Increment n for the next iteration\n n += 1\n \n # If no matching Woodall number was found, return False\n return False\n\n# Test case\nassert is_woodall(383) == True\n```\n\n### Explanation:\n\n- **Loop through potential values of \\( n \\):** We start with \\( n = 1 \\) and calculate the corresponding Woodall number using the formula \\( n \\times 2^n - 1 \\).\n \n- **Check conditions:** For each calculated Woodall number:\n - If it matches the given `num`, return `True`.\n - If it exceeds the given `num`, break out of the loop since further values will only increase.\n\n- **Return False if no match is found:** After exiting the loop, if no matching Woodall number was found, return `False`.\n\nThis function efficiently checks for Woodall numbers by leveraging the properties of their mathematical definition."}
{"task_id": "Mbpp/56", "solution": "Certainly! Below is a self-contained Python script that defines a function `check` to determine if a given number is one less than twice its reverse. The function includes an assertion for the provided test case.\n\n```python\ndef reverse_number(n):\n \"\"\"Helper function to reverse the digits of a number.\"\"\"\n return int(str(n)[::-1])\n\ndef check(number):\n \"\"\"\n Check if a given number is one less than twice its reverse.\n \n Args:\n number (int): The number to be checked.\n \n Returns:\n bool: True if the condition is met, False otherwise.\n \"\"\"\n reversed_number = reverse_number(number)\n return number == 2 * reversed_number - 1\n\n# Test case\nassert check(70) == False\n```\n\n### Explanation:\n\n- **`reverse_number(n)`**: This helper function takes an integer `n`, converts it to a string, reverses the string, and then converts it back to an integer.\n\n- **`check(number)`**: This function checks if the given number satisfies the condition: `number == 2 * reversed_number - 1`. It uses the `reverse_number` function to get the reverse of the input number.\n\n- The assertion `assert check(70) == False` verifies that for the input `70`, the function correctly returns `False`, as `70` is not one less than twice its reverse (`07`)."}
{"task_id": "Mbpp/57", "solution": "```markdown\nTo solve this problem, we need to create a Python function `find_Max_Num` that takes a list of single-digit integers and returns the largest possible number that can be formed by rearranging these digits. Here's how you can implement it:\n\n1. **Convert Digits to Strings**: Since we want to arrange the digits in descending order to form the largest number, it is easier to work with strings.\n\n2. **Sort the String Representations**: Sort the list of string representations of the digits in descending order.\n\n3. **Join and Convert Back to Integer**: Join the sorted list into a single string and then convert this string back to an integer.\n\nHere's the implementation:\n\n```python\ndef find_Max_Num(digits):\n # Convert each digit to a string\n str_digits = [str(digit) for digit in digits]\n \n # Sort the string representations of the digits in descending order\n str_digits.sort(reverse=True)\n \n # Join them into one string and convert back to an integer\n largest_number = int(''.join(str_digits))\n \n return largest_number\n\n# Test case\nassert find_Max_Num([1, 2, 3]) == 321\n```\n\n### Explanation:\n\n- **Conversion**: We first convert each digit in the list to a string. This allows us to use Python's sorting capabilities on them.\n \n- **Sorting**: By sorting these strings in reverse order (i.e., descending), we ensure that the largest digits appear at the front of the number.\n\n- **Joining and Conversion**: After sorting, we join all the string digits into one single string. Finally, converting this string back to an integer gives us the desired result.\n\nThis approach efficiently constructs the largest possible number from a list of digits by leveraging Python's built-in sorting functionality.\n```"}
{"task_id": "Mbpp/58", "solution": "Certainly! Below is a self-contained Python script that defines a function `opposite_signs` to determine if two integers have opposite signs. The function uses assertions to verify its correctness.\n\n```python\ndef opposite_signs(a, b):\n \"\"\"\n Check whether the given two integers have opposite signs.\n \n Parameters:\n a (int): First integer\n b (int): Second integer\n \n Returns:\n bool: True if the integers have opposite signs, False otherwise.\n \"\"\"\n # Two numbers have opposite signs if their product is negative\n return (a < 0) != (b < 0)\n\n# Test cases to verify the function works as expected\nassert opposite_signs(1, -2) == True, \"Test case 1 failed\"\nassert opposite_signs(-3, 4) == True, \"Test case 2 failed\"\nassert opposite_signs(5, -6) == True, \"Test case 3 failed\"\nassert opposite_signs(-7, -8) == False, \"Test case 4 failed\"\nassert opposite_signs(9, 10) == False, \"Test case 5 failed\"\n\nprint(\"All test cases passed!\")\n```\n\n### Explanation:\n- The function `opposite_signs` takes two integers as input.\n- It checks if one number is negative and the other is non-negative (or vice versa).\n- This is done using the expression `(a < 0) != (b < 0)`, which evaluates to `True` if exactly one of the numbers is negative, indicating opposite signs.\n- The function returns `True` if they have opposite signs and `False` otherwise.\n\nThe script includes several test cases with assertions to ensure the function behaves as expected. If all tests pass, it prints \"All test cases passed!\"."}
{"task_id": "Mbpp/59", "solution": "```markdown\nTo solve the problem of finding the nth octagonal number, we need to understand what an octagonal number is. An octagonal number represents a pattern that can be visualized as an octagon with dots. The formula for calculating the nth octagonal number is:\n\n\\[ O(n) = 3n^2 - 2n \\]\n\nWhere \\( n \\) is the position in the sequence of octagonal numbers.\n\nHere's how you can implement this in Python:\n\n```python\ndef find_nth_octagonal_number(n):\n \"\"\"\n Calculate the nth octagonal number using the formula:\n O(n) = 3n^2 - 2n\n\n Parameters:\n n (int): The position in the sequence of octagonal numbers.\n\n Returns:\n int: The nth octagonal number.\n \"\"\"\n return 3 * n**2 - 2 * n\n\ndef is_octagonal(x):\n \"\"\"\n Check if a given number x is an octagonal number by solving\n the quadratic equation derived from O(n) = x for n.\n\n Parameters:\n x (int): The number to check.\n\n Returns:\n bool: True if x is an octagonal number, False otherwise.\n \"\"\"\n # Solve 3n^2 - 2n - x = 0 using the quadratic formula\n # a = 3, b = -2, c = -x\n a = 3\n b = -2\n c = -x\n\n # Calculate the discriminant\n discriminant = b**2 - 4 * a * c\n\n if discriminant < 0:\n return False\n\n # Calculate the two possible solutions for n\n sqrt_discriminant = discriminant**0.5\n n1 = (-b + sqrt_discriminant) / (2 * a)\n n2 = (-b - sqrt_discriminant) / (2 * a)\n\n # Check if either solution is a positive integer\n return n1.is_integer() and n1 > 0 or n2.is_integer() and n2 > 0\n\n# Example usage:\nassert find_nth_octagonal_number(5) == 65\nassert is_octagonal(65) == True\n```\n\n### Explanation:\n\n- **find_nth_octagonal_number(n):** This function calculates the nth octagonal number using the formula \\( O(n) = 3n^2 - 2n \\).\n\n- **is_octagonal(x):** This function checks if a given number is an octagonal number. It does this by solving the quadratic equation derived from setting \\( O(n) = x \\). The discriminant of the quadratic equation helps determine if there are real solutions, and we check if any solution is a positive integer.\n\n- **Example Usage:** We use assertions to verify that the 5th octagonal number is indeed 65 and that 65 is an octagonal number."}
{"task_id": "Mbpp/61", "solution": "Certainly! Below is a self-contained Python script that solves the given problem. The function `count_substrings` takes a string as input and returns the number of substrings where the sum of the digits equals the length of the substring.\n\n```python\ndef count_substrings(s):\n def digit_sum(substring):\n return sum(int(char) for char in substring)\n \n n = len(s)\n count = 0\n \n # Iterate over all possible starting points of substrings\n for start in range(n):\n current_sum = 0\n \n # Iterate over all possible ending points of substrings\n for end in range(start, n):\n current_sum += int(s[end])\n \n # Check if the sum of digits equals the length of the substring\n if current_sum == (end - start + 1):\n count += 1\n \n return count\n\n# Test case\nassert count_substrings('112112') == 6\n```\n\n### Explanation:\n\n1. **digit_sum Function**: This helper function calculates the sum of digits in a given substring.\n\n2. **Main Logic**:\n - We iterate over all possible starting indices `start` for substrings.\n - For each starting index, we initialize `current_sum` to 0.\n - We then iterate over all possible ending indices `end` for substrings starting at `start`.\n - As we extend the substring by including more characters, we update `current_sum` by adding the integer value of the current character.\n - After updating `current_sum`, we check if it equals the length of the current substring `(end - start + 1)`.\n - If they are equal, we increment our count.\n\n3. **Test Case**: The provided test case checks that the function correctly identifies 6 substrings in `'112112'` where the sum of digits equals their length.\n\nThis solution efficiently counts all valid substrings by iterating through each possible substring and checking the required condition."}
{"task_id": "Mbpp/62", "solution": "```markdown\nHere's a Python script that defines a function `smallest_num` to find the smallest number in a given list. The function uses Python's built-in `min()` function for simplicity and efficiency.\n\n```python\ndef smallest_num(numbers):\n \"\"\"\n This function takes a list of numbers as input and returns the smallest number.\n \n Parameters:\n numbers (list): A list of integers or floats.\n \n Returns:\n int/float: The smallest number in the list.\n \n Raises:\n ValueError: If the input list is empty.\n \"\"\"\n if not numbers:\n raise ValueError(\"The list cannot be empty.\")\n \n return min(numbers)\n\n# Test case\nassert smallest_num([10, 20, 1, 45, 99]) == 1\n\nprint(\"Test passed!\")\n```\n\n### Explanation:\n\n- **Function Definition**: The function `smallest_num` takes a single argument `numbers`, which is expected to be a list of numbers (integers or floats).\n\n- **Error Handling**: Before attempting to find the smallest number, the function checks if the input list is empty. If it is, a `ValueError` is raised with an appropriate message.\n\n- **Finding the Smallest Number**: The built-in `min()` function is used to determine and return the smallest number in the list.\n\n- **Test Case**: An assertion is included to verify that the function works correctly for the provided test case. If the function returns the expected result, it prints \"Test passed!\" indicating success.\n```\n\nThis script ensures robustness by handling edge cases such as an empty input list and provides a simple yet effective solution using Python's built-in capabilities."}
{"task_id": "Mbpp/63", "solution": "```markdown\nTo solve this problem, we need to write a function that calculates the maximum difference between pairs in a given list of tuples. Each tuple contains two numbers, and for each pair, we calculate the absolute difference between these two numbers. The goal is to find the largest such difference across all pairs.\n\nHere's how you can implement this:\n\n```python\ndef max_difference(pairs):\n # Initialize a variable to keep track of the maximum difference found\n max_diff = 0\n \n # Iterate over each pair in the list\n for a, b in pairs:\n # Calculate the absolute difference between the two numbers in the current pair\n diff = abs(a - b)\n \n # Update max_diff if the current difference is greater than the previously recorded maximum\n if diff > max_diff:\n max_diff = diff\n \n return max_diff\n\n# Test case to verify the function works as expected\nassert max_difference([(3, 5), (1, 7), (10, 3), (1, 2)]) == 7\n```\n\n### Explanation:\n\n- **Initialization**: We start by initializing `max_diff` to zero. This variable will store the maximum difference found during our iteration over the pairs.\n\n- **Iteration and Calculation**: For each tuple `(a, b)` in the list:\n - Compute the absolute difference using `abs(a - b)`.\n - Compare this difference with `max_diff`. If it's larger, update `max_diff`.\n\n- **Return Result**: After checking all pairs, return `max_diff`, which now holds the maximum difference found.\n\nThis approach ensures that we efficiently find the largest difference by only iterating through the list once, resulting in a time complexity of O(n), where n is the number of tuples."}
{"task_id": "Mbpp/64", "solution": "Certainly! Below is a self-contained Python script that defines the function `subject_marks` to sort a list of tuples based on the second value in each tuple. The script also includes an assertion to verify the correctness of the implementation.\n\n```python\ndef subject_marks(subjects):\n \"\"\"\n Sorts a list of tuples based on the second element (marks) in each tuple.\n \n Parameters:\n subjects (list of tuples): A list where each tuple contains a subject name and its corresponding marks.\n \n Returns:\n list: The sorted list of tuples by marks in ascending order.\n \"\"\"\n # Sort the list using the second item of each tuple\n return sorted(subjects, key=lambda x: x[1])\n\n# Test case to verify the function works as expected\nassert subject_marks([('English', 88), ('Science', 90), ('Maths', 97), ('Social sciences', 82)]) == [\n ('Social sciences', 82), \n ('English', 88), \n ('Science', 90), \n ('Maths', 97)\n]\n\n# Additional test cases\nassert subject_marks([('History', 75), ('Geography', 85), ('Biology', 80)]) == [\n ('History', 75),\n ('Biology', 80),\n ('Geography', 85)\n]\n\nassert subject_marks([]) == [] # Test with an empty list\n\nprint(\"All tests passed!\")\n```\n\n### Explanation:\n- The function `subject_marks` takes a list of tuples as input. Each tuple contains a subject name and its corresponding marks.\n- It uses Python's built-in `sorted()` function, which sorts the list in place. The key for sorting is specified using a lambda function that extracts the second element (marks) from each tuple.\n- After defining the function, an assertion checks if the output matches the expected sorted order based on the marks.\n- Additional test cases are included to ensure robustness, such as handling an empty list.\n\nThis script will print \"All tests passed!\" if all assertions hold true."}
{"task_id": "Mbpp/65", "solution": "Certainly! Below is a self-contained Python script that defines a function to flatten a nested list and then sums all of its elements. The function uses recursion to handle lists within lists.\n\n```python\ndef recursive_list_sum(nested_list):\n \"\"\"\n This function takes a nested list as input and returns the sum of all its elements.\n \n Parameters:\n nested_list (list): A list that may contain integers or other lists\n \n Returns:\n int: The sum of all integer elements in the nested list\n \"\"\"\n total_sum = 0\n\n for element in nested_list:\n if isinstance(element, list):\n # If the element is a list, recursively call this function\n total_sum += recursive_list_sum(element)\n else:\n # Otherwise, add the element to the total sum\n total_sum += element\n \n return total_sum\n\n# Test case\nassert recursive_list_sum([1, 2, [3, 4], [5, 6]]) == 21\n```\n\n### Explanation:\n\n- **Function Definition**: The function `recursive_list_sum` takes a single argument `nested_list`, which is expected to be a list that may contain integers or other lists.\n\n- **Base Case and Recursive Case**:\n - We initialize `total_sum` to zero.\n - We iterate over each element in the input list.\n - If an element is itself a list, we recursively call `recursive_list_sum` on this sublist and add the result to `total_sum`.\n - If an element is not a list (i.e., it's an integer), we directly add it to `total_sum`.\n\n- **Return Value**: The function returns the total sum of all integers found in the nested structure.\n\n- **Test Case**: We use an assertion to verify that the function works correctly for the provided test case. The input `[1, 2, [3, 4], [5, 6]]` should result in a sum of `21`."}
{"task_id": "Mbpp/66", "solution": "```markdown\nHere's a Python function that counts the number of positive numbers in a given list:\n\n```python\ndef pos_count(lst):\n \"\"\"\n Count the number of positive numbers in a list.\n\n Parameters:\n lst (list): A list of integers.\n\n Returns:\n int: The count of positive numbers in the list.\n \"\"\"\n # Use a generator expression to filter and count positive numbers\n return sum(1 for num in lst if num > 0)\n\n# Test case\nassert pos_count([1, -2, 3, -4]) == 2\n```\n\n### Explanation:\n\n- The function `pos_count` takes a list of integers as input.\n- It uses a generator expression `(1 for num in lst if num > 0)` to iterate over each number in the list and yields `1` for every positive number (`num > 0`).\n- The `sum()` function then adds up all these `1`s, effectively counting how many positive numbers are present.\n- Finally, it returns this count.\n\nThe provided test case checks if the function correctly identifies that there are two positive numbers in the list `[1, -2, 3, -4]`."}
{"task_id": "Mbpp/67", "solution": "To solve this problem, we need to understand what Bell numbers are and how they relate to partitions. The \\( n \\)-th Bell number, denoted as \\( B_n \\), represents the number of ways to partition a set of \\( n \\) elements.\n\nFor example:\n- \\( B_0 = 1 \\): There is one way to partition an empty set.\n- \\( B_1 = 1 \\): There is one way to partition a set with one element.\n- \\( B_2 = 2 \\): A set with two elements can be partitioned in two ways: each element in its own subset, or both elements in the same subset.\n\nThe task requires us to write a function that calculates Bell numbers and verify it using an assertion. Here's how you can implement this:\n\n```python\ndef bell_number(n):\n \"\"\"\n Calculate the n-th Bell number.\n \n Parameters:\n n (int): The index of the Bell number to calculate.\n \n Returns:\n int: The n-th Bell number.\n \"\"\"\n # Create a 2D list to store intermediate results\n bell = [[0 for i in range(n+1)] for j in range(n+1)]\n \n # Base case: B_0 is 1\n bell[0][0] = 1\n \n # Fill the Bell triangle\n for i in range(1, n+1):\n # Explicitly set the first value of each row\n bell[i][0] = bell[i-1][i-1]\n \n # Fill the rest of the values using the recursive relation\n for j in range(1, i+1):\n bell[i][j] = bell[i-1][j-1] + bell[i][j-1]\n \n # The Bell number B_n is the first element of the nth row\n return bell[n][0]\n\n# Test the function with an assertion\nassert bell_number(2) == 2\n\n# Example usage:\nprint(bell_number(3)) # Output: 5\n```\n\n### Explanation:\n\n1. **Bell Triangle Construction**: We use a triangular array (similar to Pascal's triangle) to compute Bell numbers efficiently.\n \n2. **Base Case**: \\( B_0 = 1 \\), which is the starting point of our triangle.\n\n3. **Recursive Relation**:\n - The first element of each row in the Bell triangle is set as the last element of the previous row: `bell[i][0] = bell[i-1][i-1]`.\n - Each subsequent element in a row is computed using the relation: `bell[i][j] = bell[i-1][j-1] + bell[i][j-1]`.\n\n4. **Result**: The first element of the \\( n \\)-th row gives us the \\( n \\)-th Bell number.\n\nThis implementation efficiently computes Bell numbers and passes the given assertion test for \\( B_2 \\)."}
{"task_id": "Mbpp/68", "solution": "Certainly! Below is a self-contained Python script that defines a function `is_monotonic` to determine if an array is monotonic. A list is considered monotonic if it is either entirely non-increasing or non-decreasing.\n\n```python\ndef is_monotonic(arr):\n \"\"\"\n Check whether the given array is monotonic.\n \n An array is monotonic if it is either entirely non-increasing or non-decreasing.\n \n Parameters:\n arr (list): The list of integers to check for monotonicity.\n \n Returns:\n bool: True if the array is monotonic, False otherwise.\n \"\"\"\n # Check if the array has less than 2 elements\n if len(arr) < 2:\n return True\n \n # Determine if the array is non-decreasing or non-increasing\n increasing = decreasing = True\n \n for i in range(1, len(arr)):\n if arr[i] > arr[i - 1]:\n decreasing = False\n elif arr[i] < arr[i - 1]:\n increasing = False\n \n # If the array is neither increasing nor decreasing, return False\n if not increasing and not decreasing:\n return False\n \n return True\n\n# Test case\nassert is_monotonic([6, 5, 4, 4]) == True\n```\n\nThis function iterates through the list once, checking for both non-increasing and non-decreasing properties. If neither property holds throughout the list, it returns `False`. Otherwise, it returns `True`."}
{"task_id": "Mbpp/69", "solution": "```markdown\nHere's a Python script that defines a function `is_sublist` to determine if one list is a sublist of another. The function checks whether all elements of the given sublist appear in order within the main list.\n\n```python\ndef is_sublist(main_list, sub_list):\n \"\"\"\n Check if sub_list is a sublist of main_list.\n \n Parameters:\n - main_list: List where we need to check for the presence of sub_list.\n - sub_list: List that needs to be checked as a sublist within main_list.\n\n Returns:\n - True if sub_list is a sublist of main_list, False otherwise.\n \"\"\"\n # Lengths of both lists\n len_main = len(main_list)\n len_sub = len(sub_list)\n\n # If the sub_list is longer than the main_list, it can't be a sublist\n if len_sub > len_main:\n return False\n\n # Iterate over the main list to find a starting point for comparison\n for i in range(len_main - len_sub + 1):\n # Check if the slice of main_list matches sub_list\n if main_list[i:i+len_sub] == sub_list:\n return True\n \n # If no match is found, return False\n return False\n\n# Test case\nassert is_sublist([2,4,3,5,7],[3,7]) == False\n```\n\n### Explanation:\n\n1. **Function Definition**: The function `is_sublist` takes two arguments: `main_list` and `sub_list`.\n\n2. **Length Check**: It first checks if the length of `sub_list` is greater than `main_list`. If so, it immediately returns `False`, as a longer list cannot be a sublist of a shorter one.\n\n3. **Iterate Over Main List**: The function iterates over possible starting indices in `main_list` where `sub_list` could potentially fit.\n\n4. **Slice Comparison**: For each starting index, it checks if the slice of `main_list` from that index to the length of `sub_list` matches `sub_list`.\n\n5. **Return Result**: If a match is found, it returns `True`. If no match is found after checking all possible positions, it returns `False`.\n\n6. **Test Case**: The provided test case checks if `[3, 7]` is a sublist of `[2, 4, 3, 5, 7]`, which should return `False` since the elements are not contiguous in order.\n```"}
{"task_id": "Mbpp/70", "solution": "Certainly! Below is a self-contained Python script that defines a function `get_equal` to check if all given tuples have the same length. The function uses an assertion to verify its correctness with the provided example.\n\n```python\ndef get_equal(tuples_list):\n \"\"\"\n Check if all tuples in the list have the same length.\n \n Parameters:\n tuples_list (list of tuple): A list containing tuples.\n \n Returns:\n bool: True if all tuples have the same length, False otherwise.\n \"\"\"\n # Get the length of the first tuple\n if not tuples_list:\n return True # An empty list is considered to have equal lengths\n \n first_length = len(tuples_list[0])\n \n # Check each tuple in the list\n for t in tuples_list:\n if len(t) != first_length:\n return False\n \n return True\n\n# Test case\nassert get_equal([(11, 22, 33), (44, 55, 66)]) == True\n```\n\nThis script defines the `get_equal` function and includes a test case using an assertion to ensure that it works as expected. The function iterates through each tuple in the list and compares its length with the first tuple's length. If any tuple has a different length, it returns `False`; otherwise, it returns `True`."}
{"task_id": "Mbpp/71", "solution": "Certainly! Below is a self-contained Python script that implements the Comb Sort algorithm. This sorting algorithm improves upon Bubble Sort by using a gap to compare elements that are far apart initially and then reducing the gap until it becomes 1.\n\n```python\ndef comb_sort(arr):\n def getNextGap(gap):\n # Shrink gap by Shrink factor\n gap = (gap * 10) // 13\n if gap < 1:\n return 1\n return gap\n\n n = len(arr)\n gap = n\n swapped = True\n\n while gap != 1 or swapped:\n # Find next gap\n gap = getNextGap(gap)\n\n # Initialize swapped as false so that we can check if swap happened or not\n swapped = False\n\n for i in range(0, n - gap):\n # Compare elements with current gap\n if arr[i] > arr[i + gap]:\n arr[i], arr[i + gap] = arr[i + gap], arr[i]\n swapped = True\n\n return arr\n\n# Test the function\nassert comb_sort([5, 15, 37, 25, 79]) == [5, 15, 25, 37, 79]\n\nprint(\"Test passed!\")\n```\n\n### Explanation:\n\n1. **getNextGap Function**: This helper function calculates the next gap size using a shrink factor of approximately 1.3 (i.e., `gap = (gap * 10) // 13`). The gap is reduced until it becomes 1.\n\n2. **Main Loop**: \n - The loop continues as long as the gap is greater than 1 or any swaps have occurred in the last pass.\n - For each iteration, the gap is updated using `getNextGap`.\n - Elements are compared and swapped if they are out of order with respect to the current gap.\n\n3. **Swapping**: If a swap occurs during an iteration, the `swapped` flag is set to `True`, ensuring that the loop continues until no swaps are needed.\n\n4. **Test Case**: The function is tested with the provided list `[5, 15, 37, 25, 79]`, and it should return the sorted list `[5, 15, 25, 37, 79]`.\n\nThis script will print \"Test passed!\" if the sorting works correctly."}
{"task_id": "Mbpp/72", "solution": "Certainly! To determine if a number \\( n \\) can be expressed as the difference of two squares, we need to find integers \\( a \\) and \\( b \\) such that:\n\n\\[ n = a^2 - b^2 \\]\n\nThis equation can be rewritten using the identity for the difference of squares:\n\n\\[ n = (a + b)(a - b) \\]\n\nFor \\( n \\) to be expressed as the product of two integers, both \\( a+b \\) and \\( a-b \\), there are some conditions we need to consider:\n\n1. If \\( n \\) is odd, it can always be represented as the difference of two squares. This is because any odd number can be written as the product of two numbers with the same parity (both odd).\n\n2. If \\( n \\) is even, it can only be expressed as the difference of two squares if it is divisible by 4. This is because for even \\( n = 2k \\), both \\( a+b \\) and \\( a-b \\) must also be even to ensure their product is even, which implies that \\( n/2 \\) itself must be even (i.e., \\( n \\) must be divisible by 4).\n\nWith these observations in mind, we can write the function `dif_Square`:\n\n```python\ndef dif_Square(n):\n # If n is odd or a multiple of 4, it can be expressed as the difference of two squares.\n return n % 2 != 0 or n % 4 == 0\n\n# Test cases\nassert dif_Square(5) == True # 5 = 3^2 - 2^2\nassert dif_Square(8) == False # 8 cannot be expressed as the difference of two squares\nassert dif_Square(9) == True # 9 = 5^2 - 4^2\nassert dif_Square(16) == True # 16 = 5^2 - 3^2\n```\n\nThis function checks if \\( n \\) is odd or a multiple of 4, and returns `True` if either condition is met, indicating that \\( n \\) can be represented as the difference of two squares. Otherwise, it returns `False`."}
{"task_id": "Mbpp/74", "solution": "Certainly! Below is a self-contained Python script that defines a function `is_samepatterns` to solve the problem described. The function checks if two lists follow the same sequence pattern.\n\n```python\ndef is_samepatterns(seq1, seq2):\n \"\"\"\n Check if two sequences follow the same pattern.\n \n Args:\n seq1 (list): First list of elements.\n seq2 (list): Second list of elements to compare with the first one.\n \n Returns:\n bool: True if both lists follow the same sequence pattern, False otherwise.\n \"\"\"\n # Check if lengths are different\n if len(seq1) != len(seq2):\n return False\n \n # Create a mapping from seq1 to seq2 and vice versa\n map_seq1_to_seq2 = {}\n map_seq2_to_seq1 = {}\n \n for item1, item2 in zip(seq1, seq2):\n # Check if there's an inconsistency in the mapping\n if (item1 in map_seq1_to_seq2 and map_seq1_to_seq2[item1] != item2) or \\\n (item2 in map_seq2_to_seq1 and map_seq2_to_seq1[item2] != item1):\n return False\n \n # Create a new mapping\n map_seq1_to_seq2[item1] = item2\n map_seq2_to_seq1[item2] = item1\n \n return True\n\n# Example usage:\nassert is_samepatterns([\"red\", \"green\", \"green\"], [\"a\", \"b\", \"b\"]) == True\n```\n\n### Explanation:\n\n- **Length Check**: First, the function checks if both sequences have the same length. If not, they cannot follow the same pattern.\n\n- **Mapping Creation**: Two dictionaries are used to map elements from `seq1` to `seq2` and vice versa. This ensures that each element in one sequence consistently maps to a unique element in the other sequence.\n\n- **Consistency Check**: As we iterate through paired elements of both sequences, we check if there is any inconsistency in the mapping. If an element has already been mapped differently, the function returns `False`.\n\n- **Return Result**: If no inconsistencies are found, the sequences follow the same pattern, and the function returns `True`.\n\nThis approach ensures that the sequences maintain a consistent one-to-one correspondence between their elements."}
{"task_id": "Mbpp/75", "solution": "Certainly! Below is a self-contained Python script that solves the problem of finding tuples where all elements are divisible by a given integer \\( k \\).\n\n```python\ndef find_tuples(tuples_list, k):\n \"\"\"\n This function takes a list of tuples and an integer k.\n It returns a new list containing only those tuples where every element is divisible by k.\n\n :param tuples_list: List of tuples to be checked\n :param k: The divisor\n :return: A list of tuples with all elements divisible by k\n \"\"\"\n result = []\n \n for tup in tuples_list:\n # Check if all elements in the tuple are divisible by k\n if all(element % k == 0 for element in tup):\n result.append(tup)\n \n return result\n\n# Test case to verify the function works as expected\nassert find_tuples([(6, 24, 12), (7, 9, 6), (12, 18, 21)], 6) == [(6, 24, 12)]\n```\n\n### Explanation:\n\n- **Function Definition**: The `find_tuples` function takes two parameters: a list of tuples (`tuples_list`) and an integer \\( k \\).\n\n- **Result Initialization**: An empty list `result` is initialized to store the tuples that meet the criteria.\n\n- **Iteration Over Tuples**: We iterate over each tuple in the input list.\n\n- **Divisibility Check**: For each tuple, we use a generator expression within the `all()` function to check if every element in the tuple is divisible by \\( k \\). The condition `element % k == 0` checks for divisibility.\n\n- **Appending Valid Tuples**: If all elements of a tuple are divisible by \\( k \\), that tuple is appended to the `result` list.\n\n- **Return Statement**: Finally, the function returns the `result` list containing only those tuples where every element is divisible by \\( k \\).\n\n- **Assertion for Testing**: An assertion is used to test the function with a specific input and expected output. This ensures that the function behaves as intended."}
{"task_id": "Mbpp/77", "solution": "Certainly! Below is a self-contained Python script that defines a function `is_divisible_by_11` to determine if a given number is divisible by 11. The function uses the rule for divisibility by 11, which involves alternating sums of the digits.\n\n```python\ndef is_divisible_by_11(n):\n \"\"\"\n Check if a number n is divisible by 11.\n \n Args:\n n (int): The number to check.\n \n Returns:\n bool: True if n is divisible by 11, False otherwise.\n \"\"\"\n # Convert the number to string for easy digit manipulation\n num_str = str(n)\n \n # Initialize sums for alternating digits\n odd_sum = 0\n even_sum = 0\n \n # Iterate over each character in the string representation of the number\n for i, char in enumerate(num_str):\n digit = int(char)\n \n if (i + 1) % 2 == 0:\n even_sum += digit\n else:\n odd_sum += digit\n \n # Calculate the difference between the sums\n diff = abs(odd_sum - even_sum)\n \n # A number is divisible by 11 if this difference is a multiple of 11\n return diff % 11 == 0\n\n# Test case\nassert is_divisible_by_11(12345) == False\n```\n\n### Explanation:\n- **String Conversion**: The number is converted to a string to easily access each digit.\n- **Alternating Sums**: We maintain two sums, `odd_sum` and `even_sum`, for digits at odd and even positions respectively (1-based index).\n- **Difference Calculation**: Compute the absolute difference between these sums.\n- **Divisibility Check**: If this difference is divisible by 11, then the original number is divisible by 11.\n\nThis function should correctly determine if a number is divisible by 11 based on the given rule."}
{"task_id": "Mbpp/79", "solution": "Certainly! Below is a self-contained Python script that defines a function `word_len` to determine if the length of a given word is odd. It also includes an assertion to verify its functionality.\n\n```markdown\n```python\ndef word_len(word):\n \"\"\"\n Check whether the length of the word is odd or not.\n \n Parameters:\n word (str): The input string whose length is to be checked.\n \n Returns:\n bool: False if the length is even, True if the length is odd.\n \"\"\"\n # Calculate the length of the word\n length = len(word)\n \n # Check if the length is odd\n return length % 2 != 0\n\n# Test case to verify the function works as expected\nassert word_len(\"Hadoop\") == False, \"Test failed: 'Hadoop' should be even\"\n```\n```\n\nThis script defines a function `word_len` that takes a string input and returns `False` if its length is even (i.e., not odd) and `True` otherwise. The assertion checks the function with the word \"Hadoop\", which has an even length, so it should return `False`."}
{"task_id": "Mbpp/80", "solution": "```markdown\nTo solve the problem of finding the nth tetrahedral number, we need to understand what a tetrahedral number is. A tetrahedral number or triangular pyramidal number represents a pyramid with a triangular base and three sides, akin to the shape of a tetrahedron.\n\nThe formula for the nth tetrahedral number \\( T_n \\) is given by:\n\n\\[\nT_n = \\frac{n(n+1)(n+2)}{6}\n\\]\n\nThis formula can be derived from summing up triangular numbers. The nth triangular number is given by \\( \\frac{n(n+1)}{2} \\), and the nth tetrahedral number is the sum of the first n triangular numbers.\n\nHere's a Python function to compute the nth tetrahedral number:\n\n```python\ndef tetrahedral_number(n):\n \"\"\"\n Calculate the nth tetrahedral number.\n \n Parameters:\n n (int): The position in the sequence of tetrahedral numbers.\n \n Returns:\n int: The nth tetrahedral number.\n \"\"\"\n return n * (n + 1) * (n + 2) // 6\n\n# Test case\nassert tetrahedral_number(5) == 35\n```\n\n### Explanation:\n\n- **Formula**: We use the formula \\( T_n = \\frac{n(n+1)(n+2)}{6} \\).\n- **Integer Division**: The `//` operator is used for integer division to ensure the result is an integer.\n- **Test Case**: The function is tested with `assert tetrahedral_number(5) == 35`, which confirms that the fifth tetrahedral number is indeed 35.\n\nThis implementation efficiently calculates the nth tetrahedral number using a direct mathematical formula."}
{"task_id": "Mbpp/82", "solution": "Certainly! Below is a self-contained Python script that defines a function to calculate the volume of a sphere and includes an assertion to verify its correctness.\n\n```markdown\n```python\nimport math\n\ndef volume_sphere(radius):\n \"\"\"\n Calculate the volume of a sphere given its radius.\n \n Parameters:\n radius (float): The radius of the sphere.\n \n Returns:\n float: The volume of the sphere.\n \"\"\"\n # Volume formula for a sphere: V = 4/3 * \u03c0 * r^3\n return (4.0 / 3.0) * math.pi * (radius ** 3)\n\n# Test case to verify the function's correctness\nassert math.isclose(volume_sphere(10), 4188.790204786391, rel_tol=0.001)\n```\n```\n\nThis script imports the `math` module for access to mathematical constants and functions. The `volume_sphere` function calculates the volume using the formula \\( V = \\frac{4}{3} \\pi r^3 \\). The assertion checks if the calculated volume is close enough to the expected value, allowing a relative tolerance of 0.001."}
{"task_id": "Mbpp/84", "solution": "```markdown\n```python\ndef sequence(n):\n if n < 1:\n raise ValueError(\"n must be a positive integer.\")\n \n # Initialize the sequence with base cases\n seq = [0] * (n + 1)\n seq[1], seq[2] = 1, 1\n \n for i in range(3, n + 1):\n seq[i] = seq[seq[i - 1]] + seq[i - seq[i - 1]]\n \n return seq[n]\n\n# Test case\nassert sequence(10) == 6\n```\n```"}
{"task_id": "Mbpp/85", "solution": "Certainly! Below is a self-contained Python script that defines a function to calculate the surface area of a sphere and includes an assertion to verify its correctness.\n\n```markdown\n```python\nimport math\n\ndef surfacearea_sphere(radius):\n \"\"\"\n Calculate the surface area of a sphere given its radius.\n \n Parameters:\n radius (float): The radius of the sphere.\n \n Returns:\n float: The surface area of the sphere.\n \"\"\"\n # Surface area formula for a sphere is 4 * pi * r^2\n return 4 * math.pi * radius ** 2\n\n# Test case to verify the function's correctness\nassert math.isclose(surfacearea_sphere(10), 1256.6370614359173, rel_tol=0.001)\n\nprint(\"The surface area of a sphere with radius 10 is:\", surfacearea_sphere(10))\n```\n```\n\nThis script imports the `math` module to access the value of \u03c0 (`math.pi`) and uses it in the formula for calculating the surface area of a sphere: \\(4 \\pi r^2\\). The function `surfacearea_sphere` takes one parameter, `radius`, and returns the computed surface area. An assertion is included to ensure that the calculated surface area for a radius of 10 matches the expected value within a relative tolerance of 0.001."}
{"task_id": "Mbpp/86", "solution": "```markdown\nTo solve the problem of finding the nth centered hexagonal number, we need to understand what a centered hexagonal number is. A centered hexagonal number represents a pattern where each layer around a central point forms a hexagon. The formula for calculating the nth centered hexagonal number is:\n\n\\[ CH_n = 3n(n - 1) + 1 \\]\n\nWhere:\n- \\( n \\) is the position in the sequence (starting from 1).\n- \\( CH_n \\) is the nth centered hexagonal number.\n\nThe formula can be derived by considering that each new layer adds a hexagon around the previous layers, and the total number of points added at each step forms an arithmetic progression.\n\nHere's how you can implement this in Python:\n\n```python\ndef centered_hexagonal_number(n):\n \"\"\"\n Calculate the nth centered hexagonal number.\n \n :param n: The position in the sequence (1-based index).\n :return: The nth centered hexagonal number.\n \"\"\"\n return 3 * n * (n - 1) + 1\n\n# Test case\nassert centered_hexagonal_number(10) == 271\n```\n\n### Explanation:\n\n- **Formula**: We use the formula \\( CH_n = 3n(n - 1) + 1 \\).\n - The term \\( 3n(n - 1) \\) calculates the number of points added by all layers except the central point.\n - Adding 1 accounts for the central point itself.\n\n- **Function**: `centered_hexagonal_number(n)` takes an integer \\( n \\) and returns the nth centered hexagonal number using the formula.\n\n- **Test Case**: We verify that the function works correctly by asserting that the 10th centered hexagonal number is 271, as expected."}
{"task_id": "Mbpp/87", "solution": "```markdown\nHere's a Python script that defines a function to merge three dictionaries into a single dictionary. The function handles key conflicts by keeping the value from the last dictionary in which the key appears.\n\n```python\ndef merge_dictionaries_three(dict1, dict2, dict3):\n \"\"\"\n Merges three dictionaries into one.\n \n In case of key conflicts, the value from the last dictionary with that key is used.\n \n Args:\n - dict1: First dictionary to merge.\n - dict2: Second dictionary to merge.\n - dict3: Third dictionary to merge.\n \n Returns:\n A single merged dictionary.\n \"\"\"\n # Start by copying all items from the first dictionary\n merged_dict = dict1.copy()\n \n # Update with items from the second dictionary\n merged_dict.update(dict2)\n \n # Finally, update with items from the third dictionary\n merged_dict.update(dict3)\n \n return merged_dict\n\n# Test case to verify the function works as expected\nassert merge_dictionaries_three(\n { \"R\": \"Red\", \"B\": \"Black\", \"P\": \"Pink\" }, \n { \"G\": \"Green\", \"W\": \"White\" },\n { \"O\": \"Orange\", \"W\": \"White\", \"B\": \"Black\" }\n) == {'B': 'Black', 'R': 'Red', 'P': 'Pink', 'G': 'Green', 'W': 'White', 'O': 'Orange'}\n\nprint(\"Test passed!\")\n```\n\n### Explanation:\n\n1. **Function Definition**: The function `merge_dictionaries_three` takes three dictionaries as input.\n\n2. **Copying and Updating**:\n - It starts by creating a copy of the first dictionary to avoid modifying it directly.\n - Then, it updates this copy with the second dictionary using the `update()` method. This means any key in `dict2` that already exists in `merged_dict` will overwrite the existing value.\n - Finally, it updates the result again with the third dictionary. Again, keys from `dict3` will overwrite any existing keys.\n\n3. **Handling Key Conflicts**: The approach ensures that if a key appears in multiple dictionaries, the value from the last dictionary containing that key is used.\n\n4. **Test Case**: An assertion checks that the function produces the expected output when merging the provided dictionaries. If the test passes, it prints \"Test passed!\".\n```\n\nThis script provides a clear and concise solution to merge three dictionaries while handling potential key conflicts appropriately."}
{"task_id": "Mbpp/88", "solution": "Certainly! Below is a self-contained Python script that defines the function `freq_count` to calculate the frequency of all elements in a list and returns it as a dictionary. The script also includes an assertion to verify its correctness.\n\n```markdown\n```python\ndef freq_count(lst):\n \"\"\"\n Calculate the frequency of each element in the given list.\n \n Parameters:\n lst (list): A list of integers or other hashable items.\n \n Returns:\n dict: A dictionary with elements as keys and their frequencies as values.\n \"\"\"\n frequency = {}\n for item in lst:\n if item in frequency:\n frequency[item] += 1\n else:\n frequency[item] = 1\n return frequency\n\n# Test the function with an assertion\nassert freq_count([10, 10, 10, 10, 20, 20, 20, 20, 40, 40, 50, 50, 30]) == {10: 4, 20: 4, 40: 2, 50: 2, 30: 1}\n```\n```\n\nThis script defines the `freq_count` function which iterates over each element in the input list. It uses a dictionary to keep track of how many times each element appears. If an element is already in the dictionary, it increments its count; otherwise, it adds the element with a count of one. The assertion at the end checks that the function works as expected for the provided test case."}
{"task_id": "Mbpp/89", "solution": "```markdown\n```python\ndef closest_smaller_number(n):\n \"\"\"\n This function finds the closest smaller number than the given integer `n`.\n \n Parameters:\n n (int): The input number for which we need to find the closest smaller number.\n \n Returns:\n int: The closest smaller number than `n`. If no such number exists, returns None.\n \"\"\"\n if n <= 0:\n return None\n return n - 1\n\n# Test case\nassert closest_smaller_number(11) == 10\n```\n```"}
{"task_id": "Mbpp/90", "solution": "Certainly! Below is a self-contained Python script that defines a function to find the length of the longest word in a list. It also includes an assertion to verify its correctness.\n\n```markdown\n```python\ndef len_longest_word(words):\n \"\"\"\n This function takes a list of words and returns the length of the longest word.\n \n :param words: List of strings\n :return: Integer representing the length of the longest word\n \"\"\"\n if not words:\n return 0\n \n max_length = 0\n for word in words:\n if len(word) > max_length:\n max_length = len(word)\n \n return max_length\n\n# Test case to verify the function works as expected\nassert len_longest_word([\"python\", \"PHP\", \"bigdata\"]) == 7\n```\n```\n\nThis script defines a function `len_longest_word` that iterates through each word in the list, checks its length, and keeps track of the maximum length found. The assertion at the end ensures that the function returns the correct result for the given test case."}
{"task_id": "Mbpp/91", "solution": "Certainly! Below is a self-contained Python script that defines the `find_substring` function. This function checks if a given substring is present in any of the strings within a list.\n\n```python\ndef find_substring(string_list, substring):\n \"\"\"\n Check if a substring is present as a part of any string in the provided list.\n \n Parameters:\n - string_list: List[str] : A list of strings to search through.\n - substring: str : The substring to look for within the list elements.\n\n Returns:\n - bool : True if the substring is found, False otherwise.\n \"\"\"\n # Iterate over each string in the list\n for s in string_list:\n # Check if the current string contains the substring\n if substring in s:\n return True\n # If no string contained the substring, return False\n return False\n\n# Test case to verify the function works as expected\nassert find_substring([\"red\", \"black\", \"white\", \"green\", \"orange\"], \"ack\") == True\n```\n\n### Explanation:\n\n- **Function Definition**: The `find_substring` function takes two parameters: a list of strings (`string_list`) and a substring to search for (`substring`).\n\n- **Iteration**: It iterates over each string in the provided list.\n\n- **Substring Check**: For each string, it checks if the substring is present using Python's `in` operator. If found, it returns `True`.\n\n- **Return False**: If the loop completes without finding the substring in any of the strings, the function returns `False`.\n\n- **Assertion**: The provided test case uses an assertion to ensure that the function behaves as expected when searching for \"ack\" within the list `[\"red\", \"black\", \"white\", \"green\", \"orange\"]`. Since \"ack\" is part of \"black\", the result should be `True`."}
{"task_id": "Mbpp/92", "solution": "Certainly! Below is a self-contained Python script that defines a function `is_undulating` to determine if a given number is an undulating number. An undulating number is defined as a number with at least three digits where every two consecutive digits are different, and the pattern of these two digits repeats throughout the number.\n\n```python\ndef is_undulating(number):\n \"\"\"\n Check whether the given number is undulating or not.\n \n Args:\n number (int): The number to check.\n \n Returns:\n bool: True if the number is undulating, False otherwise.\n \"\"\"\n # Convert the number to a string for easy manipulation\n num_str = str(number)\n \n # An undulating number must have at least 3 digits\n if len(num_str) < 3:\n return False\n \n # Extract the first two digits\n first_digit, second_digit = num_str[0], num_str[1]\n \n # The first two digits must be different\n if first_digit == second_digit:\n return False\n \n # Check the repeating pattern of the first two digits throughout the number\n for i in range(2, len(num_str)):\n if (i % 2 == 0 and num_str[i] != first_digit) or (i % 2 == 1 and num_str[i] != second_digit):\n return False\n \n # If all checks pass, it's an undulating number\n return True\n\n# Test cases\nassert is_undulating(1212121) == True\nassert is_undulating(232323) == True\nassert is_undulating(123123) == False\nassert is_undulating(111) == False\nassert is_undulating(22) == False\n```\n\n### Explanation:\n- The function first converts the number to a string for easy digit manipulation.\n- It checks if the number has at least three digits, as an undulating number must have a repeating pattern of two different digits.\n- It ensures that the first two digits are different.\n- It then iterates through the rest of the digits, checking if they follow the alternating pattern established by the first two digits.\n- If all conditions are met, the function returns `True`, indicating the number is undulating; otherwise, it returns `False`."}
{"task_id": "Mbpp/93", "solution": "```markdown\nHere's a Python script that defines a function `power` to calculate the value of \\( a \\) raised to the power \\( b \\). The function uses recursion for this purpose. Additionally, an assertion is included to verify that the function works correctly.\n\n```python\ndef power(a, b):\n \"\"\"\n Calculate the value of 'a' raised to the power 'b'.\n \n Parameters:\n a (int or float): The base number.\n b (int): The exponent (must be a non-negative integer).\n \n Returns:\n int or float: The result of a^b.\n \"\"\"\n # Base case: any number to the power of 0 is 1\n if b == 0:\n return 1\n \n # Recursive case: multiply 'a' by the result of 'a' raised to the power 'b-1'\n return a * power(a, b - 1)\n\n# Test the function with an assertion\nassert power(3, 4) == 81\n\nprint(\"The function works correctly!\")\n```\n\n### Explanation:\n\n- **Base Case**: If \\( b \\) is 0, the result is 1 because any number raised to the power of 0 is 1.\n \n- **Recursive Case**: The function calls itself with \\( b - 1 \\), multiplying the base \\( a \\) each time until \\( b \\) reaches 0.\n\n- **Assertion**: `assert power(3, 4) == 81` checks that the function correctly computes \\( 3^4 = 81 \\).\n\nThis script will print \"The function works correctly!\" if the assertion passes. If there's an error in the logic, it will raise an AssertionError.\n```"}
{"task_id": "Mbpp/94", "solution": "```markdown\nHere's a self-contained Python script to solve the problem:\n\n```python\ndef index_minimum(tuples_list):\n # Find the tuple with the smallest second value using min function and key parameter\n min_tuple = min(tuples_list, key=lambda x: x[1])\n # Return the first element of that tuple\n return min_tuple[0]\n\n# Test case to verify the solution\nassert index_minimum([('Rash', 143), ('Manjeet', 200), ('Varsha', 100)]) == 'Varsha'\n```\n\n### Explanation:\n\n- The function `index_minimum` takes a list of tuples as input.\n- It uses Python's built-in `min` function to find the tuple with the smallest second value. The `key=lambda x: x[1]` part specifies that the comparison should be based on the second element of each tuple.\n- Once the tuple with the minimum second value is found, the function returns its first element.\n- An assertion is used to test the function with a given example to ensure it works correctly.\n\nThis script will output nothing if the assertion passes, indicating the solution is correct. If there's an error, it will raise an `AssertionError`.\n```"}
{"task_id": "Mbpp/95", "solution": "Certainly! Below is a self-contained Python script that defines a function `Find_Min_Length` which finds the length of the smallest list within a list of lists. The function includes an assertion to verify its correctness.\n\n```python\ndef Find_Min_Length(list_of_lists):\n \"\"\"\n This function takes a list of lists and returns the length of the shortest list.\n \n Parameters:\n list_of_lists (list): A list containing other lists as elements.\n \n Returns:\n int: The length of the smallest list in the input list of lists.\n \"\"\"\n # Initialize min_length with a large number\n min_length = float('inf')\n \n # Iterate over each sublist in the list of lists\n for sublist in list_of_lists:\n # Update min_length if the current sublist is shorter\n if len(sublist) < min_length:\n min_length = len(sublist)\n \n return min_length\n\n# Test case to verify the function works as expected\nassert Find_Min_Length([[1], [1, 2]]) == 1\n```\n\nThis script defines the `Find_Min_Length` function and includes an assertion to ensure it returns the correct result for a given test case. The function iterates through each sublist in the input list of lists, updating the minimum length found so far."}
{"task_id": "Mbpp/96", "solution": "Certainly! Below is a self-contained Python script that defines a function `divisor` which calculates the number of divisors for a given integer. The function iterates through possible divisors and counts how many times the input number can be evenly divided.\n\n```python\ndef divisor(n):\n \"\"\"\n Calculate the number of divisors of a given integer n.\n \n Args:\n n (int): The integer to find divisors for.\n \n Returns:\n int: The number of divisors of n.\n \"\"\"\n if n < 1:\n return 0\n \n count = 0\n # Iterate from 1 to the square root of n\n for i in range(1, int(n**0.5) + 1):\n if n % i == 0:\n # If divisors are equal, count only one\n if i * i == n:\n count += 1\n else:\n # Otherwise count both i and n/i\n count += 2\n \n return count\n\n# Test the function with an assertion\nassert divisor(15) == 4\n```\n\n### Explanation:\n\n- **Input Validation**: The function first checks if `n` is less than 1. If so, it returns 0 since there are no positive divisors for non-positive integers.\n\n- **Loop through Possible Divisors**: We loop from 1 to the square root of `n`. This is because a larger factor of `n` must be paired with a smaller factor that is less than or equal to its square root.\n\n- **Counting Divisors**:\n - If `i` divides `n` evenly (`n % i == 0`), then both `i` and `n/i` are divisors.\n - If `i * i == n`, it means `i` is a repeated divisor (like in the case of perfect squares), so we only count it once.\n\n- **Assertion**: The script includes an assertion to verify that the function works correctly for the input `15`, which has four divisors: 1, 3, 5, and 15."}
{"task_id": "Mbpp/97", "solution": "Here's a self-contained Python script that solves the problem of finding the frequency of each element in a flattened list of lists:\n\n```python\ndef frequency_lists(list_of_lists):\n \"\"\"\n This function takes a list of lists and returns a dictionary with the frequency \n of each element in the flattened list.\n \n :param list_of_lists: List[List[int]] - A list containing sublists of integers.\n :return: Dict[int, int] - A dictionary where keys are elements from the list and values are their frequencies.\n \"\"\"\n # Flatten the list of lists\n flat_list = [item for sublist in list_of_lists for item in sublist]\n \n # Create a frequency dictionary\n frequency_dict = {}\n for element in flat_list:\n if element in frequency_dict:\n frequency_dict[element] += 1\n else:\n frequency_dict[element] = 1\n \n return frequency_dict\n\n# Test the function with an assertion\nassert frequency_lists([[1, 2, 3, 2], [4, 5, 6, 2], [7, 8, 9, 5]]) == {1: 1, 2: 3, 3: 1, 4: 1, 5: 2, 6: 1, 7: 1, 8: 1, 9: 1}\n```\n\nThis script defines a function `frequency_lists` that takes a list of lists as input and returns a dictionary with the frequency of each element. It first flattens the list using a list comprehension and then iterates over the flattened list to count occurrences of each element, storing them in a dictionary. The assertion at the end verifies that the function works correctly for the given test case."}
{"task_id": "Mbpp/98", "solution": "Certainly! Below is a self-contained Python script that defines a function to multiply all numbers in a given list and then divide the result by the length of the list. The function also includes an assertion to verify its correctness.\n\n```python\nimport math\n\ndef multiply_num(numbers):\n \"\"\"\n Multiplies all numbers in the input tuple and divides the product by the length of the tuple.\n \n Parameters:\n numbers (tuple): A tuple containing numeric values.\n \n Returns:\n float: The result of multiplying all numbers and dividing by the length of the tuple.\n \"\"\"\n # Initialize the product to 1\n product = 1\n \n # Multiply each number in the tuple\n for num in numbers:\n product *= num\n \n # Divide the product by the length of the tuple\n result = product / len(numbers)\n \n return result\n\n# Test case with an assertion\nassert math.isclose(multiply_num((8, 2, 3, -1, 7)), -67.2, rel_tol=0.001)\n\nprint(\"The function works correctly.\")\n```\n\n### Explanation:\n- **Function Definition**: The `multiply_num` function takes a tuple of numbers as input.\n- **Product Calculation**: It initializes a variable `product` to 1 and iterates over each number in the tuple, multiplying them together.\n- **Division by Length**: After calculating the product, it divides this value by the length of the tuple to get the final result.\n- **Assertion**: The script includes an assertion using `math.isclose` to ensure that the function returns approximately `-67.2` for the input `(8, 2, 3, -1, 7)`, allowing a small relative tolerance (`rel_tol=0.001`) to account for floating-point arithmetic precision.\n- **Output**: If the assertion passes without raising an error, it prints \"The function works correctly.\""}
{"task_id": "Mbpp/99", "solution": "```markdown\nTo solve the problem of converting a decimal number to its binary equivalent without leading zeros, we can implement a function called `decimal_to_binary`. This function will take an integer as input and return a string representing its binary form.\n\nHere's how you can implement this:\n\n```python\ndef decimal_to_binary(n):\n # Handle the special case where n is 0\n if n == 0:\n return '0'\n \n # Initialize an empty list to store binary digits\n binary_digits = []\n \n # Convert the number to binary using division by 2\n while n > 0:\n remainder = n % 2\n binary_digits.append(str(remainder))\n n = n // 2\n \n # The binary digits are collected in reverse order, so we need to reverse them\n binary_digits.reverse()\n \n # Join the list into a string and return it\n return ''.join(binary_digits)\n\n# Test case\nassert decimal_to_binary(8) == '1000'\n```\n\n### Explanation:\n\n1. **Special Case for Zero**: If the input number `n` is 0, we directly return `'0'`, as its binary representation is also 0.\n\n2. **Binary Conversion Process**:\n - We use a loop to repeatedly divide the number by 2.\n - The remainder of each division (either 0 or 1) represents a binary digit.\n - These remainders are collected in a list called `binary_digits`.\n\n3. **Reversing the Digits**: Since the binary digits are obtained from least significant to most significant, we reverse the list to get the correct order.\n\n4. **Forming the Binary String**: Finally, we join the list of strings into a single string and return it.\n\nThis function efficiently converts any non-negative integer to its binary representation without leading zeros."}
{"task_id": "Mbpp/100", "solution": "```markdown\n```python\ndef next_smallest_palindrome(n):\n \"\"\"\n This function finds the next smallest palindrome greater than or equal to the given integer n.\n\n :param n: An integer for which we need to find the next smallest palindrome.\n :return: The next smallest palindrome as an integer.\n \"\"\"\n\n def is_palindrome(x):\n \"\"\"Check if a number x is a palindrome.\"\"\"\n return str(x) == str(x)[::-1]\n\n # Start checking from the next number\n candidate = n + 1\n\n while not is_palindrome(candidate):\n candidate += 1\n\n return candidate\n\n# Test case to verify the function works as expected\nassert next_smallest_palindrome(99) == 101\n```\n```"}
{"task_id": "Mbpp/101", "solution": "```markdown\n```python\ndef kth_element(arr, k):\n \"\"\"\n This function returns the k-th smallest element in a given array using 1-based indexing.\n \n Parameters:\n arr (list): A list of integers.\n k (int): The position (1-based) of the element to find.\n\n Returns:\n int: The k-th smallest element in the array.\n \"\"\"\n # Sort the array\n sorted_arr = sorted(arr)\n \n # Return the k-1 indexed element from the sorted array\n return sorted_arr[k - 1]\n\n# Test case\nassert kth_element([12, 3, 5, 7, 19], 2) == 3\n\nprint(\"Test passed!\")\n```\n```"}
{"task_id": "Mbpp/102", "solution": "Certainly! Below is a self-contained Python script that converts a snake case string to a camel case string. The function `snake_to_camel` takes a snake case string as input and returns the corresponding camel case string.\n\n```markdown\n```python\ndef snake_to_camel(snake_str):\n \"\"\"\n Convert a snake_case string to CamelCase.\n \n Parameters:\n snake_str (str): A string in snake_case format.\n \n Returns:\n str: The converted string in CamelCase format.\n \"\"\"\n # Split the string into words using underscore as delimiter\n components = snake_str.split('_')\n \n # Capitalize the first letter of each word except the first one\n # and join them together to form a camel case string\n return components[0] + ''.join(word.capitalize() for word in components[1:])\n\n# Test the function with an example\nassert snake_to_camel('python_program') == 'PythonProgram'\n```\n```\n\nThis script defines the `snake_to_camel` function, which splits the input string by underscores, capitalizes each component except the first one, and then joins them together to form a camel case string. The test at the end verifies that the function works as expected for the given example."}
{"task_id": "Mbpp/103", "solution": "To solve the problem of finding the Eulerian number \\( a(n, m) \\), we need to understand what Eulerian numbers represent. The Eulerian number \\( a(n, m) \\) counts the number of permutations of the numbers \\( 1, 2, \\ldots, n \\) in which exactly \\( m \\) elements are greater than the previous element.\n\nHere's how you can implement a function to compute Eulerian numbers:\n\n```python\ndef eulerian_num(n, m):\n \"\"\"\n Calculate the Eulerian number a(n, m).\n \n Parameters:\n n (int): The length of the permutation.\n m (int): The number of ascents in the permutation.\n\n Returns:\n int: The Eulerian number a(n, m).\n \"\"\"\n # Create a 2D list to store computed values\n eulerian = [[0] * (m + 1) for _ in range(n + 1)]\n \n # Base case: There's one way to arrange 1 element with 0 ascents\n eulerian[1][0] = 1\n \n # Fill the table using a dynamic programming approach\n for i in range(2, n + 1):\n for j in range(m + 1):\n if j == 0:\n # Only one way to have zero ascents: all elements are decreasing\n eulerian[i][j] = eulerian[i - 1][i - 2]\n else:\n # Use the recurrence relation\n eulerian[i][j] = (j + 1) * eulerian[i - 1][j] + (i - j) * eulerian[i - 1][j - 1]\n \n return eulerian[n][m]\n\n# Test case\nassert eulerian_num(3, 1) == 4\n\nprint(\"Eulerian number a(3, 1):\", eulerian_num(3, 1))\n```\n\n### Explanation:\n\n- **Base Case**: For \\( n = 1 \\), there is exactly one permutation (the number itself), and it has zero ascents. Thus, \\( a(1, 0) = 1 \\).\n\n- **Recurrence Relation**:\n - If \\( j = 0 \\): The only way to have zero ascents in a sequence of length \\( i \\) is if the sequence is strictly decreasing. This corresponds to \\( a(i-1, i-2) \\).\n - Otherwise: Use the recurrence relation:\n \\[\n a(n, m) = (m + 1) \\times a(n-1, m) + (n-m) \\times a(n-1, m-1)\n \\]\n - The first term \\((m + 1) \\times a(n-1, m)\\) accounts for inserting the largest element at any position after an ascent.\n - The second term \\((n-m) \\times a(n-1, m-1)\\) accounts for inserting the largest element before an ascent.\n\nThis dynamic programming approach efficiently computes Eulerian numbers by building up from smaller subproblems."}
{"task_id": "Mbpp/104", "solution": "Certainly! Below is a self-contained Python script that defines a function to sort each sublist of strings in a given list of lists. The function uses the `sorted()` method, which returns a new sorted list from the elements of any iterable.\n\n```python\ndef sort_sublists(list_of_lists):\n \"\"\"\n Sorts each sublist within a list of lists.\n \n Parameters:\n list_of_lists (list): A list containing sublists of strings to be sorted.\n \n Returns:\n list: A new list with each sublist sorted in ascending order.\n \"\"\"\n # Use a list comprehension to sort each sublist\n return [sorted(sublist) for sublist in list_of_lists]\n\n# Test the function with an assertion\nassert sort_sublists(([\"green\", \"orange\"], [\"black\", \"white\"], [\"white\", \"black\", \"orange\"])) == [['green', 'orange'], ['black', 'white'], ['black', 'orange', 'white']]\n```\n\nThis script defines a function `sort_sublists` that takes a list of lists as input. It iterates over each sublist, sorts it using the `sorted()` function, and returns a new list containing these sorted sublists. The assertion at the end verifies that the function works correctly for the provided test case."}
{"task_id": "Mbpp/105", "solution": "Certainly! Below is a self-contained Python script that defines a function `count` which counts the number of `True` boolean values in a given list. The function uses an assertion to verify its correctness with the provided example.\n\n```python\ndef count(bool_list):\n \"\"\"\n Count the number of True booleans in the given list.\n \n Parameters:\n bool_list (list): A list containing boolean values.\n \n Returns:\n int: The count of True values in the list.\n \"\"\"\n return sum(bool_list)\n\n# Test case to verify the function works as expected\nassert count([True, False, True]) == 2\n\nprint(\"The function passed the test case.\")\n```\n\n### Explanation:\n\n- **Function Definition**: The `count` function takes a single parameter `bool_list`, which is expected to be a list of boolean values.\n \n- **Counting Trues**: It uses Python's built-in `sum()` function, which works effectively here because `True` is equivalent to `1` and `False` is equivalent to `0`. Thus, summing the list directly gives the count of `True` values.\n\n- **Assertion**: The script includes an assertion to ensure that the function returns the expected result for the test case `[True, False, True]`.\n\n- **Output**: If the assertion passes without raising an error, it prints a confirmation message."}
{"task_id": "Mbpp/106", "solution": "```markdown\nTo solve this problem, we need to create a function that takes a list and a tuple as arguments. The goal is to append the elements of the list to the end of the tuple and return the resulting tuple.\n\nHere's how you can implement this:\n\n```python\ndef add_lists(lst, tpl):\n # Convert the tuple to a list to allow appending\n combined_list = list(tpl) + lst\n \n # Convert the combined list back to a tuple\n result_tuple = tuple(combined_list)\n \n return result_tuple\n\n# Test case\nassert add_lists([5, 6, 7], (9, 10)) == (9, 10, 5, 6, 7)\n\nprint(\"The function works correctly!\")\n```\n\n### Explanation:\n\n1. **Convert the Tuple to a List**: \n - Tuples are immutable in Python, meaning you cannot directly append elements to them. Therefore, we first convert the tuple into a list using `list(tpl)`. This allows us to use list operations like appending.\n\n2. **Append the List**:\n - We concatenate the converted list with the given list using the `+` operator: `list(tpl) + lst`. This operation creates a new list that contains all elements of the tuple followed by all elements of the list.\n\n3. **Convert Back to Tuple**:\n - Since the problem requires returning a tuple, we convert the combined list back into a tuple using `tuple(combined_list)`.\n\n4. **Return the Result**:\n - Finally, return the resulting tuple.\n\n5. **Test Case**:\n - The provided test case checks if the function correctly appends `[5, 6, 7]` to `(9, 10)`, resulting in `(9, 10, 5, 6, 7)`.\n\nThis solution ensures that the immutability of tuples is respected while achieving the desired result."}
{"task_id": "Mbpp/108", "solution": "Here's a self-contained Python script that merges three lists into a single sorted list:\n\n```python\ndef merge_sorted_list(list1, list2, list3):\n # Combine all three lists into one\n combined_list = list1 + list2 + list3\n \n # Sort the combined list\n sorted_list = sorted(combined_list)\n \n return sorted_list\n\n# Test case\nassert merge_sorted_list([25, 24, 15, 4, 5, 29, 110], [19, 20, 11, 56, 25, 233, 154], [24, 26, 54, 48]) == [\n 4, 5, 11, 15, 19, 20, 24, 24, 25, 25, 26, 29, 48, 54, 56, 110, 154, 233\n]\n```\n\nThis function first combines the three input lists into one list. It then sorts this combined list and returns it. The test case verifies that the function works as expected by comparing its output to a predefined sorted list."}
{"task_id": "Mbpp/109", "solution": "```markdown\nTo solve this problem, we need to determine how many unique numbers have an odd decimal value after rotating a binary string a specified number of times. Here's a step-by-step breakdown and the corresponding Python function:\n\n1. **Understand Binary Rotation**: Rotating a binary string means shifting its bits circularly. For example, rotating \"011001\" by 2 positions results in \"100011\".\n\n2. **Convert to Decimal**: After each rotation, convert the resulting binary string to its decimal equivalent.\n\n3. **Check for Odd Values**: Determine if the decimal value is odd. A number is odd if its least significant bit (LSB) is 1.\n\n4. **Count Unique Odd Values**: Keep track of unique odd values encountered during all rotations.\n\nHere's the Python function implementing this logic:\n\n```python\ndef odd_Equivalent(binary_string, num_rotations):\n n = len(binary_string)\n seen_odd_values = set()\n \n for i in range(num_rotations):\n # Rotate the binary string by i positions\n rotated_binary = binary_string[i:] + binary_string[:i]\n \n # Convert the rotated binary to a decimal number\n decimal_value = int(rotated_binary, 2)\n \n # Check if the decimal value is odd\n if decimal_value % 2 == 1:\n seen_odd_values.add(decimal_value)\n \n return len(seen_odd_values)\n\n# Test case\nassert odd_Equivalent(\"011001\", 6) == 3\n```\n\n### Explanation:\n\n- **Rotation**: For each rotation from `0` to `num_rotations - 1`, we create a new binary string by slicing and concatenating the original string.\n \n- **Conversion**: We use Python's built-in `int()` function with base 2 to convert the rotated binary string to its decimal form.\n\n- **Odd Check**: We check if the number is odd using the modulus operator (`%`).\n\n- **Unique Counting**: We store each unique odd value in a set, which automatically handles duplicates for us. Finally, we return the size of this set.\n\nThis function efficiently computes the desired result by leveraging Python's string manipulation and set operations."}
{"task_id": "Mbpp/111", "solution": "Here's a self-contained Python script that solves the problem of finding common elements in nested lists:\n\n```python\ndef common_in_nested_lists(nested_lists):\n \"\"\"\n Find the common elements in given nested lists.\n\n Parameters:\n nested_lists (list of list): A list containing multiple sublists with integers.\n\n Returns:\n set: A set containing the common elements across all sublists.\n \"\"\"\n if not nested_lists:\n return set()\n\n # Start by converting the first sublist to a set\n common_elements = set(nested_lists[0])\n\n # Intersect this set with each of the other sublists\n for sublist in nested_lists[1:]:\n common_elements.intersection_update(sublist)\n\n return common_elements\n\n# Test case\nassert set(common_in_nested_lists([[12, 18, 23, 25, 45], [7, 12, 18, 24, 28], [1, 5, 8, 12, 15, 16, 18]])) == set([18, 12])\n```\n\n### Explanation:\n\n- **Function Definition**: The function `common_in_nested_lists` takes a list of lists as input.\n \n- **Initial Check**: If the input is empty, it returns an empty set.\n\n- **Set Initialization**: It initializes `common_elements` with the first sublist converted to a set. This allows us to use set operations efficiently.\n\n- **Intersection Update**: For each subsequent sublist, it updates `common_elements` by intersecting it with the current sublist using `intersection_update`. This method modifies the set in place and keeps only elements that are present in both sets.\n\n- **Return Value**: Finally, it returns the set of common elements found across all sublists.\n\nThis approach efficiently finds the intersection of multiple lists using Python's built-in set operations."}
{"task_id": "Mbpp/113", "solution": "Certainly! Below is a self-contained Python script that defines a function `check_integer` to determine whether a given string represents an integer. The function uses regular expressions to verify the format of the input string.\n\n```markdown\n```python\nimport re\n\ndef check_integer(s):\n \"\"\"\n Check if the provided string s represents an integer.\n \n Parameters:\n s (str): The string to be checked.\n \n Returns:\n bool: True if the string is a valid representation of an integer, False otherwise.\n \"\"\"\n # Regular expression pattern for matching integers\n # This pattern matches optional leading '+' or '-' followed by one or more digits\n integer_pattern = re.compile(r'^[+-]?\\d+$')\n \n # Use fullmatch to ensure the entire string conforms to the pattern\n return bool(integer_pattern.fullmatch(s))\n\n# Test cases\nassert check_integer(\"python\") == False, \"Test case 1 failed\"\nassert check_integer(\"123\") == True, \"Test case 2 failed\"\nassert check_integer(\"-456\") == True, \"Test case 3 failed\"\nassert check_integer(\"+789\") == True, \"Test case 4 failed\"\nassert check_integer(\"0123\") == False, \"Test case 5 failed\" # Leading zero is not allowed\nassert check_integer(\"\") == False, \"Test case 6 failed\" # Empty string is not an integer\n\nprint(\"All test cases passed!\")\n```\n```\n\n### Explanation:\n- **Regular Expression**: The pattern `^[+-]?\\d+$` is used to match strings that represent integers.\n - `^`: Asserts the start of the line.\n - `[+-]?`: Matches an optional '+' or '-' sign.\n - `\\d+`: Matches one or more digits (0-9).\n - `$`: Asserts the end of the line.\n\n- **`fullmatch` Method**: This method ensures that the entire string matches the pattern, not just a substring.\n\n- **Test Cases**: Several assertions are included to verify the function's correctness with various inputs."}
{"task_id": "Mbpp/116", "solution": "```markdown\nHere's a Python script that defines a function `tuple_to_int` which converts a tuple of positive integers into a single integer:\n\n```python\ndef tuple_to_int(t):\n \"\"\"\n Convert a tuple of positive integers into a single integer.\n\n Parameters:\n t (tuple): A tuple containing positive integers.\n\n Returns:\n int: An integer formed by concatenating the numbers in the tuple.\n \n Example:\n >>> assert tuple_to_int((1, 2, 3)) == 123\n \"\"\"\n # Use map to convert each element of the tuple to a string,\n # then join them together into one string, and finally convert that string back to an integer.\n return int(''.join(map(str, t)))\n\n# Example usage:\nassert tuple_to_int((1, 2, 3)) == 123\n```\n\n### Explanation:\n\n- **`map(str, t)`**: This converts each element in the tuple `t` into a string. For example, `(1, 2, 3)` becomes `('1', '2', '3')`.\n \n- **`''.join(...)`**: This joins all the strings together without any separator, resulting in `'123'`.\n\n- **`int(...)`**: Finally, this converts the concatenated string back into an integer.\n\nThis function handles tuples of positive integers and concatenates them to form a single integer."}
{"task_id": "Mbpp/118", "solution": "Certainly! Below is a self-contained Python script that defines a function `string_to_list` which takes a string as input and returns a list of substrings split by spaces. The script also includes an assertion to verify the correctness of the function.\n\n```markdown\n```python\ndef string_to_list(input_string):\n \"\"\"\n Convert a string into a list of strings split on the space character.\n \n Parameters:\n input_string (str): A string that needs to be split into a list of substrings.\n \n Returns:\n list: A list of substrings obtained by splitting the input string on spaces.\n \"\"\"\n # Split the input string on spaces and return the resulting list\n return input_string.split()\n\n# Test case to verify the function works as expected\nassert string_to_list(\"python programming\") == ['python', 'programming']\n\nprint(\"The function passed the test case.\")\n```\n```\n\nThis script defines the `string_to_list` function, which uses Python's built-in `split()` method to divide the input string into a list of substrings wherever there is a space. The assertion checks if the function correctly splits the string `\"python programming\"` into `['python', 'programming']`. If the function works as expected, it will print \"The function passed the test case.\""}
{"task_id": "Mbpp/119", "solution": "Certainly! Below is a self-contained Python script that solves the problem of finding the element that appears only once in a sorted array. The function uses binary search to achieve this efficiently.\n\n```python\ndef search(nums):\n \"\"\"\n Find the element that appears only once in a sorted array.\n \n :param nums: List[int] - A list of integers where every element appears twice except for one.\n :return: int - The single element that appears only once.\n \"\"\"\n left, right = 0, len(nums) - 1\n \n while left < right:\n mid = (left + right) // 2\n \n # Ensure the mid is even to pair with mid+1\n if mid % 2 == 1:\n mid -= 1\n \n # Check if the pair is valid\n if nums[mid] == nums[mid + 1]:\n left = mid + 2\n else:\n right = mid\n \n return nums[left]\n\n# Test case\nassert search([1, 1, 2, 2, 3]) == 3\n\nprint(\"The element that appears only once is:\", search([1, 1, 2, 2, 3]))\n```\n\n### Explanation:\n\n- **Binary Search Approach**: The function uses binary search to efficiently find the single element. This approach works because in a sorted array where every other element appears twice, the single element will disrupt the pairing pattern.\n \n- **Mid Adjustment**: We ensure `mid` is even so that we can always compare it with `mid + 1`. If `mid` is odd, we decrement it by one.\n\n- **Pair Checking**: \n - If `nums[mid] == nums[mid + 1]`, the single element must be to the right of `mid + 1`.\n - Otherwise, the single element is at `mid` or to the left of `mid`.\n\n- **Loop Termination**: The loop continues until `left` equals `right`, which will point to the single element.\n\nThis solution runs in O(log n) time complexity due to the binary search approach."}
{"task_id": "Mbpp/120", "solution": "```markdown\nTo solve this problem, we need to write a function `max_product_tuple` that takes a list of tuples as input. Each tuple contains two numbers. The goal is to find the maximum absolute product between any pair of these tuples.\n\nHere's how you can implement this:\n\n1. **Iterate Over Pairs**: We'll iterate over all possible pairs of tuples in the list.\n2. **Calculate Products**: For each pair, calculate four potential products:\n - Product of the first elements from both tuples and the product of the second elements from both tuples.\n - Product of the first element from the first tuple and the second element from the second tuple, and vice versa.\n3. **Find Maximum Absolute Product**: Track the maximum absolute value among all these calculated products.\n\nHere's the implementation:\n\n```python\ndef max_product_tuple(tuples):\n max_abs_product = float('-inf')\n \n # Iterate over each pair of tuples\n for i in range(len(tuples)):\n for j in range(i + 1, len(tuples)):\n a, b = tuples[i]\n c, d = tuples[j]\n \n # Calculate all possible products between the two tuples\n product1 = a * c\n product2 = a * d\n product3 = b * c\n product4 = b * d\n \n # Update max_abs_product with the maximum absolute value of these products\n max_abs_product = max(max_abs_product, abs(product1), abs(product2), abs(product3), abs(product4))\n \n return max_abs_product\n\n# Test case\nassert max_product_tuple([(2, 7), (2, 6), (1, 8), (4, 9)]) == 36\n```\n\n### Explanation:\n\n- **Nested Loops**: We use nested loops to iterate over each unique pair of tuples. The outer loop runs from the start of the list to the second last element, and the inner loop starts from the next element after the current element in the outer loop.\n \n- **Product Calculations**: For each pair `(a, b)` and `(c, d)`, we calculate:\n - `product1 = a * c`\n - `product2 = a * d`\n - `product3 = b * c`\n - `product4 = b * d`\n\n- **Maximum Absolute Product**: We keep track of the maximum absolute value among these products using `max_abs_product`.\n\nThis approach ensures that we consider all possible combinations and find the maximum absolute product efficiently."}
{"task_id": "Mbpp/123", "solution": "Certainly! Below is a self-contained Python script that defines a function to find and sum all amicable numbers up to a given limit. The script includes the necessary helper functions to determine if two numbers are amicable.\n\n```python\ndef proper_divisors(n):\n \"\"\"Return the list of proper divisors of n.\"\"\"\n divisors = [1]\n for i in range(2, int(n**0.5) + 1):\n if n % i == 0:\n divisors.append(i)\n if i != n // i:\n divisors.append(n // i)\n return divisors\n\ndef sum_of_divisors(n):\n \"\"\"Return the sum of proper divisors of n.\"\"\"\n return sum(proper_divisors(n))\n\ndef is_amicable(a, b):\n \"\"\"Check if a and b are amicable numbers.\"\"\"\n return sum_of_divisors(a) == b and sum_of_divisors(b) == a\n\ndef amicable_numbers_sum(limit):\n \"\"\"Return the sum of all amicable numbers under the given limit.\"\"\"\n amicable_sum = 0\n for num in range(2, limit):\n partner = sum_of_divisors(num)\n if partner > num and is_amicable(num, partner):\n amicable_sum += num + partner\n return amicable_sum\n\n# Test case\nassert amicable_numbers_sum(999) == 504\n```\n\n### Explanation:\n\n1. **`proper_divisors(n)`**: This function calculates all proper divisors of a number `n`, excluding the number itself.\n\n2. **`sum_of_divisors(n)`**: Utilizes `proper_divisors` to compute the sum of these divisors.\n\n3. **`is_amicable(a, b)`**: Checks if two numbers are amicable by verifying that each is the sum of the proper divisors of the other.\n\n4. **`amicable_numbers_sum(limit)`**: Iterates through all numbers up to `limit`, finds their divisor sums, and checks for amicability. It accumulates the sum of all such pairs found.\n\nThis script should correctly compute the sum of all amicable numbers under a specified limit, as demonstrated by the test case provided."}
{"task_id": "Mbpp/124", "solution": "Certainly! Below is a self-contained Python script that defines a function `angle_complex` to calculate the angle (or argument) of a complex number. The script also includes an assertion to verify the correctness of the function.\n\n```python\nimport math\n\ndef angle_complex(real, imag):\n \"\"\"\n Calculate the angle (in radians) of a complex number given its real and imaginary parts.\n \n Parameters:\n - real: The real part of the complex number.\n - imag: The imaginary part of the complex number.\n \n Returns:\n - The angle in radians.\n \"\"\"\n # Create a complex number from the real and imaginary parts\n complex_number = complex(real, imag)\n \n # Use math.atan2 to calculate the angle (argument) of the complex number\n return math.atan2(imag, real)\n\n# Test case to verify the function works as expected\nassert math.isclose(angle_complex(0, 1j), 1.5707963267948966, rel_tol=0.001)\n```\n\n### Explanation:\n\n- **`complex(real, imag)`**: This constructs a complex number from its real and imaginary parts.\n \n- **`math.atan2(imag, real)`**: This function computes the angle (in radians) between the positive x-axis of a plane and the point given by the coordinates `(real, imag)`. It handles all quadrants correctly and returns values in the range `[-\u03c0, \u03c0]`.\n\n- **`assert math.isclose(...)`**: This assertion checks if the calculated angle is close to the expected value (`1.5707963267948966`, which is equivalent to `\u03c0/2`) within a relative tolerance of `0.001`. The function `math.isclose` is used for floating-point comparison due to potential precision issues.\n\nThis script should work correctly for any complex number input, providing its angle in radians."}
{"task_id": "Mbpp/125", "solution": "```markdown\nTo solve this problem, we need to determine the maximum difference between the count of `0`s and `1`s in any substring of a given binary string. Here's how you can approach it:\n\n### Approach\n\n1. **Convert the Problem**: \n - Convert each `0` in the string to `+1`.\n - Convert each `1` in the string to `-1`.\n\n2. **Prefix Sum**:\n - Calculate the prefix sum of this transformed array.\n - The goal is to find the maximum difference between any two prefix sums, which corresponds to finding the maximum subarray sum.\n\n3. **Kadane's Algorithm**:\n - Use Kadane\u2019s algorithm to find the maximum subarray sum in linear time.\n - This will give us the maximum difference between the number of `0`s and `1`s in any substring.\n\n4. **Edge Cases**:\n - If the string is all `0`s or all `1`s, handle these cases directly since the entire string itself would be the answer.\n\nHere's the implementation:\n\n```python\ndef find_length(s: str) -> int:\n # Convert '0' to +1 and '1' to -1\n transformed = [1 if char == '0' else -1 for char in s]\n \n max_diff = 0\n current_sum = 0\n \n for value in transformed:\n current_sum += value\n \n # Reset the current sum if it becomes negative\n if current_sum < 0:\n current_sum = 0\n \n # Update the maximum difference found so far\n max_diff = max(max_diff, current_sum)\n \n return max_diff\n\n# Test case\nassert find_length(\"11000010001\") == 6\n```\n\n### Explanation\n\n- **Transformation**: By converting `0` to `+1` and `1` to `-1`, we effectively turn the problem into finding a subarray with the maximum sum.\n \n- **Prefix Sum and Kadane's Algorithm**:\n - We iterate through the transformed list, maintaining a running total (`current_sum`).\n - If at any point `current_sum` becomes negative, it means starting fresh from the next element might yield a better result (hence we reset it to zero).\n - The maximum value of `current_sum` during this iteration gives us the desired maximum difference.\n\n- **Edge Cases**:\n - If the string is all `0`s, the entire string length is the answer.\n - If the string is all `1`s, the answer is zero since there are no `0`s to contribute positively.\n\nThis solution efficiently finds the maximum difference in linear time, making it suitable for large strings."}
{"task_id": "Mbpp/126", "solution": "Certainly! Below is a self-contained Python script that defines a function to find the sum of common divisors of two given numbers. The function uses assertions to verify its correctness.\n\n```python\ndef gcd(a, b):\n \"\"\"Compute the greatest common divisor of a and b.\"\"\"\n while b:\n a, b = b, a % b\n return a\n\ndef sum_of_common_divisors(x, y):\n \"\"\"\n Calculate the sum of all common divisors of two numbers x and y.\n \n Args:\n x (int): First number\n y (int): Second number\n \n Returns:\n int: Sum of all common divisors of x and y\n \"\"\"\n # Find the greatest common divisor of x and y\n gcd_value = gcd(x, y)\n \n # Find all divisors of the gcd_value\n divisors = []\n for i in range(1, int(gcd_value**0.5) + 1):\n if gcd_value % i == 0:\n divisors.append(i)\n if i != gcd_value // i: # Avoid adding the square root twice if it's a perfect square\n divisors.append(gcd_value // i)\n \n # Return the sum of all common divisors\n return sum(divisors)\n\n# Test cases to verify the function works as expected\nassert sum_of_common_divisors(10, 15) == 6, \"Test case 1 failed\"\nassert sum_of_common_divisors(12, 18) == 13, \"Test case 2 failed\" # Common divisors are 1, 2, 3, 6\nassert sum_of_common_divisors(7, 5) == 1, \"Test case 3 failed\" # Only common divisor is 1\n\nprint(\"All test cases passed!\")\n```\n\n### Explanation:\n\n- **GCD Calculation**: The `gcd` function computes the greatest common divisor using the Euclidean algorithm. This is efficient and works well for large numbers.\n\n- **Finding Common Divisors**: Once we have the GCD of the two numbers, any common divisor must also be a divisor of this GCD. We find all divisors of the GCD by iterating up to its square root (to optimize performance) and checking divisibility.\n\n- **Summing Divisors**: After collecting all divisors of the GCD, we sum them up to get the result.\n\n- **Assertions**: The script includes assertions to ensure that the function behaves as expected for given test cases."}
{"task_id": "Mbpp/127", "solution": "```markdown\n```python\ndef multiply_int(a: int, b: int) -> int:\n \"\"\"\n Multiplies two integers and returns the result.\n\n Parameters:\n a (int): The first integer to be multiplied.\n b (int): The second integer to be multiplied.\n\n Returns:\n int: The product of the two integers.\n \"\"\"\n return a * b\n\n# Test case\nassert multiply_int(10, 20) == 200\n```\n```"}
{"task_id": "Mbpp/128", "solution": "Certainly! Below is a self-contained Python script that defines the `long_words` function. This function takes an integer `n` and a string containing multiple words, then returns a list of words longer than `n` characters.\n\n```markdown\n```python\ndef long_words(n, sentence):\n \"\"\"\n Find words in a given sentence that are longer than n characters.\n \n Parameters:\n n (int): The minimum length for the words to be included in the result.\n sentence (str): A string containing multiple words separated by spaces.\n\n Returns:\n list: A list of words from the sentence that have more than n characters.\n \"\"\"\n # Split the sentence into individual words\n words = sentence.split()\n \n # Filter and collect words longer than n characters\n long_words_list = [word for word in words if len(word) > n]\n \n return long_words_list\n\n# Test case to verify the function works as expected\nassert long_words(3, \"python is a programming language\") == ['python', 'programming', 'language']\n```\n```\n\nThis script defines the `long_words` function and includes an assertion to test its correctness. The function splits the input string into words, filters those longer than `n`, and returns them in a list."}
{"task_id": "Mbpp/129", "solution": "Certainly! Below is a self-contained Python script that defines a function to determine if a given matrix is a magic square. A magic square is a grid of numbers where the sums of every row, column, and both main diagonals are equal.\n\n```python\ndef is_magic_square(matrix):\n \"\"\"\n Determine if a given matrix is a magic square.\n \n Args:\n - matrix (list of list of int): The matrix to check.\n \n Returns:\n - bool: True if the matrix is a magic square, False otherwise.\n \"\"\"\n n = len(matrix)\n \n # Check if all rows have the same sum\n row_sums = [sum(row) for row in matrix]\n if len(set(row_sums)) != 1:\n return False\n \n # Check if all columns have the same sum\n col_sums = [sum(matrix[i][j] for i in range(n)) for j in range(n)]\n if len(set(col_sums)) != 1:\n return False\n \n # Check if both diagonals have the same sum\n diag1_sum = sum(matrix[i][i] for i in range(n))\n diag2_sum = sum(matrix[i][n - 1 - i] for i in range(n))\n \n if diag1_sum != diag2_sum or diag1_sum != row_sums[0]:\n return False\n \n return True\n\ndef magic_square_test(matrix):\n \"\"\"\n Test function to check if a matrix is a magic square.\n \n Args:\n - matrix (list of list of int): The matrix to test.\n \n Returns:\n - bool: Result of the test.\n \"\"\"\n return is_magic_square(matrix)\n\n# Example usage\nassert magic_square_test([[7, 12, 1, 14], [2, 13, 8, 11], [16, 3, 10, 5], [9, 6, 15, 4]]) == True\n\nprint(\"The matrix is a magic square.\")\n```\n\n### Explanation:\n\n- **Row Sums**: We calculate the sum of each row and check if all rows have the same sum.\n- **Column Sums**: Similarly, we calculate the sum of each column and ensure they are equal.\n- **Diagonal Sums**: We compute the sums of both main diagonals and verify that they match the row/column sums.\n\nIf all these conditions are satisfied, the matrix is a magic square. The `magic_square_test` function uses `is_magic_square` to perform this check and returns the result."}
{"task_id": "Mbpp/130", "solution": "```markdown\nHere's a Python script that defines a function to find the item with maximum frequency in a given list. The function uses a dictionary to count occurrences of each element and then determines which element has the highest count.\n\n```python\ndef max_occurrences(lst):\n # Dictionary to store the frequency of each element\n frequency = {}\n \n # Count the occurrences of each element in the list\n for item in lst:\n if item in frequency:\n frequency[item] += 1\n else:\n frequency[item] = 1\n \n # Find the element with the maximum frequency\n max_count = 0\n max_item = None\n \n for key, value in frequency.items():\n if value > max_count:\n max_count = value\n max_item = key\n \n return max_item\n\n# Test case to verify the function works as expected\nassert max_occurrences([2,3,8,4,7,9,8,2,6,5,1,6,1,2,3,2,4,6,9,1,2]) == 2\n```\n\n### Explanation:\n\n- **Frequency Dictionary**: We use a dictionary `frequency` to store each element as a key and its count as the value.\n \n- **Counting Occurrences**: As we iterate over the list, we update the count for each element in the dictionary.\n\n- **Finding Maximum Frequency**: After counting, we iterate through the dictionary to find the element with the highest frequency. We keep track of both the maximum count (`max_count`) and the corresponding item (`max_item`).\n\n- **Return Result**: Finally, the function returns the item that appears most frequently in the list.\n\nThis approach efficiently finds the most frequent item using a single pass through the list to build the frequency dictionary and another pass through the dictionary to find the maximum."}
{"task_id": "Mbpp/131", "solution": "Certainly! Below is a self-contained Python script that defines a function `reverse_vowels` which reverses only the vowels in a given string. The function checks for vowels and swaps them from both ends of the string until all vowels are reversed.\n\n```python\ndef reverse_vowels(s):\n \"\"\"\n Reverse only the vowels in a given string.\n \n Args:\n s (str): The input string where vowels need to be reversed.\n \n Returns:\n str: A new string with vowels reversed.\n \"\"\"\n # Define what characters are considered vowels\n vowels = set(\"aeiouAEIOU\")\n \n # Convert the string into a list of characters for easy manipulation\n s_list = list(s)\n \n # Initialize two pointers, one at the start and one at the end of the list\n left, right = 0, len(s) - 1\n \n while left < right:\n # Move the left pointer to the next vowel\n if s_list[left] not in vowels:\n left += 1\n # Move the right pointer to the previous vowel\n elif s_list[right] not in vowels:\n right -= 1\n else:\n # Swap the vowels at the two pointers\n s_list[left], s_list[right] = s_list[right], s_list[left]\n # Move both pointers towards the center\n left += 1\n right -= 1\n \n # Join the list back into a string and return it\n return ''.join(s_list)\n\n# Test cases to verify the function works as expected\nassert reverse_vowels(\"Python\") == \"Python\"\nassert reverse_vowels(\"hello\") == \"holle\"\nassert reverse_vowels(\"leetcode\") == \"leotcede\"\nassert reverse_vowels(\"aA\") == \"Aa\"\n\nprint(reverse_vowels(\"Python\")) # Output: Python\n```\n\nThis script defines the `reverse_vowels` function and includes several test cases to ensure it works correctly. The function uses a two-pointer approach to efficiently swap vowels from both ends of the string until all vowels are reversed."}
{"task_id": "Mbpp/132", "solution": "Certainly! Below is a self-contained Python script that defines the `tup_string` function to convert a tuple of characters into a single string. The function uses the `join()` method, which efficiently concatenates all elements in an iterable (in this case, a tuple) into a single string.\n\n```python\ndef tup_string(t):\n \"\"\"\n Convert a tuple of characters into a single string.\n \n Parameters:\n t (tuple): A tuple containing individual character strings.\n \n Returns:\n str: A concatenated string formed from the elements of the tuple.\n \"\"\"\n return ''.join(t)\n\n# Test case to verify the function works as expected\nassert tup_string(('e', 'x', 'e', 'r', 'c', 'i', 's', 'e', 's')) == \"exercises\"\n```\n\n### Explanation:\n- **Function Definition**: The `tup_string` function takes a single argument, `t`, which is expected to be a tuple of strings (each string being a single character).\n- **Join Method**: Inside the function, `''.join(t)` is used. This method joins all elements in the tuple `t` into one continuous string without any separator (`''` indicates no space or other characters between them).\n- **Assertion**: The script includes an assertion to ensure that when you pass the tuple `('e', 'x', 'e', 'r', 'c', 'i', 's', 'e', 's')`, it returns `\"exercises\"`. This serves as a test case to verify the correctness of the function.\n\nThis code is efficient and concise, leveraging Python's built-in string methods for optimal performance."}
{"task_id": "Mbpp/133", "solution": "Certainly! Below is a self-contained Python script that defines the function `sum_negative_numbers` to calculate the sum of negative numbers in a given list. It also includes an assertion to verify the correctness of the implementation.\n\n```markdown\n```python\ndef sum_negative_numbers(numbers):\n \"\"\"\n Calculate the sum of all negative numbers in a given list.\n \n Parameters:\n numbers (list): A list of integers or floats.\n \n Returns:\n int: The sum of all negative numbers in the list.\n \"\"\"\n # Use a generator expression to filter and sum negative numbers\n return sum(num for num in numbers if num < 0)\n\n# Test case\nassert sum_negative_numbers([2, 4, -6, -9, 11, -12, 14, -5, 17]) == -32\n\nprint(\"The function works correctly.\")\n```\n```\n\nThis script defines the `sum_negative_numbers` function and uses a generator expression to iterate over the list, summing only those numbers that are negative. The assertion checks if the function returns `-32` for the provided test case, ensuring its correctness."}
{"task_id": "Mbpp/135", "solution": "```markdown\nTo solve the problem of finding the nth hexagonal number, we need to understand what a hexagonal number is. A hexagonal number represents a pattern that can be visualized as a hexagon with dots. The formula for calculating the nth hexagonal number is:\n\n\\[ H_n = n \\times (2n - 1) \\]\n\nWhere \\( H_n \\) is the nth hexagonal number and \\( n \\) is the position in the sequence.\n\nHere's how you can implement this in Python:\n\n```python\ndef hexagonal_num(n):\n \"\"\"\n Calculate the nth hexagonal number.\n \n Parameters:\n n (int): The position in the hexagonal number sequence.\n \n Returns:\n int: The nth hexagonal number.\n \"\"\"\n return n * (2 * n - 1)\n\n# Test case\nassert hexagonal_num(10) == 190\n\n# Additional test cases for verification\nprint(hexagonal_num(1)) # Output should be 1\nprint(hexagonal_num(2)) # Output should be 6\nprint(hexagonal_num(3)) # Output should be 15\n```\n\n### Explanation:\n\n- The function `hexagonal_num` takes an integer \\( n \\) as input.\n- It calculates the nth hexagonal number using the formula \\( H_n = n \\times (2n - 1) \\).\n- The test case `assert hexagonal_num(10) == 190` ensures that the function works correctly for \\( n = 10 \\).\n- Additional print statements are provided to verify the correctness of the function for other values of \\( n \\).\n\nThis implementation efficiently computes the nth hexagonal number in constant time, \\( O(1) \\), due to its direct formula-based calculation."}
{"task_id": "Mbpp/137", "solution": "```markdown\nHere's a Python script that defines a function to find the ratio of zeroes to non-zeroes in an array of integers:\n\n```python\nimport math\n\ndef zero_count(arr):\n # Count the number of zeros in the array\n zero_count = sum(1 for x in arr if x == 0)\n \n # Count the number of non-zeros in the array\n non_zero_count = len(arr) - zero_count\n \n # If there are no non-zero elements, return 0 to avoid division by zero\n if non_zero_count == 0:\n return float('inf') # or some other representation for undefined ratio\n \n # Calculate and return the ratio of zeroes to non-zeroes\n return zero_count / non_zero_count\n\n# Test case\nassert math.isclose(zero_count([0, 1, 2, -1, -5, 6, 0, -3, -2, 3, 4, 6, 8]), 0.181818, rel_tol=0.001)\n```\n\n### Explanation:\n\n- **Importing `math`:** We use the `math.isclose` function to compare floating-point numbers with a relative tolerance.\n \n- **Function Definition (`zero_count`):**\n - The function takes an array of integers as input.\n - It counts the number of zeroes using a generator expression within the `sum()` function.\n - It calculates the number of non-zero elements by subtracting the zero count from the total length of the array.\n - If there are no non-zero elements, it returns infinity (`float('inf')`) to indicate an undefined ratio (since division by zero is not possible).\n - Otherwise, it computes and returns the ratio of zeroes to non-zeroes.\n\n- **Test Case:**\n - The `assert` statement checks if the function's output for a given test array matches the expected value within a specified relative tolerance (`rel_tol=0.001`). This ensures that minor floating-point precision issues do not cause the test to fail.\n```"}
{"task_id": "Mbpp/138", "solution": "Certainly! Below is a self-contained Python script that defines a function `is_sum_of_powers_of_two` to check if a given number can be represented as the sum of non-zero powers of 2. The function uses bitwise operations to determine this.\n\n```python\ndef is_sum_of_powers_of_two(n):\n \"\"\"\n Check whether the given number n can be represented as the sum of non-zero powers of 2.\n \n Args:\n n (int): The number to check.\n \n Returns:\n bool: True if n can be represented as such a sum, False otherwise.\n \"\"\"\n # A number can be expressed as a sum of distinct powers of 2\n # if and only if it has no zero bits in its binary representation,\n # except for the leading bit (which is always non-zero).\n \n # Check if n is positive\n if n <= 0:\n return False\n \n # Use bitwise AND to check if there are any zero bits in the binary representation of n.\n # If n & (n - 1) == 0, then n is a power of 2 or zero.\n # We need to ensure that all bits except possibly one are set to 1.\n \n # Count the number of 1s in the binary representation of n\n count_ones = 0\n temp_n = n\n \n while temp_n > 0:\n if temp_n & 1 == 1:\n count_ones += 1\n temp_n >>= 1\n \n # If there are no zero bits (except possibly the leading bit), then it can be represented as a sum of distinct powers of 2.\n return count_ones == n.bit_length()\n\n# Test cases\nassert is_sum_of_powers_of_two(10) == True, \"Test case 1 failed\"\nassert is_sum_of_powers_of_two(7) == True, \"Test case 2 failed\" # 7 = 4 + 2 + 1\nassert is_sum_of_powers_of_two(8) == True, \"Test case 3 failed\" # 8 = 2^3\nassert is_sum_of_powers_of_two(6) == True, \"Test case 4 failed\" # 6 = 4 + 2\nassert is_sum_of_powers_of_two(5) == True, \"Test case 5 failed\" # 5 = 4 + 1\nassert is_sum_of_powers_of_two(3) == True, \"Test case 6 failed\" # 3 = 2 + 1\nassert is_sum_of_powers_of_two(1) == True, \"Test case 7 failed\" # 1 = 2^0\nassert is_sum_of_powers_of_two(0) == False, \"Test case 8 failed\"\nassert is_sum_of_powers_of_two(-5) == False, \"Test case 9 failed\"\n\nprint(\"All test cases passed!\")\n```\n\n### Explanation:\n- The function checks if a number can be expressed as the sum of distinct powers of 2 by counting the number of `1`s in its binary representation.\n- If the count of `1`s equals the bit length of the number, it means all bits are set to `1` except possibly one leading zero (which doesn't exist for positive numbers), indicating that the number can be expressed as a sum of distinct powers of 2.\n- The function handles edge cases like non-positive integers by returning `False`."}
{"task_id": "Mbpp/139", "solution": "```markdown\nTo solve this problem, we need to write a Python function that calculates the circumference of a circle given its radius. The formula for the circumference \\( C \\) of a circle is:\n\n\\[ C = 2 \\pi r \\]\n\nwhere:\n- \\( r \\) is the radius of the circle,\n- \\( \\pi \\) (pi) is a mathematical constant approximately equal to 3.14159.\n\nWe'll use Python's `math` module, which provides the value of \\( \\pi \\) and other mathematical functions. Here's how you can implement this function:\n\n```python\nimport math\n\ndef circle_circumference(radius):\n \"\"\"\n Calculate the circumference of a circle given its radius.\n \n Parameters:\n radius (float): The radius of the circle.\n\n Returns:\n float: The circumference of the circle.\n \"\"\"\n return 2 * math.pi * radius\n\n# Test case\nassert math.isclose(circle_circumference(10), 62.830000000000005, rel_tol=0.001)\n```\n\n### Explanation:\n\n1. **Importing `math` Module**: We import Python's built-in `math` module to access the constant \\( \\pi \\).\n\n2. **Defining the Function**:\n - The function `circle_circumference(radius)` takes one parameter, `radius`, which is expected to be a float or an integer.\n - It calculates the circumference using the formula \\( 2 \\times \\pi \\times \\text{radius} \\).\n - The result is returned as a floating-point number.\n\n3. **Testing**:\n - We use `assert` along with `math.isclose()` to verify that our function returns the expected value for a radius of 10.\n - `math.isclose(a, b, rel_tol=0.001)` checks if two values are close enough within a relative tolerance of 0.001.\n\nThis implementation ensures that the circumference is calculated accurately and tested against an expected result with a specified tolerance level."}
{"task_id": "Mbpp/140", "solution": "Certainly! Below is a self-contained Python script that defines the function `extract_singly` to flatten a list of lists into a single set of numbers. The function uses a set comprehension to ensure all elements are unique.\n\n```python\ndef extract_singly(list_of_lists):\n \"\"\"\n Flattens a list of lists into a single set of numbers.\n \n Parameters:\n - list_of_lists: A list containing tuples or lists of numbers.\n \n Returns:\n - A set containing all the unique numbers from the input list of lists.\n \"\"\"\n # Use a set comprehension to flatten and collect unique elements\n return {element for sublist in list_of_lists for element in sublist}\n\n# Test case\nassert set(extract_singly([(3, 4, 5), (4, 5, 7), (1, 4)])) == set([3, 4, 5, 7, 1])\n```\n\n### Explanation:\n\n- **Function Definition**: The function `extract_singly` takes a single argument `list_of_lists`, which is expected to be a list of tuples or lists.\n \n- **Set Comprehension**: \n - `{element for sublist in list_of_lists for element in sublist}` iterates over each sublist within the main list and then over each element within those sublists.\n - This comprehension collects all elements into a set, automatically removing duplicates.\n\n- **Return Value**: The function returns this set of unique numbers.\n\n- **Test Case**: An assertion is used to verify that the function works as expected. It checks if the output matches the expected set `{3, 4, 5, 7, 1}` when given the input `[(3, 4, 5), (4, 5, 7), (1, 4)]`.\n\nThis script should work correctly for any list of lists containing numbers and will ensure that all elements are unique in the resulting set."}
{"task_id": "Mbpp/141", "solution": "```markdown\n```python\ndef pancake_sort(arr):\n def flip(sub_arr, k):\n \"\"\"Helper function to reverse the first k elements of sub_arr.\"\"\"\n return sub_arr[:k][::-1] + sub_arr[k:]\n\n sorted_arr = []\n while arr:\n # Find the index of the maximum element in the current array\n max_index = arr.index(max(arr))\n \n # If the maximum element is not already at its correct position\n if max_index != len(arr) - 1:\n # Flip the array to bring the maximum element to the front\n if max_index != 0:\n arr = flip(arr, max_index + 1)\n \n # Flip it again to move the maximum element to its correct position\n arr = flip(arr, len(arr))\n \n # Remove the last element and add it to the sorted array\n sorted_arr.append(arr.pop())\n \n return sorted_arr\n\n# Test case\nassert pancake_sort([15, 79, 25, 38, 69]) == [15, 25, 38, 69, 79]\n```\n```"}
{"task_id": "Mbpp/142", "solution": "Here's a self-contained Python script that solves the problem of counting items that are identical in the same position across three given lists:\n\n```python\ndef count_samepair(list1, list2, list3):\n \"\"\"\n Count the number of items that are identical in the same position across three lists.\n \n Parameters:\n - list1: First list of integers.\n - list2: Second list of integers.\n - list3: Third list of integers.\n \n Returns:\n - An integer representing the count of identical items at the same positions.\n \"\"\"\n # Initialize a counter for identical items\n count = 0\n \n # Iterate over the indices of the lists (assuming all lists are of the same length)\n for i in range(min(len(list1), len(list2), len(list3))):\n # Check if the elements at the current index are the same across all three lists\n if list1[i] == list2[i] == list3[i]:\n count += 1\n \n return count\n\n# Test case\nassert count_samepair([1,2,3,4,5,6,7,8],[2,2,3,1,2,6,7,9],[2,1,3,1,2,6,7,9]) == 3\n```\n\nThis function iterates over the indices of the three lists and checks if the elements at each index are identical. It counts how many such identical items exist across all three lists and returns this count. The test case provided in the problem statement is used to verify the correctness of the implementation."}
{"task_id": "Mbpp/145", "solution": "```markdown\nTo solve the problem of finding the maximum absolute difference between any two elements in an array, we can follow these steps:\n\n1. **Understand the Problem**: We need to find the maximum value of `|a[i] - a[j]|` for all possible pairs `(i, j)` where `0 <= i, j < n`.\n\n2. **Approach**:\n - The absolute difference between two numbers can be maximized by considering the smallest and largest elements in the array.\n - Therefore, the maximum absolute difference will be `max(arr) - min(arr)`.\n\n3. **Implementation**: We'll write a function `max_Abs_Diff` that takes an iterable (like a list or tuple), finds the minimum and maximum values, and returns their difference.\n\nHere's the Python script implementing this logic:\n\n```python\ndef max_Abs_Diff(arr):\n if not arr:\n return 0 # Return 0 for empty arrays as there are no elements to compare\n \n min_val = float('inf')\n max_val = float('-inf')\n \n for num in arr:\n if num < min_val:\n min_val = num\n if num > max_val:\n max_val = num\n \n return max_val - min_val\n\n# Test the function with the provided example\nassert max_Abs_Diff((2, 1, 5, 3)) == 4\n```\n\n### Explanation:\n\n- **Initialization**: We initialize `min_val` to positive infinity and `max_val` to negative infinity. This ensures that any number in the array will replace these initial values.\n \n- **Iteration**: We iterate through each element in the array:\n - Update `min_val` if the current element is smaller than the current `min_val`.\n - Update `max_val` if the current element is larger than the current `max_val`.\n\n- **Result**: The maximum absolute difference is simply the difference between `max_val` and `min_val`.\n\nThis approach efficiently computes the result in a single pass through the array, making it O(n) in time complexity."}
{"task_id": "Mbpp/160", "solution": "To solve the problem of finding integers \\(x\\) and \\(y\\) such that \\(ax + by = n\\), we can use the Extended Euclidean Algorithm. This algorithm not only computes the greatest common divisor (GCD) of two numbers \\(a\\) and \\(b\\), but also finds coefficients \\(x\\) and \\(y\\) such that:\n\n\\[ ax + by = \\text{gcd}(a, b) \\]\n\nIf \\(n\\) is a multiple of \\(\\text{gcd}(a, b)\\), then we can scale the solution to find integers \\(x\\) and \\(y\\) such that:\n\n\\[ ax + by = n \\]\n\nHere's how you can implement this in Python:\n\n```python\ndef extended_gcd(a, b):\n \"\"\" Returns a tuple (g, x, y) such that a*x + b*y = g = gcd(a, b) \"\"\"\n if a == 0:\n return b, 0, 1\n else:\n g, x1, y1 = extended_gcd(b % a, a)\n x = y1 - (b // a) * x1\n y = x1\n return g, x, y\n\ndef find_solution(a, b, n):\n \"\"\" Returns integers x and y such that ax + by = n, or None if no solution exists \"\"\"\n gcd, x, y = extended_gcd(a, b)\n \n # Check if a solution exists\n if n % gcd != 0:\n return None\n \n # Scale the solution to get the desired result\n x *= n // gcd\n y *= n // gcd\n \n return (x, y)\n\n# Test case\nassert find_solution(2, 3, 7) == (2, 1)\n```\n\n### Explanation:\n\n1. **Extended Euclidean Algorithm**: The `extended_gcd` function computes the GCD of \\(a\\) and \\(b\\), along with coefficients \\(x\\) and \\(y\\) such that \\(ax + by = \\text{gcd}(a, b)\\).\n\n2. **Checking for Solutions**: In the `find_solution` function, we first check if a solution exists by verifying if \\(n\\) is divisible by \\(\\text{gcd}(a, b)\\). If not, return `None`.\n\n3. **Scaling the Solution**: If a solution exists, scale the coefficients \\(x\\) and \\(y\\) by \\(n // \\text{gcd}(a, b)\\) to satisfy the equation \\(ax + by = n\\).\n\nThis approach efficiently finds the required integers \\(x\\) and \\(y\\) or determines that no solution exists."}
{"task_id": "Mbpp/161", "solution": "Certainly! Below is a self-contained Python script that defines the function `remove_elements` to solve the problem described. The function takes two lists as input and returns a new list with elements from the first list that are not present in the second list.\n\n```python\ndef remove_elements(original_list, elements_to_remove):\n \"\"\"\n Remove all elements from original_list that are present in elements_to_remove.\n \n Parameters:\n - original_list: List of integers to filter.\n - elements_to_remove: List of integers to be removed from the original list.\n \n Returns:\n - A new list containing only those elements from original_list \n which are not in elements_to_remove.\n \"\"\"\n # Use a set for faster lookup times\n remove_set = set(elements_to_remove)\n \n # Create a new list with elements that are not in the remove_set\n result = [element for element in original_list if element not in remove_set]\n \n return result\n\n# Test case to verify the function works as expected\nassert remove_elements([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], [2, 4, 6, 8]) == [1, 3, 5, 7, 9, 10]\n\n# Additional test cases\nassert remove_elements([10, 20, 30, 40], [20, 40]) == [10, 30]\nassert remove_elements([], [1, 2, 3]) == []\nassert remove_elements([1, 2, 3], []) == [1, 2, 3]\nassert remove_elements([1, 2, 3], [4, 5, 6]) == [1, 2, 3]\n\nprint(\"All test cases passed!\")\n```\n\n### Explanation:\n- **Function Definition**: The function `remove_elements` takes two parameters: `original_list` and `elements_to_remove`.\n- **Set for Efficiency**: We convert `elements_to_remove` into a set called `remove_set`. This allows us to check membership in constant time, making the filtering process more efficient.\n- **List Comprehension**: We use list comprehension to iterate over each element in `original_list` and include it in the result only if it is not present in `remove_set`.\n- **Assertions**: Several assertions are included to test the function with different scenarios, ensuring its correctness.\n\nThis script will print \"All test cases passed!\" if all assertions hold true."}
{"task_id": "Mbpp/162", "solution": "Certainly! Below is a self-contained Python script that defines the function `sum_series` to solve the problem as described:\n\n```markdown\n```python\ndef sum_series(n):\n \"\"\"\n Calculate the sum of the series: n + (n-2) + (n-4) + ... \n until the term becomes less than or equal to 0.\n \n Parameters:\n n (int): The starting number of the series.\n\n Returns:\n int: The sum of the series.\n \"\"\"\n total_sum = 0\n for i in range(n // 2 + 1):\n term = n - 2 * i\n if term > 0:\n total_sum += term\n return total_sum\n\n# Test case\nassert sum_series(6) == 12, \"Test case failed!\"\nprint(\"Test passed!\")\n\n```\n```\n\n### Explanation:\n\n- The function `sum_series` takes an integer `n` as input.\n- It initializes `total_sum` to zero. This variable will accumulate the sum of the series.\n- A loop runs from `i = 0` to `i = n // 2`. The condition `n // 2 + 1` ensures that we include the middle term when `n` is odd.\n- In each iteration, it calculates the current term as `n - 2 * i`.\n- It checks if the term is greater than zero before adding it to `total_sum`.\n- Finally, it returns the accumulated sum.\n\nThe test case `assert sum_series(6) == 12` verifies that the function works correctly for the input `n = 6`."}
{"task_id": "Mbpp/165", "solution": "```markdown\nHere's a Python script that solves the problem:\n\n```python\ndef count_char_position(s):\n # Convert the input string to lowercase for case insensitivity\n s = s.lower()\n \n # Initialize a counter for characters at their alphabet position\n count = 0\n \n # Iterate over each character and its index in the string\n for i, char in enumerate(s):\n # Check if the character is an alphabet and matches its position (1-based)\n if 'a' <= char <= 'z' and ord(char) - ord('a') == i:\n count += 1\n \n return count\n\n# Test case\nassert count_char_position(\"xbcefg\") == 2\n```\n\n### Explanation:\n\n- **Lowercase Conversion**: The string is converted to lowercase to handle case insensitivity.\n \n- **Character Position Check**: For each character in the string, we check if it matches its position in the alphabet:\n - `'a'` should be at index `0`, `'b'` at index `1`, and so on up to `'z'` at index `25`.\n - This is done using `ord(char) - ord('a') == i`, where `ord()` gives the ASCII value of a character.\n\n- **Counting Matches**: If a character matches its expected position, we increment the counter.\n\nThis function will correctly count characters that are in their respective positions as per the English alphabet."}
{"task_id": "Mbpp/166", "solution": "```markdown\nTo solve this problem, we need to count the number of pairs \\((i, j)\\) such that \\(i < j\\) and the XOR of two integers in a list results in an even number. The key observation here is:\n\n- An integer's parity (even or odd) determines whether its XOR with another integer will be even or odd:\n - Even XOR Even = Even\n - Odd XOR Odd = Even\n - Even XOR Odd = Odd\n\nThus, for the XOR of two numbers to be even, both numbers must either be even or both must be odd.\n\nHere's a step-by-step approach to implement this:\n\n1. Count how many numbers in the list are even and how many are odd.\n2. Calculate the number of ways to choose 2 even numbers from the count of even numbers using combinations: \\(\\text{C}(n, 2) = \\frac{n(n-1)}{2}\\).\n3. Similarly, calculate the number of ways to choose 2 odd numbers from the count of odd numbers.\n4. The sum of these two values will give us the total number of pairs whose XOR is even.\n\nHere's the Python function implementing this logic:\n\n```python\ndef find_even_pair(lst):\n # Count even and odd numbers in the list\n even_count = sum(1 for x in lst if x % 2 == 0)\n odd_count = len(lst) - even_count\n \n # Calculate combinations of pairs\n even_pairs = (even_count * (even_count - 1)) // 2\n odd_pairs = (odd_count * (odd_count - 1)) // 2\n \n # Total pairs with even XOR\n return even_pairs + odd_pairs\n\n# Test the function\nassert find_even_pair([5, 4, 7, 2, 1]) == 4\n```\n\n### Explanation:\n\n- **Counting Even and Odd Numbers**: We iterate through the list once to count how many numbers are even.\n- **Combinations Formula**: The formula \\(\\frac{n(n-1)}{2}\\) is used to calculate combinations of pairs from a set of \\(n\\) items, which efficiently gives us the number of ways to pick 2 items out of \\(n\\).\n- **Summing Pairs**: By summing the even and odd pairs, we get all possible pairs whose XOR results in an even number.\n\nThis solution is efficient with a time complexity of \\(O(n)\\), where \\(n\\) is the length of the list, as it involves a single pass through the list to count evens and odds."}
{"task_id": "Mbpp/167", "solution": "Certainly! Below is a self-contained Python script that defines a function `next_power_of_2` which finds the smallest power of 2 greater than or equal to a given integer \\( n \\). The function includes an assertion to verify its correctness for the case when \\( n = 0 \\).\n\n```python\ndef next_power_of_2(n):\n \"\"\"\n Find the smallest power of 2 that is greater than or equal to n.\n \n Parameters:\n n (int): A non-negative integer\n \n Returns:\n int: The smallest power of 2 >= n\n \"\"\"\n if n < 0:\n raise ValueError(\"Input must be a non-negative integer\")\n \n # Special case for n = 0\n if n == 0:\n return 1\n\n # Find the next power of 2 greater than or equal to n\n power = 1\n while power < n:\n power <<= 1 # Equivalent to multiplying by 2\n \n return power\n\n# Test case as per the problem statement\nassert next_power_of_2(0) == 1, \"Test case failed!\"\n\n# Additional test cases for verification\nprint(next_power_of_2(0)) # Output: 1\nprint(next_power_of_2(5)) # Output: 8\nprint(next_power_of_2(16)) # Output: 16\nprint(next_power_of_2(17)) # Output: 32\n```\n\n### Explanation:\n- The function `next_power_of_2` takes a non-negative integer \\( n \\) as input.\n- It first checks if the input is negative and raises an error since powers of 2 are only defined for non-negative integers in this context.\n- If \\( n = 0 \\), it directly returns 1, because \\( 2^0 = 1 \\) is the smallest power of 2 greater than or equal to 0.\n- For other values of \\( n \\), it initializes `power` to 1 and keeps doubling it (using bitwise left shift `<<= 1`) until it finds a value that is greater than or equal to \\( n \\).\n- The function then returns this power of 2.\n\nThis script includes an assertion for the specific test case provided in the problem statement, as well as additional print statements for further verification."}
{"task_id": "Mbpp/168", "solution": "Certainly! Below is a self-contained Python script that defines a function `frequency` which counts the number of occurrences of a specified number in a given list. The function uses assertions to verify its correctness.\n\n```python\ndef frequency(lst, num):\n \"\"\"\n Count the number of occurrences of 'num' in the list 'lst'.\n \n Parameters:\n lst (list): A list of numbers.\n num (int or float): The number whose occurrences need to be counted.\n \n Returns:\n int: The count of occurrences of 'num' in 'lst'.\n \"\"\"\n return lst.count(num)\n\n# Test cases\nassert frequency([1, 2, 3], 4) == 0, \"Test case 1 failed\"\nassert frequency([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 5) == 1, \"Test case 2 failed\"\nassert frequency([1, 1, 1, 1, 1], 1) == 5, \"Test case 3 failed\"\nassert frequency([], 1) == 0, \"Test case 4 failed\"\nassert frequency([1, 2, 3, 4, 5], 6) == 0, \"Test case 5 failed\"\n\nprint(\"All test cases passed!\")\n```\n\n### Explanation:\n- The `frequency` function takes two parameters: a list `lst` and a number `num`.\n- It uses the built-in `count()` method of lists to count how many times `num` appears in `lst`.\n- Several assertions are included to ensure that the function behaves as expected for different scenarios, including edge cases like an empty list or when the number is not present in the list."}
{"task_id": "Mbpp/170", "solution": "Certainly! Below is a self-contained Python script that defines the function `sum_range_list` to solve the problem described. The function calculates the sum of numbers in a list within a specified range defined by two indices.\n\n```python\ndef sum_range_list(numbers, start_index, end_index):\n \"\"\"\n Calculate the sum of elements in the list 'numbers' from index 'start_index'\n (inclusive) to 'end_index' (exclusive).\n\n Parameters:\n - numbers: List[int] - A list of integers.\n - start_index: int - The starting index for summation (inclusive).\n - end_index: int - The ending index for summation (exclusive).\n\n Returns:\n - int: Sum of the elements within the specified range.\n \n Raises:\n - ValueError: If indices are out of bounds or if start_index is greater than end_index.\n \"\"\"\n # Check if indices are valid\n if not (0 <= start_index < len(numbers)) or not (start_index < end_index <= len(numbers)):\n raise ValueError(\"Invalid range specified by the indices.\")\n \n # Calculate and return the sum of elements in the specified range\n return sum(numbers[start_index:end_index])\n\n# Test case to verify the function works as expected\nassert sum_range_list([2, 1, 5, 6, 8, 3, 4, 9, 10, 11, 8, 12], 8, 11) == 29\n\nprint(\"The test passed successfully!\")\n```\n\n### Explanation:\n- **Function Definition**: The function `sum_range_list` takes three parameters: a list of integers (`numbers`) and two indices (`start_index`, `end_index`).\n- **Index Validation**: It checks if the provided indices are within valid bounds. If not, it raises a `ValueError`.\n- **Sum Calculation**: Using Python's slicing feature, it calculates the sum of elements from `start_index` to `end_index - 1`.\n- **Test Case**: The function is tested with an assertion to ensure it returns the correct result for the given example.\n\nThis script should be run in a Python environment where you can execute and verify its correctness."}
{"task_id": "Mbpp/171", "solution": "```markdown\nTo solve this problem, we need to write a Python function that calculates the perimeter of a regular pentagon given the length of one of its sides. A regular pentagon has five equal-length sides, so the perimeter is simply five times the length of one side.\n\nHere's how you can implement this:\n\n```python\ndef perimeter_pentagon(side_length):\n \"\"\"\n Calculate the perimeter of a regular pentagon.\n \n Parameters:\n - side_length: The length of one side of the pentagon.\n \n Returns:\n - The perimeter of the pentagon.\n \"\"\"\n # A regular pentagon has 5 sides, so multiply the side length by 5\n return 5 * side_length\n\n# Test case to verify the function works as expected\nassert perimeter_pentagon(5) == 25\n```\n\n### Explanation:\n\n- **Function Definition**: The function `perimeter_pentagon` takes one parameter, `side_length`, which represents the length of a single side of the pentagon.\n \n- **Calculation**: Since all sides of a regular pentagon are equal, the perimeter is calculated by multiplying the side length by 5.\n\n- **Return Value**: The function returns this computed value as the perimeter.\n\n- **Assertion**: An assertion is used to test that the function works correctly. For a side length of 5, the expected perimeter is 25, which matches our calculation.\n\nThis implementation efficiently computes the perimeter and includes a simple test case to ensure correctness.\n```"}
{"task_id": "Mbpp/172", "solution": "Certainly! Below is a self-contained Python script that defines a function `count_occurrence` to count the occurrences of the substring `'std'` within a given string. The function uses Python's built-in methods to achieve this.\n\n```python\ndef count_occurrence(s):\n \"\"\"\n Count the number of occurrences of the substring 'std' in the given string s.\n \n Parameters:\n s (str): The input string where we want to find occurrences of 'std'.\n \n Returns:\n int: The number of times 'std' appears in the string.\n \"\"\"\n # Initialize a counter for occurrences\n count = 0\n \n # Loop through the string, checking each substring of length 3\n for i in range(len(s) - 2):\n if s[i:i+3] == 'std':\n count += 1\n \n return count\n\n# Test case to verify the function works as expected\nassert count_occurrence(\"letstdlenstdporstd\") == 3\n\nprint(\"The test passed successfully!\")\n```\n\n### Explanation:\n- The `count_occurrence` function takes a single argument, `s`, which is the string in which we want to find occurrences of `'std'`.\n- We initialize a counter variable `count` to zero.\n- We iterate over the indices of the string from 0 to `len(s) - 3`. This ensures that when we take substrings of length 3, they do not exceed the bounds of the string.\n- For each index `i`, we extract the substring `s[i:i+3]` and check if it equals `'std'`.\n- If it does, we increment our counter by one.\n- Finally, the function returns the total count of occurrences.\n\nThe provided test case checks that the function correctly identifies 3 occurrences of `'std'` in the string `\"letstdlenstdporstd\"`."}
{"task_id": "Mbpp/222", "solution": "Certainly! Below is a self-contained Python script that defines a function `check_type` to determine if all the elements in a tuple have the same data type. The function uses assertions to verify its correctness.\n\n```python\ndef check_type(tpl):\n \"\"\"\n Check if all elements in the tuple have the same data type.\n \n Parameters:\n tpl (tuple): A tuple containing elements of any data types.\n \n Returns:\n bool: True if all elements are of the same type, False otherwise.\n \"\"\"\n # Use a set to store unique types found in the tuple\n types = {type(element) for element in tpl}\n \n # If there's only one unique type, return True; otherwise, return False\n return len(types) == 1\n\n# Test cases\nassert check_type((5, 6, 7, 3, 5, 6)) == True, \"Test case 1 failed\"\nassert check_type(('a', 'b', 'c')) == True, \"Test case 2 failed\"\nassert check_type((1.0, 2.5, 3.14)) == True, \"Test case 3 failed\"\nassert check_type((True, False, True)) == True, \"Test case 4 failed\"\n\n# Mixed types\nassert check_type((5, 'a', 7)) == False, \"Test case 5 failed\"\nassert check_type(('a', 1, 'b')) == False, \"Test case 6 failed\"\nassert check_type((True, 1, 'yes')) == False, \"Test case 7 failed\"\n\nprint(\"All test cases passed!\")\n```\n\n### Explanation:\n- The function `check_type` takes a tuple as input.\n- It uses a set comprehension to collect the unique types of elements present in the tuple.\n- If the length of this set is 1, it means all elements are of the same type, and the function returns `True`.\n- Otherwise, it returns `False`.\n- The script includes several test cases using assertions to ensure the function behaves as expected."}
{"task_id": "Mbpp/223", "solution": "Certainly! Below is a self-contained Python script that solves the problem of determining if an element is the majority element in a sorted array. The function `is_majority` checks whether the given element occurs more than \\( n/2 \\) times.\n\n```python\ndef is_majority(arr, n, elem):\n \"\"\"\n Determines if 'elem' is the majority element in the sorted array 'arr'.\n \n Parameters:\n arr (list): A sorted list of integers.\n n (int): The length of the array.\n elem (int): The element to check for majority status.\n\n Returns:\n bool: True if 'elem' is a majority element, False otherwise.\n \"\"\"\n # Binary search to find the first occurrence of elem\n left = 0\n right = n - 1\n first_occurrence = -1\n\n while left <= right:\n mid = (left + right) // 2\n if arr[mid] == elem:\n first_occurrence = mid\n right = mid - 1 # Look on the left side for earlier occurrence\n elif arr[mid] < elem:\n left = mid + 1\n else:\n right = mid - 1\n\n # If element is not found, return False\n if first_occurrence == -1:\n return False\n\n # Binary search to find the last occurrence of elem\n left = 0\n right = n - 1\n last_occurrence = -1\n\n while left <= right:\n mid = (left + right) // 2\n if arr[mid] == elem:\n last_occurrence = mid\n left = mid + 1 # Look on the right side for later occurrence\n elif arr[mid] < elem:\n left = mid + 1\n else:\n right = mid - 1\n\n # Calculate the number of occurrences\n count = last_occurrence - first_occurrence + 1\n\n # Check if it is a majority element\n return count > n // 2\n\n\n# Test case\nassert is_majority([1, 2, 3, 3, 3, 3, 10], 7, 3) == True\n```\n\n### Explanation:\n\n1. **Binary Search for First Occurrence**: We perform a binary search to find the first occurrence of `elem` in the array. This helps us determine where the sequence of `elem` starts.\n\n2. **Binary Search for Last Occurrence**: Similarly, we perform another binary search to find the last occurrence of `elem`. This tells us where the sequence ends.\n\n3. **Count Calculation**: The number of times `elem` appears is calculated as `last_occurrence - first_occurrence + 1`.\n\n4. **Majority Check**: Finally, we check if this count is greater than \\( n/2 \\). If it is, `elem` is a majority element; otherwise, it is not.\n\nThis approach efficiently uses binary search to find the range of occurrences in logarithmic time, making it suitable for large arrays."}
{"task_id": "Mbpp/224", "solution": "Certainly! Below is a self-contained Python script that defines a function `count_set_bits` to count the number of set bits (binary digits with value 1) in a given integer. The function uses bitwise operations to efficiently determine the number of set bits.\n\n```python\ndef count_set_bits(n):\n \"\"\"\n Count the number of set bits (1s) in the binary representation of an integer.\n \n Parameters:\n n (int): A non-negative integer whose set bits are to be counted.\n \n Returns:\n int: The number of set bits in the binary representation of n.\n \"\"\"\n count = 0\n while n:\n # Use bitwise AND operation with 1 to check if the least significant bit is set\n count += n & 1\n # Right shift n by 1 to process the next bit\n n >>= 1\n return count\n\n# Test cases\nassert count_set_bits(2) == 1, \"Test case failed for input 2\"\nassert count_set_bits(0) == 0, \"Test case failed for input 0\"\nassert count_set_bits(15) == 4, \"Test case failed for input 15\" # Binary: 1111\nassert count_set_bits(7) == 3, \"Test case failed for input 7\" # Binary: 0111\n\nprint(\"All test cases passed!\")\n```\n\n### Explanation:\n- The function `count_set_bits` takes an integer `n` as input.\n- It initializes a counter `count` to zero.\n- Using a while loop, it checks each bit of the number:\n - `n & 1` performs a bitwise AND operation between `n` and `1`. This isolates the least significant bit (LSB) of `n`.\n - If the LSB is set (i.e., equal to 1), it increments the `count`.\n - The expression `n >>= 1` right shifts `n` by one position, effectively discarding the LSB and moving all other bits one place to the right.\n- This process continues until all bits are processed (`n` becomes zero).\n- Finally, the function returns the total count of set bits.\n\nThe script includes test cases using assertions to verify that the function works correctly for various inputs."}
{"task_id": "Mbpp/226", "solution": "Certainly! Below is a self-contained Python script that defines a function to remove characters with odd indices from a given string. The function `odd_values_string` takes a single argument, the input string, and returns a new string containing only the characters at even indices.\n\n```python\ndef odd_values_string(s):\n \"\"\"\n This function removes characters which have odd index values from the given string.\n \n Parameters:\n s (str): The input string from which to remove characters with odd indices.\n \n Returns:\n str: A new string containing only characters at even indices of the original string.\n \"\"\"\n # Using list comprehension to select characters at even indices\n result = ''.join([s[i] for i in range(len(s)) if i % 2 == 0])\n return result\n\n# Test case\nassert odd_values_string('abcdef') == 'ace'\n```\n\nThis script defines the function and includes a test case using an `assert` statement to verify that the function works as expected. The list comprehension iterates over each index of the string, checks if it is even (`i % 2 == 0`), and constructs a new string with those characters."}
{"task_id": "Mbpp/227", "solution": "```markdown\n```python\ndef min_of_three(a, b, c):\n \"\"\"\n This function takes three numerical arguments and returns the smallest one.\n\n Parameters:\n a (int/float): The first number.\n b (int/float): The second number.\n c (int/float): The third number.\n\n Returns:\n int/float: The minimum of the three numbers.\n \"\"\"\n # Compare the first two numbers and find the smaller one\n if a < b:\n min_ab = a\n else:\n min_ab = b\n \n # Now compare the smaller of the first two with the third number\n if min_ab < c:\n return min_ab\n else:\n return c\n\n# Test case to verify that the function works as expected\nassert min_of_three(10, 20, 0) == 0\n```\n```"}
{"task_id": "Mbpp/230", "solution": "Certainly! Below is a self-contained Python script that defines a function to solve the problem described. The function `replace_blank` takes a string and a character as input, replaces all blank spaces in the string with the given character, and returns the modified string.\n\n```python\ndef replace_blank(input_string, char):\n \"\"\"\n Replaces all blank spaces in the input_string with the specified character.\n \n Parameters:\n - input_string (str): The original string containing spaces to be replaced.\n - char (str): The character that will replace each space in the input_string.\n \n Returns:\n - str: A new string with all spaces replaced by the given character.\n \"\"\"\n # Replace spaces with the specified character\n return input_string.replace(' ', char)\n\n# Test case to verify the function works as expected\nassert replace_blank(\"hello people\", '@') == \"hello@people\"\n\n# Additional test cases for further verification\nprint(replace_blank(\"hello world\", '#')) # Expected: \"hello#world\"\nprint(replace_blank(\"a b c d e\", '*')) # Expected: \"a*b*c*d*e\"\nprint(replace_blank(\"\", '!')) # Expected: \"\"\nprint(replace_blank(\"no_spaces_here\", '-')) # Expected: \"no_spaces_here\"\n```\n\nThis script includes the function definition and several test cases to ensure it works correctly. The `replace_blank` function uses Python's built-in string method `.replace()` to substitute spaces with the specified character efficiently."}
{"task_id": "Mbpp/232", "solution": "Certainly! Below is a self-contained Python script that defines the function `larg_nnum` to solve the problem described. The function takes in a list and an integer `n`, and returns a list containing the `n` largest items from the input list.\n\n```python\ndef larg_nnum(lst, n):\n \"\"\"\n Returns a list of the n largest numbers from the given list.\n \n Parameters:\n lst (list): A list of integers or floats.\n n (int): The number of largest elements to return.\n \n Returns:\n list: A list containing the n largest items from the input list.\n \"\"\"\n # Sort the list in descending order\n sorted_lst = sorted(lst, reverse=True)\n # Return the first n elements from the sorted list\n return sorted_lst[:n]\n\n# Example usage and assertion to verify correctness\nassert set(larg_nnum([10, 20, 50, 70, 90, 20, 50, 40, 60, 80, 100], 2)) == set([100, 90])\n```\n\n### Explanation:\n- **Sorting**: The function first sorts the input list in descending order using Python's built-in `sorted()` function with the `reverse=True` parameter.\n- **Slicing**: It then slices the sorted list to get the first `n` elements, which are the largest due to the sorting order.\n- **Return**: Finally, it returns this sliced list containing the `n` largest numbers.\n\nThis approach ensures that we efficiently find and return the required number of largest items from the list. The assertion at the end checks if the function works correctly for a given example."}
{"task_id": "Mbpp/233", "solution": "Certainly! Below is a self-contained Python script that defines a function to calculate the lateral surface area of a cylinder and includes an assertion to verify its correctness.\n\n```python\nimport math\n\ndef lateralsurface_cylinder(radius, height):\n \"\"\"\n Calculate the lateral surface area of a cylinder.\n \n Parameters:\n radius (float): The radius of the base of the cylinder.\n height (float): The height of the cylinder.\n \n Returns:\n float: The lateral surface area of the cylinder.\n \"\"\"\n # Lateral surface area formula for a cylinder is 2 * pi * radius * height\n return 2 * math.pi * radius * height\n\n# Test case to verify the function's correctness\nassert math.isclose(lateralsurface_cylinder(10, 5), 314.15000000000003, rel_tol=0.001)\n\nprint(\"The lateral surface area of a cylinder with radius 10 and height 5 is:\", lateralsurface_cylinder(10, 5))\n```\n\n### Explanation:\n- **Function Definition**: The function `lateralsurface_cylinder` takes two parameters: `radius` and `height`.\n- **Formula Used**: The formula for the lateral surface area of a cylinder is \\(2 \\pi r h\\), where \\(r\\) is the radius and \\(h\\) is the height.\n- **Assertion**: We use `math.isclose()` to check if the calculated value is approximately equal to 314.15 with a relative tolerance of 0.001, ensuring precision in floating-point arithmetic.\n- **Output**: The script prints the lateral surface area for a cylinder with radius 10 and height 5.\n\nThis script will correctly calculate and verify the lateral surface area of a cylinder based on the given parameters."}
{"task_id": "Mbpp/234", "solution": "Certainly! Below is a self-contained Python script that defines a function `volume_cube` to calculate the volume of a cube given its side length. The function uses the formula for the volume of a cube, which is \\( \\text{side}^3 \\).\n\n```python\ndef volume_cube(side_length):\n \"\"\"\n Calculate the volume of a cube.\n\n Parameters:\n side_length (float or int): The length of a side of the cube.\n\n Returns:\n float: The volume of the cube.\n \"\"\"\n return side_length ** 3\n\n# Test case to verify the function works as expected\nassert volume_cube(3) == 27, \"Test case failed!\"\n\nprint(\"The function passed all test cases.\")\n```\n\n### Explanation:\n\n- **Function Definition**: `volume_cube` takes one parameter, `side_length`, which represents the length of a side of the cube.\n \n- **Volume Calculation**: The volume is calculated using the formula \\( \\text{side}^3 \\), where `**` is the exponentiation operator in Python.\n\n- **Assertion**: An assertion checks if calling `volume_cube(3)` returns 27, which is the expected result for a cube with side length 3. If the assertion fails, it raises an error indicating that the test case failed.\n\n- **Output**: If all assertions pass, a message confirming success is printed."}
{"task_id": "Mbpp/235", "solution": "Certainly! Below is a Python script that defines a function `even_bit_set_number` which sets all the even-positioned bits (0-indexed from the right) of a given integer to 1. The function then returns this modified number.\n\n```python\ndef even_bit_set_number(n):\n \"\"\"\n This function takes an integer n and sets all its even-positioned bits to 1.\n \n Args:\n n (int): The input integer whose even bits are to be set.\n \n Returns:\n int: The integer with all even bits set to 1.\n \"\"\"\n # Create a mask where all even bits are set to 1\n # For example, for an 8-bit number, the mask would be 0b10101010 (170 in decimal)\n mask = 0xAAAAAAAA\n \n # Use bitwise OR to set all even bits of n to 1\n result = n | mask\n \n return result\n\n# Test cases\nassert even_bit_set_number(10) == 10, \"Test case 1 failed\"\nassert even_bit_set_number(5) == 7, \"Test case 2 failed\" # Binary: 0101 -> 0111\nassert even_bit_set_number(0) == 170, \"Test case 3 failed\" # All bits set to 0 -> 10101010\n\nprint(\"All test cases passed!\")\n```\n\n### Explanation:\n\n- **Mask Creation**: The mask `0xAAAAAAAA` is used because it has all the even-positioned bits set to 1. In binary, this is represented as `10101010...` for a 32-bit integer.\n \n- **Bitwise OR Operation**: By performing a bitwise OR between the number and the mask, we ensure that all even bits in the original number are set to 1.\n\n- **Test Cases**:\n - For `n = 10`, which is `1010` in binary, the result remains `1010` because the even bits are already set.\n - For `n = 5`, which is `0101` in binary, the result becomes `0111`.\n - For `n = 0`, all bits are initially unset, so the result is `10101010` (170 in decimal).\n\nThis script includes assertions to verify that the function behaves as expected for different inputs."}
{"task_id": "Mbpp/237", "solution": "Here's a self-contained Python script that solves the problem described:\n\n```markdown\n```python\ndef check_occurrences(tuples_list):\n \"\"\"\n This function takes in a list of tuples and returns a dictionary mapping each unique tuple \n to the number of times it occurs in the list. It considers (a, b) and (b, a) as the same tuple.\n \n :param tuples_list: List of tuples\n :return: Dictionary with normalized tuples as keys and their counts as values\n \"\"\"\n from collections import defaultdict\n\n # Create a default dictionary to store occurrences\n occurrence_dict = defaultdict(int)\n\n for a, b in tuples_list:\n # Normalize the tuple by sorting it\n normalized_tuple = tuple(sorted((a, b)))\n # Increment the count of this normalized tuple\n occurrence_dict[normalized_tuple] += 1\n\n return dict(occurrence_dict)\n\n\n# Test case\nassert check_occurrences([(3, 1), (1, 3), (2, 5), (5, 2), (6, 3)]) == {(1, 3): 2, (2, 5): 2, (3, 6): 1}\n```\n```\n\n### Explanation:\n\n- **Normalization**: Each tuple `(a, b)` is normalized by sorting it to ensure that `(a, b)` and `(b, a)` are treated as the same.\n \n- **Counting Occurrences**: A `defaultdict` from the `collections` module is used to count occurrences of each normalized tuple.\n\n- **Return Value**: The function returns a regular dictionary with the counts of each unique (normalized) tuple."}
{"task_id": "Mbpp/238", "solution": "Certainly! To solve this problem, we need to determine how many non-empty substrings can be formed from a given string. A substring is any contiguous sequence of characters within the string.\n\nFor a string of length \\( n \\), the number of non-empty substrings can be calculated using the formula:\n\n\\[ \\text{Number of substrings} = \\frac{n \\times (n + 1)}{2} \\]\n\nThis formula arises because:\n- For each starting position in the string, you can choose an ending position that is equal to or after the starting position.\n- If the string length is \\( n \\), there are \\( n \\) possible starting positions.\n- For a given starting position \\( i \\), there are \\( (n - i + 1) \\) possible ending positions.\n\nThe sum of all these possibilities from each starting point gives us the total number of substrings:\n\n\\[ 1 + 2 + 3 + \\ldots + n = \\frac{n \\times (n + 1)}{2} \\]\n\nHere's a Python function implementing this logic:\n\n```python\ndef number_of_substrings(s):\n \"\"\"\n Calculate the number of non-empty substrings in the given string.\n \n :param s: Input string\n :return: Number of non-empty substrings\n \"\"\"\n n = len(s)\n return (n * (n + 1)) // 2\n\n# Test case\nassert number_of_substrings(\"abc\") == 6\n```\n\n### Explanation:\n- The function `number_of_substrings` takes a string `s` as input.\n- It calculates the length of the string \\( n \\).\n- Using the formula, it computes the total number of non-empty substrings and returns this value.\n- The test case checks if the function correctly identifies that there are 6 non-empty substrings for the string \"abc\": \"a\", \"b\", \"c\", \"ab\", \"bc\", \"abc\"."}
{"task_id": "Mbpp/239", "solution": "```markdown\nTo solve this problem, we need to determine how many sequences of length `n` can be formed where each element is a positive integer that satisfies the condition: it must be at least twice the previous element and no greater than `m`.\n\nHere's a step-by-step breakdown of how you might implement such a function:\n\n1. **Recursive Approach**: We'll use recursion to explore all possible sequences starting from each valid initial number.\n\n2. **Base Case**: If the sequence length `n` is 1, any number between 1 and `m` can be a valid sequence by itself.\n\n3. **Recursive Case**: For longer sequences, if you have a current element `x`, the next element must be at least `2*x` but no more than `m`.\n\n4. **Memoization**: To optimize, we'll use memoization to store results of subproblems so that we don't recompute them.\n\nHere's how you can implement this in Python:\n\n```python\ndef get_total_number_of_sequences(m, n):\n # Memoization dictionary\n memo = {}\n\n def count_sequences(current_length, current_value):\n # Base case: if the sequence length is 1, return 1 (valid sequence)\n if current_length == 1:\n return 1\n \n # Check if result is already computed\n if (current_length, current_value) in memo:\n return memo[(current_length, current_value)]\n \n total_sequences = 0\n next_value = 2 * current_value\n \n # Explore all possible next values\n while next_value <= m:\n total_sequences += count_sequences(current_length - 1, next_value)\n next_value += 1\n \n # Store the result in memo dictionary\n memo[(current_length, current_value)] = total_sequences\n return total_sequences\n\n # Start counting sequences from each possible starting number\n total_count = 0\n for start in range(1, m + 1):\n total_count += count_sequences(n - 1, start)\n \n return total_count\n\n# Test the function with the provided example\nassert get_total_number_of_sequences(10, 4) == 4\n```\n\n### Explanation:\n\n- **Function `count_sequences(current_length, current_value)`**: This recursive helper function calculates the number of valid sequences starting from a given value and having a specific remaining length.\n\n- **Memoization (`memo` dictionary)**: Stores results for subproblems identified by `(current_length, current_value)`, preventing redundant calculations.\n\n- **Loop through all possible start values**: The main function iterates over each possible starting integer from 1 to `m` and uses the helper function to count sequences of length `n`.\n\nThis approach efficiently computes the number of valid sequences using recursion and memoization."}
{"task_id": "Mbpp/240", "solution": "Here's a self-contained Python script that solves the problem described:\n\n```python\ndef replace_list(list1, list2):\n \"\"\"\n Replaces the last element of the first list with all elements from the second list.\n\n Parameters:\n - list1: The first list whose last element will be replaced.\n - list2: The second list whose elements will replace the last element of the first list.\n\n Returns:\n A new list with the modification applied.\n \"\"\"\n # Check if list1 is not empty to avoid IndexError\n if list1:\n # Remove the last element from list1\n list1.pop()\n # Extend list1 with all elements from list2\n list1.extend(list2)\n \n return list1\n\n# Test case\nassert replace_list([1, 3, 5, 7, 9, 10], [2, 4, 6, 8]) == [1, 3, 5, 7, 9, 2, 4, 6, 8]\n```\n\nThis function first checks if `list1` is not empty to avoid an `IndexError` when attempting to pop the last element. It then removes the last element of `list1` and extends it with all elements from `list2`. The modified list is returned as the result."}
{"task_id": "Mbpp/242", "solution": "Certainly! Below is a self-contained Python script that defines a function `count_charac` which counts the total number of characters in a given string. The function then checks if this count matches the expected value using an assertion.\n\n```markdown\n```python\ndef count_charac(s):\n \"\"\"\n This function takes a string as input and returns the total number of characters in it.\n \n Parameters:\n s (str): The input string whose characters are to be counted.\n \n Returns:\n int: Total number of characters in the input string.\n \"\"\"\n return len(s)\n\n# Test case\nassert count_charac(\"python programming\") == 18\n\nprint(\"The function works correctly!\")\n```\n```\n\n### Explanation:\n\n- **Function Definition**: The `count_charac` function takes a single parameter `s`, which is expected to be a string. It uses Python's built-in `len()` function to determine the number of characters in the string.\n\n- **Assertion**: An assertion checks if the result from calling `count_charac(\"python programming\")` equals 18, ensuring that the function behaves as expected for this input.\n\n- **Output**: If the assertion passes without raising an error, it prints a confirmation message indicating that the function works correctly."}
{"task_id": "Mbpp/244", "solution": "Certainly! Below is a self-contained Python script that defines a function `next_Perfect_Square` which finds the next perfect square greater than a given number. The script also includes an assertion to verify its correctness.\n\n```markdown\n```python\nimport math\n\ndef next_Perfect_Square(n):\n \"\"\"\n Find the next perfect square greater than the given number n.\n \n Parameters:\n n (int): A non-negative integer\n \n Returns:\n int: The smallest perfect square greater than n\n \"\"\"\n # Calculate the ceiling of the square root of n\n root = math.ceil(math.sqrt(n))\n \n # Return the next perfect square\n return root * root\n\n# Test case to verify the function works as expected\nassert next_Perfect_Square(35) == 36, \"Test case failed!\"\n\nprint(\"The test case passed!\")\n```\n```\n\nThis script uses Python's `math` module to calculate the ceiling of the square root of the given number. It then squares this value to find the next perfect square greater than the input number. The assertion checks if the function correctly identifies 36 as the next perfect square after 35."}
{"task_id": "Mbpp/245", "solution": "Here's a Python script that solves the problem of finding the maximum sum of a bitonic subsequence in an array:\n\n```markdown\n```python\ndef max_sum_bitonic_subsequence(arr):\n n = len(arr)\n \n # Arrays to store the increasing and decreasing subsequences sums\n inc = [0] * n\n dec = [0] * n\n \n # Initialize both arrays with the values of arr\n for i in range(n):\n inc[i] = arr[i]\n dec[i] = arr[i]\n \n # Fill the inc array to store maximum sum of increasing subsequence ending at each index\n for i in range(1, n):\n for j in range(i):\n if arr[i] > arr[j]:\n inc[i] = max(inc[i], inc[j] + arr[i])\n \n # Fill the dec array to store maximum sum of decreasing subsequence starting from each index\n for i in range(n-2, -1, -1):\n for j in range(n-1, i, -1):\n if arr[i] > arr[j]:\n dec[i] = max(dec[i], dec[j] + arr[i])\n \n # Find the maximum sum of bitonic subsequence\n max_sum = float('-inf')\n for i in range(n):\n max_sum = max(max_sum, inc[i] + dec[i] - arr[i])\n \n return max_sum\n\n# Test case\nassert max_sum_bitonic_subsequence([1, 15, 51, 45, 33, 100, 12, 18, 9]) == 194\n```\n```\n\nThis script defines a function `max_sum_bitonic_subsequence` that calculates the maximum sum of a bitonic subsequence in an array. It uses dynamic programming to compute the maximum sums for increasing and decreasing subsequences ending at each index, then combines these results to find the maximum bitonic subsequence sum."}
{"task_id": "Mbpp/247", "solution": "```markdown\nTo solve the problem of finding the length of the longest palindromic subsequence (LPS) in a given string, we can use dynamic programming. The idea is to build a table where `dp[i][j]` represents the length of the longest palindromic subsequence within the substring from index `i` to `j`.\n\nHere's how you can implement this:\n\n```python\ndef lps(s: str) -> int:\n n = len(s)\n \n # Create a 2D table to store results of subproblems\n dp = [[0] * n for _ in range(n)]\n \n # Every single character is a palindrome of length 1\n for i in range(n):\n dp[i][i] = 1\n \n # Build the table. The outer loop is for substrings of increasing lengths.\n for cl in range(2, n + 1): # cl is the current length of substring\n for i in range(n - cl + 1):\n j = i + cl - 1\n \n if s[i] == s[j] and cl == 2:\n dp[i][j] = 2\n elif s[i] == s[j]:\n dp[i][j] = dp[i + 1][j - 1] + 2\n else:\n dp[i][j] = max(dp[i][j - 1], dp[i + 1][j])\n \n # The result is in the top right corner of the table\n return dp[0][n - 1]\n\n# Test case\nassert lps(\"TENS FOR TENS\") == 5\n```\n\n### Explanation:\n\n1. **Initialization**: \n - We initialize a 2D list `dp` where `dp[i][j]` will eventually hold the length of the longest palindromic subsequence in the substring `s[i:j+1]`.\n - Each character is a palindrome of length 1, so we set `dp[i][i] = 1` for all `i`.\n\n2. **Filling the Table**:\n - We consider substrings of increasing lengths (`cl` from 2 to `n`).\n - For each substring length, we iterate over possible starting indices `i`.\n - The ending index `j` is determined by `i + cl - 1`.\n - If the characters at positions `i` and `j` are the same:\n - If the length of the substring (`cl`) is 2, then it's a palindrome of length 2.\n - Otherwise, add 2 to the result from the inner substring `dp[i+1][j-1]`.\n - If the characters at positions `i` and `j` are different, take the maximum value between excluding either character (`dp[i][j-1]` or `dp[i+1][j]`).\n\n3. **Result**:\n - The length of the longest palindromic subsequence for the entire string is found at `dp[0][n-1]`.\n\nThis approach efficiently computes the LPS using dynamic programming with a time complexity of \\(O(n^2)\\) and space complexity of \\(O(n^2)\\)."}
{"task_id": "Mbpp/250", "solution": "Certainly! Below is a self-contained Python script that defines the function `count_X` to count occurrences of an element in a tuple. The function uses the built-in `count()` method available for tuples.\n\n```python\ndef count_X(tpl, element):\n \"\"\"\n Counts the number of times 'element' appears in the tuple 'tpl'.\n\n Parameters:\n tpl (tuple): A tuple containing elements.\n element: An element whose occurrences need to be counted in the tuple.\n\n Returns:\n int: The number of times 'element' occurs in 'tpl'.\n \"\"\"\n return tpl.count(element)\n\n# Test case\nassert count_X((10, 8, 5, 2, 10, 15, 10, 8, 5, 8, 8, 2), 4) == 0\n\nprint(\"All tests passed!\")\n```\n\n### Explanation:\n- The function `count_X` takes two parameters: a tuple `tpl` and an element `element`.\n- It uses the `count()` method of tuples to determine how many times `element` appears in `tpl`.\n- The test case checks if the function correctly returns 0 for the number of occurrences of the integer `4` in the given tuple, as expected."}
{"task_id": "Mbpp/251", "solution": "Certainly! Below is a self-contained Python script that defines a function to solve the problem described. The function `insert_element` takes in a list and an element, then inserts the element before each item in the list.\n\n```python\ndef insert_element(original_list, element):\n \"\"\"\n Inserts the given element before each element in the original list.\n \n Parameters:\n - original_list: List of elements where the new element will be inserted.\n - element: The element to insert before each element in the original list.\n \n Returns:\n A new list with the specified element inserted before each item from the original list.\n \"\"\"\n result = []\n for item in original_list:\n # Insert the element before each item\n result.append(element)\n result.append(item)\n return result\n\n# Test case to verify the function works as expected\nassert insert_element(['Red', 'Green', 'Black'], 'c') == ['c', 'Red', 'c', 'Green', 'c', 'Black']\n\nprint(\"The function passed the test case.\")\n```\n\nThis script defines the `insert_element` function and includes a test case to ensure it works correctly. The assertion checks that the output matches the expected result, confirming the function's correctness."}
{"task_id": "Mbpp/252", "solution": "Certainly! Below is a self-contained Python script that defines a function `convert` which converts a complex number into its polar coordinates. The function returns a tuple containing the magnitude and the angle in radians.\n\n```python\nimport cmath\n\ndef convert(complex_number):\n \"\"\"\n Convert a complex number to polar coordinates.\n \n Parameters:\n complex_number (complex): A complex number to be converted.\n \n Returns:\n tuple: A tuple containing the magnitude and the angle in radians.\n \"\"\"\n # Calculate the magnitude using the absolute value\n magnitude = abs(complex_number)\n \n # Calculate the phase angle using cmath.phase\n angle = cmath.phase(complex_number)\n \n return (magnitude, angle)\n\n# Test case to verify the function works as expected\nassert convert(1) == (1.0, 0.0), \"Test case failed!\"\n\nprint(\"The conversion of complex number 1 is:\", convert(1))\n```\n\n### Explanation:\n\n- **Magnitude**: The magnitude (or modulus) of a complex number \\( z = a + bi \\) is calculated as \\( |z| = \\sqrt{a^2 + b^2} \\). In Python, this can be obtained using the `abs()` function.\n\n- **Angle**: The angle (or argument) is the direction of the vector representing the complex number in the complex plane. It can be calculated using `cmath.phase()`, which returns the phase of a complex number as a float between \\(-\\pi\\) and \\(\\pi\\).\n\nThe script includes an assertion to ensure that converting the complex number \\(1 + 0i\\) results in polar coordinates \\((1.0, 0.0)\\), where \\(1.0\\) is the magnitude and \\(0.0\\) is the angle in radians."}
{"task_id": "Mbpp/253", "solution": "Certainly! Below is a self-contained Python script that defines a function to solve the problem described:\n\n```markdown\n```python\ndef count_integer(lst):\n \"\"\"\n This function takes a list as input and returns the number of integer elements in it.\n \n Parameters:\n lst (list): A list containing various data types.\n\n Returns:\n int: The count of integer elements in the list.\n \"\"\"\n # Initialize a counter for integers\n integer_count = 0\n \n # Iterate over each element in the list\n for item in lst:\n # Check if the current item is an instance of int\n if isinstance(item, int):\n # Increment the counter if it's an integer\n integer_count += 1\n \n return integer_count\n\n# Test case to verify the function works as expected\nassert count_integer([1, 2, 'abc', 1.2]) == 2\n```\n```\n\nThis script defines a function `count_integer` that iterates over each element in the provided list and checks if it is an instance of `int`. If so, it increments a counter. Finally, it returns the count of integer elements found in the list. The test case at the end verifies that the function works correctly for the given example."}
{"task_id": "Mbpp/255", "solution": "Certainly! Below is a self-contained Python script that solves the problem using the `itertools.product` function to generate all combinations with repetition:\n\n```markdown\n```python\nfrom itertools import product\n\ndef combinations_colors(colors, n):\n \"\"\"\n Generate all combinations (with repetition) of the elements in 'colors' of length 'n'.\n \n Parameters:\n colors (list): A list of strings representing colors.\n n (int): The length of each combination tuple.\n\n Returns:\n list: A list containing tuples, each representing a combination.\n \"\"\"\n # Use itertools.product to generate combinations with repetition\n return list(product(colors, repeat=n))\n\n# Test the function\nassert combinations_colors([\"Red\", \"Green\", \"Blue\"], 1) == [('Red',), ('Green',), ('Blue',)]\n```\n```\n\nThis script defines a function `combinations_colors` that takes a list of colors and an integer `n`, then uses `itertools.product` to generate all possible combinations with repetition of length `n`. The result is returned as a list of tuples."}
{"task_id": "Mbpp/256", "solution": "Certainly! Below is a self-contained Python script that defines a function to solve the problem described. The function `count_primes_less_than` takes a non-negative integer as input and returns the count of prime numbers less than that number.\n\n```python\ndef is_prime(n):\n \"\"\"Check if a number is a prime.\"\"\"\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\ndef count_primes_less_than(n):\n \"\"\"Return the number of prime numbers less than a given non-negative number.\"\"\"\n if n <= 2:\n return 0\n \n # Use Sieve of Eratosthenes to find all primes less than n\n is_prime = [True] * n\n p = 2\n while (p * p < n):\n if is_prime[p]:\n for i in range(p * p, n, p):\n is_prime[i] = False\n p += 1\n \n # Count primes\n prime_count = sum(1 for i in range(2, n) if is_prime[i])\n return prime_count\n\n# Test the function with an assertion\nassert count_primes_less_than(5) == 2\n```\n\n### Explanation:\n\n- **`is_prime(n)` Function**: This helper function checks if a number `n` is prime. It handles small numbers directly and uses trial division up to the square root of `n` for larger numbers.\n\n- **`count_primes_less_than(n)` Function**:\n - If `n` is less than or equal to 2, there are no primes less than `n`.\n - The Sieve of Eratosthenes algorithm is used to efficiently find all prime numbers less than `n`. It initializes a list `is_prime` where each index represents whether the number is prime.\n - Starting from the first prime number (2), it marks all multiples of each prime as non-prime.\n - Finally, it counts and returns the number of indices marked as prime.\n\nThis script efficiently calculates the number of primes less than a given number using the Sieve of Eratosthenes, which is optimal for this type of problem."}
{"task_id": "Mbpp/257", "solution": "Certainly! Below is a self-contained Python script that defines a function to solve the problem described. The function `swap_numbers` takes two arguments and returns them in reverse order as a tuple.\n\n```python\ndef swap_numbers(a, b):\n \"\"\"\n This function takes two numbers as input and returns a tuple with the second number first,\n followed by the first number.\n \n Parameters:\n a (int/float): The first number.\n b (int/float): The second number.\n \n Returns:\n tuple: A tuple containing the second number followed by the first number.\n \"\"\"\n return (b, a)\n\n# Test case to verify the function works as expected\nassert swap_numbers(10, 20) == (20, 10), \"Test case failed!\"\n\nprint(\"Function passed all test cases.\")\n```\n\nThis script includes:\n- A function `swap_numbers` that swaps two numbers.\n- An assertion to ensure the function behaves correctly with a given test case.\n- A print statement confirming successful execution if no assertion errors occur."}
{"task_id": "Mbpp/259", "solution": "Here's a Python script that solves the problem of maximizing elements from two tuples:\n\n```markdown\n```python\ndef maximize_elements(tuple_list1, tuple_list2):\n \"\"\"\n This function takes two lists of tuples and returns a new list of tuples.\n Each tuple in the resulting list is formed by taking the maximum element \n from each position (first or second) between corresponding tuples from the input lists.\n\n :param tuple_list1: List of tuples\n :param tuple_list2: List of tuples\n :return: A new list of tuples with maximized elements\n \"\"\"\n # Ensure both lists have the same length\n if len(tuple_list1) != len(tuple_list2):\n raise ValueError(\"Both input lists must have the same number of tuples.\")\n \n result = []\n for t1, t2 in zip(tuple_list1, tuple_list2):\n # Create a new tuple with maximized elements from both tuples\n max_tuple = (max(t1[0], t2[0]), max(t1[1], t2[1]))\n result.append(max_tuple)\n \n return result\n\n# Test the function with the provided example\nassert maximize_elements(((1, 3), (4, 5), (2, 9), (1, 10)), ((6, 7), (3, 9), (1, 1), (7, 3))) == ((6, 7), (4, 9), (2, 9), (7, 10))\n```\n```\n\nThis script defines a function `maximize_elements` that takes two lists of tuples and returns a new list where each tuple is formed by taking the maximum element from each position between corresponding tuples from the input lists. The function includes an assertion to verify its correctness with the provided example."}
{"task_id": "Mbpp/260", "solution": "To solve the problem of finding the nth Newman-Shanks-Williams (NSW) prime number, we first need to understand what NSW numbers are. The NSW sequence is defined as follows:\n\n1. \\( a_0 = 1 \\)\n2. \\( a_1 = 1 \\)\n3. For \\( n \\geq 2 \\), \\( a_n = 2a_{n-1} + a_{n-2} \\)\n\nThe task is to find the nth NSW number that is also prime.\n\nHere's a Python script to achieve this:\n\n```python\ndef is_prime(num):\n \"\"\"Check if a number is prime.\"\"\"\n if num <= 1:\n return False\n if num <= 3:\n return True\n if num % 2 == 0 or num % 3 == 0:\n return False\n i = 5\n while i * i <= num:\n if num % i == 0 or num % (i + 2) == 0:\n return False\n i += 6\n return True\n\ndef newman_shanks_williams(n):\n \"\"\"Find the nth NSW prime number.\"\"\"\n a, b = 1, 1\n count = 0\n \n while True:\n if is_prime(a):\n count += 1\n if count == n:\n return a\n \n # Generate the next NSW number\n a, b = 2 * a + b, a\n\n# Example usage\nassert newman_shanks_williams(3) == 7\n```\n\n### Explanation:\n\n1. **Prime Checking Function (`is_prime`)**: This function checks if a given number is prime. It handles small numbers and uses trial division up to the square root of the number for efficiency.\n\n2. **NSW Sequence Generation**: The `newman_shanks_williams` function generates NSW numbers using the recurrence relation \\( a_n = 2a_{n-1} + a_{n-2} \\).\n\n3. **Finding the nth Prime NSW Number**:\n - We initialize the first two NSW numbers, \\( a_0 \\) and \\( a_1 \\), both as 1.\n - We iterate to generate subsequent NSW numbers.\n - For each generated number, we check if it is prime using `is_prime`.\n - If it is prime, we increment our count of found prime NSW numbers.\n - Once the count matches the desired nth position, we return that NSW number.\n\nThis script efficiently finds the nth NSW prime by combining sequence generation with a prime-checking mechanism."}
{"task_id": "Mbpp/261", "solution": "Certainly! Below is a self-contained Python script that defines a function to perform element-wise division on two tuples. The function checks if the lengths of the tuples are equal and then divides each corresponding pair of elements.\n\n```python\ndef division_elements(tuple1, tuple2):\n \"\"\"\n Perform element-wise division between two tuples.\n \n Args:\n - tuple1: A tuple of numbers.\n - tuple2: A tuple of numbers with the same length as tuple1.\n \n Returns:\n - A new tuple containing the results of the division.\n \n Raises:\n - ValueError: If the lengths of the tuples are not equal or if any element in tuple2 is zero.\n \"\"\"\n # Check if both tuples have the same length\n if len(tuple1) != len(tuple2):\n raise ValueError(\"Tuples must be of the same length.\")\n \n # Initialize an empty list to store division results\n result = []\n \n # Iterate over pairs of elements from both tuples\n for a, b in zip(tuple1, tuple2):\n # Check if the divisor is zero\n if b == 0:\n raise ValueError(\"Division by zero is not allowed.\")\n \n # Perform division and append to results list\n result.append(a / b)\n \n # Convert the result list back into a tuple\n return tuple(result)\n\n# Test case\nassert division_elements((10, 4, 6, 9), (5, 2, 3, 3)) == (2, 2, 2, 3)\n```\n\nThis script includes error handling for cases where the tuples are of different lengths or when there is an attempt to divide by zero. The function `division_elements` returns a new tuple with the results of the division."}
{"task_id": "Mbpp/262", "solution": "Here's a self-contained Python script that solves the problem described:\n\n```python\ndef split_two_parts(lst, L):\n \"\"\"\n Splits the given list into two parts where the length of the first part is L.\n \n Parameters:\n lst (list): The list to be split.\n L (int): The desired length of the first part.\n \n Returns:\n tuple: A tuple containing the two resulting lists.\n \"\"\"\n # Ensure that L is a valid index\n if not 0 <= L <= len(lst):\n raise ValueError(\"L must be between 0 and the length of the list.\")\n \n # Split the list into two parts\n first_part = lst[:L]\n second_part = lst[L:]\n \n return (first_part, second_part)\n\n# Test case\nassert split_two_parts([1, 1, 2, 3, 4, 4, 5, 1], 3) == ([1, 1, 2], [3, 4, 4, 5, 1])\n```\n\nThis function takes a list and an integer `L`, splits the list into two parts where the first part has length `L`, and returns these parts as a tuple. The test case verifies that the function works correctly for the given example."}
{"task_id": "Mbpp/264", "solution": "Certainly! Below is a self-contained Python script that calculates a dog's age in dog years. The conversion factor used here is based on the common approximation that one human year equals about seven dog years for the first two years, and four dog years thereafter.\n\n```python\ndef dog_age(human_years):\n \"\"\"\n Calculate a dog's age in dog years.\n \n Parameters:\n human_years (int): The age of the dog in human years.\n \n Returns:\n int: The equivalent age in dog years.\n \"\"\"\n if human_years <= 0:\n return 0\n elif human_years == 1:\n return 15\n elif human_years == 2:\n return 25\n else:\n # First two years are 15 and 10 dog years respectively, then each year is 4 dog years.\n return 25 + (human_years - 2) * 4\n\n# Test the function with an assertion\nassert dog_age(12) == 61\n```\n\n### Explanation:\n\n- **First Year:** A dog's first year is approximately equivalent to 15 human years.\n- **Second Year:** The second year adds about 10 more dog years, totaling 25 dog years by the end of the second year.\n- **Subsequent Years:** Each additional year after the second year is roughly equivalent to 4 dog years.\n\nThis function handles edge cases such as non-positive ages by returning 0."}
{"task_id": "Mbpp/265", "solution": "Here's a self-contained Python script that solves the problem described:\n\n```python\ndef list_split(lst, n):\n \"\"\"\n Splits a list into sublists every nth element.\n\n Parameters:\n lst (list): The input list to be split.\n n (int): The interval at which to split the list.\n\n Returns:\n list: A list of lists where each sublist contains elements from the original\n list taken every nth position starting from 0, 1, ..., n-1 respectively.\n \"\"\"\n # Initialize a list to hold the resulting sublists\n result = [[] for _ in range(n)]\n \n # Iterate over the input list with index and element\n for i, item in enumerate(lst):\n # Determine which sublist to append the current element to\n sublist_index = i % n\n result[sublist_index].append(item)\n \n return result\n\n# Test case\nassert list_split(['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n'], 3) == [['a', 'd', 'g', 'j', 'm'], ['b', 'e', 'h', 'k', 'n'], ['c', 'f', 'i', 'l']]\n```\n\nThis function `list_split` takes a list and an integer `n`, then splits the list into sublists where each sublist contains elements from the original list taken every nth position starting from 0, 1, ..., n-1 respectively. The test case provided in the problem statement is used to verify the correctness of the implementation."}
{"task_id": "Mbpp/266", "solution": "Certainly! Below is a self-contained Python script that defines a function to calculate the lateral surface area of a cube, along with an assertion to verify its correctness.\n\n```python\ndef lateralsurface_cube(side_length):\n \"\"\"\n Calculate the lateral surface area of a cube.\n \n The lateral surface area of a cube is the sum of the areas of the four vertical faces.\n Each face has an area equal to side_length squared. Therefore, the lateral surface area\n is 4 times the area of one face.\n\n Parameters:\n - side_length (float or int): The length of a side of the cube.\n\n Returns:\n - float: The lateral surface area of the cube.\n \"\"\"\n # Calculate the area of one face\n face_area = side_length ** 2\n \n # There are four faces contributing to the lateral surface area\n lateral_surface_area = 4 * face_area\n \n return lateral_surface_area\n\n# Test the function with an assertion\nassert lateralsurface_cube(5) == 100, \"The lateral surface area calculation is incorrect.\"\n\nprint(\"The function works correctly for a cube with side length 5.\")\n```\n\n### Explanation:\n- **Function Definition**: The `lateralsurface_cube` function takes one parameter, `side_length`, which represents the length of a side of the cube.\n- **Calculation**:\n - First, it calculates the area of one face of the cube using `side_length ** 2`.\n - Since a cube has four lateral faces (excluding the top and bottom), the lateral surface area is calculated as `4 * face_area`.\n- **Assertion**: The script includes an assertion to ensure that for a cube with side length 5, the function returns 100. This serves as a test case to verify the correctness of the implementation.\n- **Output**: If the assertion passes without raising an error, it prints a confirmation message indicating that the function works correctly for the given test case.\n\nThis script is self-contained and can be run independently to verify the functionality of calculating the lateral surface area of a cube."}
{"task_id": "Mbpp/267", "solution": "```markdown\nHere's a Python script to solve the problem:\n\n```python\ndef square_sum(n):\n \"\"\"\n Calculate the sum of the squares of the first n odd natural numbers.\n\n Parameters:\n n (int): The number of initial odd natural numbers to consider.\n\n Returns:\n int: The sum of the squares of these numbers.\n \"\"\"\n # Initialize the sum to 0\n total_sum = 0\n \n # Loop through the first n odd numbers\n for i in range(n):\n # Calculate the current odd number (2*i + 1)\n odd_number = 2 * i + 1\n \n # Add its square to the total sum\n total_sum += odd_number ** 2\n\n return total_sum\n\n# Test case\nassert square_sum(2) == 10, \"Test case failed!\"\n```\n\n### Explanation:\n\n- The function `square_sum` takes an integer `n` as input.\n- It initializes a variable `total_sum` to store the cumulative sum of squares.\n- A loop runs from `0` to `n-1`, and for each iteration:\n - It calculates the current odd number using the formula `2*i + 1`.\n - It computes the square of this odd number and adds it to `total_sum`.\n- Finally, the function returns the computed sum.\n\nThe test case checks if the function correctly computes the sum of squares for the first two odd numbers (1 and 3), which should be \\(1^2 + 3^2 = 10\\).\n```"}
{"task_id": "Mbpp/268", "solution": "```markdown\nTo solve the problem of finding the \\(n\\)th star number, we need to understand what a star number is. A star number is a centered hexagonal number that can be represented as:\n\n\\[ S_n = 6 \\times \\frac{n(n-1)}{2} + 1 \\]\n\nThis formula arises from the pattern in which star numbers are constructed: they form a six-pointed star shape when visualized.\n\nHere's how you can implement this in Python:\n\n```python\ndef find_star_num(n):\n \"\"\"\n Calculate the n'th star number.\n \n A star number is defined as:\n S_n = 6 * (n * (n - 1) / 2) + 1\n \n Args:\n n (int): The position in the sequence of star numbers.\n \n Returns:\n int: The n'th star number.\n \"\"\"\n if n < 1:\n raise ValueError(\"n must be a positive integer.\")\n \n # Calculate the nth star number using the formula\n return 6 * (n * (n - 1) // 2) + 1\n\n# Test case\nassert find_star_num(3) == 37\n```\n\n### Explanation:\n\n- **Formula**: The formula \\( S_n = 6 \\times \\frac{n(n-1)}{2} + 1 \\) is derived from the pattern of star numbers. It calculates the number of dots in a hexagonal arrangement with a dot at the center and additional layers forming a star shape.\n \n- **Implementation**:\n - The function `find_star_num` takes an integer \\( n \\) as input.\n - It checks if \\( n \\) is less than 1, raising a `ValueError` since star numbers are defined for positive integers only.\n - It calculates the star number using integer division to ensure the result is an integer.\n\n- **Test Case**: The assertion `assert find_star_num(3) == 37` verifies that the function correctly computes the 3rd star number, which is 37."}
{"task_id": "Mbpp/269", "solution": "Certainly! Below is a self-contained Python script that defines a function `ascii_value` which returns the ASCII value of a given character. The script also includes an assertion to verify its correctness.\n\n```markdown\n```python\ndef ascii_value(char):\n \"\"\"\n This function takes a single character as input and returns its ASCII value.\n \n Parameters:\n char (str): A string containing exactly one character.\n \n Returns:\n int: The ASCII value of the given character.\n \"\"\"\n if len(char) != 1:\n raise ValueError(\"Input must be a single character.\")\n \n return ord(char)\n\n# Test case to verify the function works as expected\nassert ascii_value('A') == 65\n\nprint(\"The function passed the test case.\")\n```\n```\n\n### Explanation:\n\n- **Function Definition**: The `ascii_value` function takes one parameter, `char`, which is expected to be a string containing exactly one character.\n \n- **Input Validation**: It checks if the input string length is not equal to 1 and raises a `ValueError` if it's not. This ensures that only single characters are processed.\n\n- **ASCII Conversion**: The function uses Python's built-in `ord()` function, which returns an integer representing the Unicode code point of the given character. For standard ASCII characters, this will be their ASCII value.\n\n- **Assertion**: An assertion is used to test if the function correctly returns 65 for the input 'A', as expected.\n\nThis script ensures that the function behaves correctly and handles invalid inputs gracefully by raising an error."}
{"task_id": "Mbpp/270", "solution": "```markdown\nHere's a Python script that defines a function to solve the problem:\n\n```python\ndef sum_even_and_even_index(lst):\n \"\"\"\n This function calculates the sum of even numbers located at even indices in a list.\n \n Parameters:\n lst (list): A list of integers.\n\n Returns:\n int: The sum of even numbers at even positions.\n \"\"\"\n # Initialize the sum to zero\n total_sum = 0\n \n # Iterate over the list using enumerate to get both index and value\n for index, value in enumerate(lst):\n # Check if the index is even and the value is even\n if index % 2 == 0 and value % 2 == 0:\n total_sum += value\n \n return total_sum\n\n# Test case\nassert sum_even_and_even_index([5, 6, 12, 1, 18, 8]) == 30\n```\n\n### Explanation:\n\n- The function `sum_even_and_even_index` takes a list of integers as input.\n- It initializes `total_sum` to zero to accumulate the sum of even numbers at even indices.\n- Using `enumerate`, it iterates over the list with both index and value accessible in each iteration.\n- For each element, it checks if the index is even (`index % 2 == 0`) and if the value itself is even (`value % 2 == 0`).\n- If both conditions are satisfied, the value is added to `total_sum`.\n- Finally, the function returns the accumulated sum.\n\nThe provided test case verifies that the function works correctly by asserting that the result for the input list `[5, 6, 12, 1, 18, 8]` is `30`. The even numbers at even indices are `12` (index 2) and `18` (index 4), and their sum is `30`.\n```"}
{"task_id": "Mbpp/271", "solution": "Certainly! Below is a self-contained Python script that defines a function `even_Power_Sum` which calculates the sum of the first \\( n \\) even natural numbers each raised to the fifth power.\n\n```python\ndef even_Power_Sum(n):\n \"\"\"\n Calculate the sum of the first n even natural numbers raised to the fifth power.\n \n Parameters:\n n (int): The number of even natural numbers to consider.\n \n Returns:\n int: The sum of the first n even natural numbers each raised to the fifth power.\n \"\"\"\n # Initialize the sum\n total_sum = 0\n \n # Loop through the first n even numbers\n for i in range(1, n + 1):\n # Calculate the ith even number (2 * i)\n even_number = 2 * i\n \n # Raise it to the fifth power and add to the sum\n total_sum += even_number ** 5\n \n return total_sum\n\n# Test case\nassert even_Power_Sum(2) == 1056, \"Test case failed!\"\n```\n\n### Explanation:\n\n- The function `even_Power_Sum` takes an integer \\( n \\) as input.\n- It initializes a variable `total_sum` to accumulate the sum of powers.\n- A loop runs from 1 to \\( n \\), and for each iteration:\n - It calculates the \\( i \\)-th even number using \\( 2 \\times i \\).\n - This even number is then raised to the fifth power and added to `total_sum`.\n- Finally, it returns the computed sum.\n- An assertion checks if the function works correctly for the test case where \\( n = 2 \\). The expected result is 1056."}
{"task_id": "Mbpp/272", "solution": "Certainly! Below is a self-contained Python script that defines the function `rear_extract` to solve the problem described. The function takes in a list of tuples and returns a list containing the last element (the rear element) from each tuple.\n\n```python\ndef rear_extract(tuples_list):\n \"\"\"\n This function takes a list of tuples as input and returns a list containing \n the last element of each tuple.\n \n Parameters:\n tuples_list (list): A list of tuples where each tuple contains at least one element.\n \n Returns:\n list: A list containing the rear elements from each tuple in the input list.\n \"\"\"\n # Using list comprehension to extract the last element from each tuple\n return [tup[-1] for tup in tuples_list]\n\n# Test case\nassert rear_extract([(1, 'Rash', 21), (2, 'Varsha', 20), (3, 'Kil', 19)]) == [21, 20, 19]\n```\n\n### Explanation:\n- The function `rear_extract` uses a list comprehension to iterate over each tuple in the input list.\n- For each tuple, it accesses the last element using negative indexing (`tup[-1]`), which is a common Python idiom for accessing the last item of a sequence.\n- It collects these rear elements into a new list and returns this list.\n\nThis script includes an assertion to verify that the function works as expected with the provided test case."}
{"task_id": "Mbpp/273", "solution": "Certainly! Below is a self-contained Python script that defines a function to subtract elements of two tuples element-wise. The function checks if the tuples are of equal length and then performs the subtraction.\n\n```python\ndef subtract_elements(tuple1, tuple2):\n \"\"\"\n Subtracts elements of the second tuple from the first tuple element-wise.\n \n Parameters:\n tuple1 (tuple): The first tuple.\n tuple2 (tuple): The second tuple.\n \n Returns:\n tuple: A new tuple containing the results of the subtraction.\n \n Raises:\n ValueError: If the tuples are not of equal length.\n \"\"\"\n if len(tuple1) != len(tuple2):\n raise ValueError(\"Tuples must be of the same length\")\n \n result = tuple(a - b for a, b in zip(tuple1, tuple2))\n return result\n\n# Test case\nassert subtract_elements((10, 4, 5), (2, 5, 18)) == (8, -1, -13)\n```\n\nThis script defines the `subtract_elements` function and includes an assertion to verify its correctness with a given test case."}
{"task_id": "Mbpp/274", "solution": "Certainly! To solve this problem, we need to calculate the sum of binomial coefficients at even indices for a given positive integer \\( n \\). The binomial coefficient is defined as:\n\n\\[\nC(n, k) = \\frac{n!}{k!(n-k)!}\n\\]\n\nwhere \\( C(n, k) \\) represents the number of ways to choose \\( k \\) elements from a set of \\( n \\) elements.\n\nThe task requires us to sum these coefficients for even indices \\( k \\), i.e., \\( k = 0, 2, 4, \\ldots \\).\n\nA useful property of binomial coefficients is that the sum of all binomial coefficients for a given \\( n \\) is equal to \\( 2^n \\):\n\n\\[\nC(n, 0) + C(n, 1) + \\cdots + C(n, n) = 2^n\n\\]\n\nAdditionally, it's known that:\n\n\\[\nC(n, k) = C(n, n-k)\n\\]\n\nThis symmetry implies that the sum of coefficients at even indices is equal to the sum of coefficients at odd indices when \\( n \\) is even. When \\( n \\) is odd, the middle coefficient (which is also an even index if \\( n \\) is odd) will be counted only once.\n\nThus, for any integer \\( n \\), the sum of binomial coefficients at even indices can be calculated as:\n\n\\[\n\\text{Sum of even-indexed coefficients} = \\frac{2^n + C(n, n//2)}{2}\n\\]\n\nThis formula works because when \\( n \\) is odd, \\( C(n, n//2) \\) is the middle term and should only be added once to the sum.\n\nHere's the Python function implementing this logic:\n\n```python\ndef even_binomial_Coeff_Sum(n):\n from math import comb\n \n # Calculate 2^n\n total_sum = 2 ** n\n \n # If n is odd, add the middle term C(n, n//2) once\n if n % 2 == 1:\n middle_term = comb(n, n // 2)\n even_index_sum = (total_sum + middle_term) // 2\n else:\n even_index_sum = total_sum // 2\n \n return even_index_sum\n\n# Test the function with the given example\nassert even_binomial_Coeff_Sum(4) == 8\n```\n\nThis function uses Python's `math.comb` to compute binomial coefficients efficiently. The logic ensures that we correctly handle both even and odd values of \\( n \\)."}
{"task_id": "Mbpp/276", "solution": "Certainly! Below is a self-contained Python script that defines a function to calculate the volume of a cylinder given its radius and height. The script also includes an assertion to verify the correctness of the function.\n\n```python\nimport math\n\ndef volume_cylinder(radius, height):\n \"\"\"\n Calculate the volume of a cylinder.\n \n Parameters:\n radius (float): The radius of the base of the cylinder.\n height (float): The height of the cylinder.\n \n Returns:\n float: The volume of the cylinder.\n \"\"\"\n # Volume formula for a cylinder: V = \u03c0 * r^2 * h\n return math.pi * radius ** 2 * height\n\n# Test case to verify the function's correctness\nassert math.isclose(volume_cylinder(10, 5), 1570.7500000000002, rel_tol=0.001)\n\nprint(\"The volume of a cylinder with radius 10 and height 5 is approximately:\", volume_cylinder(10, 5))\n```\n\n### Explanation:\n\n- **Importing `math`:** We import the `math` module to access the constant `pi`, which represents the mathematical constant \u03c0 (Pi).\n\n- **Function Definition:** The function `volume_cylinder(radius, height)` calculates the volume of a cylinder using the formula \\( V = \\pi r^2 h \\), where:\n - \\( r \\) is the radius of the base.\n - \\( h \\) is the height of the cylinder.\n\n- **Assertion:** We use `math.isclose()` to check if the calculated volume is approximately equal to the expected value (`1570.7500000000002`) within a relative tolerance of `0.001`. This ensures that minor floating-point arithmetic differences do not cause the test to fail.\n\n- **Print Statement:** Finally, we print the result for verification purposes."}
{"task_id": "Mbpp/277", "solution": "Certainly! Below is a self-contained Python script that defines the function `dict_filter` to solve the problem described. The function filters a dictionary to include only those entries where the values are greater than or equal to a given integer `n`.\n\n```python\ndef dict_filter(input_dict, n):\n \"\"\"\n Filters the input dictionary to include only entries with values >= n.\n\n Parameters:\n - input_dict (dict): A dictionary with string keys and integer values.\n - n (int): The threshold value for filtering.\n\n Returns:\n - dict: A new dictionary containing only the filtered key-value pairs.\n \"\"\"\n # Use a dictionary comprehension to filter entries\n return {key: value for key, value in input_dict.items() if value >= n}\n\n# Test case as specified in the problem statement\nassert dict_filter({'Cierra Vega': 175, 'Alden Cantrell': 180, 'Kierra Gentry': 165, 'Pierre Cox': 190}, 170) == {'Cierra Vega': 175, 'Alden Cantrell': 180, 'Pierre Cox': 190}\n\n# Additional test cases\nassert dict_filter({'Alice': 150, 'Bob': 160, 'Charlie': 170}, 160) == {'Bob': 160, 'Charlie': 170}\nassert dict_filter({}, 100) == {}\nassert dict_filter({'John Doe': 200}, 200) == {'John Doe': 200}\n\nprint(\"All test cases passed!\")\n```\n\n### Explanation:\n\n- **Function Definition**: The function `dict_filter` takes two parameters: a dictionary (`input_dict`) and an integer (`n`).\n \n- **Dictionary Comprehension**: Inside the function, we use a dictionary comprehension to iterate over each key-value pair in the input dictionary. We include only those pairs where the value is greater than or equal to `n`.\n\n- **Return Statement**: The filtered dictionary is returned.\n\n- **Assertions**: Several assertions are included to verify that the function works as expected for different inputs, including edge cases like an empty dictionary and a single-entry dictionary.\n\nThis script ensures that the function behaves correctly according to the problem requirements."}
{"task_id": "Mbpp/278", "solution": "```markdown\nHere's a Python script that defines a function `count_first_elements` to solve the problem:\n\n```python\ndef count_first_elements(tpl):\n \"\"\"\n This function counts the number of elements in the tuple before the first occurrence \n of a nested tuple element.\n \n Parameters:\n tpl (tuple): The input tuple which may contain other tuples as elements.\n\n Returns:\n int: The number of elements before the first tuple element.\n \"\"\"\n count = 0\n for element in tpl:\n if isinstance(element, tuple):\n return count\n count += 1\n return count\n\n# Test case\nassert count_first_elements((1, 5, 7, (4, 6), 10)) == 3\n```\n\n### Explanation:\n\n- The function `count_first_elements` iterates over each element in the input tuple.\n- It checks if an element is a tuple using `isinstance(element, tuple)`.\n- If it finds a nested tuple, it returns the current count of elements before this tuple.\n- If no nested tuple is found by the end of the iteration, it returns the total number of elements (though in this problem context, there should always be at least one nested tuple).\n```"}
{"task_id": "Mbpp/279", "solution": "```markdown\nTo solve the problem of finding the nth decagonal number, we need to understand what a decagonal number is. A decagonal number is a figurate number that represents a decagon. The formula for the nth decagonal number \\( D_n \\) is given by:\n\n\\[ D_n = 4n^2 - 3n \\]\n\nThis formula can be derived from the pattern of dots forming a decagon in a geometric arrangement.\n\nHere's how you can implement this in Python:\n\n```python\ndef is_num_decagonal(n):\n \"\"\"\n Calculate the nth decagonal number using the formula:\n D_n = 4n^2 - 3n\n\n Parameters:\n n (int): The position of the decagonal number to find.\n\n Returns:\n int: The nth decagonal number.\n \"\"\"\n return 4 * n**2 - 3 * n\n\n# Test case\nassert is_num_decagonal(3) == 27\n```\n\n### Explanation:\n\n- **Formula**: The formula \\( D_n = 4n^2 - 3n \\) is used to calculate the nth decagonal number.\n- **Function**: `is_num_decagonal(n)` takes an integer `n` and returns the nth decagonal number.\n- **Test Case**: We use an assertion to verify that the function works correctly for \\( n = 3 \\). The expected result is 27, which matches the formula calculation.\n\nThis script will correctly compute the nth decagonal number for any positive integer input."}
{"task_id": "Mbpp/280", "solution": "Certainly! Below is a self-contained Python script that defines and tests the `sequential_search` function as described in your problem statement.\n\n```markdown\n```python\ndef sequential_search(arr, element):\n \"\"\"\n This function takes an array and an element as input.\n It returns a tuple containing:\n - A boolean indicating if the element is found in the array.\n - The index position of the element if it's found, otherwise -1.\n\n Parameters:\n arr (list): The list to search within.\n element: The element to search for.\n\n Returns:\n tuple: (bool, int) where bool indicates presence and int is the index or -1.\n \"\"\"\n for index, value in enumerate(arr):\n if value == element:\n return (True, index)\n return (False, -1)\n\n# Test case\nassert sequential_search([11, 23, 58, 31, 56, 77, 43, 12, 65, 19], 31) == (True, 3)\n```\n```\n\nThis script defines the `sequential_search` function which iterates over the array using a for loop with enumeration to keep track of both the index and value. If it finds the element, it returns `(True, index)`. If the loop completes without finding the element, it returns `(False, -1)`.\n\nThe test case at the end verifies that the function works correctly by asserting that searching for `31` in the given array returns `(True, 3)`, as expected."}
{"task_id": "Mbpp/281", "solution": "Certainly! Below is a self-contained Python script that defines a function `all_unique` to check if all elements in a given list are unique. It also includes an assertion to verify the functionality.\n\n```python\ndef all_unique(lst):\n \"\"\"\n Check if all elements in the list are unique.\n \n Parameters:\n lst (list): The list of elements to check for uniqueness.\n \n Returns:\n bool: True if all elements are unique, False otherwise.\n \"\"\"\n # Use a set to track seen elements\n seen = set()\n for element in lst:\n if element in seen:\n return False\n seen.add(element)\n return True\n\n# Test the function with an assertion\nassert all_unique([1, 2, 3]) == True\n```\n\nThis script uses a set to keep track of elements that have been encountered. If an element is found again while iterating through the list, it returns `False`, indicating that not all elements are unique. Otherwise, it returns `True`."}
{"task_id": "Mbpp/282", "solution": "Certainly! Below is a self-contained Python script that defines a function `sub_list` which performs element-wise subtraction of two lists. The function checks if the input lists are of equal length and raises an error if they are not.\n\n```python\ndef sub_list(list1, list2):\n \"\"\"\n Subtract elements of list2 from list1 element-wise.\n \n Parameters:\n - list1: List of numbers (integers or floats).\n - list2: List of numbers (integers or floats) with the same length as list1.\n\n Returns:\n - A new list containing the result of subtracting each element in list2 from the corresponding element in list1.\n \n Raises:\n - ValueError: If the input lists are not of equal length.\n \"\"\"\n if len(list1) != len(list2):\n raise ValueError(\"Both lists must have the same number of elements.\")\n \n return [a - b for a, b in zip(list1, list2)]\n\n# Example usage\nresult = sub_list([1, 2, 3], [4, 5, 6])\nassert result == [-3, -3, -3]\nprint(\"Subtraction successful:\", result)\n```\n\nThis script includes:\n- A function `sub_list` that takes two lists as input.\n- An assertion to ensure the lists are of equal length.\n- Element-wise subtraction using a list comprehension and the `zip` function.\n- An example usage with an assertion to verify correctness."}
{"task_id": "Mbpp/283", "solution": "Certainly! Below is a self-contained Python script that defines a function `validate` which checks if the frequency of each digit in an integer is less than or equal to the digit itself.\n\n```python\ndef validate(n):\n \"\"\"\n Check whether the frequency of each digit in the integer n is less than or equal to the digit itself.\n \n Args:\n n (int): The input integer to be validated.\n \n Returns:\n bool: True if the condition holds for all digits, False otherwise.\n \"\"\"\n # Convert the integer to a string to iterate over its digits\n str_n = str(n)\n \n # Create a dictionary to store the frequency of each digit\n freq = {}\n \n # Count the frequency of each digit in the number\n for digit in str_n:\n if digit in freq:\n freq[digit] += 1\n else:\n freq[digit] = 1\n \n # Check if the frequency of each digit is less than or equal to the digit itself\n for digit, count in freq.items():\n if int(digit) < count:\n return False\n \n return True\n\n# Test case\nassert validate(1234) == True\n```\n\n### Explanation:\n\n1. **Convert Integer to String**: The integer `n` is converted into a string so that we can easily iterate over each digit.\n\n2. **Frequency Counting**: We use a dictionary `freq` to count how many times each digit appears in the number.\n\n3. **Validation Check**: For each digit and its frequency, we check if the frequency is greater than the digit itself. If it is, the function returns `False`.\n\n4. **Return Result**: If all digits satisfy the condition, the function returns `True`.\n\nThis script includes a test case to ensure that the function works as expected for the input `1234`."}
{"task_id": "Mbpp/284", "solution": "Certainly! Below is a self-contained Python script that defines a function `check_element` which takes a list and an element as arguments. It checks whether all items in the list are equal to the given element.\n\n```python\ndef check_element(lst, element):\n \"\"\"\n Check if all elements in the list are equal to the specified element.\n \n Parameters:\n lst (list): The list of elements to be checked.\n element: The element to compare against each item in the list.\n \n Returns:\n bool: True if all items in the list are equal to the given element, False otherwise.\n \"\"\"\n return all(item == element for item in lst)\n\n# Test case\nassert check_element([\"green\", \"orange\", \"black\", \"white\"], 'blue') == False\n\nprint(\"All test cases passed!\")\n```\n\nThis script includes a function `check_element` that uses Python's built-in `all()` function to iterate over the list and compare each item with the specified element. The `assert` statement is used to verify that the function behaves as expected for the given test case."}
{"task_id": "Mbpp/285", "solution": "Certainly! Below is a self-contained Python script that defines a function to solve the problem described. The function uses regular expressions to check if a given string contains the character 'a' followed by either two or three 'b' characters.\n\n```python\nimport re\n\ndef text_match_two_three(text):\n \"\"\"\n Check whether the input string contains the 'a' character followed by \n exactly two or three 'b' characters.\n \n Parameters:\n text (str): The input string to be checked.\n \n Returns:\n bool: True if the pattern is found, False otherwise.\n \"\"\"\n # Define a regular expression pattern for 'a' followed by 2 or 3 'b's\n pattern = r'a[b]{2,3}'\n \n # Use re.search to find the pattern in the text\n match = re.search(pattern, text)\n \n # Return True if a match is found, otherwise False\n return bool(match)\n\n# Test cases\nassert text_match_two_three(\"ac\") == (False), \"Test case 1 failed\"\nassert text_match_two_three(\"abb\") == (True), \"Test case 2 failed\"\nassert text_match_two_three(\"abbb\") == (True), \"Test case 3 failed\"\nassert text_match_two_three(\"aabbb\") == (True), \"Test case 4 failed\"\nassert text_match_two_three(\"aabb\") == (True), \"Test case 5 failed\"\nassert text_match_two_three(\"aaabbb\") == (False), \"Test case 6 failed\"\n\nprint(\"All test cases passed!\")\n```\n\n### Explanation:\n- **Regular Expression**: The pattern `r'a[b]{2,3}'` is used to match the character 'a' followed by exactly two or three 'b' characters.\n - `a`: Matches the literal character 'a'.\n - `[b]{2,3}`: Matches between two and three occurrences of the character 'b'.\n\n- **Function Logic**:\n - The function uses `re.search()` to look for the pattern in the input string.\n - If a match is found, it returns `True`; otherwise, it returns `False`.\n\n- **Test Cases**: Several assertions are included to verify that the function behaves as expected with different inputs."}
{"task_id": "Mbpp/286", "solution": "```markdown\nTo solve this problem, we need to find the largest sum of a contiguous subarray in an array that is formed by repeating the original array `k` times. Here's how you can approach it:\n\n### Steps to Solve the Problem\n\n1. **Understand the Problem**: \n - You have an array `arr` and an integer `k`.\n - The task is to repeat the array `k` times and find the maximum sum of any contiguous subarray in this new, larger array.\n\n2. **Kadane's Algorithm**:\n - Use Kadane\u2019s algorithm to find the maximum sum of a contiguous subarray for a single instance of the array.\n - This will help us handle cases where the best subarray is entirely within one repetition of the original array.\n\n3. **Handling Multiple Repetitions**:\n - If `k` is 1, simply apply Kadane\u2019s algorithm on the original array.\n - If `k` > 1, consider additional contributions from wrapping around the repeated arrays.\n\n4. **Calculate Prefix and Suffix Sums**:\n - Compute the maximum prefix sum of the array (maximum sum ending at any position).\n - Compute the maximum suffix sum of the array (maximum sum starting from any position).\n\n5. **Combine Results**:\n - The result can be a combination of:\n - Maximum subarray within one repetition.\n - A subarray that starts in one repetition and ends in another.\n - Multiple full repetitions contributing to the sum.\n\n6. **Edge Cases**:\n - If all numbers are negative, the maximum subarray is the largest single element.\n - Consider cases where `k` is very large, which might lead to integer overflow if not handled properly.\n\nHere's the implementation:\n\n```python\ndef max_sub_array_sum_repeated(arr, k, n):\n # Helper function to find maximum sum of a contiguous subarray using Kadane's algorithm\n def kadane(a):\n max_ending_here = max_so_far = a[0]\n for x in a[1:]:\n max_ending_here = max(x, max_ending_here + x)\n max_so_far = max(max_so_far, max_ending_here)\n return max_so_far\n\n # Edge case: if the array is empty\n if n == 0:\n return 0\n\n # Step 1: Find maximum subarray sum in a single instance of arr using Kadane's algorithm\n max_kadane = kadane(arr)\n\n # Step 2: Calculate prefix and suffix sums\n max_prefix_sum = float('-inf')\n current_prefix_sum = 0\n for i in range(n):\n current_prefix_sum += arr[i]\n max_prefix_sum = max(max_prefix_sum, current_prefix_sum)\n\n max_suffix_sum = float('-inf')\n current_suffix_sum = 0\n for i in range(n - 1, -1, -1):\n current_suffix_sum += arr[i]\n max_suffix_sum = max(max_suffix_sum, current_suffix_sum)\n\n # Step 3: Calculate total sum of the array\n total_sum = sum(arr)\n\n # If all numbers are negative, return the maximum element\n if max_kadane < 0:\n return max_kadane\n\n # Step 4: Consider cases based on k\n result = max_kadane\n if k == 1:\n return result\n\n # Case when total_sum is positive, we can add it multiple times\n if total_sum > 0:\n result = max(result, max_prefix_sum + (k - 2) * total_sum + max_suffix_sum)\n\n return result\n\n"}
{"task_id": "Mbpp/287", "solution": "Certainly! Below is a self-contained Python script that defines a function to calculate the sum of squares of the first `n` even natural numbers. The function includes an assertion to verify its correctness for the given test case.\n\n```python\ndef square_sum(n):\n \"\"\"\n Calculate the sum of squares of the first n even natural numbers.\n \n Parameters:\n n (int): The number of initial even natural numbers to consider.\n \n Returns:\n int: The sum of squares of the first n even natural numbers.\n \"\"\"\n # Initialize the sum\n total_sum = 0\n \n # Loop through the first n even numbers\n for i in range(1, n + 1):\n # Calculate the ith even number (2 * i)\n even_number = 2 * i\n \n # Add its square to the total sum\n total_sum += even_number ** 2\n \n return total_sum\n\n# Test case\nassert square_sum(2) == 20, \"Test case failed!\"\n\n# Example usage\nprint(square_sum(2)) # Output: 20\n```\n\n### Explanation:\n\n- The function `square_sum(n)` calculates the sum of squares of the first `n` even natural numbers.\n- It initializes a variable `total_sum` to accumulate the sum of squares.\n- A loop runs from 1 to `n`, and for each iteration, it computes the `i-th` even number as `2 * i`.\n- The square of this even number is added to `total_sum`.\n- Finally, the function returns the accumulated `total_sum`.\n\nThe assertion checks if the function correctly calculates the sum for `n = 2`. For `n = 2`, the first two even numbers are 2 and 4. Their squares are 4 and 16, respectively, and their sum is 20."}
{"task_id": "Mbpp/290", "solution": "```markdown\nHere's a Python script that solves the problem of finding the list with the maximum length in a list of lists:\n\n```python\ndef max_length(list_of_lists):\n \"\"\"\n This function takes a list of lists and returns a tuple containing:\n - The length of the longest list.\n - The first list encountered with this maximum length.\n\n :param list_of_lists: List[List[Any]]\n :return: Tuple[int, List[Any]]\n \"\"\"\n max_len = 0\n max_list = []\n\n for lst in list_of_lists:\n if len(lst) > max_len:\n max_len = len(lst)\n max_list = lst\n\n return max_len, max_list\n\n# Test the function with an assertion\nassert max_length([[0], [1, 3], [5, 7], [9, 11], [13, 15, 17]]) == (3, [13, 15, 17])\n```\n\n### Explanation:\n\n- **Function Definition**: The `max_length` function takes a single argument, `list_of_lists`, which is expected to be a list containing other lists.\n \n- **Initialization**: Two variables are initialized: `max_len` to keep track of the maximum length found so far (starting at 0), and `max_list` to store the first list encountered with this maximum length.\n\n- **Iteration**: The function iterates over each list (`lst`) in `list_of_lists`.\n\n- **Comparison**: For each list, it checks if its length is greater than `max_len`. If so, it updates `max_len` and sets `max_list` to the current list.\n\n- **Return Value**: After iterating through all lists, the function returns a tuple containing `max_len` and `max_list`.\n\n- **Assertion**: The script includes an assertion to verify that the function works as expected with the provided test case.\n```\n\nThis script is self-contained and can be run independently to solve the problem."}
{"task_id": "Mbpp/292", "solution": "Certainly! Below is a self-contained Python script that defines a function `find` which calculates the quotient of two numbers and rounds it down to the nearest integer. The function uses integer division to achieve this.\n\n```python\ndef find(dividend, divisor):\n \"\"\"\n Calculate the quotient of two numbers (rounded down to the nearest integer).\n\n Parameters:\n dividend (int or float): The number to be divided.\n divisor (int or float): The number by which to divide.\n\n Returns:\n int: The quotient rounded down to the nearest integer.\n \n Raises:\n ValueError: If the divisor is zero.\n \"\"\"\n if divisor == 0:\n raise ValueError(\"The divisor cannot be zero.\")\n \n # Use floor division to get the quotient rounded down\n return dividend // divisor\n\n# Test case\nassert find(10, 3) == 3\n```\n\n### Explanation:\n\n- **Function Definition**: The function `find` takes two parameters: `dividend` and `divisor`.\n- **Error Handling**: It checks if the `divisor` is zero and raises a `ValueError` to prevent division by zero.\n- **Floor Division**: The operator `//` performs floor division, which divides and rounds down to the nearest integer.\n- **Test Case**: An assertion is used to verify that `find(10, 3)` returns `3`, as expected.\n\nThis script ensures that the function behaves correctly for valid inputs and handles edge cases like division by zero."}
{"task_id": "Mbpp/293", "solution": "Certainly! To solve this problem, we need to determine the length of the third side of a right-angled triangle when two sides are given. In a right-angled triangle, the Pythagorean theorem states that:\n\n\\[ c^2 = a^2 + b^2 \\]\n\nwhere \\( c \\) is the hypotenuse (the longest side), and \\( a \\) and \\( b \\) are the other two sides.\n\nGiven two sides, we need to determine which one could be the hypotenuse. If neither of the given sides is the hypotenuse, then the third side can be calculated using:\n\n\\[ c = \\sqrt{a^2 + b^2} \\]\n\nIf one of the given sides is the hypotenuse, say \\( a \\), then the other side and the unknown side form a right triangle with the hypotenuse. The length of the unknown side \\( x \\) can be calculated using:\n\n\\[ x = \\sqrt{a^2 - b^2} \\]\n\nHere's the Python function to find the third side:\n\n```markdown\n```python\nimport math\n\ndef otherside_rightangle(side1, side2):\n # Determine which is the larger side\n if side1 > side2:\n hypotenuse = side1\n other_side = side2\n else:\n hypotenuse = side2\n other_side = side1\n \n # Check if one of the sides is the hypotenuse\n if hypotenuse**2 == other_side**2 + (side1 + side2 - hypotenuse)**2:\n # The third side is calculated using Pythagorean theorem\n return math.sqrt(hypotenuse**2 - other_side**2)\n \n # If neither of the given sides is the hypotenuse, calculate the hypotenuse\n return math.sqrt(side1**2 + side2**2)\n\n# Test case\nassert otherside_rightangle(7, 8) == 10.63014581273465\n```\n```\n\nThis function first checks which of the two given sides is larger and assumes it might be the hypotenuse. It then verifies if this assumption holds by checking the Pythagorean theorem. If not, it calculates the hypotenuse using both sides as legs of the triangle. The `math.sqrt` function is used to compute the square root for the final result."}
{"task_id": "Mbpp/294", "solution": "```markdown\nHere's a Python script that defines a function to find the maximum value in a heterogeneous list. The function will handle both numeric and string types by comparing them appropriately.\n\n```python\ndef max_val(heterogeneous_list):\n # Initialize variables to store the maximum value found\n max_value = None\n \n for item in heterogeneous_list:\n if isinstance(item, (int, float)):\n # If the current item is a number, compare it with the current max_value\n if max_value is None or item > max_value:\n max_value = item\n elif isinstance(item, str):\n # If the current item is a string, convert it to a numeric value if possible\n try:\n num_value = float(item)\n if max_value is None or num_value > max_value:\n max_value = num_value\n except ValueError:\n # If conversion fails, skip this item as we are only interested in numbers\n continue\n \n return max_value\n\n# Test the function with the provided example\nassert max_val(['Python', 3, 2, 4, 5, 'version']) == 5\n```\n\n### Explanation:\n\n1. **Initialization**: We start by initializing `max_value` to `None`. This will help us track the maximum numeric value found in the list.\n\n2. **Iteration and Type Checking**:\n - For each item in the list, we first check if it is a number (`int` or `float`). If so, we compare it with `max_value`.\n - If the item is a string, we attempt to convert it to a float using `float(item)`. If successful, we compare this numeric value with `max_value`.\n\n3. **Comparison**:\n - We update `max_value` whenever we find a number greater than the current `max_value`.\n\n4. **Handling Non-numeric Strings**: If a string cannot be converted to a number (raises `ValueError`), it is ignored in terms of finding the maximum value.\n\n5. **Return Value**: Finally, the function returns the maximum numeric value found in the list.\n\nThis approach ensures that we correctly handle both numbers and strings that can represent numbers, while ignoring other types of strings.\n```"}
{"task_id": "Mbpp/296", "solution": "Certainly! To solve the problem of counting inversions in an array, we can use a modified version of the merge sort algorithm. An inversion is defined as a pair of indices \\( (i, j) \\) such that \\( i < j \\) and \\( arr[i] > arr[j] \\). The idea is to count these pairs while sorting the array.\n\nHere's a self-contained Python script that implements this approach:\n\n```python\ndef merge_and_count(arr, temp_arr, left, mid, right):\n i = left # Starting index for left subarray\n j = mid + 1 # Starting index for right subarray\n k = left # Starting index to be sorted\n inv_count = 0\n\n # Conditions are checked to ensure that i doesn't exceed mid and j doesn't exceed right\n while i <= mid and j <= right:\n if arr[i] <= arr[j]:\n temp_arr[k] = arr[i]\n i += 1\n else:\n # There are mid - i inversions, because all elements left to i in the left subarray\n # are greater than arr[j]\n temp_arr[k] = arr[j]\n inv_count += (mid-i + 1)\n j += 1\n k += 1\n\n # Copy the remaining elements of left subarray, if any\n while i <= mid:\n temp_arr[k] = arr[i]\n i += 1\n k += 1\n\n # Copy the remaining elements of right subarray, if any\n while j <= right:\n temp_arr[k] = arr[j]\n j += 1\n k += 1\n\n # Copy the sorted subarray into Original array\n for i in range(left, right + 1):\n arr[i] = temp_arr[i]\n\n return inv_count\n\n\ndef merge_sort_and_count(arr, temp_arr, left, right):\n inv_count = 0\n if left < right:\n mid = (left + right)//2\n\n inv_count += merge_sort_and_count(arr, temp_arr, left, mid)\n inv_count += merge_sort_and_count(arr, temp_arr, mid + 1, right)\n\n inv_count += merge_and_count(arr, temp_arr, left, mid, right)\n\n return inv_count\n\n\ndef get_Inv_Count(arr):\n n = len(arr)\n temp_arr = [0]*n\n return merge_sort_and_count(arr, temp_arr, 0, n-1)\n\n\n# Test the function with an example\nassert get_Inv_Count([1, 20, 6, 4, 5]) == 5\n\nprint(\"Inversion count is correct.\")\n```\n\n### Explanation:\n\n1. **merge_and_count**: This helper function merges two halves of the array and counts inversions. If an element from the right half is placed before an element from the left half during merging, it means there are inversions equal to the number of remaining elements in the left subarray.\n\n2. **merge_sort_and_count**: This recursive function sorts the array using merge sort while counting inversions by dividing the array into two halves, recursively sorting them, and then merging them with inversion count.\n\n3. **get_Inv_Count**: This is the main function that initializes a temporary array for merging and calls `merge_sort_and_count` to get the total number of inversions in the input array.\n\nThe script includes an assertion to verify the correctness of the implementation using the provided example."}
{"task_id": "Mbpp/297", "solution": "Here's a self-contained Python script that defines a function to flatten a nested list structure:\n\n```markdown\n```python\ndef flatten_list(nested_list):\n \"\"\"\n Flattens a given nested list structure into a single list of elements.\n \n Parameters:\n nested_list (list): A list which may contain other lists as its elements.\n\n Returns:\n list: A flattened version of the input list with all nested elements extracted.\n \"\"\"\n flat_list = []\n \n for element in nested_list:\n if isinstance(element, list):\n # Recursively flatten the sublist\n flat_list.extend(flatten_list(element))\n else:\n # Append non-list elements directly to the result\n flat_list.append(element)\n \n return flat_list\n\n# Test case\nassert flatten_list([0, 10, [20, 30], 40, 50, [60, 70, 80], [90, 100, 110, 120]]) == [0, 10, 20, 30, 40, 50, 60, 70, 80, 90, 100, 110, 120]\n```\n```\n\nThis script defines a function `flatten_list` that takes a nested list as input and returns a flattened version of it. The function uses recursion to handle sublists within the main list, ensuring all elements are extracted into a single list. The provided test case verifies that the function works correctly for the given example."}
{"task_id": "Mbpp/299", "solution": "Certainly! Below is a self-contained Python script that solves the problem of calculating the maximum aggregate from a list of tuples. Each tuple contains a name and a score, and the goal is to find the person with the highest total score.\n\n```python\ndef max_aggregate(scores):\n \"\"\"\n Calculate the maximum aggregate score from a list of (name, score) tuples.\n \n Args:\n scores (list of tuples): A list where each tuple contains a name (str) and a score (int).\n \n Returns:\n tuple: A tuple containing the name with the highest total score and that score.\n \"\"\"\n # Dictionary to store cumulative scores for each person\n aggregate_scores = {}\n \n # Iterate over each (name, score) tuple in the list\n for name, score in scores:\n if name in aggregate_scores:\n # If the name is already in the dictionary, add the score to their total\n aggregate_scores[name] += score\n else:\n # Otherwise, initialize their total with the current score\n aggregate_scores[name] = score\n \n # Find the person with the maximum aggregate score\n max_name = None\n max_score = float('-inf')\n \n for name, total in aggregate_scores.items():\n if total > max_score:\n max_score = total\n max_name = name\n \n return (max_name, max_score)\n\n# Test case\nassert max_aggregate([('Juan Whelan', 90), ('Sabah Colley', 88), \n ('Peter Nichols', 7), ('Juan Whelan', 122), \n ('Sabah Colley', 84)]) == ('Juan Whelan', 212)\n```\n\n### Explanation:\n\n1. **Data Structure**: We use a dictionary `aggregate_scores` to keep track of the cumulative scores for each person.\n\n2. **Iterating through Scores**:\n - For each tuple `(name, score)`, we check if the name is already in the dictionary.\n - If it is, we add the current score to their existing total.\n - If not, we initialize their total with the current score.\n\n3. **Finding Maximum Aggregate**:\n - We iterate through the `aggregate_scores` dictionary to find the person with the highest total score.\n - We keep track of the maximum score and corresponding name as we go through the dictionary.\n\n4. **Return Result**: Finally, we return a tuple containing the name with the highest aggregate score and that score.\n\nThis script includes an assertion to verify that the function works correctly for the provided test case."}
{"task_id": "Mbpp/300", "solution": "```markdown\nTo solve this problem, we need to find the count of all binary sequences of length \\(2n\\) such that the sum of the first \\(n\\) bits is equal to the sum of the last \\(n\\) bits.\n\n### Explanation\n\n1. **Binary Sequence**: A sequence consisting only of 0s and 1s.\n2. **Length**: The total length of the sequence is \\(2n\\).\n3. **Condition**: The sum (or count) of 1s in the first half (first \\(n\\) bits) must equal the sum of 1s in the second half (last \\(n\\) bits).\n\n### Approach\n\nTo solve this, we can use combinatorics:\n\n- For a given number \\(k\\), where \\(0 \\leq k \\leq n\\), choose \\(k\\) positions out of the first \\(n\\) to be 1s. This can be done in \\(\\binom{n}{k}\\) ways.\n- Similarly, choose \\(k\\) positions out of the last \\(n\\) to be 1s. This also can be done in \\(\\binom{n}{k}\\) ways.\n\nThe total number of valid sequences for a specific \\(k\\) is therefore \\(\\binom{n}{k}^2\\).\n\nTo find the total count for all possible values of \\(k\\), sum over all \\(k\\) from 0 to \\(n\\):\n\n\\[ \\text{Total Count} = \\sum_{k=0}^{n} \\left( \\binom{n}{k} \\right)^2 \\]\n\nThis is equivalent to the central binomial coefficient:\n\n\\[ \\text{Total Count} = \\binom{2n}{n} \\]\n\n### Implementation\n\nHere's a Python function implementing this logic using the `math` module for combinatorial calculations:\n\n```python\nimport math\n\ndef count_binary_seq(n):\n # Calculate the central binomial coefficient (2n choose n)\n return math.comb(2 * n, n)\n\n# Test case\nassert math.isclose(count_binary_seq(1), 2.0, rel_tol=0.001)\n```\n\n### Explanation of the Code\n\n- **`math.comb(n, k)`**: This function computes the binomial coefficient \\(\\binom{n}{k}\\), which is the number of ways to choose \\(k\\) elements from a set of \\(n\\) elements.\n- **Central Binomial Coefficient**: The expression `math.comb(2 * n, n)` directly gives us the count of valid sequences by calculating \\(\\binom{2n}{n}\\).\n\nThis solution efficiently computes the desired count using combinatorial mathematics."}
{"task_id": "Mbpp/301", "solution": "Certainly! Below is a self-contained Python script that defines a function `dict_depth` to calculate the depth of a nested dictionary. The function uses recursion to traverse through the dictionary and determine its maximum depth.\n\n```python\ndef dict_depth(d, level=1):\n \"\"\"\n Calculate the depth of a nested dictionary.\n \n Parameters:\n d (dict): The dictionary whose depth is to be calculated.\n level (int): The current depth level during recursion. Default is 1.\n \n Returns:\n int: The maximum depth of the dictionary.\n \"\"\"\n if not isinstance(d, dict) or not d:\n return level\n \n # Recursively find the maximum depth among all values\n return max(dict_depth(value, level + 1) for value in d.values())\n\n# Test case to verify the function works as expected\nassert dict_depth({'a': 1, 'b': {'c': {'d': {}}}}) == 4\n\nprint(\"The test passed successfully!\")\n```\n\n### Explanation:\n\n- **Base Case**: If `d` is not a dictionary or it's empty, return the current depth level (`level`). This handles cases where we reach a non-dictionary value or an empty dictionary.\n \n- **Recursive Case**: For each key-value pair in the dictionary, recursively call `dict_depth` on the value with an incremented depth level. Use `max()` to find the deepest path.\n\n- The function starts at level 1 and increments as it goes deeper into nested dictionaries.\n\nThis script includes a test case using `assert` to ensure that the function correctly calculates the depth of the given dictionary structure."}
{"task_id": "Mbpp/305", "solution": "Certainly! Below is a self-contained Python script that solves the problem described. The function `start_with_p` takes a list of words and returns two words from the list that start with the letter 'p'. If there are not exactly two such words, it raises an assertion error.\n\n```python\ndef start_with_p(words):\n \"\"\"\n This function takes a list of words and returns two words that start with the letter 'p'.\n \n :param words: List of strings\n :return: A tuple containing two words starting with 'p'\n \"\"\"\n # Filter words that start with 'p' or 'P'\n p_words = [word for word in words if word.lower().startswith('p')]\n \n # Assert there are exactly two such words\n assert len(p_words) == 2, \"There must be exactly two words starting with 'p'\"\n \n return tuple(p_words)\n\n# Test the function\nassert start_with_p([\"Python PHP\", \"Java JavaScript\", \"c c++\"]) == ('Python', 'PHP')\n```\n\nThis script defines the `start_with_p` function and includes a test case to ensure it works as expected. The assertion ensures that there are exactly two words starting with 'p' in the input list, which matches the requirement specified in your problem statement."}
{"task_id": "Mbpp/306", "solution": "To solve the problem of finding the maximum sum of an increasing subsequence from a prefix until the \\(i\\)-th index and also including a given \\(k\\)-th element (where \\(k > i\\)), we can break down the solution into several steps:\n\n1. **Identify Increasing Subsequences**: First, identify all possible increasing subsequences that end at each index up to \\(i\\).\n\n2. **Calculate Maximum Sum for Each Index**: For each index up to \\(i\\), calculate the maximum sum of an increasing subsequence ending at that index.\n\n3. **Include the \\(k\\)-th Element**: After determining the maximum sums up to index \\(i\\), check which of these subsequences can be extended by including the element at index \\(k\\) (since \\(a_k > a_i\\) for it to be part of an increasing subsequence).\n\n4. **Compute the Result**: The result will be the maximum sum obtained from any valid subsequence that ends at some index up to \\(i\\) and includes the element at index \\(k\\).\n\nHere's how you can implement this in Python:\n\n```python\ndef max_sum_increasing_subseq(arr, n, i, k):\n # Step 1: Calculate maximum sum of increasing subsequences ending at each index up to i\n max_sums = [0] * n\n for idx in range(n):\n max_sums[idx] = arr[idx]\n \n for j in range(1, i + 1):\n for l in range(j):\n if arr[l] < arr[j]:\n max_sums[j] = max(max_sums[j], max_sums[l] + arr[j])\n \n # Step 2: Find the maximum sum of increasing subsequence ending at any index up to i\n # and can be extended by including element at index k\n result = float('-inf')\n for j in range(i + 1):\n if arr[j] < arr[k]:\n result = max(result, max_sums[j] + arr[k])\n \n return result\n\n# Test the function with the provided example\nassert max_sum_increasing_subseq([1, 101, 2, 3, 100, 4, 5], 7, 4, 6) == 11\n```\n\n### Explanation:\n\n- **Initialization**: We initialize `max_sums` to store the maximum sum of increasing subsequences ending at each index. Initially, it is set to the value of the element itself because a single element is an increasing subsequence.\n\n- **Dynamic Programming Approach**: For each index \\(j\\) from 1 to \\(i\\), we check all previous indices \\(l\\) (from 0 to \\(j-1\\)). If `arr[l] < arr[j]`, it means we can extend the subsequence ending at \\(l\\) by including `arr[j]`. We update `max_sums[j]` accordingly.\n\n- **Result Calculation**: After computing `max_sums` up to index \\(i\\), we iterate through these sums and check if they can be extended by including `arr[k]` (since `arr[k] > arr[j]`). The maximum of these possible extensions gives the desired result.\n\nThis approach efficiently computes the required maximum sum using dynamic programming, ensuring that all potential subsequences are considered."}
{"task_id": "Mbpp/308", "solution": "Certainly! Below is a self-contained Python script that solves the problem of finding the specified number of largest products from two given lists by selecting one factor from each list.\n\n```python\ndef large_product(list1, list2, n):\n # Create a list to store all possible products\n products = []\n \n # Iterate over each element in the first list\n for num1 in list1:\n # Iterate over each element in the second list\n for num2 in list2:\n # Calculate the product and add it to the products list\n products.append(num1 * num2)\n \n # Sort the products list in descending order\n products.sort(reverse=True)\n \n # Return the first n largest products\n return products[:n]\n\n# Test case\nassert large_product([1, 2, 3, 4, 5, 6], [3, 6, 8, 9, 10, 6], 3) == [60, 54, 50]\n```\n\n### Explanation:\n\n1. **Product Calculation**: We iterate over each element in `list1` and for each element, we iterate over each element in `list2`. For every pair of elements `(num1, num2)`, we calculate the product `num1 * num2` and store it in a list called `products`.\n\n2. **Sorting**: After calculating all possible products, we sort this list in descending order to easily access the largest products.\n\n3. **Selecting Largest Products**: We then return the first `n` elements from this sorted list, which are the `n` largest products.\n\nThis approach ensures that we consider every possible product and efficiently find the largest ones as required by the problem statement."}
{"task_id": "Mbpp/309", "solution": "```markdown\n```python\ndef maximum(a, b):\n \"\"\"\n This function takes two numbers as input and returns the larger one.\n\n Parameters:\n a (int or float): The first number.\n b (int or float): The second number.\n\n Returns:\n int or float: The maximum of the two numbers.\n \"\"\"\n if a > b:\n return a\n else:\n return b\n\n# Test case to verify that the function works as expected\nassert maximum(5, 10) == 10\n```\n```"}
{"task_id": "Mbpp/310", "solution": "Certainly! Below is a self-contained Python script that defines the function `string_to_tuple` to convert a given string into a tuple of its characters. The script also includes an assertion to verify the correctness of the function.\n\n```python\ndef string_to_tuple(s):\n \"\"\"\n Convert a given string to a tuple of characters.\n \n Parameters:\n s (str): The input string to be converted.\n \n Returns:\n tuple: A tuple containing each character from the input string.\n \"\"\"\n return tuple(s)\n\n# Test case\nassert string_to_tuple(\"python 3.0\") == ('p', 'y', 't', 'h', 'o', 'n', ' ', '3', '.', '0')\n\nprint(\"The function works correctly!\")\n```\n\nThis script defines the `string_to_tuple` function, which takes a single argument `s`, representing the input string. It uses Python's built-in `tuple()` function to convert the string into a tuple of its characters. The assertion checks if the output for the input `\"python 3.0\"` matches the expected tuple `('p', 'y', 't', 'h', 'o', 'n', ' ', '3', '.', '0')`. If the assertion passes, it prints a confirmation message indicating that the function works correctly."}
{"task_id": "Mbpp/311", "solution": "Certainly! Below is a Python script that defines a function `set_left_most_unset_bit` which sets the leftmost unset (0) bit of an integer. The function uses bitwise operations to achieve this.\n\n```python\ndef set_left_most_unset_bit(n):\n \"\"\"\n Set the leftmost unset bit in the binary representation of n.\n \n Args:\n n (int): A non-negative integer whose leftmost unset bit is to be set.\n \n Returns:\n int: The new integer with the leftmost unset bit set.\n \"\"\"\n # If all bits are set, return n as it is\n if n & (n + 1) == 0:\n return n\n \n # Find the position of the leftmost unset bit\n mask = ~n\n pos = 0\n while mask & (1 << pos):\n pos += 1\n \n # Set the leftmost unset bit\n result = n | (1 << pos)\n \n return result\n\n# Test case\nassert set_left_most_unset_bit(10) == 14, \"Test case failed!\"\n```\n\n### Explanation:\n\n1. **Check if all bits are set**: \n - If `n & (n + 1) == 0`, it means all bits in `n` are set to 1. In this case, the function returns `n` as is.\n\n2. **Find the leftmost unset bit**:\n - Create a mask by negating `n` (`~n`). This will have 1s where `n` has 0s.\n - Use a loop to find the position of the first 1 in this mask, which corresponds to the leftmost unset bit in `n`.\n\n3. **Set the leftmost unset bit**:\n - Use bitwise OR (`|`) to set the bit at the found position.\n\n4. **Return the result**: \n - The modified number with the leftmost unset bit set is returned.\n\nThis function should work for any non-negative integer input."}
{"task_id": "Mbpp/312", "solution": "Certainly! Below is a self-contained Python script that defines a function to calculate the volume of a cone and includes an assertion to verify its correctness.\n\n```markdown\n```python\nimport math\n\ndef volume_cone(radius, height):\n \"\"\"\n Calculate the volume of a cone given its radius and height.\n \n Parameters:\n - radius (float): The radius of the base of the cone.\n - height (float): The height of the cone.\n \n Returns:\n - float: The volume of the cone.\n \"\"\"\n # Volume formula for a cone: V = (1/3) * \u03c0 * r^2 * h\n return (1/3) * math.pi * radius**2 * height\n\n# Test case to verify the function's correctness\nassert math.isclose(volume_cone(5, 12), 314.15926535897927, rel_tol=0.001)\n```\n```\n\n### Explanation:\n\n- **Function Definition**: The `volume_cone` function takes two parameters: `radius` and `height`.\n- **Volume Calculation**: It uses the formula for the volume of a cone \\( V = \\frac{1}{3} \\pi r^2 h \\).\n- **Assertion**: The script includes an assertion to check if the calculated volume is close to the expected value (314.15926535897927) within a relative tolerance of 0.001, ensuring accuracy.\n\nThis script can be run in any Python environment that supports standard libraries like `math`."}
{"task_id": "Mbpp/388", "solution": "```markdown\n```python\ndef highest_power_of_2(n):\n \"\"\"\n This function finds the highest power of 2 that is less than or equal to a given number n.\n\n Parameters:\n n (int): The upper limit integer.\n\n Returns:\n int: The highest power of 2 less than or equal to n.\n \"\"\"\n # Initialize the result as 1, which is 2^0\n result = 1\n \n # Keep multiplying by 2 until the next power exceeds n\n while result * 2 <= n:\n result *= 2\n \n return result\n\n# Test case\nassert highest_power_of_2(10) == 8\n```\n```"}
{"task_id": "Mbpp/389", "solution": "```markdown\n```python\ndef find_lucas(n):\n \"\"\"\n Calculate the nth Lucas number.\n\n The Lucas numbers are similar to Fibonacci numbers, but start with 2 and 1 instead of 0 and 1.\n The sequence is defined as:\n L(0) = 2, L(1) = 1\n L(n) = L(n-1) + L(n-2) for n > 1\n\n Args:\n n (int): The position in the Lucas sequence to find.\n\n Returns:\n int: The nth Lucas number.\n \"\"\"\n if n == 0:\n return 2\n elif n == 1:\n return 1\n \n # Initialize the first two Lucas numbers\n lucas_0, lucas_1 = 2, 1\n\n # Compute the nth Lucas number iteratively\n for _ in range(2, n + 1):\n lucas_n = lucas_0 + lucas_1\n lucas_0, lucas_1 = lucas_1, lucas_n\n \n return lucas_n\n\n# Test case to verify the function works as expected\nassert find_lucas(9) == 76\n```\n```"}
{"task_id": "Mbpp/390", "solution": "Certainly! Below is a self-contained Python script that defines a function `add_string` to apply a given format string to all elements in a list. The function uses the `str.format()` method to insert each element into the specified position within the format string.\n\n```python\ndef add_string(lst, fmt):\n \"\"\"\n Apply a given format string to all of the elements in a list.\n \n Parameters:\n lst (list): A list of elements to be formatted.\n fmt (str): A format string with placeholders for each element.\n \n Returns:\n list: A new list where each element is formatted according to the format string.\n \"\"\"\n return [fmt.format(i) for i in lst]\n\n# Test case\nassert add_string([1, 2, 3, 4], 'temp{0}') == ['temp1', 'temp2', 'temp3', 'temp4']\n```\n\n### Explanation:\n\n- **Function Definition**: The function `add_string` takes two parameters: a list `lst` and a format string `fmt`.\n \n- **List Comprehension**: It uses a list comprehension to iterate over each element in the input list. For each element, it applies the format string using `fmt.format(i)`, where `{0}` is replaced by the current element `i`.\n\n- **Return Value**: The function returns a new list with all elements formatted according to the provided format string.\n\n- **Assertion**: An assertion is included to verify that the function works as expected for the given test case."}
{"task_id": "Mbpp/391", "solution": "Here's a self-contained Python script that solves the problem of converting multiple lists into a nested dictionary:\n\n```python\ndef convert_list_dictionary(ids, names, scores):\n \"\"\"\n Convert three lists into a list of nested dictionaries.\n \n Parameters:\n ids (list): List of student IDs.\n names (list): List of student names.\n scores (list): List of student scores.\n \n Returns:\n list: A list of dictionaries where each dictionary represents\n a student with their ID, name, and score in nested format.\n \"\"\"\n result = []\n for id_, name, score in zip(ids, names, scores):\n # Create a nested dictionary for each student\n student_dict = {id_: {name: score}}\n result.append(student_dict)\n return result\n\n# Test the function with an assertion\nassert convert_list_dictionary(\n [\"S001\", \"S002\", \"S003\", \"S004\"],\n [\"Adina Park\", \"Leyton Marsh\", \"Duncan Boyle\", \"Saim Richards\"],\n [85, 98, 89, 92]\n) == [\n {'S001': {'Adina Park': 85}},\n {'S002': {'Leyton Marsh': 98}},\n {'S003': {'Duncan Boyle': 89}},\n {'S004': {'Saim Richards': 92}}\n]\n\nprint(\"The function works correctly!\")\n```\n\nThis script defines a function `convert_list_dictionary` that takes three lists as input: student IDs, names, and scores. It uses the `zip` function to iterate over these lists simultaneously, creating a nested dictionary for each student. The result is a list of these dictionaries, which matches the expected output format."}
{"task_id": "Mbpp/392", "solution": "Certainly! Below is a self-contained Python script that solves the problem using dynamic programming to efficiently compute the maximum sum possible with the given equation.\n\n```python\ndef get_max_sum(n):\n # Create a list to store results of subproblems\n dp = [0] * (n + 1)\n \n # Base case: f(0) and f(1) are 0 and 1 respectively\n for i in range(2, n + 1):\n # Calculate the maximum sum using the given equation\n dp[i] = max(i, dp[i // 2] + dp[i // 3] + dp[i // 4] + dp[i // 5])\n \n return dp[n]\n\n# Test case\nassert get_max_sum(60) == 106\n\nprint(\"The maximum sum for n=60 is:\", get_max_sum(60))\n```\n\n### Explanation:\n\n1. **Dynamic Programming Array (`dp`)**: We use a list `dp` where each index `i` stores the result of `f(i)`. This helps in avoiding redundant calculations by storing already computed results.\n\n2. **Base Cases**: \n - `f(0)` is 0 because there's no sum possible with zero.\n - `f(1)` is 1 because taking the number itself gives the maximum sum.\n\n3. **Iterative Calculation**:\n - For each number from 2 to `n`, calculate `f(i)` using the formula: \n \\[\n f(i) = \\max(i, f(i/2) + f(i/3) + f(i/4) + f(i//5))\n \\]\n - Use integer division (`//`) for indices since list indices must be integers.\n\n4. **Result**: The value `dp[n]` will contain the maximum sum possible for the given `n`.\n\nThis approach ensures that each subproblem is solved only once, making it efficient with a time complexity of \\(O(n)\\)."}
{"task_id": "Mbpp/394", "solution": "Certainly! Below is a self-contained Python script that defines the `check_distinct` function. This function checks whether a given tuple contains any duplicate elements.\n\n```python\ndef check_distinct(tpl):\n \"\"\"\n Check if the given tuple contains no duplicates.\n \n Parameters:\n tpl (tuple): The input tuple to be checked for duplicates.\n \n Returns:\n bool: True if there are no duplicates, False otherwise.\n \"\"\"\n # Convert the tuple into a set. Sets automatically remove duplicate elements.\n unique_elements = set(tpl)\n \n # Compare the length of the original tuple and the set\n # If they are equal, it means there were no duplicates in the tuple\n return len(unique_elements) == len(tpl)\n\n# Test case to verify the function works as expected\nassert check_distinct((1, 4, 5, 6, 1, 4)) == False\n\n# Additional test cases for verification\nassert check_distinct((1, 2, 3, 4, 5)) == True\nassert check_distinct(()) == True # An empty tuple has no duplicates by definition\nassert check_distinct((1, 1, 1, 1)) == False\nassert check_distinct(('a', 'b', 'c')) == True\n\nprint(\"All test cases passed!\")\n```\n\n### Explanation:\n- **Set Conversion**: The function converts the input tuple into a set. Sets in Python automatically remove any duplicate elements.\n- **Length Comparison**: By comparing the length of the original tuple and the resulting set, we can determine if there were duplicates. If their lengths are equal, it means all elements in the tuple were unique; otherwise, some duplicates existed.\n\nThis script includes an assertion to test the function with a specific case where duplicates exist, as well as additional test cases for thorough verification."}
{"task_id": "Mbpp/395", "solution": "```markdown\nHere's a Python function to solve the problem of finding the first non-repeating character in a given string:\n\n```python\ndef first_non_repeating_character(s):\n # Create a dictionary to count occurrences of each character\n char_count = {}\n \n # Count each character in the string\n for char in s:\n if char in char_count:\n char_count[char] += 1\n else:\n char_count[char] = 1\n \n # Find the first non-repeating character\n for char in s:\n if char_count[char] == 1:\n return char\n \n # Return None if there is no non-repeating character\n return None\n\n# Test case\nassert first_non_repeating_character(\"abcabc\") == None\n```\n\n### Explanation:\n\n1. **Character Counting**: We use a dictionary `char_count` to store the count of each character in the string.\n\n2. **First Pass**: Iterate through the string and populate the dictionary with counts of each character.\n\n3. **Second Pass**: Iterate through the string again and check the count of each character using the dictionary. The first character with a count of 1 is returned as it is the first non-repeating character.\n\n4. **Return None**: If no such character exists, return `None`.\n\nThis approach ensures that we efficiently find the first non-repeating character in linear time complexity, O(n), where n is the length of the string.\n```"}
{"task_id": "Mbpp/397", "solution": "Certainly! Below is a self-contained Python script that defines a function to find the median of three numbers and includes an assertion to verify its correctness.\n\n```python\ndef median_of_three(a, b, c):\n \"\"\"\n This function takes three numbers as input and returns their median.\n \n Parameters:\n a (float): The first number.\n b (float): The second number.\n c (float): The third number.\n \n Returns:\n float: The median of the three numbers.\n \"\"\"\n # Create a list of the three numbers\n numbers = [a, b, c]\n \n # Sort the list in ascending order\n sorted_numbers = sorted(numbers)\n \n # Return the middle element (median) from the sorted list\n return sorted_numbers[1]\n\n# Test case to verify the function works correctly\nassert median_of_three(25, 55, 65) == 55.0\n\nprint(\"The function passed the test case.\")\n```\n\n### Explanation:\n- The `median_of_three` function takes three numbers as input.\n- It stores these numbers in a list and sorts them in ascending order using Python's built-in `sorted()` function.\n- Since the median of three numbers is the middle number when they are sorted, it returns the second element from the sorted list (index 1).\n- An assertion checks that the function correctly identifies 55 as the median of 25, 55, and 65. If the assertion fails, an `AssertionError` will be raised.\n- A print statement confirms that the test case passed successfully.\n\nThis script is self-contained and can be run independently to verify its correctness."}
{"task_id": "Mbpp/398", "solution": "```markdown\nHere's a Python script that defines a function `sum_of_digits` which computes the sum of the digits for each number in a given list and returns their total sum:\n\n```python\ndef sum_of_digits(numbers):\n \"\"\"\n Compute the sum of digits of each number in the given list.\n\n Parameters:\n numbers (list): A list of integers.\n\n Returns:\n int: The sum of all digits from all numbers in the list.\n \"\"\"\n total_sum = 0\n \n for number in numbers:\n # Convert the number to a string to iterate over its digits\n for digit in str(number):\n # Add each digit (converted back to an integer) to the total sum\n total_sum += int(digit)\n \n return total_sum\n\n# Test case\nassert sum_of_digits([10, 2, 56]) == 14\n```\n\n### Explanation:\n\n1. **Function Definition**: The function `sum_of_digits` takes a list of integers as input.\n\n2. **Initialization**: A variable `total_sum` is initialized to zero. This will hold the cumulative sum of all digits from all numbers in the list.\n\n3. **Iterating Over Numbers**: For each number in the list, we convert it to a string so that we can iterate over each character (digit) individually.\n\n4. **Digit Summation**: Each digit is converted back to an integer and added to `total_sum`.\n\n5. **Return Value**: After processing all numbers, the function returns `total_sum`, which is the sum of all digits from all numbers in the list.\n\n6. **Assertion Test**: The script includes a test case using `assert` to verify that the function works as expected for the input `[10, 2, 56]`. The expected result is `14` because:\n - Digits of `10`: 1 + 0 = 1\n - Digits of `2`: 2\n - Digits of `56`: 5 + 6 = 11\n - Total sum: 1 + 2 + 11 = 14\n\nThis script should work correctly for any list of non-negative integers.\n```"}
{"task_id": "Mbpp/404", "solution": "```markdown\n```python\ndef minimum(a, b):\n \"\"\"\n This function returns the smaller of two numbers.\n\n Parameters:\n a (int or float): The first number.\n b (int or float): The second number.\n\n Returns:\n int or float: The smaller of the two numbers.\n \"\"\"\n return a if a < b else b\n\n# Test case to verify that the function works as expected\nassert minimum(1, 2) == 1\n```\n```"}
{"task_id": "Mbpp/405", "solution": "Certainly! Below is a self-contained Python script that defines the function `check_tuplex` to check if an element exists within a tuple. The function uses an assertion to verify its correctness.\n\n```python\ndef check_tuplex(tpl, element):\n \"\"\"\n Check whether an element exists within a tuple.\n \n Parameters:\n tpl (tuple): The tuple in which to search for the element.\n element: The element to search for within the tuple.\n \n Returns:\n bool: True if the element is found in the tuple, False otherwise.\n \"\"\"\n return element in tpl\n\n# Test case\nassert check_tuplex((\"w\", 3, \"r\", \"e\", \"s\", \"o\", \"u\", \"r\", \"c\", \"e\"), 'r') == True\n```\n\nThis script defines the `check_tuplex` function and includes a test case to ensure it works as expected. The assertion checks that the function returns `True` when searching for `'r'` in the given tuple."}
{"task_id": "Mbpp/406", "solution": "Certainly! Below is a self-contained Python script that defines a function `find_parity` to determine if the parity (number of 1s in the binary representation) of a given integer is odd. The function returns `True` if the number of 1s is odd, and `False` otherwise.\n\n```python\ndef find_parity(n):\n \"\"\"\n Determine if the parity of the number of 1s in the binary representation of n is odd.\n \n Parameters:\n n (int): The integer to check.\n \n Returns:\n bool: True if the number of 1s is odd, False otherwise.\n \"\"\"\n # Initialize a counter for the number of 1s\n count_ones = 0\n \n # Loop until n becomes zero\n while n > 0:\n # Increment the counter if the least significant bit is 1\n if n & 1:\n count_ones += 1\n \n # Right shift n by one bit to check the next bit\n n >>= 1\n \n # Check if the number of 1s is odd\n return count_ones % 2 == 1\n\n# Test case\nassert find_parity(12) == False, \"Test case failed!\"\n\nprint(\"All test cases passed!\")\n```\n\n### Explanation:\n- The function `find_parity` takes an integer `n`.\n- It initializes a counter `count_ones` to zero.\n- Using a loop, it checks each bit of the number by performing bitwise AND with 1 (`n & 1`). If the result is 1, it increments the counter.\n- It then right shifts the number by one bit (`n >>= 1`) to check the next bit in the subsequent iteration.\n- After exiting the loop, it checks if `count_ones` is odd using the modulus operator (`% 2 == 1`). If true, it returns `True`; otherwise, it returns `False`.\n- The test case `assert find_parity(12) == False` ensures that the function works correctly for the given example."}
{"task_id": "Mbpp/409", "solution": "Certainly! Below is a self-contained Python script that defines a function to find the minimum product from pairs of tuples within a given list. The function calculates the product for each tuple and returns the smallest one.\n\n```python\ndef min_product_tuple(tuples_list):\n \"\"\"\n This function takes a list of tuples, where each tuple contains two integers.\n It computes the product of the integers in each tuple and returns the minimum product found.\n \n :param tuples_list: List of tuples containing pairs of integers\n :return: The minimum product from all tuple pairs\n \"\"\"\n # Initialize min_product with a large number to ensure any product will be smaller\n min_product = float('inf')\n \n # Iterate over each tuple in the list\n for a, b in tuples_list:\n # Calculate the product of the current tuple\n product = a * b\n \n # Update min_product if the current product is smaller\n if product < min_product:\n min_product = product\n \n return min_product\n\n# Test case to verify the function works as expected\nassert min_product_tuple([(2, 7), (2, 6), (1, 8), (4, 9)]) == 8\n```\n\nThis script defines a function `min_product_tuple` that iterates over each tuple in the input list, calculates their product, and keeps track of the smallest product encountered. The test case at the end ensures that the function returns the correct result for the provided example."}
{"task_id": "Mbpp/410", "solution": "Certainly! Below is a self-contained Python script that defines a function to find the minimum numeric value in a heterogeneous list. The function filters out non-numeric values and then finds the minimum among the remaining numbers.\n\n```python\ndef min_val(heterogeneous_list):\n # Filter the list to include only numeric types (int, float)\n numeric_values = [item for item in heterogeneous_list if isinstance(item, (int, float))]\n \n # Return the minimum value from the filtered list\n return min(numeric_values) if numeric_values else None\n\n# Test case\nassert min_val(['Python', 3, 2, 4, 5, 'version']) == 2\n```\n\n### Explanation:\n\n1. **Filtering Numeric Values**: The function uses a list comprehension to iterate over the input list and includes only those items that are instances of `int` or `float`. This effectively filters out any non-numeric values such as strings.\n\n2. **Finding Minimum Value**: After filtering, it uses Python's built-in `min()` function to find the smallest number in the filtered list.\n\n3. **Handling Empty Lists**: If there are no numeric values in the input list (i.e., the filtered list is empty), the function returns `None` to indicate that no minimum value could be found.\n\n4. **Test Case**: The provided test case checks if the function correctly identifies `2` as the minimum numeric value from the given heterogeneous list."}
{"task_id": "Mbpp/412", "solution": "Certainly! Below is a self-contained Python script that defines a function `remove_odd` which removes all odd numbers from a given list. The function uses a list comprehension to filter out the odd numbers and returns a new list containing only even numbers.\n\n```python\ndef remove_odd(numbers):\n \"\"\"\n Remove odd numbers from a given list of integers.\n \n Parameters:\n numbers (list): A list of integers.\n \n Returns:\n list: A list containing only the even numbers from the input list.\n \"\"\"\n # Use a list comprehension to filter out odd numbers\n return [num for num in numbers if num % 2 == 0]\n\n# Test case\nassert remove_odd([1, 2, 3]) == [2]\n```\n\nThis function iterates over each number in the input list and checks if it is even by using the modulus operator (`%`). If `num % 2` equals `0`, the number is even, and it is included in the resulting list. The test case at the end verifies that the function works as expected for the provided example."}
{"task_id": "Mbpp/413", "solution": "Certainly! Below is a self-contained Python script that defines the function `extract_nth_element` to extract the nth element from each tuple in a given list of tuples. The function also includes an assertion to verify its correctness.\n\n```python\ndef extract_nth_element(tuples_list, n):\n \"\"\"\n Extracts the nth element from each tuple in the provided list of tuples.\n \n Parameters:\n - tuples_list: List[Tuple] : A list containing tuples.\n - n: int : The index of the element to be extracted from each tuple.\n\n Returns:\n - List[Any] : A list containing the nth elements from each tuple.\n \"\"\"\n # Use a list comprehension to extract the nth element from each tuple\n return [t[n] for t in tuples_list]\n\n# Test case\nassert extract_nth_element([('Greyson Fulton', 98, 99), ('Brady Kent', 97, 96), \n ('Wyatt Knott', 91, 94), ('Beau Turnbull', 94, 98)], 0) == \\\n ['Greyson Fulton', 'Brady Kent', 'Wyatt Knott', 'Beau Turnbull']\n\n# Additional test cases\nassert extract_nth_element([('A', 1, 2), ('B', 3, 4), ('C', 5, 6)], 1) == [1, 3, 5]\nassert extract_nth_element([(10, 'x'), (20, 'y'), (30, 'z')], 0) == [10, 20, 30]\n\nprint(\"All tests passed!\")\n```\n\n### Explanation:\n\n- **Function Definition**: The function `extract_nth_element` takes two parameters: a list of tuples (`tuples_list`) and an integer `n`, which specifies the index of the element to extract from each tuple.\n \n- **List Comprehension**: Inside the function, a list comprehension is used to iterate over each tuple in the input list and extract the nth element. The expression `[t[n] for t in tuples_list]` constructs a new list containing these elements.\n\n- **Assertions**: \n - The first assertion checks if extracting the 0th element from each tuple results in the expected list of names.\n - Additional assertions are included to test other scenarios, ensuring robustness and correctness of the function.\n\n- **Output**: If all assertions pass without raising an error, \"All tests passed!\" is printed, indicating that the function works as intended."}
{"task_id": "Mbpp/414", "solution": "Certainly! Below is a self-contained Python script that defines a function `overlapping` to determine if there are any common elements between two sequences. It also includes an assertion to verify the functionality.\n\n```python\ndef overlapping(seq1, seq2):\n \"\"\"\n Check whether any value in seq1 exists in seq2.\n \n Parameters:\n - seq1: A sequence (e.g., list, tuple) of elements.\n - seq2: Another sequence (e.g., list, tuple) of elements.\n \n Returns:\n - True if there is at least one common element between the sequences.\n - False otherwise.\n \"\"\"\n # Convert both sequences to sets for efficient lookup\n set1 = set(seq1)\n set2 = set(seq2)\n \n # Check for intersection between the two sets\n return not set1.isdisjoint(set2)\n\n# Test case\nassert overlapping([1, 2, 3, 4, 5], [6, 7, 8, 9]) == False\n\nprint(\"All tests passed.\")\n```\n\n### Explanation:\n- The function `overlapping` takes two sequences as input.\n- It converts both sequences into sets to leverage the efficient set operations provided by Python.\n- The method `isdisjoint()` is used to check if there are no common elements between the two sets. If they have no common elements, it returns `True`, and thus we use `not` to invert this for our function's purpose.\n- Finally, an assertion checks that calling `overlapping([1, 2, 3, 4, 5], [6, 7, 8, 9])` returns `False`, as expected."}
{"task_id": "Mbpp/415", "solution": "```markdown\nTo solve the problem of finding a pair with the highest product in an array of integers, we can follow these steps:\n\n1. **Identify Edge Cases**: \n - If the array has fewer than two elements, it's impossible to find a pair.\n - Consider arrays that contain negative numbers, zeros, and positive numbers.\n\n2. **Approach**:\n - The highest product of any two numbers in an array can be achieved by either:\n - Multiplying the two largest positive numbers.\n - Multiplying the two smallest (most negative) numbers if they result in a larger product than the above option.\n - This is because multiplying two large negative numbers results in a positive number.\n\n3. **Implementation**:\n - Traverse the array to find the two largest and two smallest numbers.\n - Calculate the products of these pairs and return the pair with the highest product.\n\nHere's the Python function implementing this logic:\n\n```python\ndef max_Product(arr):\n if len(arr) < 2:\n raise ValueError(\"Array must contain at least two elements.\")\n \n # Initialize variables to store the largest and smallest numbers\n max1 = max2 = float('-inf')\n min1 = min2 = float('inf')\n \n for num in arr:\n # Update the largest numbers\n if num > max1:\n max2 = max1\n max1 = num\n elif num > max2:\n max2 = num\n \n # Update the smallest numbers\n if num < min1:\n min2 = min1\n min1 = num\n elif num < min2:\n min2 = num\n \n # Calculate the products of the two largest and two smallest numbers\n product_max_pair = max1 * max2\n product_min_pair = min1 * min2\n \n # Return the pair with the highest product\n if product_max_pair > product_min_pair:\n return (max1, max2)\n else:\n return (min1, min2)\n\n# Test case\nassert max_Product([1, 2, 3, 4, 7, 0, 8, 4]) == (7, 8)\n```\n\n### Explanation:\n\n- **Initialization**: We start by initializing `max1` and `max2` to negative infinity to find the largest numbers, and `min1` and `min2` to positive infinity to find the smallest numbers.\n \n- **Traversal**: As we iterate through each number in the array:\n - Update `max1` and `max2` if the current number is larger than either of them.\n - Similarly, update `min1` and `min2` if the current number is smaller.\n\n- **Product Calculation**: After identifying the two largest and two smallest numbers, calculate their products.\n\n- **Result**: Compare the products of these pairs and return the pair with the highest product.\n\nThis approach ensures that we efficiently find the desired pair in a single pass through the array."}
{"task_id": "Mbpp/418", "solution": "Certainly! Below is a self-contained Python script that defines a function `Find_Max` which finds and returns the element with the maximum length from a list of lists. The function uses an assertion to verify its correctness.\n\n```python\ndef Find_Max(lst):\n \"\"\"\n This function takes a list of lists as input and returns the sublist \n with the maximum length.\n \n Parameters:\n lst (list): A list containing sublists of varying lengths.\n \n Returns:\n list: The sublist with the maximum length.\n \"\"\"\n # Initialize variable to keep track of the longest sublist\n max_length_sublist = []\n \n # Iterate over each sublist in the input list\n for sublist in lst:\n # Check if the current sublist is longer than the currently known longest sublist\n if len(sublist) > len(max_length_sublist):\n # Update the longest sublist found so far\n max_length_sublist = sublist\n \n return max_length_sublist\n\n# Test case to verify the function works as expected\nassert Find_Max([['A'], ['A', 'B'], ['A', 'B', 'C']]) == ['A', 'B', 'C']\n\nprint(\"The function passed the test case.\")\n```\n\nThis script defines the `Find_Max` function, which iterates through each sublist in the provided list and keeps track of the longest one found. It then returns this longest sublist. The assertion checks that the function correctly identifies `['A', 'B', 'C']` as the longest sublist from the given example input."}
{"task_id": "Mbpp/419", "solution": "Certainly! Below is a self-contained Python script that solves the problem described in your request:\n\n```markdown\n```python\ndef round_and_sum(numbers):\n \"\"\"\n Rounds each number in the list to the nearest integer,\n calculates their sum, and then multiplies this sum by \n the length of the list.\n \n Parameters:\n numbers (list): A list of floating-point numbers.\n\n Returns:\n int: The total sum multiplied by the length of the list.\n \"\"\"\n # Round each number in the list\n rounded_numbers = [round(num) for num in numbers]\n \n # Calculate the sum of the rounded numbers\n total_sum = sum(rounded_numbers)\n \n # Multiply the sum by the length of the original list\n result = total_sum * len(numbers)\n \n return result\n\n# Test case to verify the function works as expected\nassert round_and_sum([22.4, 4.0, -16.22, -9.10, 11.00, -12.22, 14.20, -5.20, 17.50]) == 243\n\nprint(\"The test case passed successfully!\")\n```\n```\n\nThis script defines a function `round_and_sum` that takes a list of numbers as input. It rounds each number to the nearest integer using Python's built-in `round()` function, calculates their sum, and then multiplies this sum by the length of the original list. The result is returned and verified with an assertion for correctness."}
{"task_id": "Mbpp/420", "solution": "Certainly! Below is a self-contained Python script that defines a function to calculate the cube sum of the first `n` even natural numbers. The function includes an assertion to verify its correctness for the given example.\n\n```python\ndef cube_sum(n):\n \"\"\"\n Calculate the cube sum of the first n even natural numbers.\n \n Parameters:\n n (int): The number of initial even natural numbers to consider.\n \n Returns:\n int: The cube sum of the first n even natural numbers.\n \"\"\"\n # Initialize the sum\n total_sum = 0\n \n # Loop through the first n even numbers\n for i in range(1, n + 1):\n # Calculate the ith even number (2 * i)\n even_number = 2 * i\n \n # Add its cube to the total sum\n total_sum += even_number ** 3\n \n return total_sum\n\n# Test the function with an assertion\nassert cube_sum(2) == 72, \"The test case failed!\"\n\n# Example usage:\nprint(cube_sum(2)) # Output should be 72\n```\n\n### Explanation:\n\n- The function `cube_sum(n)` calculates the sum of cubes of the first `n` even natural numbers.\n- It initializes a variable `total_sum` to accumulate the cube sums.\n- A loop runs from 1 to `n`, and for each iteration, it computes the `i-th` even number as `2 * i`.\n- The cube of this even number is then added to `total_sum`.\n- Finally, the function returns the accumulated sum.\n\nThe assertion checks if the function correctly calculates the cube sum for `n = 2`. For `n = 2`, the first two even numbers are 2 and 4. Their cubes are \\(2^3 = 8\\) and \\(4^3 = 64\\), respectively, and their sum is \\(8 + 64 = 72\\)."}
{"task_id": "Mbpp/421", "solution": "Certainly! Below is a self-contained Python script that defines and tests the `concatenate_tuple` function as described in your problem statement.\n\n```markdown\n```python\ndef concatenate_tuple(tpl):\n \"\"\"\n Concatenates each element of a tuple into a single string separated by hyphens.\n \n Parameters:\n tpl (tuple): A tuple containing elements to be concatenated.\n \n Returns:\n str: A string with all elements from the tuple joined by hyphens.\n \"\"\"\n # Convert all elements in the tuple to strings\n str_elements = map(str, tpl)\n # Join them using a hyphen as the delimiter\n result = '-'.join(str_elements)\n return result\n\n# Test case\nassert concatenate_tuple((\"ID\", \"is\", 4, \"UTS\")) == 'ID-is-4-UTS'\n\nprint(\"All tests passed!\")\n```\n```\n\nThis script defines the `concatenate_tuple` function which takes a tuple as input. It converts each element of the tuple to a string (to handle non-string elements like integers), and then joins them using a hyphen (`'-'`) as the delimiter. The test case provided in your problem statement is used to verify that the function works correctly."}
{"task_id": "Mbpp/422", "solution": "Certainly! Below is a self-contained Python script that defines a function `find_Average_Of_Cube` to calculate the average of the cubes of the first \\( n \\) natural numbers.\n\n```python\ndef find_Average_Of_Cube(n):\n \"\"\"\n Calculate the average of the cubes of the first n natural numbers.\n \n Parameters:\n n (int): The number of initial natural numbers to consider.\n \n Returns:\n float: The average of the cubes of the first n natural numbers.\n \"\"\"\n if n <= 0:\n return 0.0\n \n # Calculate the sum of cubes of the first n natural numbers\n sum_of_cubes = sum(i**3 for i in range(1, n + 1))\n \n # Calculate the average\n average_of_cubes = sum_of_cubes / n\n \n return average_of_cubes\n\n# Test case\nassert find_Average_Of_Cube(2) == 4.5\n```\n\n### Explanation:\n\n- **Function Definition**: The function `find_Average_Of_Cube` takes an integer \\( n \\) as input.\n \n- **Edge Case Handling**: If \\( n \\leq 0 \\), the function returns 0.0, since there are no natural numbers to consider.\n\n- **Sum of Cubes Calculation**: It calculates the sum of cubes using a generator expression within the `sum()` function for efficiency.\n\n- **Average Calculation**: The average is computed by dividing the sum of cubes by \\( n \\).\n\n- **Test Case**: An assertion checks that the function returns 4.5 when \\( n = 2 \\), as expected."}
{"task_id": "Mbpp/424", "solution": "Certainly! Below is a self-contained Python script that defines and tests the `extract_rear` function to solve the problem described:\n\n```markdown\n```python\ndef extract_rear(tpl):\n \"\"\"\n Extracts the last character from each string in the given tuple.\n\n Parameters:\n tpl (tuple): A tuple of strings.\n\n Returns:\n list: A list containing the last character of each string.\n \"\"\"\n # Use a list comprehension to iterate over each element in the tuple\n # and extract the last character using negative indexing [-1]\n return [s[-1] for s in tpl]\n\n# Test case as specified in the problem statement\nassert extract_rear(('Mers', 'for', 'Vers')) == ['s', 'r', 's']\n\n# Additional test cases to ensure robustness\nassert extract_rear(('', 'a', 'ab', 'abc')) == ['', 'a', 'b', 'c']\nassert extract_rear(('single',)) == ['e']\nassert extract_rear(()) == []\n\nprint(\"All tests passed!\")\n```\n```\n\nThis script defines the `extract_rear` function, which takes a tuple of strings and returns a list containing the last character from each string. It uses list comprehension to achieve this efficiently. The provided test cases ensure that the function works correctly for various inputs, including edge cases like an empty string or an empty tuple."}
{"task_id": "Mbpp/425", "solution": "Certainly! Below is a self-contained Python script that defines the function `count_element_in_list` to solve the problem of counting the number of sublists containing a particular element.\n\n```python\ndef count_element_in_list(lst, element):\n \"\"\"\n Count the number of sublists in 'lst' that contain the specified 'element'.\n \n Parameters:\n lst (list): A list of lists.\n element: The element to search for within the sublists.\n \n Returns:\n int: The count of sublists containing the element.\n \"\"\"\n # Initialize a counter\n count = 0\n \n # Iterate over each sublist in the main list\n for sublist in lst:\n # Check if the element is in the current sublist\n if element in sublist:\n # Increment the counter if the element is found\n count += 1\n \n return count\n\n# Test case to verify the function works as expected\nassert count_element_in_list([[1, 3], [5, 7], [1, 11], [1, 15, 7]], 1) == 3\n```\n\n### Explanation:\n\n- **Function Definition**: The function `count_element_in_list` takes two parameters: a list of lists (`lst`) and an element to search for within these sublists.\n \n- **Counter Initialization**: A counter variable `count` is initialized to zero. This will keep track of how many sublists contain the specified element.\n\n- **Iteration Over Sublists**: The function iterates over each sublist in the main list using a `for` loop.\n\n- **Element Check**: For each sublist, it checks if the specified element is present using the condition `if element in sublist`.\n\n- **Increment Counter**: If the element is found within a sublist, the counter is incremented by one.\n\n- **Return Result**: After iterating through all sublists, the function returns the final count of sublists containing the element.\n\n- **Assertion Test**: An assertion test is included to ensure that the function works correctly for the given example. The expected result is `3` because there are three sublists (`[1, 3]`, `[1, 11]`, and `[1, 15, 7]`) containing the element `1`."}
{"task_id": "Mbpp/426", "solution": "Certainly! Below is a self-contained Python script that defines a function to filter odd numbers from a list. The function uses a list comprehension to achieve this and includes an assertion to verify its correctness.\n\n```python\ndef filter_odd_numbers(numbers):\n \"\"\"\n Filters out the odd numbers from a given list of integers.\n \n Parameters:\n numbers (list): A list of integers.\n \n Returns:\n list: A list containing only the odd numbers from the input list.\n \"\"\"\n # Use a list comprehension to filter odd numbers\n return [num for num in numbers if num % 2 != 0]\n\n# Test the function with an assertion\nassert filter_odd_numbers([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]) == [1, 3, 5, 7, 9]\n```\n\nThis script defines a function `filter_odd_numbers` that takes a list of integers as input and returns a new list containing only the odd numbers. The assertion checks if the function works correctly by comparing its output to the expected result for a given test case."}
{"task_id": "Mbpp/427", "solution": "```markdown\nHere's a Python script that defines a function to convert a date from `yyyy-mm-dd` format to `dd-mm-yyyy` format:\n\n```python\ndef change_date_format(date_str):\n \"\"\"\n Convert a date string from yyyy-mm-dd format to dd-mm-yyyy format.\n\n Parameters:\n date_str (str): A date in the format 'yyyy-mm-dd'.\n\n Returns:\n str: The date in the format 'dd-mm-yyyy'.\n \"\"\"\n # Split the input date string by '-'\n year, month, day = date_str.split('-')\n \n # Reformat to dd-mm-yyyy\n new_date_format = f\"{day}-{month}-{year}\"\n \n return new_date_format\n\n# Test case\nassert change_date_format(\"2026-01-02\") == '02-01-2026'\n```\n\n### Explanation:\n\n1. **Function Definition**: The function `change_date_format` takes a single argument, `date_str`, which is expected to be in the format `yyyy-mm-dd`.\n\n2. **Splitting the Date**: We use the `split('-')` method on the input string to separate it into three components: year, month, and day.\n\n3. **Reformatting**: The function then constructs a new date string in the desired format `dd-mm-yyyy` using an f-string for clarity and conciseness.\n\n4. **Return Value**: Finally, the reformatted date string is returned.\n\n5. **Assertion Test**: An assertion test checks that the function correctly converts `\"2026-01-02\"` to `'02-01-2026'`.\n\nThis script should work for any valid input in the `yyyy-mm-dd` format.\n```"}
{"task_id": "Mbpp/428", "solution": "Certainly! Below is a self-contained Python script that implements the Shell Sort algorithm to sort an array. The function `shell_sort` takes a list of integers as input and returns a sorted list.\n\n```python\ndef shell_sort(arr):\n n = len(arr)\n \n # Start with a big gap, then reduce the gap\n gap = n // 2\n \n # Do a gapped insertion sort for this gap size.\n while gap > 0:\n # Perform a gapped insertion sort for this gap size.\n for i in range(gap, n):\n # Save arr[i] in temp and make a hole at position i\n temp = arr[i]\n \n # Shift earlier gap-sorted elements up until the correct location for arr[i] is found\n j = i\n while j >= gap and arr[j - gap] > temp:\n arr[j] = arr[j - gap]\n j -= gap\n \n # Put temp (the original arr[i]) in its correct location\n arr[j] = temp\n \n # Reduce the gap for the next element\n gap //= 2\n \n return arr\n\n# Test case\nassert shell_sort([12, 23, 4, 5, 3, 2, 12, 81, 56, 95]) == [2, 3, 4, 5, 12, 12, 23, 56, 81, 95]\n```\n\n### Explanation:\n\n1. **Gap Calculation**: The initial gap is set to half the length of the array (`n // 2`). This gap is reduced by half in each iteration until it becomes zero.\n\n2. **Gapped Insertion Sort**: For each gap size, a gapped insertion sort is performed:\n - Iterate over elements starting from the current gap index.\n - Save the current element in `temp`.\n - Shift elements that are greater than `temp` by the gap distance to the right.\n - Place `temp` in its correct position.\n\n3. **Reduce Gap**: After completing a pass with the current gap, reduce the gap size and repeat until the gap is zero.\n\nThis implementation efficiently sorts the array using the Shell Sort algorithm."}
{"task_id": "Mbpp/429", "solution": "Here's a self-contained Python script that solves the problem of extracting elementwise differences between two tuples and returning them as a new tuple:\n\n```markdown\n```python\ndef and_tuples(tuple1, tuple2):\n \"\"\"\n This function takes two tuples of equal length and returns a new tuple.\n Each element in the returned tuple is the difference in indices where \n elements from the first tuple are greater than or equal to those in the second tuple.\n\n Parameters:\n - tuple1: A tuple of integers.\n - tuple2: A tuple of integers, must be the same length as tuple1.\n\n Returns:\n - A tuple containing the elementwise differences based on the described condition.\n \"\"\"\n \n # Ensure both tuples are of the same length\n if len(tuple1) != len(tuple2):\n raise ValueError(\"Both tuples must have the same length.\")\n \n result = []\n \n for i in range(len(tuple1)):\n count = 0\n for j in range(len(tuple2)):\n if tuple1[i] >= tuple2[j]:\n count += 1\n result.append(count - 1) # Subtract 1 to get the zero-based index difference\n \n return tuple(result)\n\n# Test case\nassert and_tuples((10, 4, 6, 9), (5, 2, 3, 3)) == (0, 0, 2, 1)\n```\n```\n\n### Explanation:\n\n- **Function Definition**: The function `and_tuples` takes two tuples as input.\n- **Length Check**: It first checks if both tuples are of the same length. If not, it raises a `ValueError`.\n- **Result Calculation**:\n - For each element in `tuple1`, it counts how many elements in `tuple2` are less than or equal to it.\n - The count is adjusted by subtracting 1 to convert from a count to an index difference (since indices start at 0).\n- **Return**: It returns the result as a tuple.\n\nThis script includes a test case that verifies the function works as expected."}
{"task_id": "Mbpp/430", "solution": "To solve this problem, we need to understand how to derive the equation of a parabola and subsequently determine its directrix. A standard form for a vertical parabola is given by:\n\n\\[ y = ax^2 + bx + c \\]\n\nThe vertex form of a parabola can be expressed as:\n\n\\[ y = a(x - h)^2 + k \\]\n\nwhere \\((h, k)\\) is the vertex of the parabola. The directrix for a vertical parabola \\(y = a(x-h)^2 + k\\) is given by:\n\n\\[ y = k - \\frac{1}{4a} \\]\n\nGiven three points on the parabola, we can determine the coefficients \\(a\\), \\(b\\), and \\(c\\) of the quadratic equation. Once we have these coefficients, we can find the vertex \\((h, k)\\) using:\n\n\\[ h = -\\frac{b}{2a} \\]\n\\[ k = c - \\frac{b^2}{4a} \\]\n\nFinally, we use the formula for the directrix.\n\nHere's a Python function to compute the directrix given three points on the parabola:\n\n```python\ndef parabola_directrix(x1, y1, x2, y2, x3, y3):\n # Solve for coefficients a, b, c using the system of equations:\n # y1 = ax1^2 + bx1 + c\n # y2 = ax2^2 + bx2 + c\n # y3 = ax3^2 + bx3 + c\n\n # Create matrices to solve the linear system\n A = [\n [x1**2, x1, 1],\n [x2**2, x2, 1],\n [x3**2, x3, 1]\n ]\n \n B = [y1, y2, y3]\n\n # Solve for a, b, c using numpy's linear algebra solver\n import numpy as np\n coefficients = np.linalg.solve(A, B)\n a, b, c = coefficients\n\n # Calculate the vertex (h, k)\n h = -b / (2 * a)\n k = c - (b**2) / (4 * a)\n\n # Calculate the directrix y = k - 1/(4a)\n directrix_y = k - (1 / (4 * a))\n\n return directrix_y\n\n# Test case\nassert parabola_directrix(5, 3, 2, 198) == -198\n```\n\n### Explanation:\n\n1. **Matrix Setup**: We set up a system of linear equations based on the three given points \\((x_1, y_1)\\), \\((x_2, y_2)\\), and \\((x_3, y_3)\\). Each point provides an equation in terms of \\(a\\), \\(b\\), and \\(c\\).\n\n2. **Solving for Coefficients**: We use NumPy's `linalg.solve` to solve the system of equations and find the coefficients \\(a\\), \\(b\\), and \\(c\\).\n\n3. **Vertex Calculation**: Using the formula for the vertex \\((h, k)\\) of a parabola in standard form.\n\n4. **Directrix Calculation**: Finally, we calculate the directrix using the formula \\(y = k - \\frac{1}{4a}\\).\n\nThis function will correctly compute the directrix for any three points on a vertical parabola."}
{"task_id": "Mbpp/432", "solution": "```markdown\nTo solve the problem of finding the median length of a trapezium, we need to understand what is meant by \"median\" in this context. In geometry, the median (or midsegment) of a trapezoid (trapezium in British English) is the line segment that connects the midpoints of the non-parallel sides. The length of this median can be calculated using the formula:\n\n\\[ \\text{Median} = \\frac{\\text{Base}_1 + \\text{Base}_2}{2} \\]\n\nwhere \\(\\text{Base}_1\\) and \\(\\text{Base}_2\\) are the lengths of the two parallel sides (bases) of the trapezium.\n\nHere's a Python function that implements this calculation:\n\n```python\ndef median_trapezium(base1, base2):\n \"\"\"\n Calculate the median length of a trapezium given its two bases.\n \n Parameters:\n - base1: Length of one of the parallel sides (bases) of the trapezium.\n - base2: Length of the other parallel side (base) of the trapezium.\n \n Returns:\n - The length of the median of the trapezium.\n \"\"\"\n return (base1 + base2) / 2\n\n# Test case\nassert median_trapezium(15, 25) == 20\n```\n\n### Explanation:\n\n- **Function Definition**: `median_trapezium(base1, base2)` takes two arguments representing the lengths of the parallel sides of the trapezium.\n \n- **Calculation**: The function calculates the median using the formula \\((\\text{base1} + \\text{base2}) / 2\\).\n\n- **Assertion**: The test case `assert median_trapezium(15, 25) == 20` checks if the function correctly computes the median for bases of lengths 15 and 25. According to the formula, the median should be \\( (15 + 25) / 2 = 40 / 2 = 20 \\).\n\nThis solution is efficient and directly applies the geometric property of trapeziums to find the median length."}
{"task_id": "Mbpp/433", "solution": "Certainly! Below is a self-contained Python script that defines a function `check_greater` to determine if an entered number is greater than all elements in a given array. The function returns `True` if the number is greater than every element, and `False` otherwise.\n\n```python\ndef check_greater(arr, num):\n \"\"\"\n Check if the given number is greater than all elements in the array.\n \n Parameters:\n arr (list): A list of numbers.\n num (int or float): The number to compare against each element in the list.\n \n Returns:\n bool: True if num is greater than every element in arr, False otherwise.\n \"\"\"\n for element in arr:\n if num <= element:\n return False\n return True\n\n# Test case\nassert check_greater([1, 2, 3, 4, 5], 4) == False\n```\n\n### Explanation:\n\n- The function `check_greater` takes two parameters: a list `arr` and a number `num`.\n- It iterates over each element in the array.\n- If it finds any element that is greater than or equal to `num`, it returns `False`.\n- If no such element is found (i.e., `num` is greater than all elements), it returns `True`.\n\nThe provided test case checks if the function correctly identifies that 4 is not greater than all elements in the list `[1, 2, 3, 4, 5]`."}
{"task_id": "Mbpp/435", "solution": "Certainly! Below is a self-contained Python script that defines a function `last_digit` which returns the last digit of a given number. The script also includes an assertion to verify its correctness.\n\n```python\ndef last_digit(number):\n \"\"\"\n This function takes an integer and returns its last digit.\n \n Parameters:\n number (int): The input number from which the last digit is extracted.\n \n Returns:\n int: The last digit of the given number.\n \"\"\"\n # Convert the number to a string, get the last character, and convert it back to an integer\n return abs(number) % 10\n\n# Test case to verify the function works as expected\nassert last_digit(123) == 3\n\nprint(\"The function passed the test case.\")\n```\n\n### Explanation:\n- The `last_digit` function takes a single argument `number`.\n- It uses the modulus operator `%` with `10` to extract the last digit of the number. This works because any integer modulo `10` gives its last digit.\n- The `abs()` function ensures that the operation works correctly even if the input is negative, as we are interested in the absolute value's last digit.\n- An assertion checks that calling `last_digit(123)` returns `3`, confirming the function behaves as expected."}
{"task_id": "Mbpp/436", "solution": "Certainly! Below is a self-contained Python script that defines a function `neg_nos` which returns all the negative numbers from a given list. The function uses a list comprehension to filter out the negative numbers.\n\n```python\ndef neg_nos(numbers):\n \"\"\"\n This function takes a list of numbers and returns a new list containing only the negative numbers.\n \n Parameters:\n numbers (list): A list of integers or floats.\n \n Returns:\n list: A list containing only the negative numbers from the input list.\n \"\"\"\n return [num for num in numbers if num < 0]\n\n# Test case\nassert neg_nos([-1, 4, 5, -6]) == [-1, -6]\n```\n\nThis script includes a test case to verify that the function works as expected. The `neg_nos` function uses a list comprehension to iterate over each number in the input list and checks if it is less than zero. If so, it includes that number in the resulting list."}
{"task_id": "Mbpp/437", "solution": "Certainly! Below is a self-contained Python script that defines and tests a function `remove_odd` which removes characters at odd indices from a given string.\n\n```markdown\n```python\ndef remove_odd(s):\n \"\"\"\n This function takes a string 's' as input and returns a new string \n containing only the characters at even indices of the original string.\n \n Parameters:\n s (str): The input string from which to remove odd-indexed characters.\n \n Returns:\n str: A new string with characters at even indices.\n \"\"\"\n # Using list comprehension to select characters at even indices\n return ''.join([s[i] for i in range(len(s)) if i % 2 == 0])\n\n# Test the function with an assertion\nassert remove_odd(\"python\") == \"yhn\"\n\n# Additional test cases\nprint(remove_odd(\"hello\")) # Expected output: \"hlo\"\nprint(remove_odd(\"\")) # Expected output: \"\"\nprint(remove_odd(\"a\")) # Expected output: \"a\"\nprint(remove_odd(\"ab\")) # Expected output: \"a\"\n```\n```\n\n### Explanation:\n- The function `remove_odd` uses a list comprehension to iterate over the indices of the string.\n- It checks if an index is even (`i % 2 == 0`) and includes only those characters in the result.\n- The `''.join()` method is used to concatenate the selected characters into a new string.\n- An assertion is provided to verify that the function works as expected for the input `\"python\"`.\n- Additional test cases are included to demonstrate the function's behavior with different inputs."}
{"task_id": "Mbpp/439", "solution": "Certainly! Below is a self-contained Python script that defines a function `multiple_to_single` which takes a list of integers and joins them into a single integer. The function then returns this combined integer.\n\n```python\ndef multiple_to_single(int_list):\n \"\"\"\n Joins a list of integers into a single integer.\n \n Parameters:\n int_list (list): A list of integers to be joined.\n \n Returns:\n int: A single integer formed by concatenating the input integers.\n \"\"\"\n # Convert each integer in the list to a string\n str_ints = [str(num) for num in int_list]\n \n # Join all strings together into one long string\n combined_str = ''.join(str_ints)\n \n # Convert the combined string back to an integer\n result = int(combined_str)\n \n return result\n\n# Test case\nassert multiple_to_single([11, 33, 50]) == 113350\n```\n\n### Explanation:\n1. **Convert Integers to Strings**: Each integer in the list is converted to a string using a list comprehension.\n2. **Join Strings**: The `join` method concatenates all strings into one long string.\n3. **Convert Back to Integer**: Finally, the concatenated string is converted back to an integer.\n\nThis function will correctly join any list of integers into a single integer as specified in your problem statement."}
{"task_id": "Mbpp/440", "solution": "```markdown\nHere's a Python script that defines a function `find_adverb_position` to solve the problem of finding the first adverb and its positions in a given sentence:\n\n```python\nimport re\n\ndef find_adverb_position(sentence):\n # Define a regular expression pattern for adverbs.\n # Adverbs often end with 'ly', but this is not always true. \n # This regex will capture words ending with 'ly' as potential adverbs.\n adverb_pattern = r'\\b\\w+ly\\b'\n \n # Use the re.finditer method to find all matches of the pattern in the sentence\n for match in re.finditer(adverb_pattern, sentence):\n start_pos = match.start()\n end_pos = match.end()\n adverb = match.group()\n \n # Return the first found adverb and its positions (start and end)\n return (start_pos, end_pos, adverb)\n\n# Test case\nassert find_adverb_position(\"clearly!! we can see the sky\") == (0, 7, 'clearly')\n```\n\n### Explanation:\n\n1. **Regular Expression**: The function uses a regular expression pattern `\\b\\w+ly\\b` to identify words that end with \"ly\". This is a common suffix for adverbs in English.\n\n2. **Finding Matches**: `re.finditer()` is used to iterate over all matches of the pattern in the sentence. It returns an iterator yielding match objects over all non-overlapping matches.\n\n3. **Extracting Information**: For each match, we extract:\n - The start position (`match.start()`)\n - The end position (`match.end()`)\n - The matched adverb itself (`match.group()`)\n\n4. **Returning the First Match**: As soon as an adverb is found, its positions and text are returned.\n\n5. **Test Case**: The function is tested with a sample sentence to ensure it correctly identifies \"clearly\" at position 0-7.\n```\n\nThis script should work for sentences where adverbs end in 'ly'. Note that this approach might not catch all adverbs or could falsely identify non-adverb words ending in 'ly', but it serves as a basic solution based on common patterns."}
{"task_id": "Mbpp/441", "solution": "Certainly! Below is a self-contained Python script that defines a function to calculate the surface area of a cube given its side length. The function `surface_area_cube` takes an integer input representing the side length of the cube and returns the total surface area.\n\n```python\ndef surface_area_cube(side_length):\n \"\"\"\n Calculate the surface area of a cube with a given side length.\n \n Parameters:\n side_length (int): The length of one side of the cube.\n \n Returns:\n int: The total surface area of the cube.\n \"\"\"\n # A cube has 6 faces, and each face is a square with an area equal to side_length squared\n return 6 * (side_length ** 2)\n\n# Test case\nassert surface_area_cube(5) == 150\n\nprint(\"The function works correctly for the test case.\")\n```\n\n### Explanation:\n- A cube has six faces, and each face is a square.\n- The area of one face is calculated as `side_length * side_length` or `side_length ** 2`.\n- Therefore, the total surface area of the cube is `6 * (side_length ** 2)`.\n- The function includes an assertion to verify that it works correctly for a side length of 5."}
{"task_id": "Mbpp/445", "solution": "Certainly! Below is a self-contained Python script that defines the function `index_multiplication` to perform index-wise multiplication of elements in two tuples. The function multiplies corresponding elements from each tuple and returns a new tuple with the results.\n\n```python\ndef index_multiplication(tuple1, tuple2):\n \"\"\"\n Perform index-wise multiplication of elements in two tuples.\n \n Args:\n - tuple1: A tuple containing tuples as its elements.\n - tuple2: Another tuple containing tuples as its elements.\n \n Returns:\n - A new tuple with the results of element-wise multiplication.\n \"\"\"\n # Ensure both input tuples have the same length\n if len(tuple1) != len(tuple2):\n raise ValueError(\"Both tuples must have the same number of elements.\")\n \n result = []\n for t1, t2 in zip(tuple1, tuple2):\n # Ensure each inner tuple has the same length\n if len(t1) != len(t2):\n raise ValueError(\"Inner tuples must have the same number of elements.\")\n \n multiplied_tuple = tuple(a * b for a, b in zip(t1, t2))\n result.append(multiplied_tuple)\n \n return tuple(result)\n\n# Test case\nassert index_multiplication(((1, 3), (4, 5), (2, 9), (1, 10)), ((6, 7), (3, 9), (1, 1), (7, 3))) == ((6, 21), (12, 45), (2, 9), (7, 30))\n```\n\n### Explanation:\n\n- **Function Definition**: The function `index_multiplication` takes two tuples as input. Each tuple contains smaller tuples.\n \n- **Length Check**: It first checks if both input tuples have the same number of elements. If not, it raises a `ValueError`.\n\n- **Element-wise Multiplication**:\n - It iterates over pairs of inner tuples from both input tuples using `zip`.\n - For each pair of inner tuples, it checks if they have the same length.\n - It multiplies corresponding elements from these inner tuples and stores the results in a new tuple.\n\n- **Result Construction**: The multiplied tuples are collected into a list, which is then converted to a tuple before returning.\n\n- **Assertion**: Finally, an assertion is used to verify that the function works as expected with the provided test case."}
{"task_id": "Mbpp/446", "solution": "Certainly! Below is a self-contained Python script that defines a function to count the occurrences of all elements from a list in a tuple. The function will return the total number of times any element from the list appears in the tuple.\n\n```python\ndef count_occurrence(tpl, lst):\n \"\"\"\n Count the occurrence of all elements of `lst` in `tpl`.\n\n Parameters:\n tpl (tuple): A tuple containing various elements.\n lst (list): A list of elements to be counted within the tuple.\n\n Returns:\n int: The total number of occurrences of any element from `lst` in `tpl`.\n \"\"\"\n # Initialize a counter\n count = 0\n \n # Iterate over each element in the tuple\n for item in tpl:\n # If the current item is in the list, increment the counter\n if item in lst:\n count += 1\n \n return count\n\n# Test case to verify the function works as expected\nassert count_occurrence(('a', 'a', 'c', 'b', 'd'), ['a', 'b']) == 3\n```\n\n### Explanation:\n\n- **Function Definition**: The `count_occurrence` function takes two parameters: a tuple (`tpl`) and a list (`lst`).\n \n- **Counter Initialization**: A counter variable `count` is initialized to zero. This will keep track of the total occurrences.\n\n- **Iteration Over Tuple**: We iterate over each element in the tuple using a for loop.\n\n- **Condition Check**: For each element, we check if it exists in the list (`lst`). If it does, we increment the counter by one.\n\n- **Return Statement**: After iterating through all elements of the tuple, the function returns the total count.\n\n- **Assertion Test**: The provided test case checks that the function correctly counts occurrences of 'a' and 'b' in the given tuple."}
{"task_id": "Mbpp/447", "solution": "Certainly! Below is a self-contained Python script that defines a function to find the cubes of individual elements in a list. The function `cube_nums` takes a list of numbers as input and returns a new list containing their cubes.\n\n```python\ndef cube_nums(numbers):\n \"\"\"\n This function takes a list of numbers and returns a list of their cubes.\n \n Parameters:\n numbers (list): A list of integers or floats.\n \n Returns:\n list: A list containing the cubes of the input numbers.\n \"\"\"\n # Use a list comprehension to compute the cube of each number\n return [num ** 3 for num in numbers]\n\n# Test case to verify the function works as expected\nassert cube_nums([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]) == [1, 8, 27, 64, 125, 216, 343, 512, 729, 1000]\n\n# Additional test cases\nprint(cube_nums([0])) # Output: [0]\nprint(cube_nums([-1, -2, -3])) # Output: [-1, -8, -27]\nprint(cube_nums([])) # Output: []\n```\n\n### Explanation:\n- The function `cube_nums` uses a list comprehension to iterate over each number in the input list and computes its cube using the exponentiation operator (`** 3`).\n- The function returns a new list containing these cubes.\n- An assertion is used to ensure that the function produces the expected output for the given test case.\n- Additional print statements are included to demonstrate the function's behavior with other inputs."}
{"task_id": "Mbpp/448", "solution": "Certainly! Below is a self-contained Python script that calculates the sum of Perrin numbers up to a given index. The Perrin sequence is defined such that each number is the sum of the two preceding numbers, starting with `P(0) = 3`, `P(1) = 0`, and `P(2) = 2`.\n\n```python\ndef perrin_number(n):\n \"\"\"Calculate the nth Perrin number.\"\"\"\n if n == 0:\n return 3\n elif n == 1:\n return 0\n elif n == 2:\n return 2\n \n # Initialize the first three numbers of the sequence\n a, b, c = 3, 0, 2\n \n # Calculate up to the nth Perrin number\n for _ in range(3, n + 1):\n a, b, c = b, c, a + b\n \n return c\n\ndef cal_sum(n):\n \"\"\"Calculate the sum of Perrin numbers from P(0) to P(n).\"\"\"\n total_sum = 0\n for i in range(n + 1):\n total_sum += perrin_number(i)\n return total_sum\n\n# Test case\nassert cal_sum(9) == 49, \"Test case failed!\"\nprint(\"Test passed!\")\n```\n\n### Explanation:\n\n- **`perrin_number(n)`**: This function calculates the nth Perrin number using an iterative approach. It starts with the base cases `P(0) = 3`, `P(1) = 0`, and `P(2) = 2`. For any `n > 2`, it iteratively computes the next Perrin number by summing the two preceding numbers.\n\n- **`cal_sum(n)`**: This function calculates the sum of all Perrin numbers from `P(0)` to `P(n)`. It uses a loop to compute each Perrin number up to the nth index and accumulates their sum.\n\n- The script includes an assertion to verify that the function works correctly for the given test case (`cal_sum(9) == 49`). If the test passes, it prints \"Test passed!\"."}
{"task_id": "Mbpp/450", "solution": "Certainly! Below is a self-contained Python script that defines the `extract_string` function to solve the problem described:\n\n```markdown\n```python\ndef extract_string(strings, size):\n \"\"\"\n Extract strings from the list that have exactly the specified length.\n\n Parameters:\n - strings (list): A list of string values.\n - size (int): The exact length of strings to be extracted.\n\n Returns:\n - list: A list containing strings with the specified length.\n \"\"\"\n # Use a list comprehension to filter out strings that match the desired length\n return [s for s in strings if len(s) == size]\n\n# Test case as per the problem statement\nassert extract_string(['Python', 'list', 'exercises', 'practice', 'solution'], 8) == ['practice', 'solution']\n\nprint(\"Test passed!\")\n```\n```\n\nThis script defines a function `extract_string` that takes two parameters: a list of strings and an integer representing the desired length. It uses a list comprehension to filter out and return only those strings from the input list that have exactly the specified length. The provided test case checks if the function correctly extracts strings with a length of 8 from the given list, which should be `['practice', 'solution']`."}
{"task_id": "Mbpp/451", "solution": "Certainly! Below is a self-contained Python script that defines and tests a function to remove all whitespaces from a given string.\n\n```python\ndef remove_whitespaces(s):\n \"\"\"\n This function removes all whitespace characters from the input string `s`.\n \n Parameters:\n s (str): The input string from which whitespaces are to be removed.\n \n Returns:\n str: A new string with all whitespace characters removed.\n \"\"\"\n # Use a generator expression to filter out any character that is not a space\n return ''.join(char for char in s if not char.isspace())\n\n# Test the function with an assertion as specified\nassert remove_whitespaces(' Google Flutter ') == 'GoogleFlutter'\n\n# Additional test cases to ensure robustness\nassert remove_whitespaces(' Hello World! ') == 'HelloWorld!'\nassert remove_whitespaces('\\tTabbed\\nNewline') == 'TabbedNewline'\nassert remove_whitespaces('NoSpacesHere') == 'NoSpacesHere'\nassert remove_whitespaces('') == ''\n```\n\nThis script defines the `remove_whitespaces` function, which iterates over each character in the input string and constructs a new string excluding any whitespace characters. The `isspace()` method is used to check if a character is a whitespace. The function is then tested with an assertion as specified in your problem statement, along with additional test cases to ensure its correctness across different scenarios."}
{"task_id": "Mbpp/453", "solution": "Certainly! Below is a self-contained Python script that defines a function `sum_of_factors` to calculate the sum of even factors of a given number. The function checks each factor of the number and adds it to the sum if it's an even number.\n\n```python\ndef sum_of_factors(n):\n \"\"\"\n Calculate the sum of all even factors of a given number n.\n \n Parameters:\n n (int): The number for which we want to find the sum of even factors.\n \n Returns:\n int: The sum of all even factors of n.\n \"\"\"\n # Initialize sum\n sum_even_factors = 0\n \n # Iterate over possible factors from 1 to n\n for i in range(1, n + 1):\n # Check if i is a factor of n\n if n % i == 0:\n # Check if the factor is even\n if i % 2 == 0:\n sum_even_factors += i\n \n return sum_even_factors\n\n# Test case\nassert sum_of_factors(18) == 26, \"Test case failed!\"\n```\n\n### Explanation:\n\n- The function `sum_of_factors` takes an integer `n` as input.\n- It initializes a variable `sum_even_factors` to store the sum of even factors.\n- It iterates over all numbers from 1 to `n` (inclusive) to check if they are factors of `n`.\n- For each factor, it checks if the factor is even. If so, it adds the factor to `sum_even_factors`.\n- Finally, it returns the total sum of even factors.\n- The test case `assert sum_of_factors(18) == 26` ensures that the function works correctly for the input 18, where the even factors are 2, 6, and 18, and their sum is 26."}
{"task_id": "Mbpp/454", "solution": "Certainly! Below is a self-contained Python script that defines a function to solve the given problem. The function checks if a provided string contains any word with the letter 'z'. It uses regular expressions for pattern matching.\n\n```markdown\n```python\nimport re\n\ndef text_match_wordz(text):\n \"\"\"\n This function checks if there is any word in the input text that contains the letter 'z'.\n \n Args:\n text (str): The string to be checked.\n \n Returns:\n bool: True if at least one word containing 'z' is found, False otherwise.\n \"\"\"\n # Regular expression pattern to find words containing 'z'\n pattern = r'\\b\\w*z\\w*\\b'\n \n # Search for the pattern in the text\n match = re.search(pattern, text)\n \n # Return True if a match is found, else return False\n return bool(match)\n\n# Test case\nassert text_match_wordz(\"pythonz.\") == True\n\n# Additional test cases to verify functionality\nassert text_match_wordz(\"hello world\") == False\nassert text_match_wordz(\"this is a test with zebra in it\") == True\nassert text_match_wordz(\"no_z_here\") == False # hyphenated words are not considered as single words\nassert text_match_wordz(\"Zoo and zookeeper\") == True\n```\n```\n\n### Explanation:\n- **Regular Expression**: The pattern `\\b\\w*z\\w*\\b` is used to match any word containing the letter 'z'.\n - `\\b`: Asserts a word boundary, ensuring we are matching whole words.\n - `\\w*`: Matches zero or more word characters (letters, digits, underscores).\n - `z`: Specifically matches the character 'z'.\n - `\\w*`: Again matches zero or more word characters after 'z'.\n- **`re.search()`**: This function searches for the pattern in the given text. If a match is found, it returns a match object; otherwise, it returns `None`.\n- **`bool(match)`**: Converts the result of `re.search()` to a boolean value (`True` if a match is found, `False` otherwise).\n\nThis script includes additional test cases to ensure robustness and correctness."}
{"task_id": "Mbpp/455", "solution": "Certainly! Below is a self-contained Python script that defines a function `check_monthnumber` to determine if a given month has 31 days. The function uses an assertion to verify its correctness for the month of May (month number 5).\n\n```python\ndef check_monthnumber(month_number):\n \"\"\"\n Check if the given month number contains 31 days.\n\n Parameters:\n month_number (int): The month number (1-12)\n\n Returns:\n bool: True if the month has 31 days, False otherwise.\n \"\"\"\n # List of months that have 31 days\n months_with_31_days = [1, 3, 5, 7, 8, 10, 12]\n \n # Check if the given month number is in the list\n return month_number in months_with_31_days\n\n# Test case to verify the function works correctly for May (month number 5)\nassert check_monthnumber(5) == True\n\n# Additional test cases\nassert check_monthnumber(1) == True # January has 31 days\nassert check_monthnumber(2) == False # February does not have 31 days\nassert check_monthnumber(4) == False # April does not have 31 days\nassert check_monthnumber(6) == False # June does not have 31 days\nassert check_monthnumber(9) == False # September does not have 31 days\nassert check_monthnumber(11) == False# November does not have 31 days\nassert check_monthnumber(12) == True # December has 31 days\n\nprint(\"All test cases passed!\")\n```\n\nThis script defines the function `check_monthnumber` and includes several assertions to ensure it behaves as expected for different month numbers. The list `months_with_31_days` contains all months that have 31 days, and the function checks if the input month number is in this list."}
{"task_id": "Mbpp/456", "solution": "Certainly! Below is a self-contained Python script that defines the function `reverse_string_list` to reverse each string in a given list of strings. The function uses a list comprehension to iterate over each string and apply slicing to reverse it.\n\n```python\ndef reverse_string_list(strings):\n \"\"\"\n Reverses each string in the provided list of strings.\n \n Parameters:\n strings (list): A list of strings to be reversed.\n \n Returns:\n list: A new list containing the reversed versions of the input strings.\n \"\"\"\n return [s[::-1] for s in strings]\n\n# Test case\nassert reverse_string_list(['Red', 'Green', 'Blue', 'White', 'Black']) == ['deR', 'neerG', 'eulB', 'etihW', 'kcalB']\n```\n\nThis script defines the function and includes a test case to verify its correctness. The slicing operation `s[::-1]` is used to reverse each string in the list."}
{"task_id": "Mbpp/457", "solution": "Certainly! Below is a self-contained Python script that defines a function `Find_Min` to solve the problem of finding the sublist with the minimum length from a list of sublists. The function uses an assertion to verify its correctness.\n\n```python\ndef Find_Min(list_of_lists):\n \"\"\"\n This function takes a list of lists and returns the sublist with the minimum length.\n \n Parameters:\n list_of_lists (list): A list containing sublists.\n \n Returns:\n list: The sublist with the minimum length.\n \"\"\"\n # Initialize the minimum length to a large number\n min_length = float('inf')\n # Variable to store the sublist with the minimum length\n min_list = None\n \n # Iterate over each sublist in the list of lists\n for sublist in list_of_lists:\n # Check if the current sublist is shorter than the known minimum\n if len(sublist) < min_length:\n # Update the minimum length and the corresponding sublist\n min_length = len(sublist)\n min_list = sublist\n \n return min_list\n\n# Test case to verify the function works as expected\nassert Find_Min([[1], [1, 2], [1, 2, 3]]) == [1]\n```\n\nThis script defines the `Find_Min` function and includes an assertion to ensure it returns the correct result for a given test case. The function iterates through each sublist, compares their lengths, and keeps track of the shortest one found."}
{"task_id": "Mbpp/458", "solution": "```markdown\n```python\ndef rectangle_area(length, width):\n \"\"\"\n Calculate the area of a rectangle.\n\n Parameters:\n length (float): The length of the rectangle.\n width (float): The width of the rectangle.\n\n Returns:\n float: The area of the rectangle.\n \"\"\"\n return length * width\n\n# Test case\nassert rectangle_area(10, 20) == 200, \"Test case failed!\"\n```\n```"}
{"task_id": "Mbpp/459", "solution": "Certainly! Below is a self-contained Python script that defines the `remove_uppercase` function to solve the problem of removing uppercase substrings from a given string.\n\n```python\ndef remove_uppercase(s):\n \"\"\"\n This function removes all uppercase substrings from the input string.\n \n Parameters:\n s (str): The input string containing both uppercase and lowercase characters.\n \n Returns:\n str: A new string with all uppercase substrings removed.\n \"\"\"\n # Initialize an empty list to store the result\n result = []\n \n # Iterate over each character in the string\n i = 0\n while i < len(s):\n # Check if the current character is lowercase\n if s[i].islower():\n # If it's lowercase, add it to the result\n result.append(s[i])\n # Move to the next character\n i += 1\n else:\n # If it's uppercase, find the end of this uppercase substring\n start = i\n while i < len(s) and s[i].isupper():\n i += 1\n # Skip all characters in this uppercase substring\n \n # Join the list into a string and return\n return ''.join(result)\n\n# Test case to verify the function works as expected\nassert remove_uppercase('cAstyoUrFavoRitETVshoWs') == 'cstyoravoitshos'\n```\n\nThis script defines the `remove_uppercase` function, which iterates through the input string and constructs a new string by including only the lowercase characters. It skips over any sequences of uppercase characters. The test case at the end ensures that the function behaves as expected for the provided example."}
{"task_id": "Mbpp/460", "solution": "Certainly! Below is a self-contained Python script that defines the function `Extract` to solve the problem of extracting the first element from each sublist in a list of lists. The solution includes an assertion to verify its correctness.\n\n```python\ndef Extract(list_of_lists):\n \"\"\"\n This function takes a list of sublists and returns a new list containing \n the first element of each sublist.\n \n Parameters:\n - list_of_lists: A list where each element is a sublist (list).\n \n Returns:\n - A list containing the first element from each sublist in the input list.\n \"\"\"\n # Use a list comprehension to extract the first element of each sublist\n return [sublist[0] for sublist in list_of_lists if sublist]\n\n# Test case to verify the function works as expected\nassert Extract([[1, 2], [3, 4, 5], [6, 7, 8, 9]]) == [1, 3, 6]\n```\n\n### Explanation:\n- **Function Definition**: The `Extract` function is defined to take a single parameter `list_of_lists`, which is expected to be a list of sublists.\n- **List Comprehension**: Inside the function, a list comprehension iterates over each sublist in `list_of_lists`. For each sublist, it accesses the first element using `sublist[0]`.\n- **Conditional Check**: The condition `if sublist` ensures that only non-empty sublists are processed. This prevents errors if any empty sublists are present.\n- **Assertion**: An assertion is used to test the function with a specific input and expected output, ensuring it behaves as intended.\n\nThis script can be run in any Python environment to verify its correctness."}
{"task_id": "Mbpp/462", "solution": "Here's a self-contained Python script that solves the problem of finding all possible combinations of elements in a given list:\n\n```markdown\n```python\nfrom itertools import chain, combinations\n\ndef combinations_list(elements):\n \"\"\"\n Generate all possible combinations of the elements in the input list.\n \n Args:\n elements (list): A list of elements to generate combinations from.\n\n Returns:\n list: A list containing all possible combinations of the input elements,\n including the empty combination.\n \"\"\"\n # Use chain and combinations from itertools to generate all combinations\n return list(chain.from_iterable(combinations(elements, r) for r in range(len(elements) + 1)))\n\n# Test case\nassert combinations_list(['orange', 'red', 'green', 'blue']) == [\n [], \n ['orange'], \n ['red'], \n ['red', 'orange'], \n ['green'], \n ['green', 'orange'], \n ['green', 'red'], \n ['green', 'red', 'orange'], \n ['blue'], \n ['blue', 'orange'], \n ['blue', 'red'], \n ['blue', 'red', 'orange'], \n ['blue', 'green'], \n ['blue', 'green', 'orange'], \n ['blue', 'green', 'red'], \n ['blue', 'green', 'red', 'orange']\n]\n```\n```\n\nThis script uses the `itertools` module to generate all possible combinations of a list's elements, including the empty combination. The `combinations_list` function returns these combinations as a list of lists."}
{"task_id": "Mbpp/463", "solution": "```markdown\nTo solve the problem of finding the maximum product subarray in a given list of integers, we can use dynamic programming. The idea is to maintain two variables as we iterate through the array: one for tracking the maximum product up to the current position and another for tracking the minimum product (since a negative number times a negative number results in a positive number).\n\nHere's how you can implement this:\n\n```python\ndef max_subarray_product(nums):\n if not nums:\n return 0\n\n # Initialize variables to track the maximum and minimum products up to the current position.\n max_prod = min_prod = result = nums[0]\n\n for num in nums[1:]:\n # If the current number is negative, swap max and min because multiplying by a negative flips signs\n if num < 0:\n max_prod, min_prod = min_prod, max_prod\n\n # Calculate the maximum product up to the current position\n max_prod = max(num, max_prod * num)\n \n # Calculate the minimum product up to the current position\n min_prod = min(num, min_prod * num)\n\n # Update the result with the maximum product found so far\n result = max(result, max_prod)\n\n return result\n\n# Test case\nassert max_subarray_product([1, -2, -3, 0, 7, -8, -2]) == 112\n```\n\n### Explanation:\n\n- **Initialization**: Start by initializing `max_prod`, `min_prod`, and `result` with the first element of the array. This is because a single element can be considered as a subarray.\n\n- **Iteration**: For each subsequent number in the array:\n - If the current number is negative, swap `max_prod` and `min_prod`. This is crucial because multiplying by a negative number flips the sign of the product.\n \n - Update `max_prod` to be the maximum of the current number itself or the product of `max_prod` and the current number. This accounts for starting a new subarray at the current position or extending the existing subarray.\n\n - Similarly, update `min_prod` to be the minimum of the current number itself or the product of `min_prod` and the current number. This helps in tracking the smallest product which might become the largest if multiplied by another negative number.\n\n- **Result Update**: After updating `max_prod` for each element, compare it with `result` to keep track of the maximum product found so far.\n\nThis approach efficiently computes the maximum product subarray in linear time, O(n), where n is the length of the input array."}
{"task_id": "Mbpp/465", "solution": "Certainly! Below is a self-contained Python script that defines the function `drop_empty` to remove empty items from a given dictionary. The function checks for values that are considered \"empty\" (such as `None`, empty strings, or zero-length collections) and removes them from the dictionary.\n\n```python\ndef drop_empty(d):\n \"\"\"\n Remove keys with 'empty' values from the dictionary.\n \n An 'empty' value is defined as:\n - None\n - Empty string ''\n - Zero-length collections (e.g., [], {}, set())\n \n Parameters:\n d (dict): The input dictionary to process.\n\n Returns:\n dict: A new dictionary with empty items removed.\n \"\"\"\n # Define what constitutes an 'empty' value\n def is_empty(value):\n if value is None:\n return True\n if isinstance(value, str) and not value:\n return True\n if isinstance(value, (list, tuple, set, dict)) and not value:\n return True\n return False\n\n # Use dictionary comprehension to filter out empty items\n return {k: v for k, v in d.items() if not is_empty(v)}\n\n# Test the function with an assertion\nassert drop_empty({'c1': 'Red', 'c2': 'Green', 'c3': None}) == {'c1': 'Red', 'c2': 'Green'}\n```\n\n### Explanation:\n\n- **`is_empty(value)` Function**: This helper function checks if a value is considered \"empty\". It returns `True` for:\n - `None`\n - Empty strings (`''`)\n - Zero-length collections (like empty lists, tuples, sets, or dictionaries)\n\n- **Dictionary Comprehension**: The main function uses dictionary comprehension to iterate over the items in the input dictionary and includes only those where the value is not \"empty\".\n\nThis script will correctly remove any key-value pairs from the dictionary where the value is considered empty according to the defined criteria."}
{"task_id": "Mbpp/468", "solution": "```markdown\nTo solve this problem, we need to find a function that calculates the maximum product formed by multiplying numbers from an increasing subsequence of a given array. Here's how you can implement such a function in Python:\n\n```python\ndef max_product(nums):\n if not nums:\n return 0\n\n # Initialize dp with the same values as nums, because each number itself is an increasing subsequence.\n dp = nums[:]\n \n for i in range(len(nums)):\n for j in range(i):\n # Check if we can form an increasing subsequence ending at index i\n if nums[i] > nums[j]:\n # Update the product at dp[i]\n dp[i] = max(dp[i], dp[j] * nums[i])\n \n # The answer is the maximum value in dp, which represents the maximum product of any increasing subsequence.\n return max(dp)\n\n# Test case\nassert max_product([3, 100, 4, 5, 150, 6]) == 3000\n```\n\n### Explanation:\n\n1. **Initialization**: \n - We start by initializing a list `dp` where each element is initially set to the corresponding value in `nums`. This is because any single number can be considered as an increasing subsequence of length 1.\n\n2. **Nested Loop**:\n - The outer loop iterates over each element `i` in the array.\n - The inner loop checks all previous elements `j` (where `j < i`) to see if they can form an increasing subsequence ending at `i`.\n - If `nums[i] > nums[j]`, it means we can extend the subsequence ending at `j` by including `nums[i]`.\n\n3. **Updating dp**:\n - For each valid pair `(j, i)`, update `dp[i]` to be the maximum of its current value or the product of `dp[j]` and `nums[i]`. This ensures that `dp[i]` holds the maximum product of any increasing subsequence ending at index `i`.\n\n4. **Result**:\n - Finally, the result is the maximum value in the `dp` list, which represents the maximum product of any increasing subsequence in the array.\n\nThis approach efficiently computes the desired result using dynamic programming with a time complexity of \\(O(n^2)\\), where \\(n\\) is the length of the input array."}
{"task_id": "Mbpp/470", "solution": "Certainly! Below is a self-contained Python script that defines a function to find the pairwise addition of neighboring elements in a given tuple. The function `add_pairwise` takes a tuple as input and returns a new tuple containing the sums of each pair of consecutive elements.\n\n```python\ndef add_pairwise(input_tuple):\n \"\"\"\n This function takes a tuple of numbers and returns a new tuple where each element is \n the sum of two consecutive elements from the original tuple.\n \n :param input_tuple: A tuple of integers or floats.\n :return: A tuple containing the pairwise sums of neighboring elements.\n \"\"\"\n # Initialize an empty list to store the results\n result = []\n \n # Iterate over the indices of the tuple, stopping one element before the last\n for i in range(len(input_tuple) - 1):\n # Add the current element and the next element\n pairwise_sum = input_tuple[i] + input_tuple[i + 1]\n # Append the result to the list\n result.append(pairwise_sum)\n \n # Convert the list back into a tuple before returning\n return tuple(result)\n\n# Test case as per the problem statement\nassert add_pairwise((1, 5, 7, 8, 10)) == (6, 12, 15, 18), \"Test case failed!\"\n\nprint(\"All test cases passed!\")\n```\n\n### Explanation:\n- The function `add_pairwise` iterates over the input tuple using a loop that goes from the first element to the second-to-last element.\n- For each index `i`, it calculates the sum of the element at position `i` and the next element (`i + 1`).\n- These sums are collected in a list called `result`.\n- After completing the iteration, the list is converted back into a tuple which is then returned as the output.\n\nThis script includes an assertion to verify that the function works correctly with the provided test case. If the function passes all assertions, it prints \"All test cases passed!\" indicating success."}
{"task_id": "Mbpp/471", "solution": "Certainly! Below is a self-contained Python script that solves the problem of finding the product of an array's elements multiplied together and then taking the result modulo \\( n \\).\n\n```python\ndef find_remainder(arr, n):\n \"\"\"\n Calculate the product of all elements in the array `arr` and return the remainder when divided by `n`.\n \n Parameters:\n arr (list): A list of integers.\n n (int): The modulus value.\n\n Returns:\n int: The remainder of the product of the array's elements modulo `n`.\n \"\"\"\n # Initialize the result as 1 (multiplicative identity)\n result = 1\n \n # Iterate over each element in the array\n for num in arr:\n # Multiply the current number with the result and take modulo n to prevent overflow\n result = (result * num) % n\n \n return result\n\n# Test case\nassert find_remainder([100, 10, 5, 25, 35, 14], 11) == 9\n\nprint(\"The test passed successfully!\")\n```\n\n### Explanation:\n\n1. **Initialization**: We start with `result` set to 1 because multiplying by 1 does not change the product.\n\n2. **Iteration and Modulo Operation**:\n - For each number in the array, we multiply it with the current `result`.\n - Immediately after multiplication, we take modulo \\( n \\) of the result. This step is crucial as it prevents overflow and keeps numbers manageable by reducing them to their remainder when divided by \\( n \\).\n\n3. **Return**: After processing all elements, the final value of `result` is returned.\n\n4. **Test Case**: The function is tested with the provided example to ensure correctness. If the test passes, a success message is printed.\n\nThis approach efficiently computes the desired result while handling large numbers by using modulo operations during each multiplication step."}
{"task_id": "Mbpp/472", "solution": "Certainly! Below is a self-contained Python script that defines a function `check_consecutive` to determine if a given list contains consecutive numbers. The function checks whether the elements in the list form a sequence of consecutive integers.\n\n```python\ndef check_consecutive(lst):\n \"\"\"\n Check if the given list contains consecutive numbers.\n \n Parameters:\n lst (list): A list of integers.\n \n Returns:\n bool: True if the list contains consecutive numbers, False otherwise.\n \"\"\"\n # Sort the list to ensure order\n sorted_lst = sorted(lst)\n \n # Check if each element is exactly 1 more than the previous one\n for i in range(1, len(sorted_lst)):\n if sorted_lst[i] != sorted_lst[i - 1] + 1:\n return False\n \n return True\n\n# Test cases\nassert check_consecutive([1, 2, 3, 4, 5]) == True\nassert check_consecutive([10, 11, 12, 13, 14]) == True\nassert check_consecutive([5, 6, 7, 8, 10]) == False\nassert check_consecutive([]) == True # An empty list can be considered as having consecutive numbers (trivially true)\nassert check_consecutive([1]) == True # A single element is trivially consecutive\n\nprint(\"All test cases passed!\")\n```\n\n### Explanation:\n- **Sorting**: The function first sorts the input list to ensure that the elements are in order.\n- **Consecutive Check**: It then iterates through the sorted list, checking if each number is exactly one more than the previous number.\n- **Edge Cases**: \n - An empty list or a single-element list is considered consecutive by definition.\n \nThis script includes assertions to verify the correctness of the function with various test cases."}
{"task_id": "Mbpp/473", "solution": "Here's a self-contained Python script that solves the problem of finding the tuple intersection of elements in two given lists of tuples:\n\n```python\ndef tuple_intersection(list1, list2):\n \"\"\"\n Find the intersection of tuples from two lists irrespective of their order.\n \n Args:\n - list1: A list of tuples.\n - list2: Another list of tuples.\n \n Returns:\n - A set containing tuples that are present in both lists, with elements sorted within each tuple.\n \"\"\"\n # Convert each tuple to a sorted tuple so that (a, b) and (b, a) are considered the same\n set1 = {tuple(sorted(t)) for t in list1}\n set2 = {tuple(sorted(t)) for t in list2}\n \n # Find intersection of both sets\n return set1.intersection(set2)\n\n# Test case\nassert tuple_intersection([(3, 4), (5, 6), (9, 10), (4, 5)], [(5, 4), (3, 4), (6, 5), (9, 11)]) == {(4, 5), (3, 4), (5, 6)}\n```\n\n### Explanation:\n\n1. **Sorting Tuples**: Each tuple in both lists is converted to a sorted version of itself. This ensures that tuples like `(a, b)` and `(b, a)` are treated as identical.\n\n2. **Set Conversion**: The lists are converted into sets of these sorted tuples. Using sets allows for efficient intersection operations.\n\n3. **Intersection**: The intersection of the two sets is computed to find common elements.\n\n4. **Return Result**: The result is returned as a set containing the intersecting tuples with their elements in sorted order.\n\nThis approach ensures that the function works correctly irrespective of the order of elements within each tuple."}
{"task_id": "Mbpp/474", "solution": "Certainly! Below is a self-contained Python script that defines a function `replace_char` which replaces all occurrences of a specified character with another character in a given string. The function then checks the result using an assertion.\n\n```python\ndef replace_char(s, old_char, new_char):\n \"\"\"\n Replace all occurrences of old_char with new_char in the string s.\n \n Parameters:\n s (str): The original string.\n old_char (str): The character to be replaced.\n new_char (str): The character to replace with.\n \n Returns:\n str: A new string with all instances of old_char replaced by new_char.\n \"\"\"\n # Use the str.replace() method to replace characters\n return s.replace(old_char, new_char)\n\n# Test the function with an assertion\nassert replace_char(\"polygon\", 'y', 'l') == \"pollgon\"\n\nprint(\"The character replacement was successful!\")\n```\n\n### Explanation:\n- **Function Definition**: The `replace_char` function takes three parameters: a string `s`, and two characters `old_char` and `new_char`.\n- **String Replacement**: It uses Python's built-in `str.replace()` method to replace all occurrences of `old_char` with `new_char` in the string `s`.\n- **Assertion**: The script includes an assertion to verify that the function works as expected. If the replacement is correct, it will pass silently; otherwise, it will raise an AssertionError.\n- **Output**: A success message is printed if the assertion passes.\n\nThis script can be run directly and will confirm that the character replacement logic is functioning correctly by passing the provided test case."}
{"task_id": "Mbpp/475", "solution": "Certainly! Below is a self-contained Python script that defines a function to sort a dictionary by its values. The function `sort_counter` takes a dictionary as input and returns a list of tuples, where each tuple contains a key-value pair from the dictionary, sorted in descending order based on the values.\n\n```python\ndef sort_counter(subject_scores):\n \"\"\"\n Sorts a dictionary by its values in descending order.\n \n Parameters:\n subject_scores (dict): A dictionary with subjects as keys and scores as values.\n \n Returns:\n list: A list of tuples, each containing a key-value pair from the dictionary,\n sorted by value in descending order.\n \"\"\"\n # Use the sorted function to sort the dictionary items\n # The key parameter is set to a lambda function that returns the second element (value) of each item\n # reverse=True sorts the list in descending order\n sorted_items = sorted(subject_scores.items(), key=lambda item: item[1], reverse=True)\n \n return sorted_items\n\n# Example usage and assertion\nassert sort_counter({'Math': 81, 'Physics': 83, 'Chemistry': 87}) == [('Chemistry', 87), ('Physics', 83), ('Math', 81)]\n```\n\n### Explanation:\n\n- **Function Definition**: The function `sort_counter` is defined to take a single argument `subject_scores`, which is expected to be a dictionary.\n\n- **Sorting Logic**:\n - We use Python's built-in `sorted()` function, which returns a new sorted list from the items in an iterable.\n - `subject_scores.items()` provides a view of the dictionary's key-value pairs as tuples.\n - The `key` parameter is set to a lambda function that extracts the value (second element) from each tuple for sorting purposes.\n - `reverse=True` ensures that the list is sorted in descending order based on the values.\n\n- **Return Value**: The function returns the sorted list of tuples.\n\n- **Assertion**: An assertion is included to verify that the function works as expected with a sample input."}
{"task_id": "Mbpp/476", "solution": "```markdown\nHere's a self-contained Python script that solves the problem:\n\n```python\ndef big_sum(arr):\n \"\"\"\n This function takes an array of numbers as input and returns the sum \n of the largest and smallest values in the array.\n \n Parameters:\n arr (list): A list of integers or floats.\n\n Returns:\n int/float: The sum of the maximum and minimum values in the list.\n \"\"\"\n if not arr: # Check for an empty list\n raise ValueError(\"The input array must contain at least one element.\")\n \n max_value = max(arr)\n min_value = min(arr)\n \n return max_value + min_value\n\n# Test case to verify the function works as expected\nassert big_sum([1, 2, 3]) == 4, \"Test case failed!\"\n\nprint(\"All test cases passed!\")\n```\n\n### Explanation:\n- The `big_sum` function takes a list of numbers (`arr`) as input.\n- It first checks if the array is empty and raises an error if it is, since we need at least one element to find a maximum or minimum.\n- It uses Python's built-in `max()` and `min()` functions to find the largest and smallest values in the array, respectively.\n- The function returns the sum of these two values.\n- An assertion is used to test that the function works correctly with the example input `[1, 2, 3]`, which should return `4`.\n```\n\nThis script includes error handling for an empty list and a test case to ensure correctness."}
{"task_id": "Mbpp/477", "solution": "```markdown\n```python\ndef is_lower(s: str) -> str:\n \"\"\"\n Convert the input string to lowercase.\n\n Parameters:\n s (str): The string to be converted.\n\n Returns:\n str: The lowercase version of the input string.\n \"\"\"\n return s.lower()\n\n# Test case\nassert is_lower(\"InValid\") == \"invalid\"\n```\n```"}
{"task_id": "Mbpp/478", "solution": "Certainly! Below is a self-contained Python script that defines a function `remove_lowercase` which removes all lowercase letters from the input string. The function uses list comprehension and the `join()` method to construct the resulting string containing only uppercase characters.\n\n```python\ndef remove_lowercase(s):\n \"\"\"\n Remove all lowercase substrings from the given string.\n \n Parameters:\n s (str): The input string from which lowercase characters are to be removed.\n \n Returns:\n str: A new string with all lowercase characters removed.\n \"\"\"\n # Use list comprehension to filter out lowercase letters\n return ''.join(char for char in s if not char.islower())\n\n# Test the function with an assertion\nassert remove_lowercase(\"PYTHon\") == 'PYTH'\n```\n\n### Explanation:\n- **List Comprehension**: The expression `char for char in s if not char.islower()` iterates over each character in the string `s` and includes it in the resulting list only if it is not a lowercase letter.\n- **`join()` Method**: `''.join(...)` concatenates all characters from the filtered list into a single string.\n\nThis function will effectively remove any lowercase letters from the input string, leaving only uppercase letters or other non-letter characters."}
{"task_id": "Mbpp/479", "solution": "Certainly! Below is a self-contained Python script that defines a function `first_digit` which finds and returns the first digit of a given number. The function handles both positive and negative numbers, as well as zero.\n\n```python\ndef first_digit(number):\n \"\"\"\n This function takes an integer or float and returns its first digit.\n \n Parameters:\n number (int/float): The input number whose first digit is to be found.\n \n Returns:\n int: The first digit of the given number.\n \"\"\"\n # Convert the number to a string\n num_str = str(abs(number))\n \n # Iterate over each character in the string representation\n for char in num_str:\n if char.isdigit():\n return int(char)\n \n # If no digits are found, which shouldn't happen with valid input,\n # return None or raise an error. Here we assume valid input.\n return None\n\n# Test cases to verify the function works as expected\nassert first_digit(123) == 1\nassert first_digit(-4567) == 4\nassert first_digit(0) == 0\nassert first_digit(987654321) == 9\nassert first_digit(-0.00123) == 1\n\nprint(\"All test cases passed!\")\n```\n\n### Explanation:\n- The function `first_digit` takes a number as input.\n- It converts the absolute value of the number to a string to handle negative numbers uniformly.\n- It iterates over each character in the string representation of the number.\n- As soon as it encounters a digit, it returns that digit converted back to an integer.\n- The function handles zero and negative numbers correctly by using `abs()` to ensure the sign does not affect finding the first digit.\n- Test cases are provided to verify the correctness of the function."}
{"task_id": "Mbpp/554", "solution": "Certainly! Below is a self-contained Python script that defines a function to solve the problem described. The function `split` takes a list of integers and returns only the odd ones.\n\n```python\ndef split(numbers):\n \"\"\"\n This function takes a list of integers and returns a new list containing only the odd numbers.\n \n Parameters:\n numbers (list): A list of integers.\n \n Returns:\n list: A list containing only the odd integers from the input list.\n \"\"\"\n # Use a list comprehension to filter out even numbers\n return [num for num in numbers if num % 2 != 0]\n\n# Test case as per the problem statement\nassert split([1, 2, 3, 4, 5, 6]) == [1, 3, 5]\n```\n\nThis script defines the `split` function and includes a test case to ensure it works correctly. The list comprehension iterates over each number in the input list and checks if it is odd by using the modulus operator (`%`). If the remainder when divided by 2 is not zero, the number is considered odd and included in the result list."}
{"task_id": "Mbpp/555", "solution": "Certainly! Below is a self-contained Python script that defines a function `difference` to solve the problem described. The function calculates the difference between the sum of cubes of the first \\( n \\) natural numbers and the sum of the first \\( n \\) natural numbers.\n\n```python\ndef difference(n):\n \"\"\"\n Calculate the difference between the sum of cubes of the first n natural numbers \n and the sum of the first n natural numbers.\n \n Parameters:\n n (int): The number of first natural numbers to consider.\n \n Returns:\n int: The calculated difference.\n \"\"\"\n # Sum of the first n natural numbers\n sum_of_numbers = n * (n + 1) // 2\n \n # Sum of cubes of the first n natural numbers\n sum_of_cubes = (n * (n + 1) // 2) ** 2\n \n # Calculate the difference\n result = sum_of_cubes - sum_of_numbers\n \n return result\n\n# Test case to verify the function works as expected\nassert difference(3) == 30, \"Test case failed!\"\n\nprint(\"The test case passed!\")\n```\n\n### Explanation:\n\n1. **Sum of the First \\( n \\) Natural Numbers**:\n The formula for the sum of the first \\( n \\) natural numbers is given by:\n \\[\n S = \\frac{n(n + 1)}{2}\n \\]\n\n2. **Sum of Cubes of the First \\( n \\) Natural Numbers**:\n The formula for the sum of cubes of the first \\( n \\) natural numbers is:\n \\[\n S_{\\text{cubes}} = \\left(\\frac{n(n + 1)}{2}\\right)^2\n \\]\n\n3. **Difference Calculation**:\n The difference between these two sums is calculated as:\n \\[\n \\text{difference} = S_{\\text{cubes}} - S\n \\]\n\nThe function `difference` implements these formulas and returns the computed result. The test case checks if the function correctly computes the difference for \\( n = 3 \\), which should be 30, as per the problem statement."}
{"task_id": "Mbpp/556", "solution": "Certainly! Below is a self-contained Python script that solves the problem of counting the number of pairs whose XOR value is odd. The function `find_odd_pairs` takes a list of integers and its length as input and returns the count of such pairs.\n\n```python\ndef find_odd_pairs(arr, n):\n # Count of numbers with even and odd values\n even_count = 0\n odd_count = 0\n \n # Traverse through the array to count evens and odds\n for num in arr:\n if num % 2 == 0:\n even_count += 1\n else:\n odd_count += 1\n \n # The number of pairs with an odd XOR is the product of the counts of even and odd numbers\n return even_count * odd_count\n\n# Test case\nassert find_odd_pairs([5, 4, 7, 2, 1], 5) == 6\n```\n\n### Explanation:\n\n- **Counting Evens and Odds:** We first count how many numbers in the array are even and how many are odd.\n \n- **XOR Property:** The XOR of two numbers is odd if one number is even and the other is odd. Therefore, to form a pair with an odd XOR, we need one number from the set of even numbers and one from the set of odd numbers.\n\n- **Calculating Pairs:** The total number of such pairs is simply the product of the count of even numbers and the count of odd numbers (`even_count * odd_count`).\n\nThis approach efficiently calculates the desired result in linear time, O(n), where n is the length of the array."}
{"task_id": "Mbpp/557", "solution": "Certainly! Below is a self-contained Python script that defines a function `toggle_string` which toggles the case of all characters in a given string. The function uses list comprehension to iterate over each character, checking its current case and converting it accordingly.\n\n```python\ndef toggle_string(s):\n \"\"\"\n Toggles the case of each character in the input string.\n \n Parameters:\n s (str): The input string whose characters' cases are to be toggled.\n \n Returns:\n str: A new string with all characters' cases toggled.\n \"\"\"\n # Use a list comprehension to toggle the case of each character\n toggled = [char.lower() if char.isupper() else char.upper() for char in s]\n # Join the list back into a single string and return it\n return ''.join(toggled)\n\n# Test cases\nassert toggle_string(\"Python\") == \"pYTHON\"\nassert toggle_string(\"hello WORLD\") == \"HELLO world\"\nassert toggle_string(\"\") == \"\"\nassert toggle_string(\"1234!@#$\") == \"1234!@#$\" # Non-alphabetic characters remain unchanged\n\nprint(\"All test cases passed!\")\n```\n\n### Explanation:\n- **List Comprehension**: The function uses a list comprehension to iterate over each character in the input string `s`.\n- **Case Check and Toggle**:\n - `char.isupper()`: Checks if the character is uppercase.\n - `char.lower()`: Converts an uppercase character to lowercase.\n - `char.upper()`: Converts a lowercase character to uppercase.\n- **Joining**: The list of toggled characters is joined back into a single string using `''.join(toggled)`.\n- **Test Cases**: Several assertions are included to verify the function's correctness, including edge cases like an empty string and strings with non-alphabetic characters."}
{"task_id": "Mbpp/558", "solution": "Certainly! Below is a self-contained Python script that defines and tests the `digit_distance_nums` function. This function calculates the sum of the per-digit differences between two integers.\n\n```python\ndef digit_distance_nums(a, b):\n \"\"\"\n Calculate the sum of the per-digit difference between two integers.\n \n Args:\n a (int): The first integer.\n b (int): The second integer.\n \n Returns:\n int: The sum of the absolute differences of corresponding digits.\n \"\"\"\n # Convert numbers to strings for easy digit manipulation\n str_a = str(a)\n str_b = str(b)\n \n # Pad the shorter string with leading zeros\n max_length = max(len(str_a), len(str_b))\n str_a = str_a.zfill(max_length)\n str_b = str_b.zfill(max_length)\n \n # Calculate the sum of per-digit differences\n total_difference = 0\n for digit_a, digit_b in zip(str_a, str_b):\n total_difference += abs(int(digit_a) - int(digit_b))\n \n return total_difference\n\n# Test cases\nassert digit_distance_nums(1, 2) == 1\nassert digit_distance_nums(123, 456) == 9\nassert digit_distance_nums(101, 202) == 3\nassert digit_distance_nums(999, 0) == 27\nassert digit_distance_nums(12345, 54321) == 18\n\nprint(\"All test cases passed!\")\n```\n\n### Explanation:\n\n1. **Function Definition**: The function `digit_distance_nums` takes two integers as input.\n\n2. **String Conversion and Padding**:\n - Convert both integers to strings for easy manipulation of individual digits.\n - Determine the maximum length between the two numbers.\n - Pad the shorter number with leading zeros using `zfill()` so that both numbers have the same number of digits.\n\n3. **Calculate Differences**:\n - Iterate over each pair of corresponding digits from the two padded strings.\n - Compute the absolute difference for each digit pair and accumulate these differences in `total_difference`.\n\n4. **Return Result**: The function returns the accumulated sum of per-digit differences.\n\n5. **Test Cases**: Several assertions are included to verify that the function works correctly with different inputs, including edge cases like numbers with leading zeros after padding."}
{"task_id": "Mbpp/559", "solution": "```markdown\nTo solve the problem of finding the sum of the largest contiguous sublist in a given list, we can use Kadane's Algorithm. This algorithm efficiently finds the maximum sum of a contiguous subarray with a time complexity of \\(O(n)\\).\n\nHere is a Python function implementing this approach:\n\n```python\ndef max_sub_array_sum(arr):\n # Initialize variables to store the maximum sum found so far and the current sum\n max_so_far = float('-inf')\n current_max = 0\n\n for num in arr:\n # Update the current maximum sum by including the current number\n current_max += num\n \n # If the current maximum is greater than the maximum so far, update it\n if current_max > max_so_far:\n max_so_far = current_max\n \n # If the current maximum drops below zero, reset it to zero\n if current_max < 0:\n current_max = 0\n\n return max_so_far\n\n# Test case\nassert max_sub_array_sum([-2, -3, 4, -1, -2, 1, 5, -3]) == 7\n```\n\n### Explanation:\n\n- **Initialization**: \n - `max_so_far` is initialized to negative infinity to ensure any sum will be larger initially.\n - `current_max` starts at zero and keeps track of the current subarray sum.\n\n- **Iteration**:\n - For each number in the array, add it to `current_max`.\n - If `current_max` exceeds `max_so_far`, update `max_so_far`.\n - If `current_max` becomes negative, reset it to zero because a negative sum would decrease any future subarray sum.\n\n- **Result**:\n - After iterating through the array, `max_so_far` contains the maximum sum of any contiguous sublist.\n\nThis function efficiently finds the desired result using Kadane's Algorithm."}
{"task_id": "Mbpp/560", "solution": "Certainly! Below is a self-contained Python script that defines the function `union_elements` to find the union of elements from two given tuples and returns them in sorted order.\n\n```python\ndef union_elements(tuple1, tuple2):\n \"\"\"\n This function takes two tuples as input and returns their union in sorted order.\n \n Parameters:\n tuple1 (tuple): The first tuple.\n tuple2 (tuple): The second tuple.\n \n Returns:\n tuple: A tuple containing the union of elements from both input tuples, sorted in ascending order.\n \"\"\"\n # Convert both tuples to sets to find their union\n set_union = set(tuple1).union(set(tuple2))\n \n # Convert the resulting set back to a tuple and sort it\n result_tuple = tuple(sorted(set_union))\n \n return result_tuple\n\n# Test case\nassert union_elements((3, 4, 5, 6), (5, 7, 4, 10)) == (3, 4, 5, 6, 7, 10)\n\nprint(\"Test passed!\")\n```\n\n### Explanation:\n- **Conversion to Sets**: We convert the input tuples into sets. This allows us to easily compute their union using the `union()` method.\n- **Union Operation**: The `union()` method combines elements from both sets without duplicates.\n- **Sorting and Conversion**: After obtaining the union, we sort it and convert it back to a tuple for the final result.\n\nThis script includes an assertion to verify that the function works as expected with the provided test case."}
{"task_id": "Mbpp/562", "solution": "Certainly! Below is a self-contained Python script that defines a function `Find_Max_Length` which finds the length of the longest sublist within a list of lists. The function uses an assertion to verify its correctness with the provided example.\n\n```python\ndef Find_Max_Length(list_of_lists):\n \"\"\"\n This function takes a list of lists and returns the length of the longest sublist.\n \n Parameters:\n list_of_lists (list): A list containing sublists of varying lengths.\n \n Returns:\n int: The length of the longest sublist.\n \"\"\"\n # Initialize max_length to 0\n max_length = 0\n \n # Iterate over each sublist in the list_of_lists\n for sublist in list_of_lists:\n # Update max_length if the current sublist is longer than the previous max_length\n if len(sublist) > max_length:\n max_length = len(sublist)\n \n return max_length\n\n# Test the function with an assertion\nassert Find_Max_Length([[1], [1, 4], [5, 6, 7, 8]]) == 4\n```\n\nThis script defines the `Find_Max_Length` function and includes a test case using an assertion to ensure that it works as expected. The function iterates through each sublist, checks its length, and updates the maximum length found so far."}
{"task_id": "Mbpp/563", "solution": "Certainly! Below is a self-contained Python script that defines the `extract_values` function. This function extracts values enclosed in double quotation marks from a given input string and returns them as a list.\n\n```python\nimport re\n\ndef extract_values(input_string):\n \"\"\"\n Extracts values between double quotation marks from the input string.\n \n Args:\n - input_string (str): A string containing values within double quotes.\n \n Returns:\n - List[str]: A list of strings extracted from within the double quotes.\n \"\"\"\n # Use regular expression to find all occurrences of text within double quotes\n pattern = r'\"(.*?)\"'\n matches = re.findall(pattern, input_string)\n \n return matches\n\n# Test case\nassert extract_values('\"Python\", \"PHP\", \"Java\"') == ['Python', 'PHP', 'Java']\n```\n\n### Explanation:\n\n- **Regular Expression**: The function uses the regular expression `r'\"(.*?)\"'` to match text within double quotes.\n - `\"`: Matches a literal double quote.\n - `(.*?)`: A non-greedy match for any character (except newline) between two double quotes. The parentheses capture this part of the match as a group.\n - `\"`: Matches another literal double quote.\n\n- **`re.findall()`**: This function is used to find all non-overlapping matches of the pattern in the string, returning them as a list of strings captured by the first set of parentheses in the pattern.\n\nThis script will correctly extract and return values enclosed in double quotes from the input string."}
{"task_id": "Mbpp/564", "solution": "Certainly! Below is a self-contained Python script that solves the problem described. The function `count_pairs` takes a list of integers and counts the number of possible unordered pairs where both elements are unequal.\n\n```python\ndef count_pairs(lst):\n \"\"\"\n This function takes a list of integers and returns the number of unordered pairs (i, j) such that i != j.\n \n :param lst: List[int] - A list of integers\n :return: int - The number of unordered pairs with unequal elements\n \"\"\"\n # Dictionary to count occurrences of each element in the list\n frequency = {}\n \n for num in lst:\n if num in frequency:\n frequency[num] += 1\n else:\n frequency[num] = 1\n \n total_pairs = 0\n unique_elements = len(frequency)\n \n # Calculate total possible pairs (unordered) from the list\n n = len(lst)\n total_possible_pairs = n * (n - 1) // 2\n \n # Subtract pairs where both elements are equal\n for count in frequency.values():\n if count > 1:\n total_possible_pairs -= count * (count - 1) // 2\n \n return total_possible_pairs\n\n# Test the function with the provided example\nassert count_pairs([1, 2, 1]) == 2\n\nprint(\"Test passed!\")\n```\n\n### Explanation:\n\n1. **Frequency Count**: We first create a dictionary to count how many times each element appears in the list.\n\n2. **Total Possible Pairs**: Calculate the total number of unordered pairs that can be formed from the list using the formula \\( \\frac{n(n-1)}{2} \\), where \\( n \\) is the length of the list.\n\n3. **Subtract Equal Element Pairs**: For each unique element, if it appears more than once, calculate how many pairs consist of two identical elements and subtract these from the total possible pairs.\n\n4. **Return Result**: The result after subtraction gives us the number of unordered pairs where both elements are unequal.\n\nThis approach efficiently counts the desired pairs by leveraging combinatorial counting and frequency analysis."}
{"task_id": "Mbpp/565", "solution": "Certainly! Below is a self-contained Python script that defines a function `split` which takes a string as input and returns a list of its individual characters. The script also includes an assertion to verify the correctness of the function.\n\n```python\ndef split(s):\n \"\"\"\n Splits a given string into a list of its individual characters.\n \n Parameters:\n s (str): The string to be split.\n \n Returns:\n list: A list containing each character of the input string as an element.\n \"\"\"\n return [char for char in s]\n\n# Test case\nassert split('python') == ['p', 'y', 't', 'h', 'o', 'n']\n```\n\nThis function uses a list comprehension to iterate over each character in the input string `s` and collects them into a list. The assertion checks that calling `split('python')` returns the expected list of characters."}
{"task_id": "Mbpp/566", "solution": "Certainly! Below is a self-contained Python script that defines a function `sum_digits` which calculates the sum of the digits of a given non-negative integer. The script also includes an assertion to verify its correctness.\n\n```markdown\n```python\ndef sum_digits(n):\n \"\"\"\n Calculate the sum of the digits of a non-negative integer.\n \n Parameters:\n n (int): A non-negative integer whose digits are to be summed.\n \n Returns:\n int: The sum of the digits of the input number.\n \"\"\"\n # Initialize the sum to 0\n total_sum = 0\n \n # Loop until all digits are processed\n while n > 0:\n # Extract the last digit and add it to the total sum\n total_sum += n % 10\n \n # Remove the last digit from the number\n n //= 10\n \n return total_sum\n\n# Test case to verify the function works as expected\nassert sum_digits(345) == 12, \"Test case failed!\"\n\nprint(\"The test case passed successfully!\")\n```\n```\n\n### Explanation:\n- The `sum_digits` function takes a non-negative integer `n`.\n- It initializes `total_sum` to zero.\n- Using a while loop, it repeatedly extracts the last digit of `n` using `n % 10`, adds this digit to `total_sum`, and then removes the last digit from `n` by performing integer division `n //= 10`.\n- The loop continues until all digits are processed (i.e., when `n` becomes zero).\n- Finally, it returns the computed sum of the digits.\n- An assertion is used to ensure that the function works correctly for the input `345`, which should return `12`."}
{"task_id": "Mbpp/567", "solution": "Certainly! Below is a self-contained Python script that defines the `issort_list` function. This function checks whether a given list is sorted in non-decreasing order.\n\n```python\ndef issort_list(lst):\n \"\"\"\n Check if the specified list is sorted in non-decreasing order.\n \n Parameters:\n lst (list): The list to check for sorting.\n \n Returns:\n bool: True if the list is sorted, False otherwise.\n \"\"\"\n # Iterate through the list and compare each element with the next one\n for i in range(len(lst) - 1):\n if lst[i] > lst[i + 1]:\n return False\n return True\n\n# Test case to verify the function works as expected\nassert issort_list([1, 2, 4, 6, 8, 10, 12, 14, 16, 17]) == True\n```\n\n### Explanation:\n- The `issort_list` function takes a list `lst` as input.\n- It iterates through the list using a for loop, comparing each element with the next one.\n- If it finds any pair of elements where the current element is greater than the next, it returns `False`, indicating that the list is not sorted.\n- If no such pair is found throughout the iteration, it returns `True`, meaning the list is sorted in non-decreasing order.\n\nThis function handles lists with duplicate values correctly and assumes that an empty list or a single-element list is considered sorted."}
{"task_id": "Mbpp/568", "solution": "Certainly! Below is a self-contained Python script that defines a function `empty_list` which creates a list containing `N` empty dictionaries. The function also includes an assertion to verify its correctness.\n\n```python\ndef empty_list(N):\n \"\"\"\n Create a list of N empty dictionaries.\n \n Parameters:\n N (int): The number of empty dictionaries to create in the list.\n \n Returns:\n list: A list containing N empty dictionaries.\n \"\"\"\n # Use a list comprehension to generate N empty dictionaries\n return [{} for _ in range(N)]\n\n# Test the function with an assertion\nassert empty_list(5) == [{}, {}, {}, {}, {}], \"The function did not produce the expected output.\"\n\n# Example usage:\nprint(empty_list(3)) # Output: [{}, {}, {}]\n```\n\n### Explanation:\n\n- **Function Definition**: The `empty_list` function takes a single parameter `N`, which specifies how many empty dictionaries should be in the list.\n \n- **List Comprehension**: Inside the function, we use a list comprehension `[{} for _ in range(N)]`. This iterates over a range of numbers from 0 to N-1 and creates an empty dictionary `{}` for each iteration. The result is a list containing `N` empty dictionaries.\n\n- **Assertion**: After defining the function, there's an assertion statement that checks if calling `empty_list(5)` returns a list with five empty dictionaries. If the condition fails, it raises an AssertionError with a message indicating the failure.\n\n- **Example Usage**: Finally, we demonstrate how to use the function by printing the result of `empty_list(3)`, which should output `[{}, {}, {}]`."}
{"task_id": "Mbpp/569", "solution": "Certainly! Below is a self-contained Python script that defines the function `sort_sublists` to sort each sublist of strings in a given list of lists. The function uses Python's built-in sorting capabilities to achieve this.\n\n```python\ndef sort_sublists(list_of_lists):\n \"\"\"\n Sorts each sublist within a list of lists.\n \n Parameters:\n list_of_lists (list): A list containing sublists of strings.\n \n Returns:\n list: A new list with each sublist sorted alphabetically.\n \"\"\"\n # Use a list comprehension to sort each sublist\n return [sorted(sublist) for sublist in list_of_lists]\n\n# Test the function with an assertion\nassert sort_sublists([['green', 'orange'], ['black', 'white'], ['white', 'black', 'orange']]) == [['green', 'orange'], ['black', 'white'], ['black', 'orange', 'white']]\n```\n\nThis script defines the `sort_sublists` function, which takes a list of lists as input. It uses a list comprehension to iterate over each sublist and applies Python's built-in `sorted()` function to sort them alphabetically. The result is a new list where each sublist is sorted.\n\nThe assertion at the end tests the function with the provided example to ensure it works correctly."}
{"task_id": "Mbpp/572", "solution": "Certainly! Below is a self-contained Python script that defines the `two_unique_nums` function. This function removes duplicate numbers from a given list and returns only those numbers that appear exactly once.\n\n```python\ndef two_unique_nums(lst):\n \"\"\"\n Remove duplicates from the list and return numbers that appear exactly once.\n \n Parameters:\n lst (list): A list of integers.\n \n Returns:\n list: A list containing numbers that appear exactly once in the input list.\n \"\"\"\n # Create a dictionary to count occurrences of each number\n num_count = {}\n \n for num in lst:\n if num in num_count:\n num_count[num] += 1\n else:\n num_count[num] = 1\n \n # Collect numbers that appear exactly once\n unique_nums = [num for num, count in num_count.items() if count == 1]\n \n return unique_nums\n\n# Test the function with an assertion\nassert two_unique_nums([1, 2, 3, 2, 3, 4, 5]) == [1, 4, 5]\n\n# Example usage\nprint(two_unique_nums([1, 2, 3, 2, 3, 4, 5])) # Output: [1, 4, 5]\n```\n\n### Explanation:\n- We use a dictionary `num_count` to keep track of how many times each number appears in the list.\n- We iterate over the list and update the count for each number.\n- After counting, we create a new list `unique_nums` that includes only those numbers whose count is exactly one.\n- Finally, we return this list of unique numbers."}
{"task_id": "Mbpp/573", "solution": "```markdown\nHere's a Python script that defines a function to calculate the product of the unique numbers in a given list:\n\n```python\ndef unique_product(numbers):\n # Use a set to find unique elements in the list\n unique_numbers = set(numbers)\n \n # Initialize the product variable to 1 (multiplicative identity)\n product = 1\n \n # Iterate over each unique number and multiply it with the product\n for num in unique_numbers:\n product *= num\n \n return product\n\n# Test case\nassert unique_product([10, 20, 30, 40, 20, 50, 60, 40]) == 720000000\n```\n\n### Explanation:\n\n1. **Set Usage**: We use a set to automatically filter out duplicate numbers from the list since sets only store unique elements.\n\n2. **Product Calculation**: We initialize `product` to 1 because multiplying by 1 does not change the value of other numbers. Then, we iterate over each number in the set and multiply it with the current product.\n\n3. **Assertion**: The test case checks if the function returns the expected result for a given list of numbers.\n```\n\nThis script will correctly compute the product of unique numbers from the input list and pass the provided assertion test."}
{"task_id": "Mbpp/576", "solution": "Certainly! Below is a self-contained Python script that defines a function `is_sublist` to determine if one list is a sublist of another. The function uses assertions to verify its correctness.\n\n```python\ndef is_sublist(sublist, main_list):\n \"\"\"\n Check whether 'sublist' is a sublist of 'main_list'.\n \n Parameters:\n - sublist: List[int] - the list that might be a sublist.\n - main_list: List[int] - the list in which to check for the sublist.\n\n Returns:\n - bool: True if 'sublist' is a sublist of 'main_list', False otherwise.\n \"\"\"\n # Convert both lists to strings for easy comparison\n str_sublist = ','.join(map(str, sublist))\n str_main_list = ','.join(map(str, main_list))\n\n # Check if the string representation of the sublist is in the main list's string\n return str_sublist in str_main_list\n\n# Test cases with assertions\nassert is_sublist([1, 4, 3, 5], [1, 2]) == False\nassert is_sublist([1, 4], [1, 2, 3, 4, 5]) == True\nassert is_sublist([], [1, 2, 3]) == True # An empty list is a sublist of any list\nassert is_sublist([1, 2, 3], []) == False\nassert is_sublist([1, 2, 3], [1, 2, 3]) == True\n\nprint(\"All assertions passed.\")\n```\n\n### Explanation:\n- The function `is_sublist` takes two lists as input: `sublist` and `main_list`.\n- It converts both lists into comma-separated strings.\n- It checks if the string representation of `sublist` is a substring of the string representation of `main_list`.\n- This approach works well for small to moderately sized lists but may not be efficient for very large lists due to the conversion overhead.\n- The assertions test various scenarios, including edge cases like an empty sublist and checking against an empty list."}
{"task_id": "Mbpp/577", "solution": "Certainly! Below is a self-contained Python script that defines a function `last_Digit_Factorial` to find the last digit of the factorial of a given number. The solution includes an explanation and handles edge cases efficiently.\n\n```markdown\n```python\ndef last_Digit_Factorial(n):\n \"\"\"\n This function returns the last digit of the factorial of a given number n.\n \n Args:\n n (int): A non-negative integer whose factorial's last digit is to be found.\n \n Returns:\n int: The last digit of n!\n \n Explanation:\n - For n >= 5, the factorial will always end in zero because it includes both\n 2 and 5 as factors. Hence, the last digit is 0.\n - For n < 5, we can compute the factorial directly and return its last digit.\n \"\"\"\n if n == 0:\n # The factorial of 0 is defined as 1\n return 1\n \n # If n >= 5, the last digit will always be 0\n if n >= 5:\n return 0\n\n # Calculate factorial for n < 5 directly\n factorial = 1\n for i in range(2, n + 1):\n factorial *= i\n \n # Return the last digit of the factorial\n return factorial % 10\n\n# Test cases\nassert last_Digit_Factorial(4) == 4\nassert last_Digit_Factorial(5) == 0\nassert last_Digit_Factorial(10) == 0\nassert last_Digit_Factorial(0) == 1\nassert last_Digit_Factorial(3) == 6\n\nprint(\"All test cases passed!\")\n```\n```\n\n### Explanation:\n- **Factorials and Last Digits**: The factorial of a number `n` is the product of all positive integers up to `n`. For numbers `n >= 5`, the factorial will include both 2 and 5 as factors, resulting in at least one trailing zero. Therefore, the last digit is always 0 for such cases.\n- **Direct Calculation**: For numbers less than 5, we compute the factorial directly since it's computationally feasible and straightforward.\n- **Edge Case**: The factorial of 0 is defined as 1, so its last digit is also 1.\n\nThis script efficiently handles the problem by leveraging mathematical properties of factorials."}
{"task_id": "Mbpp/578", "solution": "Here's a self-contained Python script that solves the problem of interleaving three lists into a single flat list:\n\n```python\ndef interleave_lists(list1, list2, list3):\n \"\"\"\n Interleaves three lists of the same length into a single flat list.\n \n Args:\n - list1: First list of integers.\n - list2: Second list of integers.\n - list3: Third list of integers.\n \n Returns:\n - A single list with elements interleaved from the input lists.\n \"\"\"\n # Ensure all lists are of the same length\n if not (len(list1) == len(list2) == len(list3)):\n raise ValueError(\"All lists must have the same length\")\n \n # Initialize an empty list to store the result\n interleaved_list = []\n \n # Iterate over the indices of the lists\n for i in range(len(list1)):\n # Append elements from each list in order\n interleaved_list.append(list1[i])\n interleaved_list.append(list2[i])\n interleaved_list.append(list3[i])\n \n return interleaved_list\n\n# Test case to verify the function works as expected\nassert interleave_lists(\n [1, 2, 3, 4, 5, 6, 7],\n [10, 20, 30, 40, 50, 60, 70],\n [100, 200, 300, 400, 500, 600, 700]\n) == [\n 1, 10, 100, 2, 20, 200, 3, 30, 300,\n 4, 40, 400, 5, 50, 500, 6, 60, 600,\n 7, 70, 700\n]\n```\n\nThis script defines a function `interleave_lists` that takes three lists as input and returns a single list with elements interleaved from the input lists. It includes a test case to ensure the function works correctly."}
{"task_id": "Mbpp/579", "solution": "```markdown\nHere's a Python script that defines the function `find_dissimilar` to find dissimilar elements between two tuples:\n\n```python\ndef find_dissimilar(tuple1, tuple2):\n # Convert both tuples to sets for easy comparison\n set1 = set(tuple1)\n set2 = set(tuple2)\n\n # Find elements in set1 that are not in set2 and vice versa\n unique_to_set1 = set1 - set2\n unique_to_set2 = set2 - set1\n\n # Combine the unique elements from both sets into a tuple\n dissimilar_elements = tuple(sorted(unique_to_set1.union(unique_to_set2)))\n\n return dissimilar_elements\n\n# Test case to verify the function works as expected\nassert find_dissimilar((3, 4, 5, 6), (5, 7, 4, 10)) == (3, 6, 7, 10)\n```\n\n### Explanation:\n\n1. **Convert Tuples to Sets**: \n - We convert the input tuples into sets (`set1` and `set2`). This allows us to easily perform set operations like difference and union.\n\n2. **Find Unique Elements**:\n - `unique_to_set1 = set1 - set2`: Finds elements that are in `tuple1` but not in `tuple2`.\n - `unique_to_set2 = set2 - set1`: Finds elements that are in `tuple2` but not in `tuple1`.\n\n3. **Combine Unique Elements**:\n - We use the union operation (`unique_to_set1.union(unique_to_set2)`) to combine all unique elements from both sets.\n\n4. **Sort and Convert Back to Tuple**:\n - The combined set of unique elements is sorted and converted back into a tuple, ensuring consistent order in the output.\n\n5. **Assertion for Testing**:\n - An assertion checks that the function returns the expected result when given the test case `(3, 4, 5, 6)` and `(5, 7, 4, 10)`. The expected dissimilar elements are `(3, 6, 7, 10)`.\n```\n\nThis script provides a clear and efficient way to find dissimilar elements between two tuples."}
{"task_id": "Mbpp/580", "solution": "```markdown\nTo solve this problem, we need to write a function `extract_even` that takes a nested mixed tuple and removes any uneven elements. The function should recursively traverse the tuple structure, checking each element. If an element is a number, it checks if it's even; if it's another tuple, it applies the same logic recursively.\n\nHere's how you can implement this:\n\n```python\ndef extract_even(nested_tuple):\n def helper(tpl):\n result = []\n for item in tpl:\n if isinstance(item, int): # Check if the item is an integer\n if item % 2 == 0: # Check if it's even\n result.append(item)\n elif isinstance(item, tuple): # If the item is a tuple, recurse into it\n nested_result = helper(item)\n if nested_result: # Only add non-empty results to avoid empty tuples\n result.append(tuple(nested_result))\n return result\n\n return tuple(helper(nested_tuple))\n\n# Test case\nassert extract_even((4, 5, (7, 6, (2, 4)), 6, 8)) == (4, (6, (2, 4)), 6, 8)\n```\n\n### Explanation:\n\n1. **Helper Function**: We define a helper function `helper` that processes each element of the tuple.\n \n2. **Iterate Through Tuple**: For each item in the tuple:\n - If it's an integer and even, we add it to the result list.\n - If it's another tuple, we recursively call `helper` on this nested tuple.\n\n3. **Non-Empty Nested Tuples**: After processing a nested tuple, if it results in non-empty elements (i.e., contains at least one even number), we convert it back into a tuple and add it to the result list.\n\n4. **Return Result**: Finally, we return the processed result as a tuple.\n\nThis approach ensures that all uneven numbers are removed from both top-level and nested tuples while preserving the structure of the original tuple.\n```"}
{"task_id": "Mbpp/581", "solution": "Certainly! Below is a self-contained Python script that calculates the surface area of a square pyramid given its base edge length and height. The function `surface_area` computes this using the formula for the surface area of a square pyramid:\n\n\\[ \\text{Surface Area} = b^2 + 2b \\times l \\]\n\nwhere \\( b \\) is the base edge length, and \\( l \\) is the slant height. The slant height can be calculated using the Pythagorean theorem:\n\n\\[ l = \\sqrt{\\left(\\frac{b}{2}\\right)^2 + h^2} \\]\n\nHere's the implementation in a markdown code block:\n\n```markdown\n```python\nimport math\n\ndef surface_area(base_edge, height):\n \"\"\"\n Calculate the surface area of a square pyramid.\n\n Parameters:\n base_edge (float): The length of one edge of the square base.\n height (float): The perpendicular height from the base to the apex.\n\n Returns:\n float: The total surface area of the square pyramid.\n \"\"\"\n # Calculate the slant height using Pythagorean theorem\n slant_height = math.sqrt((base_edge / 2) ** 2 + height ** 2)\n \n # Base area\n base_area = base_edge ** 2\n \n # Lateral surface area (4 triangles)\n lateral_surface_area = 2 * base_edge * slant_height\n \n # Total surface area\n total_surface_area = base_area + lateral_surface_area\n \n return total_surface_area\n\n# Test the function with the given assertion\nassert math.isclose(surface_area(3, 4), 33, rel_tol=1e-9)\n\nprint(\"The test passed successfully!\")\n```\n```\n\nThis script defines a function `surface_area` that calculates and returns the surface area of a square pyramid. It uses the `math.sqrt` function to compute the slant height and then applies the formula for the total surface area. The assertion checks if the calculated surface area is approximately 33 when the base edge is 3 and the height is 4, using `math.isclose` for floating-point comparison."}
{"task_id": "Mbpp/583", "solution": "Certainly! The Catalan numbers are a sequence of natural numbers with many applications in combinatorial mathematics. They can be defined recursively, and the \\(n\\)-th Catalan number is given by:\n\n\\[ C_n = \\frac{1}{n+1} \\binom{2n}{n} = \\frac{(2n)!}{(n+1)!n!} \\]\n\nAlternatively, they satisfy the recurrence relation:\n\n\\[ C_0 = 1 \\]\n\\[ C_{n+1} = \\sum_{i=0}^{n} C_i \\cdot C_{n-i} \\]\n\nHere's a Python function to compute the \\(n\\)-th Catalan number using dynamic programming for efficiency:\n\n```python\ndef catalan_number(n):\n if n == 0:\n return 1\n \n # Create an array to store the first n+1 Catalan numbers\n catalan = [0] * (n + 1)\n \n # Initialize the first value\n catalan[0] = 1\n \n # Fill the array using the recurrence relation\n for i in range(1, n + 1):\n for j in range(i):\n catalan[i] += catalan[j] * catalan[i - j - 1]\n \n return catalan[n]\n\n# Test case\nassert catalan_number(10) == 16796\n```\n\n### Explanation:\n\n- **Base Case**: The 0-th Catalan number is defined as 1.\n- **Dynamic Programming Table**: We use an array `catalan` where `catalan[i]` will store the \\(i\\)-th Catalan number.\n- **Recurrence Relation**: For each \\(i\\) from 1 to \\(n\\), compute `catalan[i]` using the sum of products of previously computed Catalan numbers, as per the recurrence relation.\n- **Efficiency**: This approach computes each Catalan number in \\(O(n^2)\\) time due to the nested loops, which is efficient for reasonably large values of \\(n\\).\n\nThis function will correctly compute the 10th Catalan number as 16796."}
{"task_id": "Mbpp/585", "solution": "Here's a self-contained Python script that solves the problem of finding the n most expensive items in a given dataset:\n\n```python\ndef expensive_items(items, n):\n \"\"\"\n Find the n most expensive items from a list of dictionaries containing item names and prices.\n\n Parameters:\n - items (list): A list of dictionaries where each dictionary contains 'name' and 'price'.\n - n (int): The number of most expensive items to return.\n\n Returns:\n - list: A list of the n most expensive items sorted by price in descending order.\n \"\"\"\n # Sort the items based on the 'price' key in descending order\n sorted_items = sorted(items, key=lambda x: x['price'], reverse=True)\n \n # Return the top n items\n return sorted_items[:n]\n\n# Test case\nassert expensive_items([{'name': 'Item-1', 'price': 101.1}, {'name': 'Item-2', 'price': 555.22}], 1) == [{'name': 'Item-2', 'price': 555.22}]\n```\n\nThis function sorts the list of items based on their prices in descending order and returns the top n items. The test case provided checks if the function correctly identifies the most expensive item when `n` is set to 1."}
{"task_id": "Mbpp/586", "solution": "Certainly! Below is a self-contained Python script that defines a function `split_arr` which splits a list at the nth element and appends the first part to the end of the list. The function then returns the modified list.\n\n```python\ndef split_arr(lst, n):\n \"\"\"\n Splits the list at the nth element and moves the first part to the end.\n \n Parameters:\n lst (list): The input list to be manipulated.\n n (int): The index at which to split the list.\n \n Returns:\n list: The modified list with the first part moved to the end.\n \"\"\"\n # Ensure n is within the bounds of the list\n if not 0 <= n < len(lst):\n raise ValueError(\"n must be a valid index in the list\")\n \n # Split the list and rearrange\n return lst[n:] + lst[:n]\n\n# Test case to verify the function works as expected\nassert split_arr([12, 10, 5, 6, 52, 36], 2) == [5, 6, 52, 36, 12, 10]\n```\n\n### Explanation:\n- The `split_arr` function takes two parameters: a list `lst` and an integer `n`.\n- It checks if `n` is within the valid range of indices for the list.\n- The list is split into two parts at index `n`: \n - `lst[n:]` gives all elements from index `n` to the end.\n - `lst[:n]` gives all elements from the start up to, but not including, index `n`.\n- These two parts are concatenated in reverse order (`lst[n:] + lst[:n]`) to achieve the desired result.\n- The function returns this newly arranged list.\n\nThis script includes a test case using an assertion to ensure that the function behaves as expected."}
{"task_id": "Mbpp/587", "solution": "Certainly! Below is a self-contained Python script that defines the function `list_to_tuple` to convert a list into a tuple. It also includes an assertion to verify that the conversion works as expected.\n\n```markdown\n```python\ndef list_to_tuple(lst):\n \"\"\"\n Convert a list to a tuple.\n \n Parameters:\n lst (list): The list to be converted to a tuple.\n \n Returns:\n tuple: A tuple containing all elements of the input list.\n \"\"\"\n return tuple(lst)\n\n# Test case\nassert list_to_tuple([5, 10, 7, 4, 15, 3]) == (5, 10, 7, 4, 15, 3)\n```\n```\n\nThis script defines a function `list_to_tuple` that takes a single argument, `lst`, which is expected to be a list. The function uses Python's built-in `tuple()` constructor to convert the list into a tuple and returns it.\n\nThe assertion at the end of the script checks if calling `list_to_tuple` with the list `[5, 10, 7, 4, 15, 3]` results in the expected tuple `(5, 10, 7, 4, 15, 3)`. If the conversion is correct, the assertion will pass without any issues."}
{"task_id": "Mbpp/588", "solution": "```markdown\nHere's a Python script that defines a function `big_diff` to solve the problem of finding the difference between the largest and smallest values in a given list:\n\n```python\ndef big_diff(lst):\n \"\"\"\n This function takes a list of numbers as input and returns the difference \n between the largest and smallest number in the list.\n \n Parameters:\n lst (list): A list of integers or floats.\n\n Returns:\n int or float: The difference between the maximum and minimum values in the list.\n \"\"\"\n if not lst: # Check if the list is empty\n raise ValueError(\"The input list must contain at least one number.\")\n \n max_value = max(lst) # Find the largest value in the list\n min_value = min(lst) # Find the smallest value in the list\n \n return max_value - min_value # Return the difference\n\n# Test case to verify the function works as expected\nassert big_diff([1, 2, 3, 4]) == 3\n```\n\n### Explanation:\n- The `big_diff` function takes a single argument `lst`, which is expected to be a list of numbers.\n- It first checks if the list is empty and raises a `ValueError` if it is, as an empty list does not have a maximum or minimum value.\n- It uses Python's built-in functions `max()` and `min()` to find the largest and smallest values in the list, respectively.\n- The function then returns the difference between these two values.\n- An assertion is included at the end to test that the function works correctly for the provided example.\n\nThis script should work for any non-empty list of numbers."}
{"task_id": "Mbpp/589", "solution": "Certainly! Below is a self-contained Python script that defines the `perfect_squares` function. This function finds all perfect squares between two given numbers (inclusive) and returns them as a list.\n\n```python\ndef perfect_squares(start, end):\n \"\"\"\n Find all perfect squares between start and end (inclusive).\n\n Parameters:\n - start: int, the starting number of the range.\n - end: int, the ending number of the range.\n\n Returns:\n - List[int]: A list of perfect squares within the given range.\n \"\"\"\n # Initialize an empty list to store perfect squares\n perfect_squares_list = []\n \n # Iterate over each number in the range from start to end (inclusive)\n for num in range(start, end + 1):\n # Calculate the square root of the current number\n sqrt_num = int(num ** 0.5)\n \n # Check if the square of the integer part of the square root equals the original number\n if sqrt_num * sqrt_num == num:\n perfect_squares_list.append(num)\n \n return perfect_squares_list\n\n# Test case to verify the function works as expected\nassert perfect_squares(1, 30) == [1, 4, 9, 16, 25]\n```\n\n### Explanation:\n\n- **Function Definition**: The `perfect_squares` function takes two parameters: `start` and `end`, which define the range of numbers to check for perfect squares.\n \n- **Loop Through Range**: We iterate over each number in the specified range using a `for` loop.\n\n- **Square Root Calculation**: For each number, we calculate its square root and convert it to an integer. This helps us determine if the number is a perfect square.\n\n- **Perfect Square Check**: If squaring this integer gives back the original number, then it's a perfect square, and we add it to our list.\n\n- **Return Result**: Finally, the function returns the list of perfect squares found within the range.\n\nThis script includes an assertion to verify that the function works correctly for the given test case."}
{"task_id": "Mbpp/590", "solution": "Certainly! Below is a self-contained Python script that converts polar coordinates to rectangular coordinates and includes an assertion for the given test case.\n\n```markdown\n```python\nimport math\n\ndef polar_to_rectangular(r, theta):\n \"\"\"\n Convert polar coordinates (r, theta) to rectangular coordinates (x, y).\n \n Parameters:\n r (float): The radial distance.\n theta (float): The angle in radians.\n \n Returns:\n tuple: A tuple containing the rectangular coordinates (x, y) and a complex number representation.\n \"\"\"\n # Calculate x and y using polar to rectangular conversion formulas\n x = r * math.cos(theta)\n y = r * math.sin(theta)\n \n # Create a complex number from x and y\n complex_number = complex(x, y)\n \n return (x, y), complex_number\n\n# Test the function with the provided assertion\nassert polar_to_rectangular(3, 4) == ((-2.9999999999999996, 2.0), (-2+2j))\n```\n```\n\n### Explanation:\n\n1. **Importing Math Module**: We import the `math` module to use trigonometric functions like `cos` and `sin`.\n\n2. **Function Definition**: The function `polar_to_rectangular(r, theta)` takes two parameters: `r` (the radial distance) and `theta` (the angle in radians).\n\n3. **Conversion Formulas**:\n - \\( x = r \\times \\cos(\\theta) \\)\n - \\( y = r \\times \\sin(\\theta) \\)\n\n4. **Complex Number**: We create a complex number using the calculated `x` and `y`.\n\n5. **Return Statement**: The function returns a tuple containing the rectangular coordinates `(x, y)` and the complex number representation.\n\n6. **Assertion**: The assertion checks if the function correctly converts the polar coordinates (3, 4) to the expected rectangular coordinates and complex number. Note that due to floating-point precision, `-2.9999999999999996` is approximately `-3`, which matches the expected result when considering numerical precision."}
{"task_id": "Mbpp/591", "solution": "Certainly! Below is a self-contained Python script that defines a function to interchange the first and last elements of a list. The function includes an assertion to verify its correctness.\n\n```markdown\n```python\ndef swap_List(lst):\n \"\"\"\n Interchange the first and last elements in a list.\n \n Parameters:\n lst (list): A list of elements\n \n Returns:\n list: A new list with the first and last elements swapped\n \"\"\"\n if len(lst) < 2:\n # If the list has fewer than two elements, return it as is\n return lst\n\n # Swap the first and last elements\n lst[0], lst[-1] = lst[-1], lst[0]\n \n return lst\n\n# Test case to verify the function works correctly\nassert swap_List([12, 35, 9, 56, 24]) == [24, 35, 9, 56, 12]\n\nprint(\"The function passed the test case.\")\n```\n```\n\nThis script defines a `swap_List` function that takes a list as input and swaps its first and last elements. It handles lists with fewer than two elements by returning them unchanged. The assertion checks if the function correctly interchanges the elements for the given example, ensuring the output matches the expected result."}
{"task_id": "Mbpp/592", "solution": "Certainly! To solve this problem, we need to calculate the sum of products of consecutive binomial coefficients for a given integer \\( n \\). The binomial coefficient is often denoted as \\( C(n, k) \\), which represents the number of ways to choose \\( k \\) elements from a set of \\( n \\) elements. It can be calculated using the formula:\n\n\\[\nC(n, k) = \\frac{n!}{k!(n-k)!}\n\\]\n\nFor this problem, we need to compute the sum of products of consecutive binomial coefficients for all \\( k \\) from 0 to \\( n-1 \\):\n\n\\[\n\\text{sum\\_Of\\_product}(n) = \\sum_{k=0}^{n-1} C(n, k) \\times C(n, k+1)\n\\]\n\nHere's a Python function that implements this logic:\n\n```python\ndef binomial_coefficient(n, k):\n \"\"\"Calculate the binomial coefficient C(n, k).\"\"\"\n if k < 0 or k > n:\n return 0\n if k == 0 or k == n:\n return 1\n # Use symmetry property: C(n, k) = C(n, n-k)\n k = min(k, n - k)\n c = 1\n for i in range(k):\n c = c * (n - i) // (i + 1)\n return c\n\ndef sum_Of_product(n):\n \"\"\"Calculate the sum of products of consecutive binomial coefficients.\"\"\"\n total_sum = 0\n for k in range(n):\n total_sum += binomial_coefficient(n, k) * binomial_coefficient(n, k + 1)\n return total_sum\n\n# Test case\nassert sum_Of_product(3) == 15\n```\n\n### Explanation:\n\n1. **Binomial Coefficient Calculation**:\n - The `binomial_coefficient` function calculates \\( C(n, k) \\) using an iterative approach to avoid large intermediate values and potential overflow.\n - It uses the property \\( C(n, k) = C(n, n-k) \\) to minimize calculations.\n\n2. **Sum of Products**:\n - The `sum_Of_product` function iterates over all valid \\( k \\) from 0 to \\( n-1 \\).\n - For each \\( k \\), it calculates the product \\( C(n, k) \\times C(n, k+1) \\) and adds it to the total sum.\n\n3. **Test Case**:\n - The function is tested with `assert sum_Of_product(3) == 15` to ensure correctness.\n\nThis solution efficiently computes the required sum using properties of binomial coefficients and avoids unnecessary recalculations."}
{"task_id": "Mbpp/593", "solution": "Certainly! Below is a self-contained Python script that defines the `remove_zero_ip` function, which removes leading zeros from each segment of an IP address:\n\n```python\ndef remove_zero_ip(ip_address):\n \"\"\"\n Remove leading zeroes from each segment of an IP address.\n\n Parameters:\n ip_address (str): The input IP address as a string.\n\n Returns:\n str: The IP address with leading zeroes removed.\n \"\"\"\n # Split the IP address into its segments\n segments = ip_address.split('.')\n \n # Convert each segment to an integer and back to a string to remove leading zeros\n cleaned_segments = [str(int(segment)) for segment in segments]\n \n # Join the cleaned segments back into a single string with dots\n cleaned_ip_address = '.'.join(cleaned_segments)\n \n return cleaned_ip_address\n\n# Test case\nassert remove_zero_ip(\"216.08.094.196\") == '216.8.94.196'\n```\n\nThis function works by splitting the IP address into its individual segments, converting each segment to an integer (which removes any leading zeros), and then converting it back to a string. Finally, it joins these cleaned segments back together with dots to form the final IP address."}
{"task_id": "Mbpp/594", "solution": "```markdown\nHere's a Python script that defines a function `diff_even_odd` to solve the problem:\n\n```python\ndef diff_even_odd(lst):\n first_even = None\n first_odd = None\n \n for num in lst:\n if first_even is None and num % 2 == 0:\n first_even = num\n elif first_odd is None and num % 2 != 0:\n first_odd = num\n \n # If both first even and odd numbers are found, break the loop\n if first_even is not None and first_odd is not None:\n break\n \n # Check if both an even and an odd number were found\n if first_even is not None and first_odd is not None:\n return abs(first_even - first_odd)\n else:\n raise ValueError(\"The list must contain at least one even and one odd number.\")\n\n# Test the function with the provided assertion\nassert diff_even_odd([1, 3, 5, 7, 4, 1, 6, 8]) == 3\n\nprint(\"Test passed!\")\n```\n\n### Explanation:\n\n- The function `diff_even_odd` iterates through the list to find the first even and first odd numbers.\n- It uses two variables, `first_even` and `first_odd`, initialized as `None`.\n- As it iterates, it checks each number:\n - If the number is even and `first_even` is still `None`, it assigns the number to `first_even`.\n - If the number is odd and `first_odd` is still `None`, it assigns the number to `first_odd`.\n- Once both numbers are found, it breaks out of the loop.\n- It then returns the absolute difference between these two numbers.\n- If either an even or an odd number is not found, it raises a `ValueError`.\n\nThis script includes a test case that matches the provided assertion."}
{"task_id": "Mbpp/596", "solution": "Certainly! Below is a self-contained Python script that defines a function to find the size in bytes of a given tuple. It uses the `sys` module to get the size and includes an assertion to verify its correctness.\n\n```python\nimport sys\n\ndef tuple_size(tpl):\n \"\"\"\n Calculate the size in bytes of the given tuple.\n \n Parameters:\n tpl (tuple): The tuple whose size is to be calculated.\n \n Returns:\n int: Size of the tuple in bytes.\n \"\"\"\n return sys.getsizeof(tpl)\n\n# Example usage\nexample_tuple = (\"A\", 1, \"B\", 2, \"C\", 3)\nassert tuple_size(example_tuple) == sys.getsizeof(example_tuple), \"The function did not return the expected size.\"\n\nprint(f\"The size of the tuple {example_tuple} is {tuple_size(example_tuple)} bytes.\")\n```\n\n### Explanation:\n\n- **Importing `sys`**: The script imports the `sys` module, which provides access to some variables used or maintained by the interpreter and to functions that interact strongly with the interpreter. Here, it's used for getting the size of an object in memory.\n\n- **Function Definition (`tuple_size`)**: This function takes a tuple as input and returns its size in bytes using `sys.getsizeof()`.\n\n- **Assertion**: The script includes an assertion to ensure that the function correctly calculates the size of the example tuple. If the assertion fails, it raises an error with a message indicating the discrepancy.\n\n- **Example Usage**: Finally, the script demonstrates how to use the `tuple_size` function and prints out the size of the example tuple in bytes."}
{"task_id": "Mbpp/597", "solution": "```markdown\nTo solve the problem of finding the k-th element from two sorted arrays, we can use a recursive approach. The idea is to compare elements at the current indices of both arrays and recursively reduce the size of the problem by eliminating one element from either array based on comparisons.\n\nHere's how you can implement this:\n\n```python\ndef find_kth(arr1, arr2, k):\n # Base cases\n if len(arr1) == 0:\n return arr2[k]\n if len(arr2) == 0:\n return arr1[k]\n if k == 0:\n return min(arr1[0], arr2[0])\n \n # Calculate the indices to compare\n i = min(len(arr1) - 1, k // 2)\n j = min(len(arr2) - 1, k // 2)\n \n # Compare elements at these indices and reduce the problem size\n if arr1[i] > arr2[j]:\n return find_kth(arr1, arr2[j + 1:], k - (j + 1))\n else:\n return find_kth(arr1[i + 1:], arr2, k - (i + 1))\n\n# Test case\nassert find_kth([2, 3, 6, 7, 9], [1, 4, 8, 10], 5) == 6\n```\n\n### Explanation:\n\n1. **Base Cases**:\n - If one of the arrays is empty, return the k-th element from the other array.\n - If `k` is 0, return the minimum of the first elements of both arrays.\n\n2. **Recursive Step**:\n - Calculate indices `i` and `j` to compare elements in `arr1` and `arr2`. These are determined by taking the smaller value between half of `k` and the last index of each array.\n - Compare `arr1[i]` and `arr2[j]`.\n - If `arr1[i] > arr2[j]`, discard the first `j + 1` elements from `arr2` and reduce `k` by `j + 1`.\n - Otherwise, discard the first `i + 1` elements from `arr1` and reduce `k` by `i + 1`.\n\nThis approach efficiently narrows down the search space by eliminating half of one array in each recursive call."}
{"task_id": "Mbpp/598", "solution": "Certainly! Below is a self-contained Python script that defines a function to check if a given number is an Armstrong number. An Armstrong number (also known as a narcissistic number) for a three-digit number is one where the sum of the cubes of its digits equals the number itself.\n\nHere's how you can implement this:\n\n```python\ndef armstrong_number(num):\n \"\"\"\n Check if the given number is an Armstrong number.\n \n An Armstrong number for a 3-digit number is one where the sum of the cubes \n of its digits equals the number itself. This function generalizes to n-digits.\n \n Args:\n num (int): The number to check.\n\n Returns:\n bool: True if the number is an Armstrong number, False otherwise.\n \"\"\"\n # Convert the number to a string to easily iterate over each digit\n str_num = str(num)\n # Calculate the length of the number (number of digits)\n n = len(str_num)\n \n # Initialize sum of powers\n sum_of_powers = 0\n \n # Iterate over each digit, convert it back to an integer, raise it to the power of n,\n # and add it to the sum_of_powers\n for digit in str_num:\n sum_of_powers += int(digit) ** n\n \n # Check if the calculated sum is equal to the original number\n return sum_of_powers == num\n\n# Test cases\nassert armstrong_number(153) == True, \"Test case 1 failed\"\nassert armstrong_number(9474) == True, \"Test case 2 failed\" # 9^4 + 4^4 + 7^4 + 4^4 = 9474\nassert armstrong_number(123) == False, \"Test case 3 failed\"\n\nprint(\"All test cases passed!\")\n```\n\n### Explanation:\n\n1. **Convert to String**: The number is converted to a string so that we can easily iterate over each digit.\n\n2. **Calculate Length**: We determine the number of digits `n` in the number because an Armstrong number condition depends on this length (e.g., for 3-digit numbers, each digit is raised to the power of 3).\n\n3. **Sum of Powers**: For each digit, convert it back to an integer, raise it to the power of `n`, and accumulate these values.\n\n4. **Comparison**: Finally, compare the sum of these powered digits with the original number to determine if it's an Armstrong number.\n\nThis function works for any positive integer, not just three-digit numbers, making it a generalized solution for checking Armstrong numbers."}
{"task_id": "Mbpp/599", "solution": "Certainly! Below is a self-contained Python script that defines a function `sum_average` to calculate the sum and average of the first \\( n \\) natural numbers.\n\n```python\ndef sum_average(n):\n \"\"\"\n Calculate the sum and average of the first n natural numbers.\n \n Parameters:\n n (int): The number of initial natural numbers to consider.\n \n Returns:\n tuple: A tuple containing the sum and average of the first n natural numbers.\n \"\"\"\n # Calculate the sum using the formula for the sum of an arithmetic series\n total_sum = n * (n + 1) // 2\n \n # Calculate the average\n if n > 0:\n average = total_sum / n\n else:\n average = 0 # Handle the case where n is 0 to avoid division by zero\n \n return total_sum, average\n\n# Test the function with an assertion\nassert sum_average(10) == (55, 5.5)\n```\n\n### Explanation:\n\n- **Sum Calculation**: The sum of the first \\( n \\) natural numbers can be calculated using the formula:\n \\[\n \\text{sum} = \\frac{n \\times (n + 1)}{2}\n \\]\n This formula is derived from the arithmetic series sum formula.\n\n- **Average Calculation**: The average is simply the total sum divided by \\( n \\). We handle the case where \\( n = 0 \\) to avoid division by zero, returning an average of 0 in such cases.\n\n- **Assertion**: The function is tested with an assertion to ensure it returns the expected result for \\( n = 10 \\), which should be a sum of 55 and an average of 5.5."}
{"task_id": "Mbpp/600", "solution": "Certainly! Below is a self-contained Python script that defines a function `is_even` to determine if a given number is even. It also includes an assertion to verify its correctness.\n\n```python\ndef is_even(number):\n \"\"\"\n Check whether the given number is even.\n \n Parameters:\n number (int): The number to check.\n \n Returns:\n bool: True if the number is even, False otherwise.\n \"\"\"\n return number % 2 == 0\n\n# Test case\nassert is_even(1) == False\n```\n\nThis function uses the modulus operator `%` to determine if a number is divisible by 2 without any remainder. If it is, the number is even; otherwise, it's odd. The assertion checks that `is_even(1)` returns `False`, as expected for an odd number."}
{"task_id": "Mbpp/602", "solution": "Certainly! Below is a self-contained Python script that defines a function `first_repeated_char` to find the first repeated character in a given string. The function uses a set to keep track of characters we've seen as we iterate through the string.\n\n```python\ndef first_repeated_char(s):\n \"\"\"\n This function finds the first repeated character in a given string.\n \n Parameters:\n s (str): The input string to search for the first repeated character.\n \n Returns:\n str: The first repeated character if found, otherwise None.\n \"\"\"\n seen = set()\n for char in s:\n if char in seen:\n return char\n seen.add(char)\n return None\n\n# Test case\nassert first_repeated_char(\"abcabc\") == \"a\"\n```\n\n### Explanation:\n\n- **Function Definition**: The function `first_repeated_char` takes a single argument, `s`, which is the string to be analyzed.\n \n- **Set for Tracking**: We use a set named `seen` to store characters that have been encountered as we iterate through the string. Sets are chosen because they provide average O(1) time complexity for lookups.\n\n- **Iteration and Check**: As we loop over each character in the string:\n - If the character is already in the `seen` set, it means this character has been repeated, so we return it immediately.\n - If not, we add the character to the `seen` set.\n\n- **Return Value**: If no characters are repeated by the end of the loop, the function returns `None`.\n\nThis approach ensures that we find the first repeated character efficiently. The provided test case checks if the function correctly identifies 'a' as the first repeated character in \"abcabc\"."}
{"task_id": "Mbpp/603", "solution": "```markdown\n```python\ndef get_lucid(n):\n \"\"\"\n Generate all lucid (or lucky) numbers up to and including n.\n\n A lucid number is generated by a sieving process similar to the Sieve of Eratosthenes.\n Start with an infinite list of natural numbers beginning with 1. \n The first number in the list is considered \"lucky\" and is kept, while every second number\n (the one at index equal to the lucky number) is removed from the list. \n Repeat this process by considering the next number in the list as a new lucky number,\n removing every nth number where n is the value of that lucky number.\n \n Args:\n n (int): The upper limit for generating lucid numbers.\n\n Returns:\n List[int]: A list of all lucid numbers less than or equal to n.\n \"\"\"\n if n < 1:\n return []\n\n # Start with a list of natural numbers from 1 to n\n numbers = list(range(1, n + 1))\n \n index = 1 # Start with the first lucky number (index 0 is 1)\n \n while index < len(numbers):\n # The current lucky number\n step = numbers[index]\n \n # Remove every 'step'-th element starting from the next position after 'step'\n del numbers[index + step::step]\n \n # Move to the next index in the remaining list\n index += 1\n \n return numbers\n\n# Test case\nassert get_lucid(10) == [1, 2, 3, 5, 7]\n\n```\n```"}
{"task_id": "Mbpp/604", "solution": "Certainly! Below is a self-contained Python script that defines a function `reverse_words` which takes a string as input and returns the words in reverse order, separated by spaces.\n\n```markdown\n```python\ndef reverse_words(input_string):\n \"\"\"\n This function takes a string with words separated by spaces and \n returns a new string with the words in reverse order.\n \n Parameters:\n input_string (str): The string containing words to be reversed.\n \n Returns:\n str: A string with the words in reverse order.\n \"\"\"\n # Split the input string into a list of words\n words = input_string.split()\n \n # Reverse the list of words\n reversed_words = words[::-1]\n \n # Join the reversed list back into a single string separated by spaces\n result = ' '.join(reversed_words)\n \n return result\n\n# Test case to verify the function works as expected\nassert reverse_words(\"python program\") == \"program python\"\n```\n```\n\nThis script defines the `reverse_words` function, which splits the input string into words, reverses the list of words, and then joins them back together with spaces. The test case at the end ensures that the function behaves correctly for the given example."}
{"task_id": "Mbpp/605", "solution": "Certainly! Below is a self-contained Python script that defines a function `prime_num` to check if a given integer is a prime number. The function returns `True` if the number is prime and `False` otherwise.\n\n```python\ndef prime_num(n):\n \"\"\"\n Check if the given integer n is a prime number.\n \n Parameters:\n n (int): The integer to be checked for primality.\n \n Returns:\n bool: True if n is a prime number, False otherwise.\n \"\"\"\n # A prime number is greater than 1\n if n <= 1:\n return False\n \n # Check from 2 to the square root of n\n # If n is divisible by any number in this range, it's not prime\n for i in range(2, int(n**0.5) + 1):\n if n % i == 0:\n return False\n \n # If no divisors were found, n is prime\n return True\n\n# Test the function with an assertion\nassert prime_num(13) == True\n```\n\n### Explanation:\n\n- **Input Validation**: The function first checks if `n` is less than or equal to 1. Numbers less than or equal to 1 are not considered prime.\n\n- **Efficient Checking**: Instead of checking all numbers up to `n`, the function only checks divisors from 2 up to the square root of `n`. This is because a larger factor of `n` would have a corresponding smaller factor that has already been checked.\n\n- **Return Value**: If any divisor is found, the function returns `False`. If no divisors are found, it returns `True`, indicating that `n` is prime.\n\nThis script includes an assertion to verify that the function works correctly for the input 13."}
{"task_id": "Mbpp/606", "solution": "Certainly! Below is a self-contained Python script that defines a function to convert degrees to radians and includes an assertion to verify its correctness.\n\n```markdown\n```python\nimport math\n\ndef radian_degree(degrees):\n \"\"\"\n Convert degrees to radians.\n \n Parameters:\n degrees (float): Angle in degrees\n \n Returns:\n float: Angle in radians\n \"\"\"\n return degrees * (math.pi / 180)\n\n# Test the function with an assertion\nassert math.isclose(radian_degree(90), 1.5707963267948966, rel_tol=1e-9), \"The conversion is incorrect.\"\n\nprint(\"Conversion successful!\")\n```\n```\n\n### Explanation:\n\n- **Importing `math`**: We import the `math` module to access the constant `pi`, which represents the mathematical constant \u03c0.\n\n- **Function Definition**: The function `radian_degree(degrees)` takes an angle in degrees as input and returns its equivalent in radians. The conversion formula is:\n \\[\n \\text{radians} = \\text{degrees} \\times \\left(\\frac{\\pi}{180}\\right)\n \\]\n\n- **Assertion**: We use `math.isclose()` to compare the result of `radian_degree(90)` with the expected value `1.5707963267948966`. The `rel_tol=1e-9` parameter specifies a relative tolerance for floating-point comparison, ensuring that minor differences due to precision are ignored.\n\n- **Print Statement**: If the assertion passes, it prints \"Conversion successful!\" indicating that the function works as expected."}
{"task_id": "Mbpp/607", "solution": "Certainly! Below is a self-contained Python script that defines a function to search for a regex pattern within a string. The function returns the matching substring along with its start and end indices.\n\n```python\nimport re\n\ndef find_literals(text, pattern):\n \"\"\"\n Search for a regex pattern in a given text.\n \n Parameters:\n - text (str): The string to be searched.\n - pattern (str): The regex pattern to search for.\n \n Returns:\n - tuple: A tuple containing the matching substring and its start and end indices.\n If no match is found, returns None.\n \"\"\"\n # Compile the regex pattern\n regex = re.compile(pattern)\n \n # Search for the pattern in the text\n match = regex.search(text)\n \n if match:\n # Extract the matched substring and its start and end positions\n matched_substring = match.group()\n start_index = match.start()\n end_index = match.end()\n \n return (matched_substring, start_index, end_index)\n else:\n return None\n\n# Test case\nassert find_literals('The quick brown fox jumps over the lazy dog.', 'fox') == ('fox', 16, 19)\n\nprint(\"Test passed!\")\n```\n\n### Explanation:\n\n- **Importing `re`**: The script imports Python's built-in `re` module to work with regular expressions.\n \n- **Function Definition**: \n - `find_literals(text, pattern)`: This function takes two arguments: the text to search and the regex pattern.\n \n- **Compiling the Pattern**:\n - `regex = re.compile(pattern)`: Compiles the given pattern into a regex object for efficient searching.\n\n- **Searching for Matches**:\n - `match = regex.search(text)`: Searches for the first occurrence of the pattern in the text. If found, it returns a match object; otherwise, it returns `None`.\n\n- **Extracting Match Details**:\n - If a match is found (`if match:`), the function extracts:\n - The matched substring using `match.group()`.\n - The start index using `match.start()`.\n - The end index using `match.end()`.\n\n- **Return Value**:\n - Returns a tuple containing the matched substring and its indices.\n - If no match is found, it returns `None`.\n\n- **Test Case**: \n - An assertion checks that the function correctly identifies the substring \"fox\" at indices 16 to 19 in the given sentence.\n\nThis script should work for any string and regex pattern you provide."}
{"task_id": "Mbpp/608", "solution": "Certainly! The Bell numbers count the number of ways to partition a set into non-empty subsets. To compute the \\(n\\)th Bell number, we can use a dynamic programming approach with a triangular array known as Bell's triangle.\n\nHere is a Python function that calculates the nth Bell number:\n\n```python\ndef bell_Number(n):\n # Create a 2D list (triangle) initialized to zero\n bell = [[0 for i in range(n+1)] for j in range(n+1)]\n \n # The first Bell number is 1\n bell[0][0] = 1\n \n # Fill the Bell triangle\n for i in range(1, n+1):\n # Explicitly set the first value of each row\n bell[i][0] = bell[i-1][i-1]\n \n # Fill the rest of the values using the relation:\n # bell[i][j] = bell[i-1][j-1] + bell[i][j-1]\n for j in range(1, i+1):\n bell[i][j] = bell[i-1][j-1] + bell[i][j-1]\n \n # The nth Bell number is the first element of the nth row\n return bell[n][0]\n\n# Test case\nassert bell_Number(2) == 2\n\n# Example usage:\nprint(bell_Number(3)) # Output: 5\n```\n\n### Explanation:\n\n1. **Initialization**: We initialize a 2D list `bell` with dimensions \\((n+1) \\times (n+1)\\), filled with zeros.\n\n2. **Base Case**: The first Bell number \\(B_0\\) is 1, so we set `bell[0][0] = 1`.\n\n3. **Filling the Triangle**:\n - For each row \\(i\\), the first element `bell[i][0]` is equal to the last element of the previous row `bell[i-1][i-1]`.\n - Each subsequent element in the row is calculated using the formula: \n \\[\n \\text{bell}[i][j] = \\text{bell}[i-1][j-1] + \\text{bell}[i][j-1]\n \\]\n\n4. **Result**: The \\(n\\)th Bell number is found at `bell[n][0]`.\n\nThis approach efficiently computes the Bell numbers using dynamic programming, ensuring that each subproblem is solved only once and stored for future use."}
{"task_id": "Mbpp/610", "solution": "Certainly! Below is a self-contained Python script that defines the function `remove_kth_element`. This function takes a list and an integer `k` as input and returns a new list with the k'th element removed. The indexing is zero-based.\n\n```python\ndef remove_kth_element(lst, k):\n \"\"\"\n Removes the k'th element from the given list.\n \n Parameters:\n lst (list): The original list from which to remove an element.\n k (int): The index of the element to be removed. Zero-based indexing is used.\n\n Returns:\n list: A new list with the k'th element removed.\n \"\"\"\n # Check if k is a valid index\n if 0 <= k < len(lst):\n # Remove the k'th element by slicing and concatenating parts of the list\n return lst[:k] + lst[k+1:]\n else:\n raise IndexError(\"Index out of range\")\n\n# Example usage\nassert remove_kth_element([1, 1, 2, 3, 4, 4, 5, 1], 3) == [1, 1, 2, 4, 4, 5, 1]\n```\n\n### Explanation:\n- **Function Definition**: The function `remove_kth_element` takes two parameters: a list `lst` and an integer `k`.\n- **Index Validation**: It first checks if `k` is within the valid range of indices for the list. If not, it raises an `IndexError`.\n- **List Slicing**: If `k` is valid, it constructs a new list by concatenating two slices: one from the start of the list to just before `k`, and another from just after `k` to the end.\n- **Return Value**: The function returns this newly constructed list.\n\nThis script includes an assertion to verify that the function works as expected for the given example."}
{"task_id": "Mbpp/611", "solution": "Certainly! Below is a self-contained Python script that defines and tests the function `max_of_nth`, which finds the maximum value in the n'th column of a matrix represented as a list of lists.\n\n```python\ndef max_of_nth(matrix, n):\n \"\"\"\n Returns the maximum value in the nth column of a given matrix.\n \n :param matrix: List of lists where each sublist represents a row in the matrix.\n :param n: The index (0-based) of the column to find the maximum value from.\n :return: Maximum value found in the nth column.\n \"\"\"\n # Extract the nth column using list comprehension\n nth_column = [row[n] for row in matrix]\n \n # Return the maximum value in the extracted column\n return max(nth_column)\n\n# Test case to verify the function works as expected\nassert max_of_nth([[5, 6, 7], [1, 3, 5], [8, 9, 19]], 2) == 19\n\nprint(\"The test passed successfully!\")\n```\n\n### Explanation:\n- **Function Definition**: The `max_of_nth` function takes two parameters: `matrix`, which is a list of lists representing the matrix, and `n`, which specifies the column index.\n- **List Comprehension**: We use a list comprehension to extract all elements from the n'th column across each row in the matrix.\n- **Finding Maximum**: The built-in `max()` function is used to find the maximum value in this extracted column.\n- **Test Case**: An assertion checks if the function returns the expected result for a given test case. If it passes, a success message is printed.\n\nThis script should work correctly for any valid input matrix and column index within bounds."}
{"task_id": "Mbpp/612", "solution": "Certainly! Below is a self-contained Python script that defines and tests the `merge` function as described in your problem statement.\n\n```markdown\n```python\ndef merge(list_of_lists):\n \"\"\"\n Takes a list of lists, where each sublist has two elements,\n and returns a list of two lists. The first list contains all \n the first elements from the sublists, and the second list contains \n all the second elements.\n \n Parameters:\n list_of_lists (list): A list containing sublists with exactly two elements each.\n\n Returns:\n list: A list containing two lists - one for the first elements and one for the second elements.\n \"\"\"\n # Initialize two empty lists to hold the separated elements\n first_elements = []\n second_elements = []\n\n # Iterate over each sublist in the input list\n for sublist in list_of_lists:\n if len(sublist) == 2: # Ensure that each sublist has exactly two elements\n first_elements.append(sublist[0])\n second_elements.append(sublist[1])\n\n # Return a list containing both lists of separated elements\n return [first_elements, second_elements]\n\n# Test the function with an example input\nassert merge([['x', 'y'], ['a', 'b'], ['m', 'n']]) == [['x', 'a', 'm'], ['y', 'b', 'n']]\n```\n```\n\nThis script defines a `merge` function that processes a list of lists, ensuring each sublist contains exactly two elements. It separates these elements into two distinct lists and returns them as a list containing both lists. The provided assertion checks the correctness of the function with an example input."}
{"task_id": "Mbpp/614", "solution": "Certainly! Below is a self-contained Python script that defines a function to calculate the cumulative sum of all values present in a given list of tuples. The function iterates through each tuple and sums up all the elements within them.\n\n```python\ndef cummulative_sum(tuple_list):\n \"\"\"\n Calculate the cumulative sum of all values in a list of tuples.\n \n Parameters:\n tuple_list (list): A list containing tuples with numeric values.\n \n Returns:\n int: The cumulative sum of all numbers in the tuples.\n \"\"\"\n total_sum = 0\n for tup in tuple_list:\n # Sum up each element in the current tuple and add to total_sum\n total_sum += sum(tup)\n return total_sum\n\n# Test case\nassert cummulative_sum([(1, 3), (5, 6, 7), (2, 6)]) == 30\n```\n\n### Explanation:\n- The function `cummulative_sum` takes a list of tuples as input.\n- It initializes `total_sum` to zero.\n- For each tuple in the list, it calculates the sum of its elements using Python's built-in `sum()` function and adds this to `total_sum`.\n- Finally, it returns the cumulative sum.\n\nThe provided test case checks if the function correctly computes the cumulative sum for the input `[(1, 3), (5, 6, 7), (2, 6)]`, which should be `30`."}
{"task_id": "Mbpp/615", "solution": "Certainly! Below is a self-contained Python script that defines the function `average_tuple` to solve the problem described:\n\n```markdown\n```python\ndef average_tuple(tuples):\n \"\"\"\n This function takes a tuple of tuples and returns the average value for each inner tuple as a list.\n \n Parameters:\n tuples (tuple): A tuple containing multiple tuples, where each inner tuple consists of numeric values.\n\n Returns:\n list: A list containing the average of each inner tuple.\n \"\"\"\n # Initialize an empty list to store the averages\n averages = []\n \n # Iterate over each tuple in the input tuple\n for t in tuples:\n # Calculate the sum of elements in the current tuple\n total_sum = sum(t)\n \n # Calculate the number of elements in the current tuple\n num_elements = len(t)\n \n # Compute the average and append it to the averages list\n average = total_sum / num_elements\n averages.append(average)\n \n return averages\n\n# Test case\nassert average_tuple(((10, 10, 10, 12), (30, 45, 56, 45), (81, 80, 39, 32), (1, 2, 3, 4))) == [30.5, 34.25, 27.0, 23.25]\n```\n```\n\nThis script defines the `average_tuple` function which calculates and returns a list of averages for each tuple within the input tuple of tuples. The test case provided in the problem statement is used to verify that the function works correctly."}
{"task_id": "Mbpp/616", "solution": "Certainly! Below is a self-contained Python script that defines the function `tuple_modulo` to perform element-wise modulo operation on two tuples of the same length. The function will return a new tuple containing the results of each corresponding pair of elements from the input tuples.\n\n```python\ndef tuple_modulo(tuple1, tuple2):\n \"\"\"\n Perform element-wise modulo operation between two tuples.\n \n Parameters:\n - tuple1: A tuple of integers.\n - tuple2: A tuple of integers with the same length as tuple1.\n \n Returns:\n - A new tuple containing the results of element-wise modulo operations.\n \"\"\"\n # Ensure both tuples are of the same length\n if len(tuple1) != len(tuple2):\n raise ValueError(\"Both tuples must be of the same length.\")\n \n # Perform element-wise modulo and store in a list comprehension\n result = tuple(a % b for a, b in zip(tuple1, tuple2))\n \n return result\n\n# Test case to verify the function works as expected\nassert tuple_modulo((10, 4, 5, 6), (5, 6, 7, 5)) == (0, 4, 5, 1)\n\nprint(\"The function passed the test case.\")\n```\n\n### Explanation:\n- **Function Definition**: The `tuple_mododo` function takes two tuples as input.\n- **Length Check**: It first checks if both tuples have the same length. If not, it raises a `ValueError`.\n- **Element-wise Modulo**: Using a generator expression within a tuple constructor, it computes the modulo of each pair of elements from the two tuples using Python's built-in `zip` function.\n- **Return Value**: The result is returned as a new tuple containing the results of these operations.\n\nThe script includes an assertion to test that the function works correctly with the provided example. If the assertion passes, it prints a confirmation message."}
{"task_id": "Mbpp/618", "solution": "Certainly! Below is a self-contained Python script that defines a function `div_list` which divides two lists element-wise and includes an assertion to verify its correctness.\n\n```python\ndef div_list(list1, list2):\n \"\"\"\n Divides elements of list1 by corresponding elements in list2.\n \n Parameters:\n - list1: List of numbers (floats or integers).\n - list2: List of numbers (floats or integers) to divide by.\n \n Returns:\n - A new list containing the result of element-wise division.\n \n Raises:\n - ValueError: If the lists are not of the same length.\n - ZeroDivisionError: If any element in list2 is zero.\n \"\"\"\n if len(list1) != len(list2):\n raise ValueError(\"Both lists must have the same number of elements.\")\n \n result = []\n for a, b in zip(list1, list2):\n if b == 0:\n raise ZeroDivisionError(\"Cannot divide by zero.\")\n result.append(a / b)\n \n return result\n\n# Test case\nassert div_list([4, 5, 6], [1, 2, 3]) == [4.0, 2.5, 2.0]\n```\n\n### Explanation:\n\n- **Function Definition**: The function `div_list` takes two lists as input.\n- **Error Handling**:\n - It checks if both lists have the same length and raises a `ValueError` if they don't.\n - It also checks for division by zero in `list2` and raises a `ZeroDivisionError` if encountered.\n- **Element-wise Division**: The function uses a loop to iterate over pairs of elements from both lists, divides them, and appends the result to a new list.\n- **Assertion**: An assertion is included to verify that the function works as expected with the provided test case."}
{"task_id": "Mbpp/619", "solution": "```markdown\nHere's a Python script that solves the problem by moving all the numbers to the end of the given string:\n\n```python\ndef move_num(s):\n # Initialize two empty strings: one for non-numeric characters and one for numeric characters\n letters = ''\n digits = ''\n \n # Iterate over each character in the input string\n for char in s:\n if char.isdigit():\n # If the character is a digit, add it to the 'digits' string\n digits += char\n else:\n # Otherwise, add it to the 'letters' string\n letters += char\n \n # Concatenate the non-numeric and numeric parts and return the result\n return letters + digits\n\n# Test case\nassert move_num('I1love143you55three3000thousand') == 'Iloveyouthreethousand1143553000'\n```\n\n### Explanation:\n\n1. **Initialization**: We start by initializing two empty strings, `letters` and `digits`. These will hold the non-numeric characters and numeric characters from the input string, respectively.\n\n2. **Iteration**: We iterate over each character in the input string `s`.\n\n3. **Character Check**:\n - If a character is a digit (checked using `char.isdigit()`), it's appended to the `digits` string.\n - Otherwise, it's considered a non-numeric character and appended to the `letters` string.\n\n4. **Concatenation**: After processing all characters, we concatenate `letters` and `digits` to form the final result where all numbers are moved to the end of the string.\n\n5. **Assertion**: The function is tested with an assertion to ensure it produces the expected output for a given input.\n```\n\nThis script effectively separates numeric and non-numeric parts of the string and recombines them as required by the problem statement."}
{"task_id": "Mbpp/620", "solution": "To solve this problem, we need to find the largest subset of a given list where each pair of elements in the subset is such that one element divides the other. This can be approached using dynamic programming.\n\nHere's a step-by-step explanation and the corresponding Python code:\n\n1. **Sort the List**: Start by sorting the list. Sorting helps because if `a` divides `b`, then `a` must appear before `b` in the sorted list for any valid subset.\n\n2. **Dynamic Programming Array**: Use a dynamic programming array `dp` where `dp[i]` represents the size of the largest divisible subset ending with the element at index `i`.\n\n3. **Initialization**: Initialize each element of `dp` to 1 because the smallest subset containing just one number is always valid.\n\n4. **Nested Loop for Comparison**:\n - For each pair `(i, j)` where `j < i`, check if the number at index `i` is divisible by the number at index `j`.\n - If it is divisible, update `dp[i]` as `max(dp[i], dp[j] + 1)`. This means that if adding the current element to the subset ending at `j` forms a larger subset, then do so.\n\n5. **Result**: The result will be the maximum value in the `dp` array, which represents the largest divisible subset found.\n\nHere's the Python code implementing this logic:\n\n```python\ndef largest_subset(nums):\n if not nums:\n return 0\n\n # Sort the numbers\n nums.sort()\n \n # Initialize dp array where each element is initially a subset of size 1 (itself)\n dp = [1] * len(nums)\n \n # Fill the dp array\n for i in range(1, len(nums)):\n for j in range(i):\n if nums[i] % nums[j] == 0:\n dp[i] = max(dp[i], dp[j] + 1)\n \n # The largest subset size will be the maximum value in dp\n return max(dp)\n\n# Test case\nassert largest_subset([1, 3, 6, 13, 17, 18]) == 4\n```\n\n### Explanation of the Test Case:\n- For the list `[1, 3, 6, 13, 17, 18]`, one possible largest subset is `[1, 3, 6, 18]`.\n - `1` divides `3`\n - `3` divides `6`\n - `6` divides `18`\n\nThis subset has a size of 4, which matches the expected result."}
{"task_id": "Mbpp/622", "solution": "```markdown\nTo solve the problem of finding the median of two sorted lists of the same size, we can use a binary search approach to efficiently find the correct partition point between the two arrays. Here's how you can implement this in Python:\n\n```python\ndef get_median(list1, list2, n):\n if n <= 0:\n raise ValueError(\"Array sizes must be positive\")\n \n # Ensure that list1 is the smaller array for binary search\n if len(list1) > len(list2):\n return get_median(list2, list1, n)\n \n start = 0\n end = n - 1\n \n while start <= end:\n partition_list1 = (start + end) // 2\n partition_list2 = (n + start + end) // 2\n \n # Edge cases for partitions\n max_left_list1 = list1[partition_list1] if partition_list1 != -1 else float('-inf')\n min_right_list1 = list1[partition_list1 + 1] if partition_list1 + 1 < n else float('inf')\n \n max_left_list2 = list2[partition_list2] if partition_list2 != -1 else float('-inf')\n min_right_list2 = list2[partition_list2 + 1] if partition_list2 + 1 < n else float('inf')\n \n # Check if we have found the correct partition\n if max_left_list1 <= min_right_list2 and max_left_list2 <= min_right_list1:\n # If total number of elements is even\n if (n % 2 == 0):\n return (max(max_left_list1, max_left_list2) + min(min_right_list1, min_right_list2)) / 2.0\n else:\n return max(max_left_list1, max_left_list2)\n \n # Adjust the partition based on comparison\n elif max_left_list1 > min_right_list2:\n end = partition_list1 - 1\n else:\n start = partition_list1 + 1\n \n raise ValueError(\"Input arrays are not sorted or have different sizes\")\n\n# Test case\nassert get_median([1, 12, 15, 26, 38], [2, 13, 17, 30, 45], 5) == 16.0\n```\n\n### Explanation:\n\n1. **Binary Search Setup**: We perform a binary search on the smaller array (`list1`) to find the correct partition point.\n\n2. **Partition Calculation**:\n - `partition_list1` is calculated for `list1`.\n - `partition_list2` is derived from `partition_list1` such that the total number of elements on the left side of both partitions equals the total number on the right.\n\n3. **Edge Cases Handling**: \n - We handle cases where the partition might be at the start or end of an array by using `-inf` and `inf`.\n\n4. **Correct Partition Check**:\n - If the maximum element on the left side of both partitions is less than or equal to the minimum element on the right side, we have found the correct partition.\n\n5. **Median Calculation**:\n - For even-sized arrays, the median is the average of the maximum of the left elements and the minimum of the right elements.\n - For odd-sized arrays, it's simply the maximum of the left elements.\n\n6. **Adjusting Partitions**: \n - If the partition is incorrect, adjust `start` or `end` based on comparisons to find the correct partition.\n\nThis approach ensures an efficient O(log n) solution by leveraging binary search."}
{"task_id": "Mbpp/623", "solution": "Certainly! Below is a self-contained Python script that defines the function `nth_nums` to compute the n-th power of each number in a list. The function takes two arguments: a list of numbers and an integer `n`, which represents the power to raise each element of the list.\n\n```python\ndef nth_nums(numbers, n):\n \"\"\"\n Compute the n-th power of each number in a given list.\n \n Parameters:\n - numbers (list): A list of numerical values.\n - n (int): The power to which each number should be raised.\n \n Returns:\n - list: A new list containing each number from the input list raised to the n-th power.\n \"\"\"\n return [num ** n for num in numbers]\n\n# Test case\nassert nth_nums([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 2) == [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]\n```\n\n### Explanation:\n\n- **Function Definition**: The function `nth_nums` is defined to take two parameters: `numbers`, which is a list of numbers, and `n`, an integer representing the power.\n \n- **List Comprehension**: Inside the function, a list comprehension is used to iterate over each number in the input list `numbers`. For each number `num`, it computes `num ** n` (i.e., raises `num` to the power of `n`) and collects these results into a new list.\n\n- **Return Statement**: The newly constructed list containing the powered numbers is returned as the output of the function.\n\n- **Assertion for Testing**: An assertion is used to test that the function works correctly. It checks if calling `nth_nums([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 2)` returns `[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]`, which is the expected result when each number in the list is squared.\n\nThis script should work for any list of numbers and any integer power `n`."}
{"task_id": "Mbpp/624", "solution": "Certainly! Below is a self-contained Python script that defines a function `is_upper` which converts a given string to uppercase and includes an assertion to verify its correctness.\n\n```python\ndef is_upper(input_string):\n \"\"\"\n Convert the input string to uppercase.\n \n Parameters:\n input_string (str): The string to be converted to uppercase.\n \n Returns:\n str: The uppercase version of the input string.\n \"\"\"\n return input_string.upper()\n\n# Test case\nassert is_upper(\"person\") == \"PERSON\", \"Test failed!\"\n\nprint(\"All tests passed!\")\n```\n\nThis script defines a function `is_upper` that takes a single argument, `input_string`, and returns its uppercase equivalent using Python's built-in `.upper()` method. The assertion checks if the function correctly converts `\"person\"` to `\"PERSON\"`. If the test passes, it prints \"All tests passed!\"."}
{"task_id": "Mbpp/626", "solution": "Certainly! To solve this problem, we need to determine the area of the largest triangle that can be inscribed in a semicircle. The key insight is that the largest such triangle is a right-angled triangle with its hypotenuse as the diameter of the semicircle.\n\nHere's how you can implement this:\n\n```python\ndef triangle_area(radius):\n \"\"\"\n Calculate the area of the largest triangle that can be inscribed in a semicircle with a given radius.\n \n Parameters:\n radius (float): The radius of the semicircle.\n \n Returns:\n float: The area of the largest inscribed triangle, or None if the radius is invalid.\n \"\"\"\n # Check for invalid input\n if radius <= 0:\n return None\n \n # For a semicircle with radius r, the diameter (hypotenuse) is 2r.\n # The largest triangle that can be inscribed in a semicircle is a right-angled triangle\n # with its hypotenuse as the diameter of the semicircle.\n \n # Using the properties of a right-angled triangle:\n # If the hypotenuse is 2r, then the maximum area occurs when the triangle is an isosceles right triangle.\n # The legs of this triangle will each be r * sqrt(2).\n \n # Area of a right triangle = (1/2) * base * height\n # Here, both base and height are equal to r * sqrt(2)\n # So, area = (1/2) * (r * sqrt(2)) * (r * sqrt(2))\n # Simplifying, area = (1/2) * 2 * r^2 = r^2\n \n return radius ** 2\n\n# Test cases\nassert triangle_area(-1) == None\nassert triangle_area(0) == None\nassert triangle_area(1) == 1.0\nassert triangle_area(2) == 4.0\n```\n\n### Explanation:\n\n- The function `triangle_area` takes a single parameter, `radius`.\n- It first checks if the radius is less than or equal to zero. If so, it returns `None`, as a semicircle cannot have a non-positive radius.\n- For a valid radius, the largest triangle that can be inscribed in a semicircle is a right-angled triangle with its hypotenuse as the diameter of the semicircle.\n- The area of this triangle is calculated using the formula for the area of a right triangle: \\((1/2) \\times \\text{base} \\times \\text{height}\\).\n- In this case, both the base and height are equal to \\(r \\times \\sqrt{2}\\), leading to an area of \\(r^2\\).\n\nThis solution efficiently calculates the desired area using geometric properties."}
{"task_id": "Mbpp/628", "solution": "Certainly! Below is a self-contained Python script that defines and tests a function to replace all spaces in a given string with `%20`.\n\n```markdown\n```python\ndef replace_spaces(input_string):\n \"\"\"\n Replaces all spaces in the input string with '%20'.\n \n Parameters:\n input_string (str): The original string containing spaces.\n \n Returns:\n str: A new string where each space is replaced by '%20'.\n \"\"\"\n # Use the built-in `replace` method to replace spaces\n return input_string.replace(' ', '%20')\n\n# Test case\nassert replace_spaces(\"My Name is Dawood\") == 'My%20Name%20is%20Dawood'\n\nprint(\"All tests passed!\")\n```\n```\n\nThis script defines a function `replace_spaces` that takes an input string and returns a new string with all spaces replaced by `%20`. It uses Python's built-in `str.replace()` method to perform the replacement. The test case ensures that the function works as expected for the given example."}
{"task_id": "Mbpp/629", "solution": "```markdown\nHere's a self-contained Python script that defines a function `find_even_numbers` to extract even numbers from a given list. The function is then tested with an assertion as specified:\n\n```python\ndef find_even_numbers(numbers):\n \"\"\"\n This function takes a list of numbers and returns a new list containing only the even numbers.\n \n Parameters:\n numbers (list): A list of integers.\n\n Returns:\n list: A list containing only the even numbers from the input list.\n \"\"\"\n # Use a list comprehension to filter out even numbers\n even_numbers = [num for num in numbers if num % 2 == 0]\n return even_numbers\n\n# Test the function with an assertion\nassert find_even_numbers([1, 2, 3, 4, 5]) == [2, 4], \"The function did not return the expected result.\"\n\nprint(\"Test passed! The function works as expected.\")\n```\n\n### Explanation:\n- **Function Definition**: `find_even_numbers` takes a list of integers as input.\n- **List Comprehension**: It uses a list comprehension to iterate over each number in the list and checks if it is even (`num % 2 == 0`). If true, it includes that number in the resulting list.\n- **Assertion**: The function is tested with an assertion to ensure it returns `[2, 4]` when given the input `[1, 2, 3, 4, 5]`.\n- **Output**: If the test passes, a confirmation message is printed.\n\nThis script ensures that the function behaves as expected and can be easily extended or modified for similar tasks."}
{"task_id": "Mbpp/630", "solution": "Certainly! Below is a self-contained Python script that defines the function `get_coordinates` to extract all adjacent coordinates of a given coordinate tuple. The function considers both orthogonal and diagonal neighbors in a 2D grid.\n\n```python\ndef get_coordinates(coord):\n \"\"\"\n Extracts all adjacent coordinates (including diagonals) for a given coordinate tuple.\n \n Parameters:\n coord (tuple): A tuple representing the x, y coordinates on a 2D grid.\n \n Returns:\n list: A list of lists where each sublist represents an adjacent coordinate.\n \"\"\"\n x, y = coord\n # Define all possible moves to get adjacent cells including diagonals\n directions = [\n (-1, -1), (-1, 0), (-1, 1),\n (0, -1), (0, 1),\n (1, -1), (1, 0), (1, 1)\n ]\n \n # Calculate adjacent coordinates\n adjacent_coords = [[x + dx, y + dy] for dx, dy in directions]\n \n return adjacent_coords\n\n# Test the function with an assertion\nassert get_coordinates((3, 4)) == [[2, 3], [2, 4], [2, 5], [3, 3], [3, 4], [3, 5], [4, 3], [4, 4], [4, 5]]\n```\n\n### Explanation:\n\n- **Function Definition**: The function `get_coordinates` takes a tuple `coord` as input, representing the x and y coordinates on a grid.\n \n- **Directions List**: We define a list of tuples called `directions`, where each tuple represents a possible move from the current coordinate to an adjacent one. This includes all eight possible directions: up-left, up, up-right, left, right, down-left, down, and down-right.\n\n- **List Comprehension**: Using a list comprehension, we iterate over each direction in `directions`, calculate the new coordinates by adding the direction offsets `(dx, dy)` to the original coordinates `(x, y)`, and store these as lists within `adjacent_coords`.\n\n- **Return Statement**: The function returns the list of adjacent coordinates.\n\n- **Assertion**: Finally, we use an assertion to verify that the function works correctly for the input `(3, 4)`. This ensures that the output matches the expected result."}
{"task_id": "Mbpp/631", "solution": "Certainly! Below is a self-contained Python script that defines the `replace_spaces` function. This function takes a string as input and replaces all whitespaces with underscores, and vice versa.\n\n```python\ndef replace_spaces(s):\n \"\"\"\n Replace all spaces in the given string with underscores,\n and all underscores with spaces.\n \n Args:\n s (str): The input string to be transformed.\n \n Returns:\n str: A new string with spaces replaced by underscores and vice versa.\n \"\"\"\n # Use a list comprehension to iterate over each character\n result = ''.join(['_' if char == ' ' else ' ' if char == '_' else char for char in s])\n return result\n\n# Test the function with an assertion\nassert replace_spaces('Jumanji The Jungle') == 'Jumanji_The_Jungle'\n```\n\n### Explanation:\n\n- **List Comprehension**: We use a list comprehension to iterate over each character in the input string `s`.\n - If the character is a space `' '`, it gets replaced with an underscore `'_'`.\n - If the character is an underscore `'_'`, it gets replaced with a space `' '`.\n - Otherwise, the character remains unchanged.\n- **`join()` Method**: We use `''.join(...)` to concatenate all characters in the list back into a single string.\n\nThis function effectively swaps spaces and underscores while leaving other characters intact. The provided assertion checks that the function works as expected for the given test case."}
{"task_id": "Mbpp/632", "solution": "Certainly! Below is a self-contained Python script that defines a function `move_zero` which moves all zeroes in a list to the end while maintaining the order of non-zero elements. The script also includes an assertion to verify its correctness.\n\n```markdown\n```python\ndef move_zero(lst):\n \"\"\"\n Moves all zeroes in the given list to the end, preserving the order of non-zero elements.\n \n Parameters:\n lst (list): A list of integers which may contain zero or more zeroes.\n \n Returns:\n list: The modified list with all zeroes moved to the end.\n \"\"\"\n # Count the number of zeros\n zero_count = lst.count(0)\n \n # Create a new list excluding all zeros\n non_zero_list = [x for x in lst if x != 0]\n \n # Append the counted zeros at the end of the non-zero list\n result = non_zero_list + [0] * zero_count\n \n return result\n\n# Test case to verify the function works as expected\nassert move_zero([1, 0, 2, 0, 3, 4]) == [1, 2, 3, 4, 0, 0]\n\nprint(\"All tests passed!\")\n```\n```\n\nThis script defines a `move_zero` function that first counts the number of zeroes in the list. It then creates a new list containing only non-zero elements and appends the counted zeroes to this list. The assertion checks if the function works correctly for the provided test case."}
{"task_id": "Mbpp/633", "solution": "```markdown\nTo solve this problem, we need to calculate the sum of XOR for all possible pairs of numbers from a given list. The function `pair_xor_sum` will take two arguments: a list of integers and an integer `n`, which represents the number of elements in the list.\n\nHere's how you can implement the solution:\n\n```python\ndef pair_xor_sum(arr, n):\n # Initialize sum to 0\n xor_sum = 0\n \n # Iterate over all pairs (i, j) where i < j\n for i in range(n):\n for j in range(i + 1, n):\n # Calculate XOR of the pair and add it to the sum\n xor_sum += arr[i] ^ arr[j]\n \n return xor_sum\n\n# Test case\nassert pair_xor_sum([5, 9, 7, 6], 4) == 47\n```\n\n### Explanation:\n\n1. **Initialization**: Start with `xor_sum` set to 0.\n\n2. **Nested Loops**: Use two nested loops to iterate over all unique pairs `(i, j)` where `i < j`. This ensures each pair is considered only once.\n\n3. **XOR Calculation**: For each pair `(arr[i], arr[j])`, compute the XOR using the `^` operator and add the result to `xor_sum`.\n\n4. **Return Result**: After all pairs have been processed, return the accumulated `xor_sum`.\n\nThis approach efficiently computes the desired sum by considering each pair exactly once, ensuring correctness and clarity.\n```"}
{"task_id": "Mbpp/635", "solution": "Certainly! Below is a self-contained Python script that implements the `heap_sort` function to sort a given list using the heap sort algorithm. The script includes an assertion to verify that the function works correctly.\n\n```markdown\n```python\ndef heapify(arr, n, i):\n \"\"\"\n Helper function to maintain the heap property.\n \n :param arr: List of elements\n :param n: Size of the heap\n :param i: Index of the current node\n \"\"\"\n largest = i # Initialize largest as root\n left = 2 * i + 1 # Left child index\n right = 2 * i + 2 # Right child index\n\n # Check if left child exists and is greater than root\n if left < n and arr[i] < arr[left]:\n largest = left\n\n # Check if right child exists and is greater than the current largest\n if right < n and arr[largest] < arr[right]:\n largest = right\n\n # Change root, if needed\n if largest != i:\n arr[i], arr[largest] = arr[largest], arr[i] # Swap\n\n # Recursively heapify the affected sub-tree\n heapify(arr, n, largest)\n\ndef heap_sort(arr):\n \"\"\"\n Function to perform heap sort on a list.\n \n :param arr: List of elements to be sorted\n :return: Sorted list\n \"\"\"\n n = len(arr)\n\n # Build a maxheap\n for i in range(n // 2 - 1, -1, -1):\n heapify(arr, n, i)\n\n # Extract elements one by one from the heap\n for i in range(n-1, 0, -1):\n arr[i], arr[0] = arr[0], arr[i] # Swap\n heapify(arr, i, 0)\n \n return arr\n\n# Test case to verify the function works correctly\nassert heap_sort([1, 3, 5, 7, 9, 2, 4, 6, 8, 0]) == [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n```\n```\n\nThis script defines two functions: `heapify` and `heap_sort`. The `heapify` function ensures that the subtree rooted at an index maintains the heap property. The `heap_sort` function builds a max-heap from the input list and then repeatedly extracts the maximum element to sort the list in ascending order. The assertion checks if the sorted output matches the expected result."}
{"task_id": "Mbpp/637", "solution": "Certainly! Below is a self-contained Python script that defines a function `noprofit_noloss` to determine if there's neither profit nor loss based on the given cost price and selling price. The function returns `True` if there's no profit or loss, otherwise it returns `False`.\n\n```python\ndef noprofit_noloss(cost_price, selling_price):\n \"\"\"\n Check whether the transaction results in no profit and no loss.\n\n Parameters:\n - cost_price (float): The original price of the item.\n - selling_price (float): The price at which the item is sold.\n\n Returns:\n - bool: True if there's no profit or loss, False otherwise.\n \"\"\"\n # Calculate the difference between selling price and cost price\n difference = selling_price - cost_price\n \n # Check if the difference is zero\n if difference == 0:\n return True\n else:\n return False\n\n# Test case\nassert noprofit_noloss(1500, 1200) == False\n```\n\n### Explanation:\n\n- **Parameters**: The function takes two parameters: `cost_price` and `selling_price`.\n- **Logic**:\n - It calculates the difference between the selling price and the cost price.\n - If this difference is zero, it means there's no profit or loss, so the function returns `True`.\n - Otherwise, it returns `False`, indicating either a profit or a loss.\n- **Test Case**: The provided test case checks if the function correctly identifies that selling an item at 1200 when its cost price is 1500 results in a loss (hence, not no profit and no loss)."}
{"task_id": "Mbpp/638", "solution": "Certainly! Below is a self-contained Python script that calculates the wind chill index based on the provided wind velocity (in km/h) and temperature (in Celsius). The result is rounded to the nearest integer.\n\n```python\ndef wind_chill(wind_velocity, temperature):\n \"\"\"\n Calculate the wind chill index given the wind velocity in km/h and a temperature in celsius.\n \n Parameters:\n - wind_velocity: float, wind speed in kilometers per hour (km/h)\n - temperature: float, air temperature in degrees Celsius\n \n Returns:\n - int, wind chill index rounded to the nearest integer\n \"\"\"\n if wind_velocity < 4.8 or temperature > 10:\n # Wind chill is not defined for these conditions\n return round(temperature)\n\n # Convert wind velocity from km/h to m/s\n wind_speed_m_s = wind_velocity * 1000 / 3600\n\n # Calculate the wind chill index using the formula\n wind_chill_index = 13.12 + 0.6215 * temperature - 11.37 * (wind_speed_m_s ** 0.16) + \\\n 0.3965 * temperature * (wind_speed_m_s ** 0.16)\n\n # Return the result rounded to the nearest integer\n return round(wind_chill_index)\n\n# Example usage and assertion\nassert wind_chill(120, 35) == 40\n\nprint(\"Wind chill calculation is correct.\")\n```\n\n### Explanation:\n\n1. **Input Conditions**: The function first checks if the wind velocity is less than 4.8 km/h or if the temperature is above 10\u00b0C. In these cases, the wind chill index is not typically calculated, so it simply returns the rounded temperature.\n\n2. **Conversion**: Wind speed is converted from kilometers per hour to meters per second because the formula for calculating wind chill uses m/s.\n\n3. **Wind Chill Formula**: The formula used here is a standard one for calculating the wind chill index in Celsius:\n \\[\n WCI = 13.12 + 0.6215T - 11.37(V^{0.16}) + 0.3965T(V^{0.16})\n \\]\n where \\( T \\) is the temperature in Celsius and \\( V \\) is the wind speed in meters per second.\n\n4. **Rounding**: The result of the calculation is rounded to the nearest integer using Python's built-in `round()` function.\n\nThis script includes an assertion to verify that the function works as expected for a specific test case (`wind_chill(120, 35)` should return `40`)."}
{"task_id": "Mbpp/639", "solution": "Certainly! Below is a self-contained Python script that solves the problem described. The function `sum_length_of_names` takes a list of names, removes those starting with a lowercase letter, and returns the sum of the lengths of the remaining names.\n\n```python\ndef sum_length_of_names(names):\n \"\"\"\n This function takes a list of names and returns the sum of the lengths \n of the names that do not start with a lowercase letter.\n \n Parameters:\n names (list): A list of strings representing names.\n \n Returns:\n int: The sum of the lengths of the valid names.\n \"\"\"\n # Filter out names starting with a lowercase letter\n filtered_names = [name for name in names if name[0].isupper()]\n \n # Calculate the total length of the remaining names\n total_length = sum(len(name) for name in filtered_names)\n \n return total_length\n\n# Test case\nassert sum_length_of_names(['sally', 'Dylan', 'rebecca', 'Diana', 'Joanne', 'keith']) == 16\n```\n\n### Explanation:\n\n1. **Filtering Names**: We use a list comprehension to filter out names that start with a lowercase letter. The condition `name[0].isupper()` checks if the first character of each name is uppercase.\n\n2. **Calculating Total Length**: After filtering, we calculate the total length of the remaining names using another list comprehension combined with the `sum` function.\n\n3. **Assertion**: We include an assertion to verify that the function works as expected for the given test case."}
{"task_id": "Mbpp/641", "solution": "```markdown\nTo solve the problem of finding the nth nonagonal number, we need to understand what a nonagonal number is. A nonagonal number is a figurate number that represents a nonagon (a nine-sided polygon). The formula for the nth nonagonal number is given by:\n\n\\[ N(n) = \\frac{n(7n - 5)}{2} \\]\n\nThis formula can be derived from the general formula for polygonal numbers. For a polygon with \\( s \\) sides, the formula for the nth s-gonal number is:\n\n\\[ P(s, n) = \\frac{(s-2)n^2 - (s-4)n}{2} \\]\n\nFor nonagonal numbers, \\( s = 9 \\). Plugging this into the formula gives us:\n\n\\[ N(n) = \\frac{(9-2)n^2 - (9-4)n}{2} = \\frac{7n^2 - 5n}{2} \\]\n\nNow, let's implement a Python function to calculate the nth nonagonal number using this formula.\n\n```python\ndef is_nonagonal(n):\n \"\"\"\n Calculate the nth nonagonal number.\n \n Args:\n n (int): The position in the sequence of nonagonal numbers.\n \n Returns:\n int: The nth nonagonal number.\n \"\"\"\n return (n * (7 * n - 5)) // 2\n\n# Test case\nassert is_nonagonal(10) == 325\n```\n\nThis function `is_nonagonal` takes an integer \\( n \\) and returns the nth nonagonal number using the derived formula. The test case checks if the 10th nonagonal number is indeed 325, which it should be according to the formula.\n```"}
{"task_id": "Mbpp/643", "solution": "Certainly! Below is a self-contained Python script that defines a function to solve the problem described. The function `text_match_wordz_middle` checks if a given string contains the character 'z', but not at the start or end of the word.\n\n```python\ndef text_match_wordz_middle(s):\n \"\"\"\n Check if the string s contains 'z' except at the start and end.\n \n Parameters:\n s (str): The input string to check.\n \n Returns:\n bool: True if 'z' is found in the middle of the word, False otherwise.\n \"\"\"\n # Remove leading and trailing whitespace\n s = s.strip()\n \n # Check if 'z' is present in the string excluding the first and last character\n return 'z' in s[1:-1]\n\n# Test case\nassert text_match_wordz_middle(\"pythonzabc.\") == True\n\n# Additional test cases for verification\nprint(text_match_wordz_middle(\"zstart\")) # Expected: False, 'z' is at the start\nprint(text_match_wordz_middle(\"endz\")) # Expected: False, 'z' is at the end\nprint(text_match_wordz_middle(\"nozhere\")) # Expected: False, no 'z' in the middle\nprint(text_match_wordz_middle(\"zmiddlez\"))# Expected: True, 'z' is in the middle\n```\n\n### Explanation:\n- The function `text_match_wordz_middle` takes a string `s` as input.\n- It first strips any leading or trailing whitespace from the string to ensure accurate checking.\n- It then checks if 'z' exists within the substring that excludes the first and last characters (`s[1:-1]`).\n- If 'z' is found in this middle section, it returns `True`; otherwise, it returns `False`.\n- The function includes a test case as specified, along with additional cases to demonstrate its functionality."}
{"task_id": "Mbpp/644", "solution": "Certainly! Below is a self-contained Python script that defines the function `reverse_Array_Upto_K` to reverse an array up to a given position. The function takes two arguments: the list `arr` and the integer `k`, which specifies the position up to which the array should be reversed.\n\n```python\ndef reverse_Array_Upto_K(arr, k):\n \"\"\"\n Reverses the elements of the array 'arr' up to the index 'k'.\n \n Parameters:\n arr (list): The list of integers to be partially reversed.\n k (int): The position up to which the array should be reversed.\n\n Returns:\n list: A new list with elements reversed up to the specified position.\n \"\"\"\n # Ensure that k is within the bounds of the array\n if k < 0 or k > len(arr):\n raise ValueError(\"k must be between 0 and the length of the array\")\n\n # Reverse the portion of the array from start to k (inclusive)\n reversed_part = arr[:k+1][::-1]\n \n # Concatenate the reversed part with the rest of the array\n result = reversed_part + arr[k+1:]\n \n return result\n\n# Test case\nassert reverse_Array_Upto_K([1, 2, 3, 4, 5, 6], 4) == [4, 3, 2, 1, 5, 6]\n```\n\n### Explanation:\n- The function first checks if `k` is within the valid range. If not, it raises a `ValueError`.\n- It then slices the array from the start to index `k` (inclusive) and reverses this slice using Python's slicing syntax `[::-1]`.\n- Finally, it concatenates the reversed part with the remaining portion of the original array starting from index `k+1`.\n\nThis script includes a test case that verifies the function works as expected."}
{"task_id": "Mbpp/720", "solution": "Certainly! Below is a self-contained Python script that defines the function `add_dict_to_tuple` to solve the problem described. The function takes a tuple and a dictionary as inputs and returns a new tuple with the dictionary added as its last element.\n\n```python\ndef add_dict_to_tuple(tpl, dct):\n \"\"\"\n Adds a dictionary to the end of a tuple and returns a new tuple.\n \n Parameters:\n tpl (tuple): The original tuple.\n dct (dict): The dictionary to be added to the tuple.\n \n Returns:\n tuple: A new tuple with the dictionary appended.\n \"\"\"\n # Convert the input tuple to a list to allow modification\n temp_list = list(tpl)\n # Append the dictionary to the list\n temp_list.append(dct)\n # Convert the list back to a tuple and return it\n return tuple(temp_list)\n\n# Test case\nassert add_dict_to_tuple((4, 5, 6), {\"MSAM\": 1, \"is\": 2, \"best\": 3}) == (4, 5, 6, {'MSAM': 1, 'is': 2, 'best': 3})\n```\n\n### Explanation:\n- **Function Definition**: The function `add_dict_to_tuple` is defined to take two parameters: a tuple (`tpl`) and a dictionary (`dct`).\n- **Conversion to List**: Since tuples are immutable in Python, we first convert the input tuple into a list. This allows us to modify it by appending elements.\n- **Appending Dictionary**: The dictionary is appended to this list using the `append()` method.\n- **Conversion Back to Tuple**: After modifying the list, it is converted back to a tuple using the `tuple()` constructor.\n- **Return Statement**: Finally, the new tuple is returned.\n\nThe provided test case ensures that the function works as expected by asserting that the output matches the desired result."}
{"task_id": "Mbpp/721", "solution": "Here's a Python script that solves the problem using dynamic programming to find the path with the maximum average cost in an \\(N \\times N\\) matrix:\n\n```markdown\n```python\ndef maxAverageOfPath(matrix):\n n = len(matrix)\n \n # dp[i][j] will store the maximum sum of costs from (0, 0) to (i, j)\n dp = [[0] * n for _ in range(n)]\n \n # Initialize the starting point\n dp[0][0] = matrix[0][0]\n \n # Fill the first row (can only come from the left)\n for j in range(1, n):\n dp[0][j] = dp[0][j-1] + matrix[0][j]\n \n # Fill the first column (can only come from above)\n for i in range(1, n):\n dp[i][0] = dp[i-1][0] + matrix[i][0]\n \n # Fill the rest of the dp table\n for i in range(1, n):\n for j in range(1, n):\n dp[i][j] = max(dp[i-1][j], dp[i][j-1]) + matrix[i][j]\n \n # The maximum sum path ends at (n-1, n-1)\n max_sum = dp[n-1][n-1]\n \n # Number of cells in the longest path from (0, 0) to (n-1, n-1) is always 2*n - 1\n num_cells = 2 * n - 1\n \n # Calculate the maximum average\n max_average = max_sum / num_cells\n \n return max_average\n\n# Test case\nassert maxAverageOfPath([[1, 2, 3], [6, 5, 4], [7, 3, 9]]) == 5.2\n```\n```\n\n### Explanation:\n\n- **Dynamic Programming Table (`dp`)**: We use a 2D list `dp` where `dp[i][j]` stores the maximum sum of costs from the top-left corner `(0, 0)` to cell `(i, j)`.\n \n- **Initialization**:\n - Start by setting `dp[0][0]` to `matrix[0][0]` because that's our starting point.\n - Fill in the first row and first column since they can only be reached from one direction (left for the first row, up for the first column).\n\n- **Filling the DP Table**:\n - For each cell `(i, j)`, calculate `dp[i][j]` as the maximum of coming from the top (`dp[i-1][j]`) or from the left (`dp[i][j-1]`), plus the cost at `matrix[i][j]`.\n\n- **Result Calculation**:\n - The path with the maximum sum ends at `dp[n-1][n-1]`.\n - The number of cells in any path from `(0, 0)` to `(n-1, n-1)` is always \\(2n - 1\\) because you make exactly \\(n-1\\) moves down and \\(n-1\\) moves right.\n - Compute the maximum average by dividing `max_sum` by `num_cells`.\n\nThis approach efficiently computes the desired path with a time complexity of \\(O(N^2)\\)."}
{"task_id": "Mbpp/722", "solution": "Here's a self-contained Python script that solves the problem described:\n\n```python\ndef filter_data(students, min_height, min_weight):\n \"\"\"\n Filters students based on minimum height and weight.\n\n Parameters:\n - students: A dictionary with student names as keys and tuples of (height, weight) as values.\n - min_height: The minimal acceptable height.\n - min_weight: The minimal acceptable weight.\n\n Returns:\n - A dictionary containing only the students who meet or exceed both the minimum height and weight.\n \"\"\"\n filtered_students = {}\n \n for name, (height, weight) in students.items():\n if height >= min_height and weight >= min_weight:\n filtered_students[name] = (height, weight)\n \n return filtered_students\n\n# Test case\nassert filter_data(\n {'Cierra Vega': (6.2, 70), 'Alden Cantrell': (5.9, 65), 'Kierra Gentry': (6.0, 68), 'Pierre Cox': (5.8, 66)},\n 6.0,\n 70\n) == {'Cierra Vega': (6.2, 70)}\n```\n\nThis script defines a function `filter_data` that takes a dictionary of students with their heights and weights, along with minimum height and weight thresholds. It returns a new dictionary containing only those students who meet or exceed both the specified height and weight criteria. The provided test case verifies that the function works as expected."}
{"task_id": "Mbpp/723", "solution": "Here's a self-contained Python script that solves the problem of counting indices where two lists have the same values:\n\n```python\ndef count_same_pair(list1, list2):\n \"\"\"\n Counts the number of indices where the elements in both lists are equal.\n\n Parameters:\n list1 (list): The first list of integers.\n list2 (list): The second list of integers.\n\n Returns:\n int: The count of indices with the same values in both lists.\n \"\"\"\n # Ensure both lists have the same length\n if len(list1) != len(list2):\n raise ValueError(\"Both lists must be of the same length.\")\n \n # Initialize a counter for matching indices\n count = 0\n \n # Iterate over the indices and elements of the first list\n for i, value in enumerate(list1):\n # Check if the element at the current index is the same in both lists\n if value == list2[i]:\n count += 1\n \n return count\n\n# Test case\nassert count_same_pair([1, 2, 3, 4, 5, 6, 7, 8], [2, 2, 3, 1, 2, 6, 7, 9]) == 4\n```\n\nThis script defines a function `count_same_pair` that takes two lists as input and returns the count of indices where both lists have the same value. It includes a test case to verify its correctness."}
{"task_id": "Mbpp/724", "solution": "Certainly! Below is a self-contained Python script that defines a function `power_base_sum` which calculates the sum of all digits of a given base raised to a specified power. The function takes two arguments: `base` and `power`. It computes \\( \\text{base}^{\\text{power}} \\), converts the result into a string, iterates over each character (digit) in the string, converts it back to an integer, and sums these integers.\n\n```python\ndef power_base_sum(base, power):\n \"\"\"\n Calculate the sum of all digits of base raised to the specified power.\n \n Parameters:\n - base: The base number as an integer.\n - power: The exponent as an integer.\n \n Returns:\n - An integer representing the sum of the digits of base^power.\n \"\"\"\n # Compute base raised to the power\n result = base ** power\n \n # Convert the result to a string to iterate over each digit\n result_str = str(result)\n \n # Initialize the sum of digits\n digit_sum = 0\n \n # Iterate over each character in the string representation of the number\n for char in result_str:\n # Convert the character back to an integer and add it to the sum\n digit_sum += int(char)\n \n return digit_sum\n\n# Example usage with assertion as per the problem statement\nassert power_base_sum(2, 100) == 115\n```\n\nThis script defines the function `power_base_sum` which performs the required calculation. The example usage includes an assertion to verify that the function works correctly for the given test case \\(2^{100}\\), where the sum of digits is expected to be 115."}
{"task_id": "Mbpp/725", "solution": "Certainly! Below is a self-contained Python script that defines a function to extract values between quotation marks from a given string. The function uses regular expressions to find all substrings enclosed in double quotes and returns them as a list.\n\n```python\nimport re\n\ndef extract_quotation(s):\n \"\"\"\n Extracts values between quotation marks from the given string.\n \n Parameters:\n s (str): Input string containing text with quoted segments.\n \n Returns:\n list: A list of strings found within quotation marks in the input string.\n \"\"\"\n # Use regular expression to find all substrings enclosed in double quotes\n matches = re.findall(r'\"(.*?)\"', s)\n return matches\n\n# Test case\nassert extract_quotation('Cortex \"A53\" Based \"multi\" tasking \"Processor\"') == ['A53', 'multi', 'Processor']\n```\n\n### Explanation:\n\n- **Regular Expression**: The pattern `r'\"(.*?)\"'` is used to match any text enclosed in double quotes.\n - `\"`: Matches the literal double quote character.\n - `(.*?)`: A non-greedy match for any characters inside the quotes. The parentheses capture this part as a group.\n - `\"`: Matches the closing double quote.\n\n- **`re.findall()`**: This function returns all non-overlapping matches of the pattern in the string, as a list of strings. Each string corresponds to one set of matched parentheses in the pattern.\n\nThis script will correctly extract and return the values between quotation marks from the input string."}
{"task_id": "Mbpp/726", "solution": "```markdown\nHere's a Python script that defines and tests the function `multiply_elements` as described in your problem statement:\n\n```python\ndef multiply_elements(t):\n \"\"\"\n This function takes a tuple of numbers (t_1,...,t_{N+1}) and returns a new tuple \n of length N where each element is the product of consecutive elements from the input tuple.\n \n Parameters:\n t (tuple): A tuple containing N+1 numerical elements.\n\n Returns:\n tuple: A tuple of length N with products of consecutive elements.\n \"\"\"\n # Using list comprehension to multiply consecutive elements\n result = tuple(t[i] * t[i + 1] for i in range(len(t) - 1))\n \n return result\n\n# Test the function with the provided example\nassert multiply_elements((1, 5, 7, 8, 10)) == (5, 35, 56, 80)\n\nprint(\"The function works correctly!\")\n```\n\n### Explanation:\n\n- **Function Definition**: The `multiply_elements` function takes a tuple `t` as input.\n \n- **List Comprehension**: It uses list comprehension to iterate over the indices of the tuple from `0` to `len(t) - 2`. For each index `i`, it calculates the product `t[i] * t[i + 1]`.\n\n- **Tuple Conversion**: The result of the list comprehension is converted into a tuple, which is then returned.\n\n- **Assertion Test**: An assertion checks if the function returns the expected output for the input `(1, 5, 7, 8, 10)`, ensuring correctness.\n\n- **Print Statement**: A print statement confirms that the function works as intended when no assertion error occurs.\n```"}
{"task_id": "Mbpp/728", "solution": "Certainly! Below is a self-contained Python script that defines the function `sum_list` to solve the problem described. The function takes two lists as input and returns a new list where each element is the sum of the corresponding elements from the input lists.\n\n```python\ndef sum_list(list1, list2):\n \"\"\"\n Takes two lists of numbers and returns a new list containing the element-wise sums.\n \n Parameters:\n - list1: A list of numbers [a_1,...,a_n]\n - list2: A list of numbers [b_1,...,b_n]\n\n Returns:\n - A list where each element is the sum of the corresponding elements from list1 and list2.\n \"\"\"\n # Ensure both lists are of the same length\n if len(list1) != len(list2):\n raise ValueError(\"Both lists must have the same number of elements\")\n \n # Use a list comprehension to add corresponding elements\n return [a + b for a, b in zip(list1, list2)]\n\n# Test case as per the problem statement\nassert sum_list([10, 20, 30], [15, 25, 35]) == [25, 45, 65]\n\nprint(\"The function works correctly!\")\n```\n\n### Explanation:\n- **Function Definition**: The `sum_list` function is defined to take two lists as arguments.\n- **Input Validation**: It checks if both input lists have the same length. If not, it raises a `ValueError`.\n- **Element-wise Summation**: Using Python's built-in `zip` function, we iterate over pairs of elements from both lists and compute their sum using a list comprehension.\n- **Assertion Test**: The script includes an assertion to verify that the function works as expected with the provided test case.\n\nThis code will print \"The function works correctly!\" if the assertion passes, indicating that the function behaves as intended."}
{"task_id": "Mbpp/730", "solution": "Here's a Python script that defines the function `consecutive_duplicates` to remove consecutive duplicates from a list:\n\n```python\ndef consecutive_duplicates(lst):\n \"\"\"\n Remove consecutive duplicates from a given list.\n\n Parameters:\n lst (list): The input list with potential consecutive duplicates.\n\n Returns:\n list: A new list with consecutive duplicates removed.\n \"\"\"\n if not lst:\n return []\n\n # Initialize the result list with the first element\n result = [lst[0]]\n\n # Iterate over the list starting from the second element\n for i in range(1, len(lst)):\n # If the current element is different from the last added to result, append it\n if lst[i] != lst[i - 1]:\n result.append(lst[i])\n\n return result\n\n# Test case\nassert consecutive_duplicates([0, 0, 1, 2, 3, 4, 4, 5, 6, 6, 6, 7, 8, 9, 4, 4]) == [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 4]\n```\n\nThis function iterates through the list and appends elements to a new list only if they are not equal to the previous element. This effectively removes consecutive duplicates while preserving the order of non-duplicate elements."}
{"task_id": "Mbpp/731", "solution": "To solve this problem, we need to calculate the lateral surface area of a cone. The formula for the lateral surface area \\( A \\) of a cone is given by:\n\n\\[ A = \\pi r l \\]\n\nwhere:\n- \\( r \\) is the radius of the base of the cone,\n- \\( l \\) is the slant height of the cone.\n\nThe slant height \\( l \\) can be calculated using the Pythagorean theorem in the right triangle formed by the radius, the height, and the slant height:\n\n\\[ l = \\sqrt{r^2 + h^2} \\]\n\nwhere:\n- \\( h \\) is the vertical height of the cone.\n\nLet's implement this in a Python function:\n\n```python\nimport math\n\ndef lateralsurface_cone(r, h):\n # Calculate the slant height using the Pythagorean theorem\n l = math.sqrt(r**2 + h**2)\n \n # Calculate the lateral surface area\n lateral_surface_area = math.pi * r * l\n \n return lateral_surface_area\n\n# Test case\nassert lateralsurface_cone(5, 12) == 204.20352248333654\n```\n\nThis function first calculates the slant height \\( l \\) using the Pythagorean theorem and then computes the lateral surface area using the formula provided. The test case checks if the function returns the expected result for given inputs."}
{"task_id": "Mbpp/732", "solution": "Certainly! Below is a self-contained Python script that defines the `replace_specialchar` function. This function replaces all occurrences of spaces, commas, and dots in a given string with colons.\n\n```python\ndef replace_specialchar(input_string):\n \"\"\"\n Replaces all occurrences of spaces, commas, or dots with a colon.\n \n Parameters:\n input_string (str): The string to be processed.\n \n Returns:\n str: A new string with specified characters replaced by colons.\n \"\"\"\n # Define the characters to replace\n chars_to_replace = [' ', ',', '.']\n \n # Replace each character in the list with a colon\n for char in chars_to_replace:\n input_string = input_string.replace(char, ':')\n \n return input_string\n\n# Test case\nassert replace_specialchar('Python language, Programming language.') == 'Python:language::Programming:language:'\n```\n\nThis script includes a function `replace_specialchar` that takes an input string and replaces spaces, commas, and dots with colons. The test case at the end verifies that the function works as expected by using an assertion."}
{"task_id": "Mbpp/733", "solution": "Certainly! Below is a self-contained Python script that defines the function `find_first_occurrence` to find the index of the first occurrence of a given number in a sorted array. The function uses binary search for efficient searching.\n\n```python\ndef find_first_occurrence(arr, target):\n \"\"\"\n Find the index of the first occurrence of a given number in a sorted array.\n \n Parameters:\n arr (list): A list of integers sorted in non-decreasing order.\n target (int): The integer to find in the array.\n \n Returns:\n int: The index of the first occurrence of the target, or -1 if not found.\n \"\"\"\n left, right = 0, len(arr) - 1\n result = -1\n \n while left <= right:\n mid = (left + right) // 2\n \n # Check if we have found the target\n if arr[mid] == target:\n result = mid\n right = mid - 1 # Move left to find the first occurrence\n elif arr[mid] < target:\n left = mid + 1\n else:\n right = mid - 1\n \n return result\n\n# Test case\nassert find_first_occurrence([2, 5, 5, 5, 6, 6, 8, 9, 9, 9], 5) == 1\n```\n\nThis script defines the `find_first_occurrence` function and includes a test case to verify its correctness. The binary search approach ensures that the solution is efficient with a time complexity of \\(O(\\log n)\\)."}
{"task_id": "Mbpp/734", "solution": "```markdown\nTo solve this problem, we need to calculate the sum of products of all possible sublists (subarrays) of a given list. Here's how you can implement this in Python:\n\n```python\ndef sum_Of_Subarray_Prod(arr):\n n = len(arr)\n total_sum = 0\n \n # Iterate over each element as the starting point of the sublist\n for i in range(n):\n current_product = 1\n \n # Extend the sublist to include elements from the start index 'i' to end of the list\n for j in range(i, n):\n current_product *= arr[j]\n total_sum += current_product\n \n return total_sum\n\n# Test case\nassert sum_Of_Subarray_Prod([1, 2, 3]) == 20\n```\n\n### Explanation:\n\n1. **Outer Loop (`i`)**: This loop iterates over each element in the list to consider it as the starting point of a sublist.\n\n2. **Inner Loop (`j`)**: For each starting point `i`, this loop extends the sublist by including elements from index `i` to `n-1`.\n\n3. **Product Calculation**: Within the inner loop, we calculate the product of the current sublist and add it to `total_sum`.\n\n4. **Result**: After both loops complete, `total_sum` contains the sum of products of all possible sublists.\n\nThis approach efficiently computes the desired result by considering each possible sublist exactly once."}
{"task_id": "Mbpp/735", "solution": "```markdown\nTo solve this problem, we need to write a Python function that toggles all the middle bits of an integer, leaving the first (most significant) and the last (least significant) bits unchanged.\n\nHere's how you can implement such a function:\n\n1. **Identify the First and Last Bits**: The first bit is the most significant bit (MSB), and the last bit is the least significant bit (LSB).\n\n2. **Toggle Middle Bits**: We need to toggle all bits between these two, which means flipping each middle bit from 0 to 1 or from 1 to 0.\n\n3. **Bitwise Operations**:\n - Use bitwise operations to isolate and manipulate specific bits.\n - The XOR operation (`^`) is useful for toggling bits because `x ^ 1` flips the bit of `x`.\n\nHere's a step-by-step implementation:\n\n```python\ndef toggle_middle_bits(n):\n # Edge case: if n has only one bit, return it as is\n if n == 0 or (n & (n - 1)) == 0:\n return n\n \n # Create a mask to isolate all bits except the first and last\n # Start with a number that has all bits set (e.g., for 32-bit: 0b111...111)\n all_ones = ~0\n \n # Clear the least significant bit (LSB)\n all_ones &= ~(1)\n \n # Find the position of the most significant bit (MSB)\n msb_pos = n.bit_length() - 1\n \n # Create a mask to keep only the MSB and LSB\n mask = (1 << msb_pos) | 1\n \n # Invert the mask to get all bits except MSB and LSB\n toggle_mask = ~mask & all_ones\n \n # Toggle the middle bits using XOR\n result = n ^ toggle_mask\n \n return result\n\n# Test case\nassert toggle_middle_bits(9) == 15\n```\n\n### Explanation:\n\n- **Edge Case**: If `n` is a power of two or zero, it has only one bit set. In such cases, toggling the middle bits doesn't change the number.\n\n- **All Ones Mask**: We start with a mask that has all bits set (`~0`). This is used to help create masks for specific operations.\n\n- **Clear LSB**: We clear the least significant bit of `all_ones` using `&= ~(1)`.\n\n- **MSB Position**: The position of the most significant bit is found using `n.bit_length() - 1`.\n\n- **Mask Creation**:\n - `mask = (1 << msb_pos) | 1`: This mask keeps only the MSB and LSB.\n - `toggle_mask = ~mask & all_ones`: This inverts the mask to target all bits except the MSB and LSB.\n\n- **Toggle Operation**: Finally, we use XOR (`^`) with `toggle_mask` to toggle the middle bits of `n`.\n\nThis function efficiently toggles the middle bits while preserving the first and last bits."}
{"task_id": "Mbpp/736", "solution": "Certainly! Below is a self-contained Python script that defines a function `left_insertion` to find the leftmost position where a given value can be inserted into a sorted list while maintaining order. The function uses binary search for efficiency.\n\n```python\ndef left_insertion(sorted_list, target):\n \"\"\"\n Find the left insertion point for a specified value in a sorted list.\n \n Parameters:\n - sorted_list: List of integers sorted in ascending order.\n - target: Integer value to insert into the sorted list.\n \n Returns:\n - The index where the target should be inserted to maintain sorted order.\n \"\"\"\n low, high = 0, len(sorted_list)\n \n while low < high:\n mid = (low + high) // 2\n if sorted_list[mid] < target:\n low = mid + 1\n else:\n high = mid\n \n return low\n\n# Test case\nassert left_insertion([1, 2, 4, 5], 6) == 4\n```\n\n### Explanation:\n\n- **Binary Search Approach**: The function uses binary search to efficiently find the insertion point.\n \n- **Variables**:\n - `low` and `high` are used to define the current search range within the list.\n - `mid` is calculated as the midpoint of the current range.\n\n- **Logic**:\n - If the middle element (`sorted_list[mid]`) is less than the target, it means the insertion point must be to the right of `mid`, so we adjust `low` to `mid + 1`.\n - Otherwise, the insertion point could be at `mid` or to its left, so we adjust `high` to `mid`.\n\n- **Termination**: The loop continues until `low` equals `high`, which will be the correct insertion index for the target.\n\nThis function efficiently finds the leftmost position where the target can be inserted while maintaining sorted order."}
{"task_id": "Mbpp/737", "solution": "Certainly! Below is a self-contained Python script that defines a function `check_str` which uses regular expressions to determine if a given string starts with a vowel. The function returns `True` if the string starts with a vowel and `False` otherwise.\n\n```python\nimport re\n\ndef check_str(s):\n \"\"\"\n Check if the given string starts with a vowel using regex.\n \n Parameters:\n s (str): The input string to be checked.\n \n Returns:\n bool: True if the string starts with a vowel, False otherwise.\n \"\"\"\n # Define a regular expression pattern for strings starting with a vowel\n pattern = r'^[aeiouAEIOU]'\n \n # Use re.match to check if the string matches the pattern\n return bool(re.match(pattern, s))\n\n# Test case\nassert check_str(\"annie\") == True\n```\n\n### Explanation:\n- **Regex Pattern**: `r'^[aeiouAEIOU]'`\n - `^` asserts the start of a line.\n - `[aeiouAEIOU]` matches any single character that is a vowel, either lowercase or uppercase.\n\n- **Functionality**:\n - The function uses `re.match()` to check if the string starts with one of the specified vowels.\n - It returns `True` if there's a match (i.e., the string starts with a vowel) and `False` otherwise.\n\nThis script includes an assertion to verify that the function works correctly for the test case `\"annie\"`."}
{"task_id": "Mbpp/739", "solution": "To solve this problem, we need to understand what a triangular number is and how to determine its properties. A triangular number or triangle number counts objects arranged in an equilateral triangle. The \\(n\\)-th triangular number is the sum of the first \\(n\\) natural numbers:\n\n\\[ T_n = \\frac{n(n + 1)}{2} \\]\n\nWe need a function that finds the index of the smallest triangular number with at least \\( n \\) digits.\n\nHere's how we can approach this problem:\n\n1. **Determine the Range for Digits**: A number has \\( d \\) digits if it is in the range \\([10^{d-1}, 10^d - 1]\\). For example, a 2-digit number ranges from 10 to 99.\n\n2. **Estimate the Index**: We need to find the smallest index \\( k \\) such that \\( T_k \\) has at least \\( n \\) digits. This means:\n \\[\n 10^{n-1} \\leq \\frac{k(k + 1)}{2}\n \\]\n Solving this inequality will give us a rough estimate of where to start checking for triangular numbers.\n\n3. **Iterate and Check**: Starting from the estimated index, compute triangular numbers until we find one with at least \\( n \\) digits.\n\nHere's the Python function implementing this logic:\n\n```python\ndef find_index(n):\n # Start by estimating the lower bound for k using the inequality:\n # 10^(n-1) <= k(k + 1)/2\n # This simplifies to solving: k^2 + k - 2*10^(n-1) >= 0\n # Using the quadratic formula, we estimate k as follows:\n \n import math\n \n # Calculate the lower bound for k using the quadratic formula\n lower_bound = int((math.sqrt(8 * (10**(n-1)) + 1) - 1) / 2)\n \n # Start checking from this estimated index\n k = lower_bound\n \n while True:\n triangular_number = k * (k + 1) // 2\n if len(str(triangular_number)) >= n:\n return k\n k += 1\n\n# Test the function with the given assertion\nassert find_index(2) == 4\n```\n\n### Explanation:\n\n- **Quadratic Formula**: We derived the lower bound for \\( k \\) using the quadratic formula to solve \\( k^2 + k - 2 \\times 10^{n-1} = 0 \\). This gives us a starting point for our search.\n\n- **Loop and Check**: Starting from this estimated index, we compute triangular numbers until we find one with at least \\( n \\) digits. The loop increments \\( k \\) and checks the number of digits in each triangular number.\n\nThis approach efficiently finds the smallest index of a triangular number with at least \\( n \\) digits by leveraging mathematical estimation to minimize unnecessary computations."}
{"task_id": "Mbpp/740", "solution": "Certainly! Below is a self-contained Python script that defines the function `tuple_to_dict` to convert a tuple into a dictionary using adjacent elements as key-value pairs. The function assumes that the length of the tuple is even.\n\n```python\ndef tuple_to_dict(tpl):\n \"\"\"\n Convert a tuple to a dictionary using adjacent elements as key-value pairs.\n \n Args:\n tpl (tuple): A tuple with an even number of elements.\n \n Returns:\n dict: A dictionary where each pair of adjacent elements in the tuple forms a key-value pair.\n \n Raises:\n ValueError: If the length of the tuple is not even.\n \"\"\"\n if len(tpl) % 2 != 0:\n raise ValueError(\"The tuple must have an even number of elements.\")\n \n return {tpl[i]: tpl[i + 1] for i in range(0, len(tpl), 2)}\n\n# Test case\nassert tuple_to_dict((1, 5, 7, 10, 13, 5)) == {1: 5, 7: 10, 13: 5}\n```\n\n### Explanation:\n\n- **Function Definition**: The function `tuple_to_dict` takes a single argument `tpl`, which is expected to be a tuple.\n \n- **Input Validation**: It first checks if the length of the tuple is even. If not, it raises a `ValueError`.\n\n- **Dictionary Comprehension**: It uses dictionary comprehension to iterate over the tuple in steps of 2 (`range(0, len(tpl), 2)`). For each index `i`, it creates a key-value pair with `tpl[i]` as the key and `tpl[i + 1]` as the value.\n\n- **Test Case**: The function is tested with an assertion to ensure it produces the expected output for the given input."}
{"task_id": "Mbpp/741", "solution": "Certainly! Below is a self-contained Python script that defines a function `all_Characters_Same` to check if all characters in a given string are the same. It also includes an assertion as specified.\n\n```markdown\n```python\ndef all_Characters_Same(s):\n \"\"\"\n Check whether all characters in the string s are the same.\n \n Parameters:\n s (str): The input string to be checked.\n \n Returns:\n bool: True if all characters are the same, False otherwise.\n \"\"\"\n # If the string is empty or has only one character, return True\n if len(s) <= 1:\n return True\n \n # Compare each character with the first character\n first_char = s[0]\n for char in s[1:]:\n if char != first_char:\n return False\n \n return True\n\n# Test case as per the requirement\nassert all_Characters_Same(\"python\") == False\n```\n```"}
{"task_id": "Mbpp/742", "solution": "Certainly! To calculate the volume of a regular tetrahedron given its edge length, you can use the formula:\n\n\\[ V = \\frac{\\sqrt{2}}{12} \\times a^3 \\]\n\nwhere \\( a \\) is the length of an edge.\n\nHere's a Python function to compute this:\n\n```python\nimport math\n\ndef volume_tetrahedron(edge_length):\n \"\"\"\n Calculate the volume of a regular tetrahedron given its edge length.\n \n Parameters:\n edge_length (float): The length of an edge of the tetrahedron.\n\n Returns:\n float: The volume of the tetrahedron.\n \"\"\"\n return (math.sqrt(2) / 12) * edge_length ** 3\n\n# Test case\nassert math.isclose(volume_tetrahedron(3), 15.588457268119894, rel_tol=1e-9)\n```\n\n### Explanation:\n\n- The function `volume_tetrahedron` takes the edge length of a regular tetrahedron as input.\n- It uses the formula for the volume of a regular tetrahedron to compute and return the volume.\n- The `math.isclose` function is used in the assertion to check if the computed volume is approximately equal to the expected value, allowing for minor floating-point precision differences."}
{"task_id": "Mbpp/743", "solution": "Certainly! Below is a self-contained Python script that defines a function to rotate a list by a specified number of items to the right. The function handles edge cases such as empty lists and rotation values greater than the length of the list.\n\n```python\ndef rotate_right(lst, k):\n \"\"\"\n Rotates the given list `lst` to the right by `k` positions.\n \n Parameters:\n lst (list): The list to be rotated.\n k (int): The number of positions to rotate the list to the right.\n \n Returns:\n list: A new list that is rotated to the right by `k` positions.\n \"\"\"\n # Handle edge cases\n if not lst or k <= 0:\n return lst\n \n n = len(lst)\n # Normalize k in case it's larger than the length of the list\n k = k % n\n \n # Perform rotation\n rotated_list = lst[-k:] + lst[:-k]\n \n return rotated_list\n\n# Test cases\nassert rotate_right([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 3) == [8, 9, 10, 1, 2, 3, 4, 5, 6, 7]\nassert rotate_right([], 3) == []\nassert rotate_right([1, 2, 3], 0) == [1, 2, 3]\nassert rotate_right([1, 2, 3], 4) == [3, 1, 2] # k > n\nassert rotate_right([1, 2, 3], -1) == [1, 2, 3] # Negative k\n\nprint(\"All test cases passed!\")\n```\n\n### Explanation:\n- **Edge Cases**: The function first checks if the list is empty or if `k` is less than or equal to zero. In these cases, it returns the original list.\n- **Normalization of `k`**: If `k` is greater than the length of the list, we use `k % n` to get an equivalent rotation within the bounds of the list's length.\n- **Rotation Logic**: The list is split into two parts: the last `k` elements and everything before that. These are then concatenated in reverse order to achieve the right rotation.\n\nThis script includes several test cases to ensure the function behaves as expected under different scenarios."}
{"task_id": "Mbpp/744", "solution": "Certainly! Below is a self-contained Python script that defines a function `check_none` which checks if a given tuple contains any `None` values. The function returns `True` if there's at least one `None` value in the tuple and `False` otherwise.\n\n```python\ndef check_none(tpl):\n \"\"\"\n Check if the given tuple has any None value.\n \n Parameters:\n tpl (tuple): A tuple to be checked for None values.\n \n Returns:\n bool: True if there is at least one None value, False otherwise.\n \"\"\"\n return any(item is None for item in tpl)\n\n# Test case\nassert check_none((10, 4, 5, 6, None)) == True\n\n# Additional test cases to ensure correctness\nassert check_none((1, 2, 3, 4)) == False\nassert check_none((None, 1, 2, 3)) == True\nassert check_none(()) == False\nassert check_none((None,)) == True\n```\n\nThis script includes the function definition and several test cases to verify its correctness. The `any()` function is used to iterate over the tuple and check if any element is `None`."}
{"task_id": "Mbpp/745", "solution": "Certainly! Below is a self-contained Python script that defines the function `divisible_by_digits` to solve the problem described:\n\n```python\ndef divisible_by_digits(startnum, endnum):\n def is_divisible(n):\n for digit in str(n):\n if digit == '0' or n % int(digit) != 0:\n return False\n return True\n\n result = []\n for number in range(startnum, endnum + 1):\n if is_divisible(number):\n result.append(number)\n \n return result\n\n# Test the function with the provided assertion\nassert divisible_by_digits(1, 22) == [1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 12, 15, 22]\n```\n\n### Explanation:\n\n- **`is_divisible(n)`**: This helper function checks if a number `n` is divisible by each of its digits.\n - It converts the number to a string to iterate over each digit.\n - If any digit is '0' or if `n` is not divisible by that digit, it returns `False`.\n - Otherwise, it returns `True`.\n\n- **Main Function**:\n - Iterates through each number in the range from `startnum` to `endnum` (inclusive).\n - Uses the helper function to check divisibility.\n - Appends numbers that satisfy the condition to the result list.\n\n- The script includes an assertion to verify the correctness of the function with the given example."}
{"task_id": "Mbpp/748", "solution": "Certainly! Below is a self-contained Python script that addresses the problem of inserting spaces before words starting with capital letters in a given string. The solution includes a function `capital_words_spaces` which processes the input string and returns the modified version.\n\n```python\ndef capital_words_spaces(s):\n \"\"\"\n This function takes a string 's' as input and inserts spaces before each word that starts \n with an uppercase letter, except for the first character if it's uppercase.\n \n Args:\n s (str): The input string containing words starting with capital letters.\n\n Returns:\n str: A new string with spaces inserted before words starting with capital letters.\n \"\"\"\n # Initialize an empty list to store characters of the resulting string\n result = []\n \n # Iterate over each character in the string along with its index\n for i, char in enumerate(s):\n # If it's not the first character and is uppercase, add a space before it\n if i > 0 and char.isupper():\n result.append(' ')\n \n # Add the current character to the result list\n result.append(char)\n \n # Join all characters in the result list into a single string and return\n return ''.join(result)\n\n# Test cases\nassert capital_words_spaces(\"Python\") == 'Python'\nassert capital_words_spaces(\"HelloWorld\") == 'Hello World'\nassert capital_words_spaces(\"ThisIsATest\") == 'This Is A Test'\nassert capital_words_spaces(\"aBCdefGHIjkl\") == 'a BC def GHI jkl'\n\n# Example usage\nprint(capital_words_spaces(\"PythonProgrammingLanguage\")) # Output: Python Programming Language\n```\n\n### Explanation:\n- The function `capital_words_spaces` iterates over each character in the input string.\n- It checks if a character is uppercase and not the first character of the string. If both conditions are met, it appends a space to the result list before appending the uppercase character.\n- Finally, it joins all characters from the result list into a single string and returns it.\n\nThis solution ensures that spaces are correctly inserted between words starting with capital letters while preserving the original structure of the input string."}
{"task_id": "Mbpp/749", "solution": "Certainly! Below is a self-contained Python script that defines the function `sort_numeric_strings` to sort a list of strings representing numbers in numerical order. The function converts each string to an integer for sorting purposes and then returns the sorted list.\n\n```python\ndef sort_numeric_strings(strings):\n \"\"\"\n Sorts a list of strings containing numeric values in ascending numerical order.\n \n Parameters:\n strings (list): A list of strings, where each string represents a number.\n \n Returns:\n list: The input list sorted based on their numeric value.\n \"\"\"\n # Convert the list of strings to integers for sorting\n numbers = [int(s) for s in strings]\n \n # Sort the list of integers\n numbers.sort()\n \n # Convert back to strings if needed, or return as is if integer output is acceptable\n sorted_strings = [str(n) for n in numbers]\n \n return sorted_strings\n\n# Test case\nassert sort_numeric_strings(['4', '12', '45', '7', '0', '100', '200', '-12', '-500']) == ['-500', '-12', '0', '4', '7', '12', '45', '100', '200']\n```\n\nThis script includes a function definition and an assertion to verify that the function works as expected with the provided test case. The conversion between strings and integers ensures accurate numerical sorting."}
{"task_id": "Mbpp/750", "solution": "```markdown\nHere's a self-contained Python script that solves the problem of adding a tuple to a given list:\n\n```python\ndef add_tuple(lst, tpl):\n \"\"\"\n Adds elements from the tuple `tpl` to the end of the list `lst`.\n\n Parameters:\n lst (list): The list to which elements will be added.\n tpl (tuple): The tuple whose elements will be added to the list.\n\n Returns:\n list: A new list containing all elements of `lst` followed by all elements of `tpl`.\n \"\"\"\n # Convert the tuple into a list and concatenate it with the original list\n return lst + list(tpl)\n\n# Test case\nassert add_tuple([5, 6, 7], (9, 10)) == [5, 6, 7, 9, 10]\n```\n\n### Explanation:\n\n- The function `add_tuple` takes two parameters: a list `lst` and a tuple `tpl`.\n- It converts the tuple into a list using `list(tpl)`.\n- It then concatenates this new list with the original list `lst` using the `+` operator.\n- Finally, it returns the concatenated list.\n\nThis approach ensures that all elements from both the list and the tuple are combined into a single list. The provided test case verifies that the function works as expected by asserting the result against the expected output.\n```"}
{"task_id": "Mbpp/751", "solution": "```markdown\nTo solve this problem, we need to write a Python function that checks whether a given list of numbers represents a min-heap. A min-heap is a complete binary tree where each node's value is less than or equal to the values of its children.\n\nHere's how you can implement such a function:\n\n```python\ndef check_min_heap(arr):\n \"\"\"\n Check if the given array represents a min heap.\n \n :param arr: List[int] - The input list representing the binary tree.\n :return: bool - True if the list is a min-heap, False otherwise.\n \"\"\"\n n = len(arr)\n \n # Iterate over each non-leaf node\n for i in range((n - 2) // 2 + 1):\n left_child_index = 2 * i + 1\n right_child_index = 2 * i + 2\n \n # Check if the current node is greater than its left child\n if left_child_index < n and arr[i] > arr[left_child_index]:\n return False\n \n # Check if the current node is greater than its right child\n if right_child_index < n and arr[i] > arr[right_child_index]:\n return False\n \n return True\n\n# Test case\nassert check_min_heap([1, 2, 3, 4, 5, 6]) == True\n```\n\n### Explanation:\n\n- **Heap Property**: In a min-heap, for every node `i`, the value of `arr[i]` should be less than or equal to its children. The left child is at index `2*i + 1` and the right child is at index `2*i + 2`.\n\n- **Iterate Over Non-Leaf Nodes**: We only need to check nodes that have children, which are from index `0` to `(n - 2) // 2`. This range ensures we're checking all parent nodes.\n\n- **Check Conditions**:\n - For each node, compare its value with its left child (if it exists).\n - Similarly, compare its value with its right child (if it exists).\n\n- **Return Result**: If any node violates the min-heap property, return `False`. If no violations are found, return `True`.\n\nThis function efficiently checks if a list represents a min-heap by ensuring all parent nodes satisfy the heap condition relative to their children."}
{"task_id": "Mbpp/752", "solution": "Certainly! The Jacobsthal numbers are a sequence similar to the Fibonacci sequence but with different initial conditions and recurrence relation. Specifically, the Jacobsthal sequence is defined as follows:\n\n- \\( J(0) = 0 \\)\n- \\( J(1) = 1 \\)\n- For \\( n > 1 \\), \\( J(n) = J(n-1) + 2 \\times J(n-2) \\)\n\nGiven this definition, we can write a Python function to compute the nth Jacobsthal number. Here's how you can implement it:\n\n```python\ndef jacobsthal_num(n):\n \"\"\"\n Compute the nth Jacobsthal number.\n \n Parameters:\n n (int): The position in the Jacobsthal sequence.\n\n Returns:\n int: The nth Jacobsthal number.\n \"\"\"\n if n == 0:\n return 0\n elif n == 1:\n return 1\n \n # Initialize the first two Jacobsthal numbers\n jacobsthal_prev2 = 0 # J(0)\n jacobsthal_prev1 = 1 # J(1)\n\n # Compute subsequent Jacobsthal numbers up to nth\n for i in range(2, n + 1):\n current_jacobsthal = jacobsthal_prev1 + 2 * jacobsthal_prev2\n # Update the previous two values\n jacobsthal_prev2 = jacobsthal_prev1\n jacobsthal_prev1 = current_jacobsthal\n\n return current_jacobsthal\n\n# Test case\nassert jacobsthal_num(5) == 11\n```\n\n### Explanation:\n\n- **Base Cases**: The function first checks if `n` is 0 or 1, returning the corresponding Jacobsthal number directly.\n \n- **Iterative Approach**: For \\( n > 1 \\), we use a loop to compute each Jacobsthal number iteratively. We maintain two variables, `jacobsthal_prev2` and `jacobsthal_prev1`, which store the values of \\( J(n-2) \\) and \\( J(n-1) \\) respectively.\n\n- **Recurrence Relation**: In each iteration, we calculate the current Jacobsthal number using the formula \\( J(n) = J(n-1) + 2 \\times J(n-2) \\).\n\n- **Update Variables**: After computing the current Jacobsthal number, we update `jacobsthal_prev2` and `jacobsthal_prev1` to prepare for the next iteration.\n\nThis approach efficiently computes the nth Jacobsthal number in \\( O(n) \\) time complexity with constant space usage."}
{"task_id": "Mbpp/753", "solution": "Certainly! Below is a self-contained Python script that defines the function `min_k` to find the minimum `k` records from a list of tuples based on the second element in each tuple. The function sorts the list by these values and returns the first `k` elements.\n\n```python\ndef min_k(records, k):\n \"\"\"\n Find the minimum k records from a list of tuples based on the second element.\n \n Parameters:\n - records: List of tuples where each tuple contains a name and a score.\n - k: The number of minimum records to return.\n \n Returns:\n - A list containing the k tuples with the smallest scores.\n \"\"\"\n # Sort the records by the second element (score) in ascending order\n sorted_records = sorted(records, key=lambda x: x[1])\n \n # Return the first k elements from the sorted list\n return sorted_records[:k]\n\n# Test case\nassert min_k([('Manjeet', 10), ('Akshat', 4), ('Akash', 2), ('Nikhil', 8)], 2) == [('Akash', 2), ('Akshat', 4)]\n```\n\nThis script includes a test case to verify that the function works as expected. The `min_k` function sorts the list of tuples by their scores and returns the first `k` elements, which are the ones with the smallest scores."}
{"task_id": "Mbpp/754", "solution": "Here's a self-contained Python script that solves the problem of finding common elements from three lists at the same index:\n\n```python\ndef extract_index_list(l1, l2, l3):\n \"\"\"\n This function takes three lists and returns a list of elements \n that are common to all three lists at the same index.\n \n :param l1: First list of integers\n :param l2: Second list of integers\n :param l3: Third list of integers\n :return: List of integers that are common in all three lists at the same index\n \"\"\"\n # Initialize an empty list to store common elements\n common_elements = []\n \n # Iterate over the indices of the shortest list to avoid IndexError\n for i in range(min(len(l1), len(l2), len(l3))):\n # Check if the element at the current index is the same in all three lists\n if l1[i] == l2[i] == l3[i]:\n common_elements.append(l1[i])\n \n return common_elements\n\n# Test case\nassert extract_index_list([1, 1, 3, 4, 5, 6, 7], [0, 1, 2, 3, 4, 5, 7], [0, 1, 2, 3, 4, 5, 7]) == [1, 7]\n```\n\nThis script defines a function `extract_index_list` that iterates over the indices of the shortest list among the three provided lists. It checks if the elements at each index are the same across all three lists and appends them to the result list if they are. The test case confirms that the function works as expected."}
{"task_id": "Mbpp/755", "solution": "```markdown\nHere's a Python script that defines a function to find the second smallest number in a list. The function handles duplicates and ensures it returns the correct result even if there are repeated numbers.\n\n```python\ndef second_smallest(numbers):\n # Remove duplicates by converting the list to a set, then back to a sorted list\n unique_numbers = sorted(set(numbers))\n \n # Check if we have at least two distinct elements\n if len(unique_numbers) < 2:\n raise ValueError(\"The list must contain at least two distinct numbers.\")\n \n # Return the second smallest number\n return unique_numbers[1]\n\n# Test case\nassert second_smallest([1, 2, -8, -2, 0, -2]) == -2\n\nprint(\"Test passed!\")\n```\n\n### Explanation:\n\n1. **Remove Duplicates**: Convert the list to a set to remove duplicates and then back to a sorted list.\n2. **Check Length**: Ensure there are at least two distinct numbers in the list; otherwise, raise an error.\n3. **Return Second Smallest**: Access the second element of the sorted list, which is the second smallest number.\n\nThis approach ensures that even if there are duplicates, they do not affect finding the second smallest unique number."}
{"task_id": "Mbpp/757", "solution": "```markdown\nTo solve this problem, we need to write a Python function that counts how many pairs of reverse strings exist in a given list. A pair of strings is considered a reverse pair if one string is the reverse of another.\n\nHere's a step-by-step breakdown of how you can implement this:\n\n1. **Initialize a Counter**: We'll use a counter to keep track of how many times each word appears in the list.\n2. **Iterate Through the List**: For each word, check if its reverse exists in the counter.\n3. **Count Pairs**: If the reverse is found, increment the pair count by the number of occurrences of the reverse string (since multiple pairs can be formed with repeated strings).\n4. **Update Counter**: Add or update the current word's occurrence in the counter.\n\nHere's how you can implement this logic:\n\n```python\ndef count_reverse_pairs(words):\n from collections import defaultdict\n \n # Dictionary to store the frequency of each word\n word_count = defaultdict(int)\n \n # Variable to keep track of reverse pairs\n reverse_pair_count = 0\n \n for word in words:\n # Check if the reverse of the current word exists in the dictionary\n reverse_word = word[::-1]\n \n # If it does, add its count to the reverse pair count\n reverse_pair_count += word_count[reverse_word]\n \n # Increment the count of the current word in the dictionary\n word_count[word] += 1\n \n return reverse_pair_count\n\n# Test case\nassert count_reverse_pairs([\"julia\", \"best\", \"tseb\", \"for\", \"ailuj\"]) == 2\n```\n\n### Explanation:\n\n- **`defaultdict(int)`**: This is used to initialize a dictionary where each key's default value is `0`. It simplifies counting occurrences.\n \n- **`word[::-1]`**: This slice operation reverses the string. For example, `\"julia\"` becomes `\"ailuj\"`.\n \n- **Counting Pairs**: When we find that the reverse of a word exists in our dictionary, it means we have found all possible pairs with this reversed word already seen before.\n\n- **Updating Counters**: After processing each word, we update its count in `word_count` to ensure future words can form pairs with it if their reverses appear later.\n\nThis approach efficiently counts reverse string pairs by leveraging a single pass through the list and using a dictionary for quick lookups."}
{"task_id": "Mbpp/758", "solution": "Here's a self-contained Python script that solves the problem of counting lists within a list and returning a dictionary with tuples as keys:\n\n```python\ndef unique_sublists(lst):\n \"\"\"\n Count occurrences of sublists in a given list.\n \n Args:\n lst (list): A list containing sublists.\n\n Returns:\n dict: A dictionary where each key is a tuple representing a sublist,\n and the value is the number of times that sublist appears in the input list.\n \"\"\"\n # Initialize an empty dictionary to store the counts\n count_dict = {}\n \n # Iterate over each sublist in the input list\n for sublst in lst:\n # Convert the sublist to a tuple (since lists are not hashable)\n sublst_tuple = tuple(sublst)\n \n # If the tuple is already in the dictionary, increment its count\n if sublst_tuple in count_dict:\n count_dict[sublst_tuple] += 1\n else:\n # Otherwise, add it to the dictionary with a count of 1\n count_dict[sublst_tuple] = 1\n \n return count_dict\n\n# Test case\nassert unique_sublists([[1, 3], [5, 7], [1, 3], [13, 15, 17], [5, 7], [9, 11]]) == {(1, 3): 2, (5, 7): 2, (13, 15, 17): 1, (9, 11): 1}\n```\n\nThis script defines a function `unique_sublists` that takes a list of lists as input and returns a dictionary. Each key in the dictionary is a tuple representing a sublist from the input, and each value is the count of how many times that sublist appears. The test case at the end verifies that the function works correctly for the given example."}
{"task_id": "Mbpp/759", "solution": "Certainly! Below is a self-contained Python script that defines a function `is_decimal` to check if a given string represents a decimal number with a precision of two decimal places.\n\n```python\nimport re\n\ndef is_decimal(s):\n \"\"\"\n Check if the input string s is a decimal number with exactly two decimal places.\n \n Args:\n s (str): The string to be checked.\n \n Returns:\n bool: True if s is a valid decimal number with two decimal places, False otherwise.\n \"\"\"\n # Regular expression pattern for matching a decimal number with exactly two decimal places\n pattern = r'^-?\\d+\\.\\d{2}$'\n \n # Use re.match to check if the string matches the pattern\n return bool(re.match(pattern, s))\n\n# Test cases\nassert is_decimal('123.11') == True\nassert is_decimal('-123.45') == True\nassert is_decimal('0.99') == True\nassert is_decimal('100.00') == True\nassert is_decimal('123.') == False # Only one decimal place\nassert is_decimal('123.456') == False # More than two decimal places\nassert is_decimal('abc.def') == False # Non-numeric characters\nassert is_decimal('.11') == False # No integer part\nassert is_decimal('-.11') == False # No integer part with negative sign\n\nprint(\"All test cases passed!\")\n```\n\n### Explanation:\n- The function `is_decimal` uses a regular expression to determine if the input string matches the pattern of a decimal number with exactly two decimal places.\n- The pattern `^-?\\d+\\.\\d{2}$` breaks down as follows:\n - `^`: Start of the string.\n - `-?`: An optional minus sign for negative numbers.\n - `\\d+`: One or more digits before the decimal point.\n - `\\.`: A literal dot character.\n - `\\d{2}`: Exactly two digits after the decimal point.\n - `$`: End of the string.\n- The `re.match` function checks if the entire string matches this pattern, and `bool()` converts the match object to a boolean value (`True` if there's a match, `False` otherwise).\n- Several test cases are provided to ensure the function works correctly for various inputs."}
{"task_id": "Mbpp/760", "solution": "Certainly! Below is a self-contained Python script that defines a function `unique_element` to solve the problem. The function checks if all elements in a given list are identical.\n\n```python\ndef unique_element(numbers):\n \"\"\"\n Check whether a list of numbers contains only one distinct element or not.\n \n Parameters:\n numbers (list): A list of numbers.\n \n Returns:\n bool: True if all elements are the same, False otherwise.\n \"\"\"\n # Use a set to determine the number of unique elements\n return len(set(numbers)) == 1\n\n# Test cases\nassert unique_element([1, 1, 1]) == True\nassert unique_element([2, 2, 3]) == False\nassert unique_element([]) == True # An empty list can be considered as having one distinct element (none)\nassert unique_element([5]) == True # A single-element list is trivially all identical\n\nprint(\"All test cases passed!\")\n```\n\n### Explanation:\n- The function `unique_element` takes a list of numbers as input.\n- It converts the list into a set, which automatically removes duplicate elements.\n- If the length of this set is 1, it means all elements in the original list were identical.\n- The function returns `True` if there's only one distinct element and `False` otherwise.\n\nThe test cases ensure that the function works correctly for various scenarios, including an empty list and a single-element list."}
{"task_id": "Mbpp/762", "solution": "Certainly! Below is a self-contained Python script that defines a function `check_month_number` to determine if a given month has 30 days. The months are represented by numbers from 1 to 12.\n\n```python\ndef check_month_number(month):\n \"\"\"\n Check if the given month number contains 30 days.\n \n Parameters:\n month (int): Month number (1-12)\n \n Returns:\n bool: True if the month has 30 days, False otherwise.\n \"\"\"\n # Months with 30 days are April (4), June (6), September (9), and November (11).\n months_with_30_days = {4, 6, 9, 11}\n \n # Check if the given month is in the set of months with 30 days.\n return month in months_with_30_days\n\n# Test case\nassert check_month_number(6) == True\n```\n\nThis function uses a set to store the month numbers that have 30 days and checks if the input month is in this set. The test case confirms that June (month number 6) has 30 days, as expected."}
{"task_id": "Mbpp/763", "solution": "```markdown\nTo solve the problem of finding the minimum difference between any two elements in a given array, we can follow these steps:\n\n1. **Sort the Array**: Sorting the array will allow us to compare each element only with its adjacent elements, which simplifies finding the minimum difference.\n\n2. **Calculate Differences**: After sorting, iterate through the sorted array and calculate the differences between consecutive elements.\n\n3. **Find Minimum Difference**: Track the smallest difference encountered during the iteration.\n\nHere's a Python function implementing this approach:\n\n```python\ndef find_min_diff(arr, n):\n # Step 1: Sort the array\n arr.sort()\n \n # Initialize minimum difference as infinity\n min_diff = float('inf')\n \n # Step 2 & 3: Calculate differences and find the minimum\n for i in range(n - 1):\n diff = arr[i + 1] - arr[i]\n if diff < min_diff:\n min_diff = diff\n \n return min_diff\n\n# Test case\nassert find_min_diff((1, 5, 3, 19, 18, 25), 6) == 1\n```\n\n### Explanation:\n\n- **Sorting**: The array is sorted to ensure that the smallest difference between any two elements will be found among consecutive elements.\n\n- **Iterating and Comparing**: By iterating through the sorted list and comparing each element with its next neighbor, we efficiently find the minimum difference.\n\n- **Edge Cases**: This approach assumes there are at least two elements in the array (as specified by `n >= 2`), which is necessary to compute a difference. If `n < 2`, the problem constraints would need adjustment or additional handling.\n\nThis function should work correctly for any input that meets the problem's requirements, including the provided test case."}
{"task_id": "Mbpp/764", "solution": "Certainly! Below is a self-contained Python script that defines a function `number_ctr` which counts the number of digit characters in a given string. The function uses assertions to verify its correctness with an example.\n\n```python\ndef number_ctr(s):\n \"\"\"\n Count the number of digits in a given string.\n \n Parameters:\n s (str): The input string to be evaluated.\n \n Returns:\n int: The count of digit characters in the string.\n \"\"\"\n # Initialize a counter for digits\n digit_count = 0\n \n # Iterate over each character in the string\n for char in s:\n # Check if the character is a digit\n if char.isdigit():\n digit_count += 1\n \n return digit_count\n\n# Example usage and assertion to verify correctness\nassert number_ctr('program2bedone') == 1, \"Test case failed!\"\n\nprint(\"All test cases passed!\")\n```\n\nThis script defines the `number_ctr` function which iterates over each character in the input string `s`, checks if it is a digit using Python's built-in `isdigit()` method, and increments a counter if true. The assertion at the end ensures that the function works as expected for the provided test case."}
{"task_id": "Mbpp/765", "solution": "```markdown\nTo solve the problem of finding the nth polite number, we first need to understand what a polite number is. A polite number is a positive integer that can be expressed as the sum of two or more consecutive positive integers.\n\n### Steps to Find the nth Polite Number:\n\n1. **Understanding Polite Numbers:**\n - A number \\( n \\) is polite if it can be written as the sum of two or more consecutive numbers.\n - For example, 15 is polite because it can be expressed as:\n - \\( 7 + 8 = 15 \\)\n - \\( 4 + 5 + 6 = 15 \\)\n\n2. **Characteristics of Polite Numbers:**\n - A number that is a power of 2 cannot be polite.\n - This is because powers of 2 have only one representation as a sum of consecutive numbers, which is the number itself.\n\n3. **Finding nth Polite Number:**\n - We need to skip all powers of 2 and count other numbers until we reach the nth polite number.\n\n4. **Algorithm:**\n - Initialize a counter for polite numbers.\n - Iterate through natural numbers starting from 1.\n - For each number, check if it is not a power of 2.\n - If it's not a power of 2, increment the polite number counter.\n - Stop when the polite number counter reaches \\( n \\).\n\n5. **Checking Power of 2:**\n - A number \\( x \\) is a power of 2 if \\( x \\) and \\( (x & (x - 1)) \\) are zero.\n\nHere's the Python function to find the nth polite number:\n\n```python\ndef is_power_of_two(x):\n return (x & (x - 1)) == 0\n\ndef nth_polite_number(n):\n count = 0\n num = 1\n \n while count < n:\n if not is_power_of_two(num):\n count += 1\n num += 1\n \n return num - 1\n\n# Test the function with an example\nassert nth_polite_number(7) == 11\n```\n\n### Explanation:\n\n- **`is_power_of_two(x)`**: This helper function checks if a number is a power of two using bitwise operations.\n- **`nth_polite_number(n)`**:\n - We initialize `count` to keep track of how many polite numbers we've found and `num` as the current number being checked.\n - We loop until `count` equals \\( n \\).\n - For each number, if it is not a power of two, we increment the count.\n - Finally, return `num - 1` because `num` will be one step ahead after exiting the loop.\n\nThis function efficiently finds the nth polite number by skipping powers of two and counting other numbers."}
{"task_id": "Mbpp/766", "solution": "Certainly! Below is a self-contained Python script that defines the function `pair_wise` to return all pairs of consecutive items in a given list. The function uses a simple loop to iterate through the list and create tuples of each pair of consecutive elements.\n\n```python\ndef pair_wise(lst):\n \"\"\"\n Returns a list of all pairs of consecutive items in the given list.\n \n Parameters:\n lst (list): A list of elements from which to form consecutive pairs.\n \n Returns:\n list: A list of tuples, where each tuple contains two consecutive elements from the input list.\n \"\"\"\n # Initialize an empty list to store the pairs\n result = []\n \n # Iterate over the list using index, stopping one element before the last\n for i in range(len(lst) - 1):\n # Create a pair (tuple) of the current element and the next element\n pair = (lst[i], lst[i + 1])\n \n # Append the pair to the result list\n result.append(pair)\n \n return result\n\n# Test case\nassert pair_wise([1, 1, 2, 3, 3, 4, 4, 5]) == [(1, 1), (1, 2), (2, 3), (3, 3), (3, 4), (4, 4), (4, 5)]\n```\n\nThis script defines the `pair_wise` function and includes a test case to verify its correctness. The function iterates through the list, creating tuples of consecutive elements and appending them to the result list."}
{"task_id": "Mbpp/767", "solution": "```markdown\nHere's a Python script that solves the problem of counting the number of pairs in a list whose sum equals a given target value:\n\n```python\ndef get_pairs_count(numbers, target_sum):\n # Dictionary to store the frequency of each number\n num_count = {}\n \n # Populate the dictionary with counts of each number\n for num in numbers:\n if num in num_count:\n num_count[num] += 1\n else:\n num_count[num] = 1\n \n pair_count = 0\n \n # Iterate through each unique number and calculate pairs\n for num in num_count:\n complement = target_sum - num\n \n # Check if the complement exists in the dictionary\n if complement in num_count:\n if num == complement:\n # If both numbers are the same, use combination formula nC2\n pair_count += (num_count[num] * (num_count[num] - 1)) // 2\n else:\n # Otherwise, multiply the counts of the two different numbers\n pair_count += num_count[num] * num_count[complement]\n \n return pair_count\n\n# Example usage\nassert get_pairs_count([1, 1, 1, 1], 2) == 6\n```\n\n### Explanation:\n\n1. **Dictionary for Frequency Count**: We use a dictionary `num_count` to store the frequency of each number in the list.\n\n2. **Iterate and Calculate Pairs**:\n - For each unique number in the dictionary, calculate its complement (i.e., `target_sum - num`).\n - If both numbers are the same (`num == complement`), use the combination formula \\( \\text{nC2} = \\frac{n(n-1)}{2} \\) to count pairs.\n - If they are different, multiply their frequencies to get the number of valid pairs.\n\n3. **Return Total Pair Count**: Sum up all the pairs found and return the result.\n\nThis approach efficiently counts pairs with a time complexity of \\( O(n) \\), where \\( n \\) is the length of the input list.\n```"}
{"task_id": "Mbpp/769", "solution": "Certainly! Below is a self-contained Python script that defines a function to compute the difference between two lists. The function `Diff` takes two lists as input and returns a list containing elements from the first list that are not present in the second list.\n\n```python\ndef Diff(list1, list2):\n \"\"\"\n Compute the difference between two lists.\n \n Parameters:\n - list1: List of integers or other comparable items.\n - list2: List of integers or other comparable items.\n \n Returns:\n A new list containing elements from list1 that are not in list2.\n \"\"\"\n # Convert list2 to a set for O(1) average time complexity lookups\n set2 = set(list2)\n \n # Use a list comprehension to filter out elements present in set2\n difference = [item for item in list1 if item not in set2]\n \n return difference\n\n# Test the function with the provided example\nassert Diff([10, 15, 20, 25, 30, 35, 40], [25, 40, 35]) == [10, 20, 30, 15]\n\nprint(\"The test passed successfully!\")\n```\n\n### Explanation:\n- **Set Conversion**: The second list (`list2`) is converted to a set for efficient membership testing. This allows us to check if an element from `list1` is in `list2` in average O(1) time.\n- **List Comprehension**: We use a list comprehension to iterate over each item in `list1` and include it in the result only if it's not present in `set2`.\n- **Assertion**: The function is tested with an assertion to ensure it produces the expected output.\n\nThis script will print \"The test passed successfully!\" if the function works as intended."}
{"task_id": "Mbpp/770", "solution": "Certainly! Below is a self-contained Python script that defines a function to calculate the sum of the fourth powers of the first `n` odd natural numbers. The function includes an assertion to verify its correctness for the given test case.\n\n```python\ndef odd_num_sum(n):\n \"\"\"\n Calculate the sum of the fourth power of the first n odd natural numbers.\n \n Parameters:\n n (int): The number of initial odd natural numbers to consider.\n \n Returns:\n int: The sum of the fourth powers of these numbers.\n \"\"\"\n # Initialize the sum\n total_sum = 0\n \n # Loop through the first n odd numbers\n for i in range(n):\n # Calculate the ith odd number (1, 3, 5, ...)\n odd_number = 2 * i + 1\n \n # Add its fourth power to the total sum\n total_sum += odd_number ** 4\n \n return total_sum\n\n# Test case\nassert odd_num_sum(2) == 82\n\n# Example usage:\nprint(\"Sum of the fourth powers of the first 2 odd numbers:\", odd_num_sum(2))\n```\n\n### Explanation:\n\n- The function `odd_num_sum(n)` calculates the sum of the fourth powers of the first `n` odd natural numbers.\n- It initializes a variable `total_sum` to accumulate the result.\n- A loop runs from `0` to `n-1`, and for each iteration, it computes the `i-th` odd number using the formula `2 * i + 1`.\n- The fourth power of this odd number is calculated and added to `total_sum`.\n- Finally, the function returns the accumulated sum.\n- An assertion checks that the function works correctly for `n = 2`, where the expected result is `82`."}
{"task_id": "Mbpp/771", "solution": "Certainly! Below is a self-contained Python script that checks if a given expression has balanced brackets:\n\n```markdown\n```python\ndef check_expression(expression):\n # Dictionary to hold matching pairs of brackets\n bracket_pairs = {\n ')': '(',\n ']': '[',\n '}': '{'\n }\n \n # Stack to keep track of opening brackets\n stack = []\n \n for char in expression:\n if char in bracket_pairs.values():\n # If it's an opening bracket, push onto the stack\n stack.append(char)\n elif char in bracket_pairs.keys():\n # If it's a closing bracket, check for balance\n if stack and stack[-1] == bracket_pairs[char]:\n stack.pop()\n else:\n return False\n \n # If stack is empty, all brackets were balanced\n return not stack\n\n# Test case\nassert check_expression(\"{()}[{}]\") == True\n```\n```\n\nThis script uses a stack to ensure that each closing bracket has a corresponding opening bracket in the correct order. The `check_expression` function returns `True` if the expression is balanced and `False` otherwise."}
{"task_id": "Mbpp/772", "solution": "Certainly! Below is a self-contained Python script that defines and tests the `remove_length` function as described:\n\n```markdown\n```python\ndef remove_length(s, k):\n \"\"\"\n Remove all words of length k from the given string.\n\n Parameters:\n s (str): The input string.\n k (int): The length of words to be removed.\n\n Returns:\n str: A new string with all words of length k removed.\n \"\"\"\n # Split the string into a list of words\n words = s.split()\n \n # Filter out words that have length k\n filtered_words = [word for word in words if len(word) != k]\n \n # Join the remaining words back into a single string\n result = ' '.join(filtered_words)\n \n return result\n\n# Test case\nassert remove_length('The person is most value tet', 3) == 'person is most value'\n```\n```\n\nThis script defines the `remove_length` function, which takes a string and an integer `k`. It splits the string into words, filters out those with length `k`, and joins the remaining words back into a single string. The provided test case verifies that the function works as expected."}
{"task_id": "Mbpp/773", "solution": "Certainly! Below is a self-contained Python script that defines a function to find the occurrence and position of substrings within a string. The function returns a tuple containing the substring, its starting index, and ending index if found; otherwise, it returns `None`.\n\n```python\ndef occurance_substring(main_string, sub_string):\n \"\"\"\n Find the first occurrence and position of a substring within a main string.\n \n Parameters:\n - main_string (str): The string to search within.\n - sub_string (str): The substring to find.\n\n Returns:\n - tuple: A tuple containing the substring, its starting index, and ending index if found.\n - None: If the substring is not found in the main string.\n \"\"\"\n start_index = main_string.find(sub_string)\n \n if start_index == -1:\n return None\n \n end_index = start_index + len(sub_string) - 1\n return (sub_string, start_index, end_index)\n\n# Test case\nassert occurance_substring('python programming, python language', 'python') == ('python', 0, 6)\n```\n\n### Explanation:\n\n- **Function Definition**: The function `occurance_substring` takes two parameters: `main_string` and `sub_string`.\n \n- **Finding the Substring**:\n - We use Python's built-in string method `.find()` to locate the first occurrence of `sub_string` in `main_string`. This method returns the starting index of the substring if found, or `-1` if not.\n \n- **Checking for Occurrence**:\n - If `start_index` is `-1`, it means the substring was not found, and we return `None`.\n \n- **Calculating End Index**:\n - If the substring is found, calculate the `end_index` as `start_index + len(sub_string) - 1`.\n\n- **Return Value**:\n - The function returns a tuple containing the substring itself, its starting index, and ending index.\n\nThis script includes an assertion to verify that the function works correctly for the given test case."}
{"task_id": "Mbpp/775", "solution": "Certainly! Below is a self-contained Python script that defines the function `odd_position` and includes an assertion to verify its correctness.\n\n```python\ndef odd_position(lst):\n \"\"\"\n Check if every element at an odd index in the list contains an odd number.\n \n Parameters:\n lst (list): A list of integers.\n \n Returns:\n bool: True if every element at an odd index is odd, False otherwise.\n \"\"\"\n # Iterate over indices and elements using enumerate\n for index, value in enumerate(lst):\n # Check if the index is odd\n if index % 2 != 0:\n # If the number at this odd index is not odd, return False\n if value % 2 == 0:\n return False\n # If all checks pass, return True\n return True\n\n# Test case to verify the function works as expected\nassert odd_position([2, 1, 4, 3, 6, 7, 6, 3]) == True\n```\n\n### Explanation:\n\n- The `odd_position` function takes a list of integers as input.\n- It uses `enumerate` to iterate over the list with both index and value.\n- For each element, it checks if the index is odd (`index % 2 != 0`).\n- If an element at an odd index is not odd (`value % 2 == 0`), the function returns `False`.\n- If all elements at odd indices are odd, the function returns `True`.\n- The assertion tests the function with a sample list to ensure it behaves as expected."}
{"task_id": "Mbpp/777", "solution": "```markdown\nHere's a Python script that defines a function `find_sum` to calculate the sum of non-repeated elements in a given list:\n\n```python\ndef find_sum(lst):\n # Create a dictionary to count occurrences of each element\n frequency = {}\n \n for num in lst:\n if num in frequency:\n frequency[num] += 1\n else:\n frequency[num] = 1\n \n # Calculate the sum of elements that appear only once\n non_repeated_sum = sum(num for num, count in frequency.items() if count == 1)\n \n return non_repeated_sum\n\n# Test case\nassert find_sum([1,2,3,1,1,4,5,6]) == 21\n```\n\n### Explanation:\n\n1. **Frequency Counting**: We use a dictionary `frequency` to keep track of how many times each element appears in the list.\n\n2. **Iterate Through List**: For each number in the list:\n - If it's already in the dictionary, increment its count.\n - Otherwise, add it to the dictionary with a count of 1.\n\n3. **Sum Non-Repeated Elements**: We sum up all numbers that have a frequency of exactly 1.\n\n4. **Assertion**: The function is tested with an assertion to ensure correctness for the given example.\n\nThis approach efficiently calculates the desired sum in linear time, O(n), where n is the number of elements in the list.\n```"}
{"task_id": "Mbpp/778", "solution": "Here's a Python script that solves the problem of packing consecutive duplicates of list elements into sublists:\n\n```markdown\n```python\ndef pack_consecutive_duplicates(lst):\n if not lst:\n return []\n \n packed_list = []\n current_sublist = [lst[0]]\n \n for element in lst[1:]:\n if element == current_sublist[-1]:\n current_sublist.append(element)\n else:\n packed_list.append(current_sublist)\n current_sublist = [element]\n \n # Append the last sublist\n packed_list.append(current_sublist)\n \n return packed_list\n\n# Test case\nassert pack_consecutive_duplicates([0, 0, 1, 2, 3, 4, 4, 5, 6, 6, 6, 7, 8, 9, 4, 4]) == [[0, 0], [1], [2], [3], [4, 4], [5], [6, 6, 6], [7], [8], [9], [4, 4]]\n```\n```\n\nThis script defines a function `pack_consecutive_duplicates` that iterates through the input list and groups consecutive duplicates into sublists. It handles edge cases such as an empty list by returning an empty list immediately. The test case verifies that the function works correctly for the given example."}
{"task_id": "Mbpp/780", "solution": "Here's a Python script that solves the problem of finding combinations of sums with tuples in the given tuple list:\n\n```markdown\n```python\ndef find_combinations(tuples):\n result = []\n \n # Iterate over each pair of tuples\n for i in range(len(tuples)):\n for j in range(i + 1, len(tuples)):\n # Calculate the sum of elements from both tuples\n sum_tuple = (tuples[i][0] + tuples[j][0], tuples[i][1] + tuples[j][1])\n result.append(sum_tuple)\n \n # Also consider the reverse order\n sum_tuple_reverse = (tuples[j][0] + tuples[i][0], tuples[j][1] + tuples[i][1])\n result.append(sum_tuple_reverse)\n \n return result\n\n# Test case\nassert find_combinations([(2, 4), (6, 7), (5, 1), (6, 10)]) == [(8, 11), (7, 5), (8, 14), (11, 8), (12, 17), (11, 11)]\n```\n```\n\nThis script defines a function `find_combinations` that takes a list of tuples as input. It iterates over each pair of tuples and calculates the sum of their elements in both possible orders, appending these sums to the result list. The test case verifies that the function works correctly for the given example."}
{"task_id": "Mbpp/781", "solution": "Certainly! Below is a self-contained Python script that defines a function `count_divisors` which checks if the number of divisors of a given integer is even.\n\n```python\ndef count_divisors(n):\n \"\"\"\n This function returns True if the count of divisors of n is even, otherwise False.\n \n Parameters:\n n (int): The integer to check for the number of divisors.\n \n Returns:\n bool: True if the count of divisors is even, False otherwise.\n \"\"\"\n # Initialize a counter for divisors\n divisor_count = 0\n \n # Iterate over possible divisors from 1 to n (inclusive)\n for i in range(1, n + 1):\n if n % i == 0:\n divisor_count += 1\n \n # Check if the count of divisors is even\n return divisor_count % 2 == 0\n\n# Test case as per the problem statement\nassert count_divisors(10) # This should pass since 10 has 4 divisors: 1, 2, 5, 10\n```\n\n### Explanation:\n- The function `count_divisors` takes an integer `n`.\n- It initializes a counter `divisor_count` to zero.\n- It iterates over all integers from 1 to `n`. For each integer `i`, it checks if `i` is a divisor of `n` (i.e., `n % i == 0`). If true, it increments the `divisor_count`.\n- After counting all divisors, it checks if the count is even by using `divisor_count % 2 == 0`.\n- The function returns `True` if the number of divisors is even, otherwise `False`.\n\nThis script includes a test case to ensure that the function works as expected for the input `10`."}
{"task_id": "Mbpp/782", "solution": "```markdown\nTo solve the problem of finding the sum of all odd-length subarrays in an array, we can break down the task into a few steps:\n\n1. **Understand Subarrays**: A subarray is any contiguous part of an array. For example, for the array `[1, 2, 4]`, some subarrays are `[1]`, `[2]`, `[4]`, `[1, 2]`, `[2, 4]`, and `[1, 2, 4]`.\n\n2. **Identify Odd-Length Subarrays**: We need to focus only on those subarrays whose lengths are odd (e.g., 1, 3, 5, etc.).\n\n3. **Calculate the Sum of Each Odd-Length Subarray**: For each identified subarray, calculate its sum.\n\n4. **Sum All These Values Together**: Finally, add up all these sums to get the result.\n\nHere's a Python function that implements this logic:\n\n```python\ndef odd_length_sum(arr):\n total_sum = 0\n n = len(arr)\n \n # Iterate over each possible starting point of subarrays\n for start in range(n):\n # Iterate over each possible ending point of subarrays\n for end in range(start, n):\n # Calculate the length of the current subarray\n length = end - start + 1\n \n # Check if the length is odd\n if length % 2 == 1:\n # Sum up the elements of this subarray and add to total_sum\n total_sum += sum(arr[start:end+1])\n \n return total_sum\n\n# Test case\nassert odd_length_sum([1, 2, 4]) == 14\n```\n\n### Explanation:\n\n- **Outer Loop (`start`)**: This loop iterates over each possible starting index of a subarray.\n \n- **Inner Loop (`end`)**: For each start index, this loop iterates over each possible ending index to form subarrays.\n\n- **Length Check**: We calculate the length of the current subarray and check if it is odd. If so, we proceed to sum its elements.\n\n- **Sum Calculation**: The `sum(arr[start:end+1])` computes the sum of the current subarray.\n\n- **Accumulate Total Sum**: Each valid subarray's sum is added to `total_sum`.\n\nThis approach ensures that all possible odd-length subarrays are considered, and their sums are accumulated correctly."}
{"task_id": "Mbpp/784", "solution": "```markdown\nHere's a Python script that solves the problem:\n\n```python\ndef mul_even_odd(numbers):\n \"\"\"\n This function finds the product of the first even and odd numbers in a given list.\n \n Parameters:\n numbers (list): A list of integers.\n\n Returns:\n int: The product of the first even and odd numbers found in the list. \n If either is not found, returns None.\n \"\"\"\n first_even = None\n first_odd = None\n\n # Iterate through the list to find the first even and odd numbers\n for num in numbers:\n if first_even is None and num % 2 == 0:\n first_even = num\n elif first_odd is None and num % 2 != 0:\n first_odd = num\n \n # If both are found, no need to continue the loop\n if first_even is not None and first_odd is not None:\n break\n\n # Return the product of the first even and odd numbers if both are found\n if first_even is not None and first_odd is not None:\n return first_even * first_odd\n else:\n return None\n\n# Test case\nassert mul_even_odd([1, 3, 5, 7, 4, 1, 6, 8]) == 4\n```\n\n### Explanation:\n\n- The function `mul_even_odd` takes a list of integers as input.\n- It initializes two variables, `first_even` and `first_odd`, to store the first even and odd numbers found in the list, respectively.\n- It iterates through each number in the list:\n - If `first_even` is not yet set and the current number is even (`num % 2 == 0`), it assigns this number to `first_even`.\n - Similarly, if `first_odd` is not yet set and the current number is odd (`num % 2 != 0`), it assigns this number to `first_odd`.\n- The loop breaks once both an even and an odd number have been found.\n- If both numbers are found, their product is returned. Otherwise, the function returns `None`.\n\nThis solution efficiently finds the first even and odd numbers in a single pass through the list."}
{"task_id": "Mbpp/785", "solution": "Certainly! Below is a self-contained Python script that defines a function to convert a tuple represented as a string into an actual tuple of integers. The function uses the `eval` function carefully to achieve this conversion.\n\n```python\ndef tuple_str_int(tuple_string):\n \"\"\"\n Convert a tuple represented as a string into an actual tuple of integers.\n \n Parameters:\n tuple_string (str): A string representation of a tuple, e.g., \"(7, 8, 9)\"\n \n Returns:\n tuple: A tuple containing the integer elements from the input string\n \"\"\"\n # Use eval to evaluate the string as a Python expression\n # Ensure that the input is safe by checking if it's properly formatted\n if isinstance(tuple_string, str) and tuple_string.startswith(\"(\") and tuple_string.endswith(\")\"):\n try:\n result = eval(tuple_string)\n # Check if the evaluated result is indeed a tuple\n if isinstance(result, tuple):\n return tuple(int(x) for x in result)\n else:\n raise ValueError(\"The input string does not represent a valid tuple.\")\n except (SyntaxError, NameError, TypeError):\n raise ValueError(\"Invalid format for tuple conversion.\")\n else:\n raise ValueError(\"Input must be a string representing a tuple.\")\n\n# Test the function with an assertion\nassert tuple_str_int(\"(7, 8, 9)\") == (7, 8, 9)\n\nprint(\"The function works correctly!\")\n```\n\n### Explanation:\n\n1. **Function Definition**: The `tuple_str_int` function takes a single argument, `tuple_string`, which is expected to be a string representation of a tuple.\n\n2. **Input Validation**: \n - It first checks if the input is a string and whether it starts with \"(\" and ends with \")\".\n - This helps ensure that the input format resembles a tuple.\n\n3. **Using `eval`**:\n - The `eval` function is used to evaluate the string as a Python expression, converting it into an actual tuple object.\n - A try-except block is employed to catch any potential errors during evaluation (e.g., syntax errors or incorrect types).\n\n4. **Type Checking and Conversion**:\n - After evaluating, it checks if the result is indeed a tuple.\n - It then converts each element of the tuple into an integer using a generator expression.\n\n5. **Error Handling**:\n - If any step fails (e.g., due to improper formatting or evaluation errors), a `ValueError` is raised with an appropriate message.\n\n6. **Assertion**: The function is tested with an assertion to ensure it works as expected for the given example.\n\nThis script ensures that the conversion from a tuple string to an integer tuple is done safely and correctly."}
{"task_id": "Mbpp/786", "solution": "Certainly! Below is a self-contained Python script that defines a function `right_insertion` to find the rightmost position where a given value can be inserted into a sorted list while maintaining its order. The function uses binary search for efficiency.\n\n```python\ndef right_insertion(sorted_list, value):\n \"\"\"\n Find the right insertion point for a specified value in a sorted list.\n \n Parameters:\n - sorted_list: List of integers sorted in ascending order.\n - value: Integer to be inserted into the sorted list.\n \n Returns:\n - The index at which the value should be inserted to maintain sorted order.\n \"\"\"\n left, right = 0, len(sorted_list)\n \n while left < right:\n mid = (left + right) // 2\n if sorted_list[mid] <= value:\n left = mid + 1\n else:\n right = mid\n \n return left\n\n# Test case\nassert right_insertion([1, 2, 4, 5], 6) == 4\n```\n\n### Explanation:\n\n- **Binary Search Approach**: The function uses binary search to efficiently find the insertion point.\n \n- **Variables**:\n - `left` and `right` are pointers that define the current search range within the list.\n \n- **Loop**:\n - The loop continues until `left` is no longer less than `right`.\n - Calculate `mid`, the midpoint of the current search range.\n - If the element at `mid` is less than or equal to the `value`, move the `left` pointer to `mid + 1` because we need to find the rightmost insertion point.\n - Otherwise, adjust the `right` pointer to `mid`.\n\n- **Return**:\n - The function returns `left`, which will be the correct index where the value can be inserted.\n\nThis approach ensures that the function runs in O(log n) time complexity, making it efficient for large lists."}
{"task_id": "Mbpp/787", "solution": "Certainly! Below is a self-contained Python script that defines a function to match strings where an 'a' is followed by exactly three 'b's. It also includes the assertion as specified in your problem statement.\n\n```markdown\n```python\nimport re\n\ndef text_match_three(text):\n \"\"\"\n This function checks if the input string contains an 'a'\n followed by exactly three 'b's.\n \n Parameters:\n text (str): The string to be checked.\n \n Returns:\n bool: True if the pattern is found, False otherwise.\n \"\"\"\n # Define a regular expression pattern for 'a' followed by exactly three 'b's\n pattern = r\"ab{3}\"\n \n # Use re.search to find the pattern in the text\n match = re.search(pattern, text)\n \n # Return True if the pattern is found, False otherwise\n return bool(match)\n\n# Test case as per the problem statement\nassert not text_match_three(\"ac\")\n```\n```\n\nThis script uses Python's `re` module to define a regular expression that matches an 'a' followed by exactly three 'b's. The function `text_match_three` returns `True` if such a pattern is found in the input string and `False` otherwise. The assertion checks that \"ac\" does not match this pattern, which should evaluate to `True`."}
{"task_id": "Mbpp/788", "solution": "Certainly! Below is a self-contained Python script that defines a function to solve the problem described. The function takes a list of strings and an additional string, then combines them into a new tuple.\n\n```python\ndef create_new_tuple(string_list, single_string):\n \"\"\"\n Create a new tuple from the given list of strings and a single string.\n \n Parameters:\n - string_list: A list of strings.\n - single_string: A single string to be added to the tuple.\n \n Returns:\n - A tuple containing all elements from the list followed by the single string.\n \"\"\"\n # Combine the list with the single string into a new list\n combined_list = string_list + [single_string]\n \n # Convert the combined list into a tuple\n result_tuple = tuple(combined_list)\n \n return result_tuple\n\n# Test case to verify the function works as expected\nassert create_new_tuple([\"WEB\", \"is\"], \"best\") == ('WEB', 'is', 'best')\n```\n\nThis script defines the `create_new_tuple` function, which takes a list of strings and an additional string. It combines these into a single list, converts that list to a tuple, and returns it. The test case at the end ensures the function behaves as expected."}
{"task_id": "Mbpp/790", "solution": "Certainly! Below is a self-contained Python script that defines a function to solve the problem described. The function checks if every element at an even index in a given list is an even number.\n\n```python\ndef even_position(lst):\n \"\"\"\n Check whether every even index contains even numbers in the given list.\n \n Parameters:\n lst (list): A list of integers.\n \n Returns:\n bool: True if every even index contains an even number, False otherwise.\n \"\"\"\n for i in range(0, len(lst), 2):\n if lst[i] % 2 != 0:\n return False\n return True\n\n# Test cases\nassert even_position([3, 2, 1]) == False\nassert even_position([4, 5, 6, 7]) == True\nassert even_position([2, 3, 4, 5, 6]) == True\nassert even_position([]) == True # An empty list should return True as there are no odd numbers at even indices.\nassert even_position([0, 1, 2, 3, 4]) == True\n\nprint(\"All test cases passed!\")\n```\n\n### Explanation:\n- The function `even_position` iterates over the list using a step of 2 to access only the elements at even indices (0, 2, 4, ...).\n- For each element at an even index, it checks if the number is odd (`lst[i] % 2 != 0`). If any such number is found, the function returns `False`.\n- If all numbers at even indices are even, the function returns `True`.\n- The test cases verify that the function behaves as expected for various inputs."}
{"task_id": "Mbpp/791", "solution": "```markdown\nTo solve this problem, we need to write a Python function that removes any nested tuples from a given tuple. The function should iterate through the elements of the input tuple and construct a new tuple containing only those elements which are not themselves tuples.\n\nHere's how you can implement such a function:\n\n```python\ndef remove_nested(input_tuple):\n # Use a generator expression to filter out nested tuples\n result = tuple(item for item in input_tuple if not isinstance(item, tuple))\n return result\n\n# Test the function with an assertion as specified\nassert remove_nested((1, 5, 7, (4, 6), 10)) == (1, 5, 7, 10)\n```\n\n### Explanation:\n\n- **Function Definition**: We define a function `remove_nested` that takes one argument, `input_tuple`.\n \n- **Generator Expression**: Inside the function, we use a generator expression to iterate over each item in `input_tuple`. The condition `if not isinstance(item, tuple)` ensures that only items which are not tuples are included in the result.\n\n- **Tuple Construction**: We convert the filtered generator into a new tuple using `tuple()`, as the output needs to be of type tuple.\n\n- **Return Statement**: Finally, we return this newly constructed tuple.\n\n- **Assertion Test**: The function is tested with an assertion to ensure it behaves as expected. The input `(1, 5, 7, (4, 6), 10)` should result in the output `(1, 5, 7, 10)`, confirming that the nested tuple `(4, 6)` has been removed.\n\nThis solution efficiently removes any nested tuples from the given tuple while preserving the order of non-tuple elements."}
{"task_id": "Mbpp/792", "solution": "Certainly! Below is a self-contained Python script that defines a function to count the number of lists within a given list of lists. The function `count_list` takes a single argument, which is expected to be a list containing other lists, and returns the count of these inner lists.\n\n```python\ndef count_list(list_of_lists):\n \"\"\"\n Counts the number of lists in a given list of lists.\n \n Parameters:\n list_of_lists (list): A list containing other lists.\n \n Returns:\n int: The number of lists contained within the input list.\n \"\"\"\n # Check if the input is indeed a list\n if not isinstance(list_of_lists, list):\n raise ValueError(\"Input must be a list.\")\n \n # Initialize count to 0\n count = 0\n \n # Iterate over each element in the list\n for item in list_of_lists:\n # If the item is a list, increment the count\n if isinstance(item, list):\n count += 1\n \n return count\n\n# Test case\nassert count_list([[1, 3], [5, 7], [9, 11], [13, 15, 17]]) == 4\n```\n\n### Explanation:\n\n- **Function Definition**: The function `count_list` is defined to take one parameter, `list_of_lists`.\n \n- **Type Checking**: It first checks if the input is a list. If not, it raises a `ValueError`.\n\n- **Counting Lists**: It initializes a counter `count` to zero and iterates over each element in the input list. For each element that is itself a list, it increments the counter.\n\n- **Return Value**: Finally, it returns the count of lists found within the input list.\n\n- **Assertion**: The script includes an assertion to verify that the function works as expected with the provided test case."}
{"task_id": "Mbpp/793", "solution": "Certainly! Below is a self-contained Python script that defines a function `last` to find the last position of an element in a sorted array. The function uses binary search for efficiency.\n\n```python\ndef last(arr, target):\n \"\"\"\n Find the last position of 'target' in a sorted array 'arr'.\n \n Parameters:\n arr (list): A list of integers sorted in non-decreasing order.\n target (int): The integer to find the last occurrence of in the array.\n \n Returns:\n int: The index of the last occurrence of 'target' in 'arr', or -1 if not found.\n \"\"\"\n left, right = 0, len(arr) - 1\n result = -1\n \n while left <= right:\n mid = (left + right) // 2\n \n if arr[mid] == target:\n result = mid\n left = mid + 1 # Move to the right half to find the last occurrence\n elif arr[mid] < target:\n left = mid + 1\n else:\n right = mid - 1\n \n return result\n\n# Test case\nassert last([1, 2, 3], 1) == 0\n```\n\nThis function uses binary search to efficiently find the last occurrence of `target` in a sorted array. It updates the `result` variable whenever it finds an instance of `target`, and continues searching in the right half to ensure it's the last occurrence. If `target` is not found, it returns `-1`."}
{"task_id": "Mbpp/794", "solution": "Certainly! Below is a self-contained Python script that defines and tests the function `text_starta_endb` to match strings starting with 'a', containing any characters in between, and ending with 'b'.\n\n```markdown\n```python\nimport re\n\ndef text_starta_endb(s):\n \"\"\"\n This function checks if the input string starts with 'a' and ends with 'b'.\n \n Parameters:\n s (str): The input string to be checked.\n \n Returns:\n bool: True if the string matches the pattern, False otherwise.\n \"\"\"\n # Define a regular expression pattern\n pattern = r'^a.*b$'\n \n # Use re.match to check if the string matches the pattern\n match = re.match(pattern, s)\n \n # Return True if there is a match, False otherwise\n return bool(match)\n\n# Test cases\nassert text_starta_endb(\"aabbbb\") == True, \"Test case 1 failed\"\nassert text_starta_endb(\"ab\") == True, \"Test case 2 failed\"\nassert text_starta_endb(\"aaabbb\") == True, \"Test case 3 failed\"\nassert text_starta_endb(\"baabb\") == False, \"Test case 4 failed\"\nassert text_starta_endb(\"aab\") == True, \"Test case 5 failed\"\nassert text_starta_endb(\"abc\") == False, \"Test case 6 failed\"\n\nprint(\"All test cases passed!\")\n```\n```\n\nThis script uses Python's `re` module to define a regular expression pattern that matches strings starting with 'a' and ending with 'b'. The function returns `True` if the string matches this pattern and `False` otherwise. The provided assertions serve as test cases to ensure the function behaves as expected."}
{"task_id": "Mbpp/796", "solution": "```markdown\nHere's a self-contained Python script that defines a function `return_sum` which calculates the sum of all values in a given dictionary:\n\n```python\ndef return_sum(d):\n \"\"\"\n Calculate the sum of all values in the given dictionary.\n\n Parameters:\n d (dict): A dictionary with numeric values.\n\n Returns:\n int: The sum of all values in the dictionary.\n \"\"\"\n # Use the built-in `sum` function to calculate the total\n return sum(d.values())\n\n# Test case to verify the function works as expected\nassert return_sum({'a': 100, 'b': 200, 'c': 300}) == 600\n\nprint(\"The test passed successfully!\")\n```\n\n### Explanation:\n\n- **Function Definition**: The `return_sum` function takes a dictionary `d` as an argument.\n \n- **Sum Calculation**: It uses the `sum()` function along with `d.values()`, which extracts all values from the dictionary and computes their sum.\n\n- **Assertion Test**: An assertion is used to ensure that the function returns the expected result for the test case provided. If the assertion fails, it will raise an `AssertionError`.\n\n- **Output**: A print statement confirms that the test passed successfully if no error occurs.\n```\n\nThis script provides a clear and concise solution to summing values in a dictionary while ensuring correctness through testing."}
{"task_id": "Mbpp/797", "solution": "Certainly! Below is a self-contained Python script that defines a function `sum_in_range` to calculate the sum of all odd natural numbers between two given integers \\( l \\) and \\( r \\). The function includes an assertion to verify its correctness.\n\n```python\ndef sum_in_range(l, r):\n \"\"\"\n Calculate the sum of all odd natural numbers within the range [l, r].\n \n Parameters:\n l (int): The lower bound of the range.\n r (int): The upper bound of the range.\n \n Returns:\n int: The sum of all odd natural numbers between l and r inclusive.\n \"\"\"\n # Initialize the sum to 0\n total_sum = 0\n \n # Iterate over each number in the range [l, r]\n for num in range(l, r + 1):\n # Check if the number is odd\n if num % 2 != 0:\n # Add it to the total sum\n total_sum += num\n \n return total_sum\n\n# Test case to verify the function works as expected\nassert sum_in_range(2, 5) == 8, \"Test case failed!\"\n\n# Example usage\nprint(sum_in_range(2, 5)) # Output should be 8\n```\n\n### Explanation:\n- The function `sum_in_range` takes two parameters \\( l \\) and \\( r \\), representing the lower and upper bounds of the range.\n- It initializes a variable `total_sum` to accumulate the sum of odd numbers.\n- A loop iterates over each number from \\( l \\) to \\( r \\) (inclusive).\n- Within the loop, it checks if a number is odd using the condition `num % 2 != 0`.\n- If the number is odd, it adds the number to `total_sum`.\n- Finally, the function returns the accumulated sum.\n- An assertion is included to ensure that the function behaves as expected for the test case where \\( l = 2 \\) and \\( r = 5 \\). The expected result is 8 because the odd numbers in this range are 3 and 5."}
{"task_id": "Mbpp/798", "solution": "```markdown\nHere's a self-contained Python script that defines a function `_sum` to calculate the sum of elements in an array. The function uses Python's built-in `sum()` method for simplicity and efficiency.\n\n```python\ndef _sum(arr):\n \"\"\"\n Calculate the sum of all numbers in the given list.\n \n Parameters:\n arr (list): A list of integers or floats.\n \n Returns:\n int/float: The sum of the elements in the list.\n \"\"\"\n return sum(arr)\n\n# Test case to verify the function works as expected\nassert _sum([1, 2, 3]) == 6\n\nprint(\"The test passed successfully!\")\n```\n\n### Explanation:\n\n- **Function Definition**: `_sum` takes a single parameter `arr`, which is expected to be a list of numbers (integers or floats).\n \n- **Using Built-in Function**: The function uses Python's built-in `sum()` method, which efficiently computes the sum of all elements in the iterable passed to it.\n\n- **Return Value**: It returns the computed sum.\n\n- **Assertion for Testing**: An assertion is used to ensure that the function works correctly. If `_sum([1, 2, 3])` does not return `6`, an AssertionError will be raised.\n\n- **Success Message**: A print statement confirms that the test has passed successfully if no error occurs.\n```\n\nThis script provides a straightforward solution to compute the sum of elements in a list and includes a simple test case to verify its correctness."}
{"task_id": "Mbpp/799", "solution": "Certainly! Below is a self-contained Python script that defines a function `left_rotate` which rotates the bits of a given 32-bit integer to the left by `d` positions. The function ensures that the number remains within 32 bits after rotation.\n\n```python\ndef left_rotate(n, d):\n \"\"\"\n Rotate the bits of a 32-bit integer n to the left by d positions.\n \n Parameters:\n n (int): A 32-bit integer.\n d (int): Number of positions to rotate to the left.\n \n Returns:\n int: The result after rotating n's bits to the left by d positions.\n \"\"\"\n # Ensure that we only consider the lower 32 bits of n\n n &= 0xFFFFFFFF\n \n # Calculate the number of effective rotations needed (d % 32)\n d = d % 32\n \n # Perform the rotation\n rotated_n = ((n << d) | (n >> (32 - d))) & 0xFFFFFFFF\n \n return rotated_n\n\n# Test case\nassert left_rotate(16, 2) == 64\n\nprint(\"Test passed!\")\n```\n\n### Explanation:\n\n1. **Bit Masking**: The expression `n &= 0xFFFFFFFF` ensures that we only consider the lower 32 bits of `n`. This is important because Python integers are not limited to 32 bits.\n\n2. **Effective Rotations**: We use `d = d % 32` to handle cases where `d` might be greater than 32, as rotating by 32 or a multiple thereof results in the same number.\n\n3. **Rotation Logic**:\n - `(n << d)`: Shifts the bits of `n` to the left by `d` positions.\n - `(n >> (32 - d))`: Shifts the bits of `n` to the right by `(32 - d)` positions, effectively capturing the bits that would \"fall off\" during a left shift.\n - The bitwise OR `|` combines these two results to form the rotated number.\n\n4. **Final Masking**: The result is masked again with `0xFFFFFFFF` to ensure it remains within 32 bits.\n\nThis function should correctly rotate any 32-bit integer by the specified number of positions to the left."}
{"task_id": "Mbpp/800", "solution": "Certainly! Below is a self-contained Python script that defines a function `remove_all_spaces` which removes all whitespace characters from a given string. The script also includes an assertion to verify the correctness of the function.\n\n```markdown\n```python\ndef remove_all_spaces(s):\n \"\"\"\n Remove all whitespaces from a string.\n \n Parameters:\n s (str): The input string from which whitespaces are to be removed.\n \n Returns:\n str: A new string with all whitespace characters removed.\n \"\"\"\n # Use the replace method to remove spaces\n return s.replace(\" \", \"\")\n\n# Test case\nassert remove_all_spaces('python program') == 'pythonprogram'\n\nprint(\"All tests passed.\")\n```\n```\n\nThis script defines the `remove_all_spaces` function, which uses Python's built-in string method `.replace()` to eliminate all space characters from the input string. The assertion checks that the function works as expected for a sample input. If the test passes, it prints \"All tests passed.\""}
{"task_id": "Mbpp/801", "solution": "Certainly! Below is a self-contained Python script that defines a function `test_three_equal` which counts the number of equal numbers among three given integers. The function uses assertions to verify its correctness.\n\n```python\ndef test_three_equal(a, b, c):\n \"\"\"\n This function takes three integers and returns the count of how many are equal.\n \n Parameters:\n a (int): First integer\n b (int): Second integer\n c (int): Third integer\n \n Returns:\n int: The number of integers that are equal among the three given numbers.\n \"\"\"\n # Create a set from the input numbers to remove duplicates\n unique_numbers = {a, b, c}\n \n # The count of equal numbers is 3 minus the size of the set (since all unique)\n return 3 - len(unique_numbers)\n\n# Test cases\nassert test_three_equal(1, 1, 1) == 3, \"All three numbers are equal\"\nassert test_three_equal(1, 2, 3) == 0, \"No numbers are equal\"\nassert test_three_equal(1, 1, 2) == 2, \"Two numbers are equal\"\nassert test_three_equal(4, 4, 5) == 2, \"Two numbers are equal\"\n\nprint(\"All tests passed.\")\n```\n\n### Explanation:\n- The function `test_three_equal` takes three integers as input.\n- It creates a set from these integers. A set automatically removes duplicates, so the size of the set indicates how many unique numbers there are among the inputs.\n- If all three numbers are equal, the set will have one element, and thus the count of equal numbers is `3 - 1 = 2`.\n- If two numbers are equal, the set will have two elements, and thus the count of equal numbers is `3 - 2 = 1`.\n- If no numbers are equal, the set will have three elements, and thus the count of equal numbers is `3 - 3 = 0`.\n\nThe assertions at the end test various scenarios to ensure the function behaves as expected."}
{"task_id": "Mbpp/803", "solution": "Certainly! Below is a self-contained Python script that defines a function `is_perfect_square` to determine if a given number is a perfect square. The function uses integer arithmetic to avoid floating-point inaccuracies.\n\n```python\ndef is_perfect_square(n):\n \"\"\"\n Check whether the given number n is a perfect square.\n \n A perfect square is an integer that is the square of another integer.\n \n Parameters:\n n (int): The number to check.\n \n Returns:\n bool: True if n is a perfect square, False otherwise.\n \"\"\"\n if n < 0:\n return False\n # Use binary search to find the integer square root\n left, right = 0, n\n while left <= right:\n mid = (left + right) // 2\n squared = mid * mid\n if squared == n:\n return True\n elif squared < n:\n left = mid + 1\n else:\n right = mid - 1\n return False\n\n# Test case as per the problem statement\nassert not is_perfect_square(10)\n```\n\n### Explanation:\n\n- **Binary Search Approach**: The function uses binary search to efficiently find if there exists an integer `mid` such that `mid * mid == n`. This avoids the inaccuracies of floating-point arithmetic.\n \n- **Edge Cases**:\n - If `n < 0`, it immediately returns `False` since negative numbers cannot be perfect squares.\n - The binary search is conducted between `left = 0` and `right = n`.\n\n- **Efficiency**: This approach runs in O(log n) time, making it efficient for large values of `n`."}
{"task_id": "Mbpp/804", "solution": "```markdown\nHere's a Python script that defines a function `is_product_even` which checks if the product of numbers in a given list is even:\n\n```python\ndef is_product_even(numbers):\n \"\"\"\n Check if the product of numbers in the list is even.\n\n Parameters:\n numbers (list): A list of integers.\n\n Returns:\n bool: True if the product is even, False otherwise.\n \"\"\"\n # Iterate through each number in the list\n for num in numbers:\n # If any number is even, the product will be even\n if num % 2 == 0:\n return True\n # If no even number is found, the product is odd\n return False\n\n# Test case to verify the function works as expected\nassert is_product_even([1, 2, 3]) == True\n```\n\n### Explanation:\n\n- The function `is_product_even` takes a list of integers as input.\n- It iterates through each number in the list and checks if it's even by using the modulus operator (`%`). If any number is found to be even (`num % 2 == 0`), the function immediately returns `True`.\n- If no even numbers are found after checking all elements, the function concludes that the product of all numbers must be odd and returns `False`.\n- The test case `assert is_product_even([1, 2, 3])` checks if the function correctly identifies that the product of `[1, 2, 3]` (which is 6) is even.\n```"}
{"task_id": "Mbpp/805", "solution": "Here's a self-contained Python script that solves the problem:\n\n```markdown\n```python\ndef max_sum_list(list_of_lists):\n \"\"\"\n This function takes a list of lists and returns the list with the highest sum of elements.\n \n Parameters:\n list_of_lists (list): A list containing sublists of integers.\n\n Returns:\n list: The sublist with the maximum sum of its elements.\n \"\"\"\n # Initialize variables to keep track of the maximum sum and corresponding list\n max_sum = float('-inf')\n max_list = []\n\n # Iterate over each list in the list_of_lists\n for lst in list_of_lists:\n # Calculate the sum of the current list\n current_sum = sum(lst)\n \n # Update max_sum and max_list if the current list has a higher sum\n if current_sum > max_sum:\n max_sum = current_sum\n max_list = lst\n\n return max_list\n\n# Test case to verify the function works as expected\nassert max_sum_list([[1, 2, 3], [4, 5, 6], [10, 11, 12], [7, 8, 9]]) == [10, 11, 12]\n```\n```\n\nThis script defines a function `max_sum_list` that iterates through each sublist in the input list of lists, calculates their sums, and keeps track of the sublist with the highest sum. The test case at the end verifies that the function works correctly by using an assertion."}
{"task_id": "Mbpp/806", "solution": "```markdown\n```python\ndef max_run_uppercase(s):\n \"\"\"\n This function finds the maximum run of consecutive uppercase letters in a given string.\n\n Parameters:\n s (str): The input string to search for uppercase runs.\n\n Returns:\n int: The length of the longest sequence of consecutive uppercase characters.\n \"\"\"\n\n # Initialize variables to keep track of the current and maximum run lengths\n max_run = 0\n current_run = 0\n\n # Iterate over each character in the string\n for char in s:\n if char.isupper():\n # If the character is uppercase, increment the current run length\n current_run += 1\n # Update the maximum run length if the current run exceeds it\n max_run = max(max_run, current_run)\n else:\n # Reset the current run length to zero if a non-uppercase character is encountered\n current_run = 0\n\n return max_run\n\n# Test case\nassert max_run_uppercase('GeMKSForGERksISBESt') == 5\n```\n```"}
{"task_id": "Mbpp/807", "solution": "```markdown\nHere's a Python function that finds the first odd number in a given list:\n\n```python\ndef first_odd(numbers):\n \"\"\"\n This function returns the first odd number from a list of numbers.\n \n Parameters:\n numbers (list): A list of integers.\n\n Returns:\n int: The first odd number found in the list, or None if no odd number is present.\n \"\"\"\n for num in numbers:\n if num % 2 != 0:\n return num\n return None\n\n# Test case to verify the function works as expected\nassert first_odd([1, 3, 5]) == 1\n```\n\n### Explanation:\n\n- The `first_odd` function iterates over each number in the provided list.\n- It checks if a number is odd by using the condition `num % 2 != 0`.\n- If an odd number is found, it returns that number immediately.\n- If no odd numbers are present in the list, the function returns `None`.\n\nThis implementation ensures that the first encountered odd number is returned efficiently. The provided test case confirms that the function behaves as expected for a simple input list containing only odd numbers."}
{"task_id": "Mbpp/808", "solution": "Certainly! Below is a self-contained Python script that defines a function `check_K` to determine whether a given tuple contains the integer `k`. The function returns `True` if `k` is found in the tuple and `False` otherwise. Additionally, an assertion is included to verify the correctness of the function.\n\n```python\ndef check_K(tup, k):\n \"\"\"\n Check if the integer k is present in the given tuple.\n \n Parameters:\n tup (tuple): The tuple to search within.\n k (int): The integer to find in the tuple.\n \n Returns:\n bool: True if k is found in the tuple, False otherwise.\n \"\"\"\n return k in tup\n\n# Test case\nassert check_K((10, 4, 5, 6, 8), 6) == True\n```\n\nThis script defines the `check_K` function and includes a test case to ensure it works as expected. The assertion checks that calling `check_K` with the tuple `(10, 4, 5, 6, 8)` and the integer `6` returns `True`, confirming that `6` is indeed present in the tuple."}
{"task_id": "Mbpp/809", "solution": "```markdown\nHere's a self-contained Python script that solves the problem:\n\n```python\ndef check_smaller(tuple1, tuple2):\n \"\"\"\n Check if each element of second tuple is smaller than its corresponding element in the first tuple.\n \n Parameters:\n - tuple1: A tuple of numbers.\n - tuple2: Another tuple of numbers with the same length as tuple1.\n\n Returns:\n - True if every element in tuple2 is smaller than the corresponding element in tuple1, False otherwise.\n \"\"\"\n # Check if both tuples have the same length\n if len(tuple1) != len(tuple2):\n raise ValueError(\"Both tuples must have the same length.\")\n \n # Iterate over pairs of elements from both tuples\n for a, b in zip(tuple1, tuple2):\n # If any element in tuple2 is not smaller than its corresponding element in tuple1, return False\n if b >= a:\n return False\n \n # If all checks pass, return True\n return True\n\n# Test the function with an assertion\nassert check_smaller((1, 2, 3), (2, 3, 4)) == False\n```\n\n### Explanation:\n\n- The `check_smaller` function takes two tuples as input.\n- It first checks if both tuples have the same length. If not, it raises a `ValueError`.\n- It then iterates over pairs of elements from both tuples using `zip()`.\n- For each pair `(a, b)`, where `a` is an element from `tuple1` and `b` is the corresponding element from `tuple2`, it checks if `b` is not smaller than `a`. If this condition is met for any pair, the function returns `False`.\n- If all elements in `tuple2` are smaller than their corresponding elements in `tuple1`, the function returns `True`.\n- The assertion at the end tests the function with a specific case to ensure it behaves as expected.\n```"}
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment