prompt
large listlengths 1
1
| data_source
large_stringclasses 16
values | ability
large_stringclasses 7
values | apply_chat_template
bool 1
class | qwen2.5_7b_pass_rate
float64 0
0.69
| qwen3_30b_pass_rate
float64 0.06
0.69
| extra_info
dict | reward_model
dict | id
large_stringlengths 16
45
|
|---|---|---|---|---|---|---|---|---|
[
{
"content": "You are an expert Python programmer. You will be given a question (problem specification) and will generate a correct Python program that matches the specification and passes all tests.\n\n### Question:\nGiven the head of a linked list, reverse the nodes of the list k at a time, and return the modified list.\nk is a positive integer and is less than or equal to the length of the linked list. If the number of nodes is not a multiple of k then left-out nodes, in the end, should remain as it is.\nYou may not alter the values in the list's nodes, only nodes themselves may be changed.\n \nExample 1:\n\n\nInput: head = [1,2,3,4,5], k = 2\nOutput: [2,1,4,3,5]\n\nExample 2:\n\n\nInput: head = [1,2,3,4,5], k = 3\nOutput: [3,2,1,4,5]\n\n \nConstraints:\n\nThe number of nodes in the list is n.\n1 <= k <= n <= 5000\n0 <= Node.val <= 1000\n\n \nFollow-up: Can you solve the problem in O(1) extra memory space?\n\n\n### Format:\nYou will use the following starter code to write the solution to the problem and enclose your code within delimiters.\n```python\n# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\nclass Solution:\n def reverseKGroup(self, head: Optional[ListNode], k: int) -> Optional[ListNode]:\n```",
"role": "user"
}
] |
codegen__leetcode2k
|
codegen
| true
| 0.0625
| 0.4375
|
{
"part_1": "H4sIADn8N2gC/+1c65LayBV+lQ7+YUj1uCSBYKAySaW88WYrm3Wy2T+pmSksQwOqES1ZamZMufwueZY8Wc7pC0iixSBunrgYewz05Vy/c/o0HPOlMQ5EkDHRGDR+Zky8jcfsBz1CG+NwMglHi0gsYfqvQTqGsZCP2efGwOvQRpyG05AH0TBJ43mCJP4dL0iQMhJwwj4nLBXkH0sxizmBFdM0mM9Z+obgoqcwishHRqbhI+MkIJ8WLBMhLGzCyo8Rm5MsYaMQuAc43AKKY7VpyjhLAwE8yChOUzYq8yBiFggyD8RoxjJ4wYqkJKUkyDKYDICeAMbZmzt+x1+9ekX+qeUY3PEfpWi4f8aCMYknwDEK+QMbw0MmKEnZI0szJpdwsFuGa/AFTpMHAlIERIRzRiXPlIlFq",
"part_2": "gjOY7BsqAkB7wcSgjAkibNQAFcScsGmLJXbYCZiGSoCRo1Twj4tApA6VpwYn4rZmu9KujfkJzXGF/OPQAlWKBGBHI9RsDm4NUwihlMPuJQDtYm4ihdCLaUghiTB+JiSbBYvIlRiHsBwAIQE0ALZ0ZvzYKmoRgJ44Z7HIFogN74yyOvMkI15tNTSwOQ8Y9EjPEUaAIgRqDllYyD83//c8b98DuYooztAB93xn3iyEAPlkBty61KPtmmH+vcUdLgh3h1/vxByya1HXZhpwxxuNIS83Qi1c4TaVJFShFCqtzHPRAp2EJkk95vNzmvNpc1BIZf84Qaowz8c//Edx7njDj79Bba8AZPhc1cOK0bv4iiKn64WyYC8Be8vwdRZDNaSpE2gAKf3TbcFAQcykTmbx+kSIB+M2J",
"part_3": "+Urojrd3EKETFQ7pJxtNDInUgeIZ+STAQp+m8E0iDAntJQqDXAdCFjR8POsEZ8Mj6KYqAFwumtT6GYgVBjFoVzoJAiSj58+JDIKAVxyA9sEvJQEpwAojNgHi2v8ujFVaMIgpT8DC/RPAMcwp8xm5DhEPcPh03AzoQi2G4cSjhY4OaXmLPWajH+4Bpp3BtcuDGDu2AKH+644vkvrS6QMRx1rP/txzReJJotgmdA3ie4NIhujaQIoQGGcItc/dEyPZDWgEyapGAHSKWNcJ7EkCpH4AlIZ7A8u+N6DHAG1lm9BB/OVi8gczNML+jjCWRgIpYJ+lFP/16PThZ8JOI4ysoTOX7lKXSbdQ/onHwqD34MM0zDpVElenk0TjB7g9dL46hZbgyU5BNwyySKA9F8DS9et3B0AxQ",
"part_4": "1IFEFiGo43HEkjYgcYlQ3VVYbyBFDMZzI1Ken1tR0ukfmalDnGiO7Jnbr3LfUfAKTuEa9wsBAGSGQ9EJ3cJ8jj/KUqLXWs8lKD5jLDRdGtISKp1I1zIZZMGdDVLCZuJQkXk7PxMVUhhqpQ9QzLzfV/i1dsIJ9YC9oJJ95m8vfBVFWlCpxlYtuYL18ps7CgnhSSZRRPpH4gLAypcRQhCJiEF6Xg/xykP/fH+QAbDguWArHLWL6OztEjYCFo7OU5UtUcLaJu/OpXSa5FMhgpkMtaC6lmp+nWQgASkrb8OcT7FKpc3NulVKBvmU2xWycWCZg+FNx2GS4VJ7cK9UW8/kyn9GlJ6SCuQQu2Yyg0rpRG9ZTSiuYknKWlEOEDBFgKQZl86FlUV5RNQQ25yGR45LNlG/RTcpm",
"part_5": "oSMqOZhR7bfipKxMlektW80oLMhjQ25qWQiZxZtkYFCu2BCt7HaLmhCgWRKFeAuWKQVewzX6YRiOYUTLdSVTylXIrx6uphgEsGgUYz7DSLmE9SWsL2H98sKacZEuh0kMAIYQNQHQbL0pAB/jHQpPWIFoHs3Y6KE5grovxGuacQy+7ZSKYh27WtTURcz6vpErZ1q6MILH3Py6Nmq1jsShXeSwLppaLYPrujz6lFxT0qOkS4lPSYeSNiUeJS7wRJbdIsuOXNWVO2BfP7d8byVxf1uyLpF2HS3Eht6SZU7mlRa4ZU9BPEmpKym5kJZd5AEjLgy5MObBmAdjXsduGrnekdu7kpRcq/c4ioak1TmNreDXOM0vSlbwq1qad7u7v/N8zdjX5oHHNjy2kSM8duDRh0cfhYXHL",
"part_6": "jz24LHna0F7Jcfq/Z6m52r6eltXk/E12Y5m0/NPZ1GNg7bGghF8I9bRsMrICpQGjoqUp0l1NKmDBG4rgyjKrqEIv8gQxjxUqm0XtC0F7UkKuLevt7bVViThIVDc01p0T5yqrad2df2kY9zrqO37Cugo1GMEIKwR4gh3hP412gLJOyYnuk4p/Th6ybXe0tUkOpqkDCjnbMArZ0cFNoU8hUIFtDXwFBDPHsrXRUHtp+FWMucSWJ8fPX2WoMUNGvpFJSpPdb21p0n5uZyUB7Em/S0VU0noZMqdNsdpwTsbxdNK0rwGuW0nr13gt2vPvhu1S6FmUTTzNI5tu5o2+/boRHNUJuPi0VWCqadh+BxcDY+jalrHzuc38n6VgS3UNblzKGCvZu0ZypKR+tIrR68aKuqYVSlQLB",
"part_7": "F6zslCetdK6pBryMbF1bNdXJWY7nlhXf8U20LqVNXbnteFs1XjpXLSYrRSQKnK/KBycttfO7Sf3XSeq8HmYbTT5pdwoOprAdYY/jkO1yK/02DFghu/Fm6Og6Ed3mirU7AeAGYJSIlICUmJSQlKiUoJS4lLBcwtN16z6nq1s7ui1llx8JxDEV4RWCc7MXd8e6l/lndp9km9L+JSvOPNfttlsb9J+huUDocUlgeXDlvf47WnM8v7t/ktB1iwIhDlTOs0n4C0N4yvvLbyo/bsi4D8MZByNMj3pCY1/tpPoT3InPktRLd8nPvbrGyFWsv0x6XLS6/+pcXv0uL3onv1yaVV/2W06hu//JlnTywdkKbxB9j2MRyDISbSY9Ka5GMwehDh6CFr6abNLAEIfoc9m/tY09rwhdq",
"part_8": "vW3so5jBL89cjxY6ddNUAZunoWfVKpeR3N0jG0s2E6g518zyurOiKWk2pFqFHa2vYo6Zh365tOyy24D9PXJ89KpMrJbe0kzmt0qQhXGyQQzZD2XI4BMLrNrNyoxn27Zes9oq8xWYmbBQD0GPBgL8CTqBAHp0qh+J5VNz3IGbG0EXu9XvYcqTM0+puNjzczKr92tmKr6QTlfCmYW2LEK/Ir7lSAz3NuCByu9081e1xnD3l+dLcgPLhZgQVDa3/f4Th1NqmJXg55hwrNJRbUx4rwVViUxmPPYbxIpPHiRQ8AcmyzWAtCSFjoaBNlaqFHUXDbxf/77E5a7FRD0sbdQAqn+mqS1K2OGMjPAoC5cPE3iIYYokyjGUZ0hjcflEDkPMrqx/YZJY3cvVP4yt9fnO7sHld81g3",
"part_9": "9+k17dEu9SUHWKqJdAtEqnvutksEhHvAoE9dp0K4bW10Vtoe0O0CTbjMwL0GrjhwW4SLItz1PY96Hav4NfridtaHusZUfoHX851uVha+JOlLPXzadmgbPOLQjk99h/rA2KFdn/Yc2jNu7hUtuXffWh2Npcnb0upVUK3bhVbBHtAOjPuSZxsN4/ao26ceCNa2ct69raymwvt5Wb55Wd+0taOk2PdlZ+ggqgAc4HDwPcAAEHHt0D6wdUxcuk4xYnZs5drfe6UI3bk360C4XhfY1u+02pe9TFM9zFRoB2P1fkGa47RMHUlCcNbphKwdh1qUTvlUeqaZaZ8ThHpda8jXbE7aTbt6eh3Rt6BrVeQfs29oF4Fr2OBAA+yVyqsbe/YSxnp61+vT2TnL20+T6u6bWpjd8YyqK",
"part_10": "neK5aZnKTdNp8wBPq+dwao/Bqt10u1XoexfLxQP0907UyoYWv5Ynf5cn8AB5chGTtqlfeSo6RFKFXka+GfIk4UWkN2dUnKOX8c5Oziq+hZX4xyuAgGiAGGAOEAgIBIQCogFBINEQ3V1WrPtwi6EHWz10uBu95/+nreOPQL7yCXqbgVzvQaGwzP6Acfn9oxuv4dbA2x7i0GVjnbMYfdArfdn2mUDVHQEHBcMRzD7bmDo0Wf+WBNR/Y/pD7xNuqWUW/tD98bXe9qYMxE0Bl+s36eHn2HPA8HGQ2wYgHHPcf0r5/rK6RHHGci/sCwK+HSIn9ldPki6H+S/5Qe/XwEC9fK1P5eegO/za39EMM0ag9vGr2y0SDP8nhDaUB/5yNBu3H+ljTAbLngIIdAYiHTBvv4Ph63bINdTAAA="
}
|
{
"ground_truth": {
"compressed": "H4sIADn8N2gC/81ZS4vbMBD+K8KnBESxJMuOAz330GOPTQkh8TZhs06xnUJZ9r93JI29fije+LkJMQJZ881o9GlmJL86v5PLNT5ss+SaHZ2187pxnq7xPjtd4t1546zJxjlET2R/jPbPi/0uPpwOuyxarjebmMBvl6ZRkpFTuk13L9H2fEqz91GLY7Q7kK9E9W7jyyFa/GSUU0E9Kn8tKXmGdxza0ntOGbwV6v1yLBWiqkJQowRV9NQSUrKiJKDEp0RS4lEiKOGUMNCqlPpVpZ4e5WsJkAtLw/vPUwEIrbuGzVy0ojF1rbNkdDENJdLXEq6hfA3FXHiUEuhh0MWgj0Mfhz7u2Z2jx7ta3NdQeizKuAZDY3kTeQuefN1k1bTK0pqh5ZVnA9ZPomaJDoJWQCuUSmg9aCW0UlkLrQ9tAG0g0dKgtrYozxGPIT6K+QgjEdZDNYGc0KdIBYF0yC1v7HnlWuNmQ8yckgaKI5SHUMMsFsYlBprlkPAojdDH1ayE3VKhLQ00gpINUVQYUQXBFVfYxD7tyVUjOvlqd489+Qq7Rry3ha6hvtoGituK54rziv8r5Q2F7+axkbm1KOTikBWK+AjhIaTeVe585KtHSUM4wz7DREO2d/IZMs6/oVdVS+2JsRVmNosxkwSYVZTPc0KE1VnczPAoGiCULIWmMpER+lNnZmLRZLObONSh5V6jlCpMLU+hJDZ9IQOPb4/CjUKmUsAYzDLG6N7r6LUHYKhyyM2gXE1iNapypOJHlM11jDvVLp7+BDf3qxJsGx7hZpmBvbq1BypLYAr1uoxfQdwoaoqyoFouBO50G/veumrQyaRxnuW286yxk83M7e4JrQVqsmKu5wlivvq8Vl5a3FbbVqZWH1Zetv3t/P5QaKbTQjMv3SX8EMkVTwqq4pBzJNqqvonoYqGO7ESdkWh0xzVclwp2CKE1KTUrNS01LzUxNTM1NTU3DTlbDsL5qFUh6RdoXqGBu4NZfmN3TZc977x7Cue5wekTgx/jsHznkb/tDBk2oT+jjhhSaQ6vI1pvge1hzXLDWxYZ4sMb21G/WU70pUQ0/G8WrlhKXNzH4P0YbBmP94GeSoe/PSH1gJn7ipHVc7ts87OVbfi1D/7ma+aPy/mqvnMull+S6G+UpNH3b8nl+me5cd4c6qTZv3PkrJ3kCs3bf1YBMAMpHQAA"
}
}
|
codegen__leetcode2k___4
|
[
{
"content": "You are an expert Python programmer. You will be given a question (problem specification) and will generate a correct Python program that matches the specification and passes all tests.\n\n### Question:\nImplement pow(x, n), which calculates x raised to the power n (i.e., xn).\n \nExample 1:\n\nInput: x = 2.00000, n = 10\nOutput: 1024.00000\n\nExample 2:\n\nInput: x = 2.10000, n = 3\nOutput: 9.26100\n\nExample 3:\n\nInput: x = 2.00000, n = -2\nOutput: 0.25000\nExplanation: 2-2 = 1/22 = 1/4 = 0.25\n\n \nConstraints:\n\n-100.0 < x < 100.0\n-231 <= n <= 231-1\nn is an integer.\nEither x is not zero or n > 0.\n-104 <= xn <= 104\n\n\n\n### Format:\nYou will use the following starter code to write the solution to the problem and enclose your code within delimiters.\n```python\nclass Solution:\n def myPow(self, x: float, n: int) -> float:\n \n```",
"role": "user"
}
] |
codegen__leetcode2k
|
codegen
| true
| 0
| 0.0625
|
{
"part_1": "H4sIADv8N2gC/+1a/Y7aRhB/lZUjNUcExJ9gUC5SlaZSpEZN27+qEpE9s8DqzNpnr3PQU96lz9In68zagNcY26SJ1EZnnS7n2Z2v33zsDuTBWFBJUyaNqfETY/JVtGA/FJS+seDLJQ+yUO5g+S1b8GwDVC4WbGtM3XHfiBK+4oKG8ziJNjEK+T3KCE0YoYKwbcwSSd7t5DoSBHasErrZsGRIcNM9D0Nyw8",
"part_2": "iKf2SCUHKXsVRy2HgFO29CtiFpzAIO+imSeyBxkTOtmGAJlaCDBFGSsKCqg8g1lWRDZbBmKbwwXZSSFNM0hUUK8iQoToczMRNPnjwhvxR2TGfizSYGO5iQJI7ur7Z9Inp9cr/mwZoENARcwIiUbElCecoWREZKF+xlCQE/+JAN+2QreiD7779m4vWWokBiTVHXGxFncgrc18QemviAfHixzJn4OZNq0TJt",
"part_3": "N19Djj2/fcpvHfmdI/tkaI8snddp1D2wj8zm0PaU4tfbOKRCITcl9sBGG5/b+T8u/MaNKBRdfBWJVAIcQqZK0QDUD03yAlS9IOpvoNmORV5cg0L4BX8PrJkQhKeYMsDIVpAhoJUDlgnwwYKIJPmTJRGJENeXoFFJdlHAVomBF1S3j+GPUQLRBwsOiZalTAVnGYVhdM/FiqSSJhI0BJDxGLr7hMt8TxqFmc",
"part_4": "qTfUCLfMS0YSIII5C1i7KC9R4M5YIsWMg3ICHBTPrw4UOsMnIG2yHRyG+FSDCJwLNgS7LZvYOkSlm4hByZkmUYUQlRmCIGPTJ4mVMKBnyUWCi/OGFLDvVn8E0cQX0F4BLUAEhPZ6KgQRDAx8MrgLE+vEDBM8k3DMFaQtkSuYsRkGL5WUFdZiKQURSm1YWSvuoS+l/Ls2Y0vqsSb6BqoHYr1Nz0KjWKseQh",
"part_5": "/hU6elaigZNiCTmpsLt6Ci9Pe0gF2Pb9ZS65DBnA91jd/7PqhiBC6rMEahDj9+UqC5nuMAlol934UMh9sEsnQu5ADERlKz58CZ59p1KD1Dwo7dk1oaer9AwdcHp5oj9hMkvwdEsRrQr17pDkuTXAbhIWQiuzyPPD6kD0FM5pHHI8zVW04R0uBLdzvgAKbNwOkBREmHII/WMsvmosoEMlu3kcAQaA9B7jq9",
"part_6": "5QYYvBgcYGK4gcXHiC26sATiqObb5XOIl3HTwp9vSrraps79gb/B65RpJpOhNzhCV/lk/vKVbB2MRhmWUW23LHru+M3LFihR7dxKo3T/UoNgubTTff3L1vzX5pPIOcyRo1qrE/26/KoZArU+dBC445R8HQCFzZG6eAwJ6Myj9O56BZhYWN9nllji4maon0ecEtsFPGTsYjrznGuspDxPwOWgd6sBWHewFH",
"part_7": "HoKBfwFLpxw0hxN8TivEHXoOIjLxzcnEdhyfDczO+W/nMiYgYzR2HWvkYvWAhHFXdNvjr19sCn3qTnN4rItaQ4co1vSTTlzeJY45p0H0re6Vc+ipdlcdnmKwXaclUxSktd3K7N7nBvbePK+rfYf+Yzpj/aeziHbUzZqO53dPhgog1iWA6H3EbOteFx1Leh8+ItlcG+a/aMVWxy6sJoiKL+3XB6ucheV+Zd",
"part_8": "um7Q0BRc/0bc/HO3+3gsyzfzz0Js74AiT3VdZyil6mwzsTLP+ic7BbBjZkXz7vJrvHD+QeR/b/0Ady5Jv7PG7v4PcihSSbkqu9Y2DkR76AJFwq15VZ5IYGt5IHt2mv+DQjjSE+jx9mfN0BmmNxzSNVRsb0j4ecAKCfTsGwe7/POJ5mxqe+zlQZgXWu0+3n5t8yH4yLp3w1w2+ZB9ZPePTJt+JPnS+VsVeT",
"part_9": "P6pRYH+eL5WWqqlRTbUWteL+ou2ugUm7+Ok+VyfeluBYumE1ZulDbptlNRPuRRHUkSpPuS3KjreCNn2Vwba83W3drqGNw23L/vb8qptndZtqxtpmEG1NQM1M24xlS5D1w17XVJlmO1R4W7RqekI7i9fZGedssHyrrRiqjdBulu6Vd6vZtSaKtRNrpSRa2rNdscprNqvaQE5H1mb+FoDN883Kbwt3PQJWOw",
"part_10": "K1vcCs7z3dT47qZFrtVFYLxyXN0+rSN8sDaceTvG4a1fKyOpQ2V5eW08W02IZbpWpqz7cLpHvNQfE7HFIdsqs9s973jQ2T1Jg+nPlvJDjVwc2YLeY41CLWpuUNTB/6MTHNqfqBbTDqrOZ4s/+it+TyF8L4vZZnPn5D/E18QyzpKoVLvvErC7IkxW8n+8ZbKtfG+08wCaTzTHCIszGVScY+/QNNtqoD/iQAAA=="
}
|
{
"ground_truth": {
"compressed": "H4sIADv8N2gC/6VWbWvCMBD+KyWfFGy4XJI2EfwPg30tDNG6yVwFbdlE/O9LX9RWXXtxIdCX8OTunrt7kiN7322LbPmW74r8g03ZMWGrIlvk62023yRsGiRsma6CxUe6+Bwt5tlyvZzn6XiaJFngxny/T3d5cFkY/QSzALgGNyZB5j7MOJiVvwCkhQh1HxA5XIGhaJC9EAFtDAoVKyMjFVfYdbbqxbahonqHCucWyPGpc3wDsXVAYY0SUb8hfD427MZWmwNU/QZLNmtIg+inrx2RbHhAG7WnpCdPNE72u6jbEJKXnZp6MssNg5W/No70QLK7Ri+ZMxS7YTfrFUT5QOpMhMYHQ6tH4LYc9w2juJYlLdaAtSilSUOgdwPWm1i3SRQrKSJVNpPbIiZzTCgE5OKWI8sxasKohvBTC0o2H2gMDaa9gpP3yTTCo5EuYotkK7pCoJJDNVMx+1DDwEP+Qjx7qMkuXkQJZNyd9D0I5MMDITQeZXHDivBipastMKhpfqdWV6GvfA60CvxHpAVVn1Hfn8KEW4ZoV2RbxRABNXdcajCoDShyh9a9EHNtZezD57nrhs5ZTyv6j6QZv4OSWI19lVjP+vb4ut0U5b1yNOZfh5ft9zhhJzZh+/ywSd3Nc1e4x+kXuQoqJJEKAAA="
}
}
|
codegen__leetcode2k___8
|
[
{
"content": "You are an expert Python programmer. You will be given a question (problem specification) and will generate a correct Python program that matches the specification and passes all tests.\n\n### Question:\nReverse bits of a given 32 bits unsigned integer.\nNote:\n\nNote that in some languages, such as Java, there is no unsigned integer type. In this case, both input and output will be given as a signed integer type. They should not affect your implementation, as the integer's internal binary representation is the same, whether it is signed or unsigned.\nIn Java, the compiler represents the signed integers using 2's complement notation. Therefore, in Example 2 above, the input represents the signed integer -3 and the output represents the signed integer -1073741825.\n\n \nExample 1:\n\nInput: n = 00000010100101000001111010011100\nOutput: 964176192 (00111001011110000010100101000000)\nExplanation: The input binary string 00000010100101000001111010011100 represents the unsigned integer 43261596, so return 964176192 which its binary representation is 00111001011110000010100101000000.\n\nExample 2:\n\nInput: n = 11111111111111111111111111111101\nOutput: 3221225471 (10111111111111111111111111111111)\nExplanation: The input binary string 11111111111111111111111111111101 represents the unsigned integer 4294967293, so return 3221225471 which its binary representation is 10111111111111111111111111111111.\n\n \nConstraints:\n\nThe input must be a binary string of length 32\n\n \nFollow up: If this function is called many times, how would you optimize it?\n\n\n### Format:\nYou will use the following starter code to write the solution to the problem and enclose your code within delimiters.\n```python\nclass Solution:\n def reverseBits(self, n: int) -> int:\n \n```",
"role": "user"
}
] |
codegen__leetcode2k
|
codegen
| true
| 0.5
| 0.6875
|
{
"part_1": "H4sIADz8N2gC/+1Z627bNhR+lQMVWO3BCSz5Fhtph65dgQ67d3+GuXBpmbKJyKRKUnG8Lu+yZ9mT7RzqYvlSKwWCARukBLFFHn085yP5nUPlo7dglhluvYn3Hef2pVrwV3lLx1uIKBJhGtstdn/DzBbbhFzwO2/iD/2Op7RYCsniWaLVOiGM31QKTHNgEvhdwrWFn7Z2pSSgxVKz9ZrrSyCjjYhj",
"part_2": "mHNYilsugcGHlBsr0LCFlvOYr8EkPBQ4PKPmNiIusoeWXHLNLI4BodKah4djgF0xC2tmwxU3eMP3oRxSwozBToZ4Fgc2l1M5lU+ePIGfcz8mU/kLv+XacJgLa0BFOF7mbC/ImlJpxFLyBQhp+RIDm8oflOUTgqIvmR9CglFrDjGTy5QtuemAScMVMAPfslvWIQeRMGFAqiNIsNuEX8IbiVZoEeK8",
"part_3": "dGCu7AoNktS6UFRq6esBoRgbnMT6dcW3YFYqjRc4IkJEEVG4VakGsU6QeS6tI6pDKERfDvDUuG8aJxwJkExvQfNEc1M8QEE4utka3dysOIUGwlJ77ovSZYxIF8ZVcoCTuU5EjA+UoDnaXhRIuxFyCQF6Q09k/lIkzgUXn+aR0ugBUv/NHSMbCIDN1S3v5PEQYWeHgYueI5d6coJr7P3uqDfq+1fB",
"part_4": "wK2lv/+aymJw3y2JNzTqBCQ8g667fPzJ/tANXu4eP7pT+aMbcwJ4jYd9fzT0xwG08m4/sz7C6LZpzARXmuNiQlzkwebzZawm8urGP4z1aFn2e8HQH4yHuJYVGttUy4qfm5XABU5b5JPLpC4Sx2E5eYf8+Wevrl/lrxcEfhAM+iMfWtlwn74eyl/d+PX8BeP+eDgKxr0qgxVXH0BhXTDlMnypJPrN",
"part_5": "cGzjiNxFtU6NJc1gB/Gh2MVcLlFmekGB8lrFsdpAmkzgTZTJUZTKsPAmRCnFANdMbsGKNcncCs03TmdQXEAl2Cz+wKHtV4SZye1rpVGo0a0yJ6SGO84iNx55YyzTKDu43RfYpWCjhc1sjIpT5wC20n2ROmjnchnGCrGcsLlHNwK9lrDgMTqCgCT679+/T1zymKI55gR4m0OiS7T5FjxC6l0e+Bpn",
"part_6": "o2V4HHUAlway2YaL5/SZm9LlADFJ4lxFArOkh4qqMAmGGAx3XJmpzNsyrstbpGFV3mBS5sQi0RRhbiXtJiry7i/zVjcBSsXmsKMy3mEXRX7ymRVnyYfDxrkwlB0OWvNlctCqEsrLSh+2U2SVNgxSRriJo1gx23qKN0/b1Iq0FUXAzAobc6SvScFNCm5ScJOCmxT8+CkY9RZ3Ke5UGZLUPkb6Y5hu",
"part_7": "cGvtGiLKBiQCGqWXt3pBu2JdPPHnM2hJ+AL8NlxfQ6vnwwWI9r6dhOfPcdHtGvP5YpRQMRKTxILOn45kvMcT7M1MLLAld/+C8gV2ZIJFIf7nY8aVqLezRKE/GEsRRat9WfGeqMCciv0UFh6Iw5tWiKoqqMIoHKOzMBUpRXvLCWQbnpVxnbTwnUXg90f9q96wf3XONBeWQmoqepOpJiH5o2DUHwxG",
"part_8": "Z3B2g2VPnDEt9NEZlsJ4LuB5nSY/GGqnLe6RnaicpahGGB3SlT9CAkbdUQ1S6fuJz2za+gHG0B0NzwF1z1+1c+B3z/9kAMjOYNBDTs9OTp3gPxbTBZJ/1cXV1h+Pi8pUb5v3W01x3RTXTXHdFNdNcf1577fgf/R6qwjthTQbrifQKkJC927FAkmKXNDOIZiz8MaK8Ma08xOHSXC6HuvAgXBpbD+z",
"part_9": "/n4Cb1cissXDObkxj9z3NbvhoBW9XUMg6pH8jjaI3UfJn76+3ivRM/wXi0WOyXAB0t5w2Vk6GFp9bkozhJOoeDxwp4PTjpcLQovlyjmN1IfcmDPufuowUTjh/rOHe2aWZQNv8vvHrAFnykk6GhRdXte77+x3+9XuXZV+bFdzEKjCFOeBI5AKftX8yK5Q8apVqeJH1vX1/8NwdtpXtd9p3wlOzl97",
"part_10": "MOUB4CTMubJ/b4aK6v8YpabmP894XcG/93RZ95+YiroM9CjUHsCUFb93/67jrbll3uTjyf+BUwmNCscXMzpUEJ9df3DRvbrojjDzT9wvmlFJPCNtfiS1q74hp3cb/rjbvDNvyvqmrG/K+qas/7femVu2NFgdeSjY8D2TIkljFxt2vRJU/7oNiM7TKyPv3T3WVWaWSoG33sTqlN//A5YWyGN0JQAA"
}
|
{
"ground_truth": {
"compressed": "H4sIADz8N2gC/61TXWvDIBT9K+JTAmN4jR8x0Jf9hb4KI0vsGhoMGDMopf99Jq7ty7jdw67BK+R4PJ7rvdDPMC2+f49hiUfa0Iulh8V3cZh8O1raEEt7dyDd0XWnomt9P/RtdGVjrScp2nl2IZL7j8KTHWEl2aUZg8AG4SC0qCslahQLjME6YF2t6zznzPJpoLkWUmqM6HFc3oJhRcUVSKM2pFECtALD0Vt/sIewm7pNM2z5R+ifuAQ3wijNTbXtqTgHzqXQgPuER6aqQScTNNPPqO7yf8m5eoKnazCtUCaGx/NKAMNHZkgOSVklY/ES4Q4x+De7b1RQs/TshDGJKn+5lfbTuKxNVpSvwX25MLu3Ic6lpVf6Qud4Hl1qxrCkdP0GOFsKLqQDAAA="
}
}
|
codegen__leetcode2k___28
|
[
{
"content": "You are an expert Python programmer. You will be given a question (problem specification) and will generate a correct Python program that matches the specification and passes all tests.\n\n### Question:\nGiven the root of a binary search tree, and an integer k, return the kth smallest value (1-indexed) of all the values of the nodes in the tree.\n \nExample 1:\n\n\nInput: root = [3,1,4,null,2], k = 1\nOutput: 1\n\nExample 2:\n\n\nInput: root = [5,3,6,2,4,null,null,1], k = 3\nOutput: 3\n\n \nConstraints:\n\nThe number of nodes in the tree is n.\n1 <= k <= n <= 104\n0 <= Node.val <= 104\n\n \nFollow up: If the BST is modified often (i.e., we can do insert and delete operations) and you need to find the kth smallest frequently, how would you optimize?\n\n\n### Format:\nYou will use the following starter code to write the solution to the problem and enclose your code within delimiters.\n```python\n# Definition for a binary tree node.\n# class TreeNode:\n# def __init__(self, val=0, left=None, right=None):\n# self.val = val\n# self.left = left\n# self.right = right\nclass Solution:\n def kthSmallest(self, root: Optional[TreeNode], k: int) -> int:\n```",
"role": "user"
}
] |
codegen__leetcode2k
|
codegen
| true
| 0.1875
| 0.1875
|
{
"part_1": "H4sIADz8N2gC/+1cbW/jxhH+K6zyIXZDG1wul1wKuRZN0ysCtEmLuy/F2XB0EmUTJ5E6korjBvkv/S39ZZ2ZneWbKJmydWkC2LiTxCW5Oy/PzDyzov3TZDGrZmVSTaaTvyVJ9ed8kXzNI+5kkS6X6Xy7qh7g9N+TRbpdw2iaLZIfJ1OhY3eSF+ltms1WN5siX29wln/lW2dWJM4sc5IfN0lROf94qO7yzIErbovZep0Ulw5edJ+uVs77xLlNf0gyZ+Z83CZllcKFZ3Dl+1WydspNMk9BgBkOn8OMC3PTbZIlxayCNZx5XhTJvL+GU93NKmc9q+Z3SQkHSXcqmmkzK0s4OYP5Kli4vLzKrrLPPvvM+SfLMb3K/kqi4f1FnldOvoQV34O6xYNTJrNifudURZK4NB/om2ZVcpsUzgfXKZJqW5hbP1R3TrmGdWBa54fZaps4Z+KCjJgszmlSlAGupJMljuBRBq4oYU46wHVAwv/+5yr7y4+z9WaVOGKKEl9l32SbbTU1Er5y3klXuIGbbVcr1792nQ8wJq6y77YVXSXwDjuDPzyDcqUbur",
"part_2": "6dhV4ETyWbqSTeigL9Oc/KqpiB9iVN+BaF367fgyVAlR01nLR0MtBFOF++gjnhJcMX4QVXmYefvoU7LsEW9ahZ5nW+WuX3znYzdb4xFvrqzVucbJ0DTtNkAatV4K6z9DK5dJ37xJmDTxY5rF0iDNFJi2SVAG7yDeIHfFwaVD0AHLMEZqhyZwme2fXbskgAn1m1enCdO5DiPt+uzH35pkrX6b+TPxpbIoJe5wVgD2xRw3xbJjTnknRIs1unrGZFBRaag7K47H2RVuaaMl9tCaUwisc2GlDQJJuvcpgLFuZb79PqDowLioEUMCHi+Pvvv99QPIA4ztcJaJTShMu8aABMrkDnXOJV8xWEg/MWxtD6UxzCn0WydG5u8P6bm7MyWS1dBOkrz3VWybJ69W2eAfohBdyZz+f1jfiD15MfX+FNO2dwBjiFbzvnaEo4Se9XmZHuDRsGFrGygY/esItYPATx1PlugxfOVu+sRgjfKQbouXPxB3yfkpkgm20KMBCks0m63uQAkzm4CDIKguMq4zGAN/isPgTn3tUHkD8TQECCzl9CEnSqhw06mE//",
"part_3": "nkeX22xe5fmq7J9ordc/hf4cvOcumW0+9gffpyVmwt6oEb0/agIA4NAbR81aY6BktgQ3LFf5rDr7HA4+P8fRHbQ8ESv7kLIfJ4dQcpWhCIjrG8T1mUmnU2eVlpVdLcWExGm4bEnA+RoFM4OcDK2OPNk77/qcJzJ5FT9CYoCc/goMAJ/OzluDl7PNJskWZzgZj9/fpZB56WxreZQXZjA3bfINKmtnYrFT50uwQcaCmLzFQqXXlFNBYJS/Na2d2tqwr016fd69uCN1fWdbEOeLWu9TCGZd+ATJ6NY9orE70e4WF2l5U87WyQ3i42zjOh97kNiQ4Pjp4y4u3hZbxgXkWXs9hM+ey1/PVmX7+g2B+3fgYPzwyPVlsntBV3hyCmhgnENy9y4g2+AV1khXGaQ6y7BuqrRaJZDyXvjNC785gt8AhKBYJgWwEETPC7fYzy3qFStE1bvrZsQUABNvBZ7vpUVIF7ROd5TnGigo7R9GOL5dduvlQGrp3YSzQ+U5G5j2g3PRSfotUUG7V443MGsvC1926vqQvOwOwFi5WaXYSVLMwTF0ox9u0gWMgE",
"part_4": "suLGQvAOprQCxkmovZxfsS+9V5jnGP7nmB5ws8PxE8AXPFw80mB0sCyqxnzs4vWx5B1OLbdIKumt8l8w9nkK0XKXYLlnjgBgQ2HHb8jNdrGCwXO8Kaf33O1e4clRKj52jKHc1DL8JOJmkyKnUjp4tcR7qOUK5jQsC8xq7je90h8+qj3LhSYMRWp1iIp/Rpymj0jHBvADPCxL7rhPDJN1ILWgkWiuwqwjMr+/6QTvteNdwEcwkUGxfCJXAsZnmFMjYIjvAdSqZJ4IBkjkncfRJEYwRlaUISJhwtC9pEsVnaptKd+YQePaFvjazY4JExuOSF/GYJOAFa+4+q54csTHSsMC3t5JB2wgbKWM95RrGIlZPwHsK7Vs06cBjgsngK/mv4HBs4xgZFaCEflJfofrwR3hUch3AuhPcI/msY0/Aew3sM18RWYumRyLHfkbnTKBzlHb3HOyOgJjxIN625r8/PRxtSmzRg7BLWfgm6iwXkMyG77vdGr4KukWx/n/2C/hCeZxZHM6APA/Yp+hHNLRg43ZzXPZb1cdA7E3nGiZw/ZJ3l6utifUwGOuwF",
"part_5": "bfLleKtIxkDAGLCWUQ0GKGitbbRNV5QGbQrElC2NFSRcHeB/mxJ9A9JAPw2k5B5FUrbjjTBbR57HkeextwSpFRKmWzmNY81GY8TBKjzyMk2Lmkm6vl5Aq+f757fyaoNLHY7m8d5TNXGITMLj+DHVuI2jeEwtDvefEnp/WKinJ6cjk2QdDljMggMU4pjMivHj++NFttWnFdN1JWrFtGxKj9QmBRyWyvqqb/DGb039lki55DjkBXBtAPMG4WOZTaqnl3vSW7fIVUjO2FFQNhWoU2uOYBraoD4ybFQyYvyalQojFwGFaQI5q8VSNcPNb6XZiOHnMb6kwZgfGkf6cWN2aWX3jeH88SVBGO4njPSxWZ8w1IlZ2QK73y3K4uRO6jqmHWq8suHd6hm0m/nHAd4dj43cWkJrF30kgEYknU6isZGsWio0opKresS6aeWaLNUK3kcTsazvkpaQ++rYEB1DPqzmeJk0BETVaIkHeAjbg4JAGz6GeSWImVzDtSpCkt0VOxifXzWLKXyWOaxpZOA1jAS1iCzhb1iJMpEUs26sfs1J2sSzxUuU5SVBTU",
"part_6": "5Cr5sb9Ylz41DOP1ip1JHNetP+CxJnYIfBrxOA33SPe8vIgUj0WhlrkG/XHKQX4UL9QpyL6/wRScIWjI4NOnsx45tZ0WmCxVHFQhub2hzK1SLoRKh1dGSsLHc6qk9g0fjYajSCOLW2K1rUqQZrNNwYYWalygxjEveo/G5zJMPjSoPXlALVNGfdUK7XZRmFLXSDBbzLJGoWgff397biE+7vHb1lqGtPsLZenUGa3bMBsnBsMJqNR/HEnZVju2rJBcA7kMEOZDd5YNdM1aANVbNt9Jy9moC3VTsR36aunZjvZjfhnZwcWBtGo7qXkMGu21SH9iyYXBzVcx6JquGtkE+3x9jlonWaanTXuyhhnXn7kbmvbu9caX0KUzBZ0CftanXj3aGONur3eTskOuIuinMfkcc+UTyCZlGUSAoZRUAyjV3McSNYbPttguq0C+JkO9vBLxB7YjfY+s3aQOLqs5dBdld7gLOyHE9rgg5D7/LyXvXss3DRJDKLENtfx7xlgS0FUld4D3HrGt4jeI/qisnfvYmnVZHnCR/V3zHUmz1RC9nSuE1J0w5RwMN7",
"part_7": "hACKfjMblfIZO3uP7iyrbr41nRiln9DuC3NH0s6/kdfKwcK2iab3C+xqZm86shvUIq6/8GTiIb3T6TG4Qx7UUsTdHXKry8DuuNGh2R332Aoipnu9bpkDCZ6G++f313Xe9+tPTS0I609Rrz482nh3G0N1ajD/P3iZGmLgn/jbmS72mj67/jK0nc30MAx7myEMQ1vwhixpHo8sHl5+g+XlCc+X32Dh32BxXn6B5Vf+CyzWYX/KyvukmDpn1lFg9B/SBQBiSa4kMzvvZ/MPVTr/UJ7zw7zlBhD08izv2IclwXy9xyXnW8jemX1KsDWeb2nUa4b6z1ia6cDUPEfvKUVz0fC5Whr7wCVfNvBwZCMgfxp48rK5xkw68Jyl0eeLnecs06VVFTLh0NObporYtXces9wVr3nQMsWkfpNTsp5M3/1kBgCshwoF3GfvmIjJz+7uXQeLQ/t2OXh7BLcD0WjujV1gJs2hEcfKE3TkUeNn5Pv99v3R4O0xaAJNnA9KAcMDWQTMp9yINfNwbmhDehIOvWgXGCAQQKCG0JFDDy9ia1bV0SPYa1hNhg1BBT",
"part_8": "G4RHRYBF4ubK8WDi4GeinSrFZUD90s9ODdvrGKIvNEaB5J8/l2Lhdaev+AsH7Iq0UjVrOyyh1ZxeN4A+oMckYkKtBaIMbAZs10ngtcGQguMGGgzzF6Pkb/gXZAlCV4Aq70XaVdaOBD7QJb1r6rtRv7LnQysZVCem0xYv9xk+kdkz3iUdFZ4t314BIaAwG1CNlM7RANwHhCDlrdG5wNLCXJKj7ZCSyE/Yggc4IhAzIq2BIsIchD7fBtHUg+CNqD0FqCNU3USI5aPh/rMbF2wFS6E/PDyknyRkDeMPop9gbC2SioKR4xpE08Q1qRqI2M3AD+2dj2O64J9kGYVhANGhEJjEqPUOmRGbH/wu4Ndy5MgBIYDUojAi82a9ir4fN02Klhj0ZTafVEy/2aXixC1QjAgxGoeiCyGXmYumunxQcTdzg4KvQeWI0RaEyQM5QgPwaDBeT4dODvyTgmy1mMc7qzGJec46TGMNi7qLFkxzLWpja/SyiY8hHPBsA0AjcIx4SsVI9WAdRB2xIZuronsLT5byjd7QlQjVCKkAtI8ptvGIHAJdFfVC/QmMwO",
"part_9": "NPnYt8khIn975FeJrvVDNLAfs3mklcXv6OoPpyeBZVmgNDEugN6rcS0tgvzBZC6ON17LZA1CefIO6tWjvIXKzzBxiR8FN69u9dKPe21/vDVRZoCurFxWCLRjm6BYEmqjskb3gQwi+Vpp2YyvRgD5QO0xKsBJieVHGX/F3RpEKiGiNJZUCKkgJpYSuCoCrjIoSTCcITStjjvBPtUgKvCBx0UJpIoMLbJ1SSEOYxKTFOCqVNOAujApU5gCLk6hNxjo+uhA76ek/RlSPU78uW8Qrur3IL4JC5+57WBCG8auZ+Nzh8RwPWqHgFCfqHh2y8Oe0KFM1lJoqOMaptRifLMINtRoDJMZKJMFNaSN+SO0i3TV6c0Qj0iM+4tk3cnYMsnQiPqUEDIF5vjQldBK+oOsUIZ705fHKUsx7WxQz1PT2oKya78ANHWGiwxcvqfljI9unce03tqYimT2TDBx99orKeOh2+nYhf9k9i4pO3nDYTocvXK4YVWMhVAN9nt7m7GA9hNq6Fvi0GB/MFqF94SiYVSODtO4kBCj67KGfQzVmVG8eLQHR/VDx3XlbX",
"part_10": "LAYWjV0F0fGQWoWze0Q9f9pdZPV6lbTfSxdFuz5ftcO2pT1g5jiYg5UkRjkd9T1ffUTxcjEugAeBJ5akwAFCSJ2ZxSQwxLHLn3EpwMtaIL1A4R7Ydop2TtlObaUN00IofrWNDwnobvtFJxm+EIjlvjIcPqY2prgH0BhYjdULhh7EbCjeoU3N0OFScQIjI7VNzARRYiEs2oJDJABH/kRuCv6NfV0ctRHf3efRLV5AnimBhoodn0IJJWJ43Is3lDGG5L1DUwk9LWSmS2V/C5EA6rbtGR3jP3cAJeKG72cIx4vQ0cEsxu4HikCz7tgQ97DOVSWO9UNJ6zkM/vNiuF/B61s9R+ct+msuoUEDlxYVUjKMyTvGrpO+8U1yGqd9zbboOMe2363NH12p2sk2o2mf605w+H4lMJ61mVLG7wgRHaPRDqwtMXXuR43pT+wWWrWXZ7g98Nv3wveeB7yfbf88I/juODt17+wtfL8x/P/Qtf1ey2nEzfTRB5cPh1sqnuLl6nBUzxhhADg18ZBJljh6/kQTq6/tmdpOXNNkthzcm0KrbJz/8DdiuwSWtYAAA="
}
|
{
"ground_truth": {
"compressed": "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"
}
}
|
codegen__leetcode2k___36
|
[
{
"content": "You are an expert Python programmer. You will be given a question (problem specification) and will generate a correct Python program that matches the specification and passes all tests.\n\n### Question:\nGiven a string num that contains only digits and an integer target, return all possibilities to insert the binary operators '+', '-', and/or '*' between the digits of num so that the resultant expression evaluates to the target value.\nNote that operands in the returned expressions should not contain leading zeros.\n \nExample 1:\n\nInput: num = \"123\", target = 6\nOutput: [\"1*2*3\",\"1+2+3\"]\nExplanation: Both \"1*2*3\" and \"1+2+3\" evaluate to 6.\n\nExample 2:\n\nInput: num = \"232\", target = 8\nOutput: [\"2*3+2\",\"2+3*2\"]\nExplanation: Both \"2*3+2\" and \"2+3*2\" evaluate to 8.\n\nExample 3:\n\nInput: num = \"3456237490\", target = 9191\nOutput: []\nExplanation: There are no expressions that can be created from \"3456237490\" to evaluate to 9191.\n\n \nConstraints:\n\n1 <= num.length <= 10\nnum consists of only digits.\n-231 <= target <= 231 - 1\n\n\n\n### Format:\nYou will use the following starter code to write the solution to the problem and enclose your code within delimiters.\n```python\nclass Solution:\n def addOperators(self, num: str, target: int) -> List[str]:\n \n```",
"role": "user"
}
] |
codegen__leetcode2k
|
codegen
| true
| 0.5625
| 0.625
|
{
"part_1": "H4sIAD38N2gC/+1Z7W7bNhR9FU794U9lsp30w1gKrPsG2nVD92eIDVeWaJuITKoklcQr8i57lj3ZzqUk15KVxN3QDShspK5FXp57eMl7eSS99+LQhoZbb+y95Nx+o2L+bdHS92KxWIgoS+wG3T+GOkabkDG/8cbD0bDvKS2WQobJLNVqnRLG7ypjoeYslIzfpFxb9svGrpRksFjqcL3m+oSR0bVIEjbnbCmuuGQ",
"part_2": "he5dxYwUM27CcJ3zNTMojAfchNXeAGOeDllxyHVr4YJHSmkd1H8yuQsvWoY1W3OCCV6EcUhoag84QeBaOzclETuSjR4/YrwWP8UT+UFAzVgu5ZDIrkCMlbSikYUomGxYjBNY4UExaSMuXXDMb6iW3faa5zbR0flJljJiLRFhBtBRsDQWICM4RRb1hKqWZKW1Yq9fqs5aPLwB/qTRrdVsIl73moEQjCrdq4XgZlV",
"part_3": "OjHs0NViyUllYAF4bmzK/CJEPQnGOyygkyauaY/M8KAXUQjoOMDegVcDQDHu+gGWZWKktiJtU2GizhYUxh+oNrReH868+J/O4mXKcJZ4MxhfcnmWZ27Pies4k3GI4mXr8kcs4eT+TrzDqTC/R2h13qx6/esIdfU4JLk1C6RRyzF8qu2NbOxX9ru50uzfaxW9uSyrCJCjZzhcrTChU46A0dFYB3h3dSKewKKoVth",
"part_4": "crTCpVRE5XR6dnj4ejJ6bOgwujZ4Nlgh1SdwW8rTkmHf1JVFirfsNiYSLVIc/CI2QLJWvNE5HaJkjvHlVbxGwBZjTW2xjEesK/Oie9JwuUSM8fVIJhImgE2gxEm35c72QEofzhy44oZ4Rc1+GxAiGXyfa800hZOthUiM9ztwoVKEnVN+8sAwSLDIlQqonqthc1tjEoyl+DFFi8LCa0Hl1GigLVRWTH0WtgVtm3M",
"part_5": "E7EGgiaSb9++TV0pmcAcFYK9KSBBieET8wUL4/h1maZtw5NFn2IxpipRrteYykCH+c/ZSwTjAj3TAoA+zg0KKRZpIVBJPbFOlaZEShIUM1q2iSza8tKzvURwVtsLFG5uxZpT8NyS2k1KASq6u0XrIpORVSox9Y4df/UuikfjmBUP03f1xrkwVIRrrUXVrLWWFa7eTjPbacMk5QLbfpGo0LZbuGh1qBVhKw+KmRU",
"part_6": "24QjfsUwfy/SxTP8XZRrZh5qFKciIEu/TlcgQITl34fvQRsDxwrSzPgo7v+qzKNOAS1E4OjtD6SMWLGPn59jrsg3H9e7ChMaTVUFo36ZgchKmKZdx23nat8oTr9q+oAJHmYkUXXKiXFK5g4tgX5yDM21JWF1kUyLWClp3sJpji1zud0l+Q5sQkW07FIYosx4bTDuNTl2MgjtcUKjd4L6DLb8pCGjFerWpodOAzB",
"part_7": "PDDwV1a9CrYk+8Hnb6/T5qYP4Oml9H8w9Ga+5x0XJ+7u6nHcm6uee7rQp+zrh34JjtNLrVadwxpFNJGcwp6LP8b+JNvJ25lyceiQ3ktUlx4CGnXQHBNe4AL2ciRsuHMuUjr/3t2QejSFGBpOQ/VoNjNThWg8+mGnBp9WaWKuwdZHaZ0+3OyW4uU5WAFIcBJWO04tFlGxImFnRjUu5sesyinbTJ29sHCKgO7URK9",
"part_8": "3sB9sRgPqzlBB2pcqfzWg/BBFX/QYES9ALCCPz8v27wINDotAI0OD1sGnvyuiDgJDL5dsr5Ye8VkFEB8vC4QXBWGXlWuu8GvTPnPvDPCCW/89Kb4zO+483j8ebxePP4b5/xsc/+EV854a+lueZ6zNrlREH6SsS0SC4Ujiabh9GlFdGl6RT32SZFnOk2u+HZHvmcfNIZlPrave3J5VM/LyS54G4Q2c70YaHtQB5U",
"part_9": "2nmB+wdi+17pnVN0IrEkSVdNTIsSyVwWXLiBYzFtnBFBFeYd9pwN3G4sGi6CB8Q7lVYhM77f23xrUAb5XqXeL933nfwvyVWvPk6sYx/HsaBtdq/fQqDiaMP3lkS+5r2PI5N7fZPNUZeigx37DY79mmP/IM+vsAEFbotzRXGQ826j86rCr1JpaOzs1pFqPrAPgnJH0ZOWz3X9vqLPx7mSIugQmil3vHjji/d5Awr",
"part_10": "MAccShpcDvYupd9vfH713vlbG7MnyRoy6GK9CNGjyRpQ9JX4A+z2hUnVdV+PNfqsavIpw16A9AV5zXNXh3u207625Db3x+8a38yRs16QAZiTz0T4MBmd+8NQPnrAgGLs/mEFVLGd0Rn7SBze7b2voWdLw6fD4/uYowY8S/P97f2PDpUHx917hxMLlG5dz+PGC5CfO2Uu6nN7itDCzTAokqze2OuO3fwMUX6U5KSQAAA=="
}
|
{
"ground_truth": {
"compressed": "H4sIAD38N2gC/42SzWrEIBSFX0XcJNHM4E+cNoE8Qxdd1lIkOj80NYPRRRnm3WsmaRduqgiXy+V8nAPnBk9uClZ/eBf8GXbwJuEx2MFfJqtGCTsgoTZHMJzN8FkOyuqLVt5UnZQWxKfm2TgP/g6lDV+gB1JKyBtxYPypacmy1cArdzI+Hlva0gr0PXh7/5/COEvkz6u2YJgjVtSgYIhjVmSwSOqEbCiCyQIiu3UgkkPjTUKjTXYqyngiPmxWKI65FhcUxVxZPhIS30hZYkpEIhe/RhDB4mGE7MQDtf61Ca/TGJaOlNVeaf1yNU75yc2VhHdYw9l/jyaWyYU47j9hXYs1ZAIAAA=="
}
}
|
codegen__leetcode2k___48
|
[
{
"content": "You are an expert Python programmer. You will be given a question (problem specification) and will generate a correct Python program that matches the specification and passes all tests.\n\n### Question:\nGiven an array of integers nums containing n + 1 integers where each integer is in the range [1, n] inclusive.\nThere is only one repeated number in nums, return this repeated number.\nYou must solve the problem without modifying the array nums and using only constant extra space.\n \nExample 1:\n\nInput: nums = [1,3,4,2,2]\nOutput: 2\n\nExample 2:\n\nInput: nums = [3,1,3,4,2]\nOutput: 3\n\nExample 3:\n\nInput: nums = [3,3,3,3,3]\nOutput: 3\n \nConstraints:\n\n1 <= n <= 105\nnums.length == n + 1\n1 <= nums[i] <= n\nAll the integers in nums appear only once except for precisely one integer which appears two or more times.\n\n \nFollow up:\n\nHow can we prove that at least one duplicate number must exist in nums?\nCan you solve the problem in linear runtime complexity?\n\n\n\n### Format:\nYou will use the following starter code to write the solution to the problem and enclose your code within delimiters.\n```python\nclass Solution:\n def findDuplicate(self, nums: List[int]) -> int:\n \n```",
"role": "user"
}
] |
codegen__leetcode2k
|
codegen
| true
| 0
| 0.0625
|
{
"part_1": "H4sIAD38N2gC/+1Z3W7aSBR+lZF7Udh1omBwSNCmVdvd7q7Uartqb1YhohMzhlHssWuPA6jqu+RZ8mT7nbGHAE3acdWLVRdCKcyc3+985+AxH70p17wU2ht5r4TQL7Kp+LVZ8b2pjGMZVYleYfu1mMoqxapUU7H0RkE/9L2skDOpeDLJiyzNyco/WcV4IRhXTCxzUWj2ZqXnmWKQmBU8TUVxyEhoIZOEX",
"part_2": "Qo2k9dCMc4+VKLUEoIdSF4mImVlLiKJADgtd2FxWivNhBIF1/DBoqwoRLTrg+k51yzlOpqLEh/EtiljKedliU0OexqOy8OxGqtHjx6xv5s4RmP1ex0ankXBVyyLmVRazERRMlWlJbwrzaWSanZ7o9jPrHe3v5gLgCB4NLdrTJZ4a6IpuJoJdt7zmbrAWpRUJTwhgndGC4KZSuBPQVTkAqlOyeElGVHGtY",
"part_3": "8NXRVkTpa3N1YKYRgxmCKI06rUrMySa2HcWlwXEmBVAChDgVeI3uzWOZLx2xsCCDFhxwSCPEvNlUZFdcEBJo8o2tubsfptydM8Eaw3Ivz+VHmlRzU4Z5Rg3x/4gR9cjNVflTZ7AclZreA+rb7f6G1o9Te1+vdrNX/bWhTjCwq/QKF0aTR77JczpuildxSOFVk4TISa6Tk7ow0U0gph61xemLdj9Yy4AqT",
"part_4": "WRW6KwXgO+AtbtAh1X0Yi1yzOCoAO5pWiKaflwmIuwYxaDwxdZAyiaYbia5mKmowU+sssSbIFq3IT+B94G4GOC1NLU1XwHM9EcFSaHEyrPCGaC0sYwwGxlHhtwn0KRGBkBYJ8zg3IJFJRNkWlKBYUn0BfSr16SjHYNnmZFWiwUU0005ZVWZuKTcxEHpCm0IghwlRhOmOLQupaBo4r04pY3XRPxBNoiAy2",
"part_5": "EGCjSoRFYFORyBQWCsLn/fv3uWn6McTRy+xtYxIhMTymImYxRtWvFpAOihD7BoERewU8zlGMiy47eEJVabToYWxjzqFyscSg82SaZ5hjEfLCrIGLcqyaNfAKia4/ApH5+gMmqyAECbEY45HpVU6oNNs/NatxpSKdZUm5u7Hhb3eLQLhXZy54/mF38RL8w4zcWa1D313NchqtIOPOOmW2sYYkVYy2i5OM6",
"part_6": "85jfHjcpVXAZuf4REudCMC3n6L7KbqfottTFH2C6QKaIk+0yHeeYEazsxzRstm+xKzY2KdHw/yySjvXVJmlwfnaptdlT9iSIt2Rr2fJJBGx7pgG7KDmHaPR9dm7ohI+uxKrs7hrkiwROl0VGuLgM64sryZyihXK7ACYHayxPqixhlQNFkHxI2MjlC5WkzxDIEjTJtjpHm4lRqBhoEKCIscFbXTVAXunkr",
"part_7": "5euk3gdC1L31B2vWP7OfTZwGd9nwU+w6DsARE0Z+8rWj0jHBhFqIduWoFRaZ61StDGkZuXvlGpA2u89B28uBkPjfGBDckxi74Rbp7OIfWtI3esgp3Eg69XBBmd+uzYvEL3xLwZrgE5/brTNX/cnd5ptVFpyNYGkIHFsCHPwLW+TYndtHpHBrUTA9yxCfHbmmrQvj2C9kQJbGB3TRU44bL25Yhm073t0++",
"part_8": "3iaot/4aW4gNTrMDyPlxXatgC9nA9/kInrU3F4/Y87jsj37ZY4ebcbJPUXY/ZWrjTo+0k3Sx36DxMN6d28E3UckRj6xtu01d97ClW+/tf+5Pb/uT2f7r/xX7M2182y2eqXIhixDo2O8JdTtGPscnfxMYueXSlZXRVdpuTbZmDcnSwvee+F/m+98bUxvFp/P3T+u+c+yQ17iQzPeqNzj/WCwDr7stpgEYO",
"part_9": "MAZ6F5C3kl7P++R/Lg0pyNLACB2kA7/525INvmzZwe7d0NqU7T9k18FiCIsD498l1rvx5+LfjmUXDIJ78goewDb0T/1j/Ov7J3gd7uR5+oCHutpuHhppR1nDCsc8BwaT7VoPvlAZUxsHaZyeTgHHEMC0JfagBVWDFkUN/AYcB9lw3V4u0JiWaZFb3zECd4oMDfEGQDswNAx3sB5+Eb9wZ4iED0pb+eMW5",
"part_10": "HKiSwu0Qzt0HKNuKG7QdKum+wCyNQqdRpAdbkGr+rtkuR7wn9u+8L1UaO6NPj7wyz5d+Kd0HT2hYw8pHfXCg6OTg6MhOzoamSfEEnzHTejK5Pvfnd38/YhuEwcnw/0vSvtzyf5c4vKLkuazEheU3nOp2WuuZF4l5ryPrWdEIvz/Dhm9oV8cABM+PpeKFyv2FnajuXfxCRen5aRSEh3njTQuXD/9CyNVphUhJAAA"
}
|
{
"ground_truth": {
"compressed": "H4sIAD38N2gC/51Wy26DMBD8lZVPQUJVsTEkSNz6Bz3WVYV4NCjUVIAPVZR/r2NsIL10TWQlSDDMemZ2nSv5HHolq49pUNOZZOQqSKNkObW9LDpBMhCkqhsoz3V5OZSFrNqqmOogE0KC/hTjWA8TLDcOUn2NkMMbDyEOgYVAQ4j0eg8gzyH6DxaZp6lBajxHwqjB2DVjqBcVkocZzFyb5WEYHuTruXl97KrC7oSZp+3CV8UclYdi9M/uKcIZvatTCIn51uCjuUgXVU4I2iVKHrQrzAtjg+elSuyUtDmK0UZbr5Gw6NlodzTyJabKnU0W7+gWuiMy1NW2NhnFibOwYTW1/bxDA+ZVmHcWUxf42JhGXRfwxbHUR32+jEWOg22RyY5QM7wB3qbx7UD12tjac84Sj6B4j9it7xw/ZbcDne5LGVaShyPwgW1e8wn+2nfqfrYfgqemldWL+u7a8n6gC3IjIRmnn67W/wIGpX9uv0VnBN8dCAAA"
}
}
|
codegen__leetcode2k___49
|
[
{
"content": "You are an expert Python programmer. You will be given a question (problem specification) and will generate a correct Python program that matches the specification and passes all tests.\n\n### Question:\nGiven an integer array nums, return an integer array counts where counts[i] is the number of smaller elements to the right of nums[i].\n \nExample 1:\n\nInput: nums = [5,2,6,1]\nOutput: [2,1,1,0]\nExplanation:\nTo the right of 5 there are 2 smaller elements (2 and 1).\nTo the right of 2 there is only 1 smaller element (1).\nTo the right of 6 there is 1 smaller element (1).\nTo the right of 1 there is 0 smaller element.\n\nExample 2:\n\nInput: nums = [-1]\nOutput: [0]\n\nExample 3:\n\nInput: nums = [-1,-1]\nOutput: [0,0]\n\n \nConstraints:\n\n1 <= nums.length <= 105\n-104 <= nums[i] <= 104\n\n\n\n### Format:\nYou will use the following starter code to write the solution to the problem and enclose your code within delimiters.\n```python\nclass Solution:\n def countSmaller(self, nums: List[int]) -> List[int]:\n```",
"role": "user"
}
] |
codegen__leetcode2k
|
codegen
| true
| 0.0625
| 0.625
|
{
"part_1": "H4sIAD38N2gC/+1a63LiRhZ+lS5ctYFM45IEAkzFqU0mu9mpSirZ9eyPLUwxsmiga3SL1NiwU/MueZZ9sv1OtwRC4jp29seWjW1Qd5/7Od85Aj41pp7yMqEaw8ZPQqi38VT8kK/wxlTOZtJfBmqN7b956RRrMpqKVWPouC5vxKmcy8gLJkkahwnx+Fe8ZF4qmBcxsUpEqtiva7WII4YT89QLQ5FeMzr0JIOAPQg2l48iYh77bSkyJXGwiZMPgQhZlghfQrxHyy1wnBqiuYhE6inIYH6cpsKvymBq4SkWespfiAwXYpeV5pR4WYZN",
"part_2": "D/wUBGfX99F9dHV1xf6e6zG8j340qkVMRkrMRQrDUm/NomWYcZYKtUz37PrxMlIZe1oIeMFcjOSYSaMIaB9wNJ6xLIRsvBQwVRCFivUJeHSh6ACJASUU+8/v99FfVl6YBILZQ1L0XZQs1VAfYbds5HKH97g9vo9+WSq9M3K4jYc1Jsok8CIvt+l9RYpLlxQv/Dl1pZqO9pbduq6TOjkpTIujYM3sKjlr7qXrbenOJbG3JFaVREeucI+zzz3tHc+QT7YEnf0EvELDDRVF4m0cZSr1EPVM09rsm1tNeR2IaK4WdGlb7n3Utq1usUcp",
"part_3": "oNe7RFLk2l/jFFkKLpuCWGZCWz6LgyB+ktGcZcpLFaz1UZiUI0+pVOZMFgdLnc955hR1QwETkR/E4LWOlznpk1QLGbGpCGQIDill/IcPHxJdOfc4joJgdzlLqMTwMxUzk8J3xuXNTAQzrg0asp9kpkbwwrjF2t9ur4aaLXAiScVMAigaMkxi4IAPk1Cr4J7dR/kaHAkbN5dwxmJzAVwSSoaCnDUDvDC1Tsgh+fbX+epsGfkqjoOsulGSV90i+/fSLISX/FZdfJAZYUxl1aheXY0TgqY4ra6TZaU1GBnNkGmzIPZU8ytcfNWiVbit",
"part_4": "wMGJkioQcN8rCr2i0B+CQkg2lCgMinzKM4MA36Odp+t31OPF9H0qRAkKJhMZSTWZFDDQyvfoh5auI6gdVdZ8MsUas69ZM2JvEMP7/MSfgWxK+qEAAE23QgB7D1I1V2XmeZav2J9Ye1XQ0+FlQiiR67PihG7KK1M+LSTcuyKrjYalva2Ko9WYvbk11Lv7K1qv+eR6o2RZGVRuui502fENXGDVdfqWWVVtSNpGpaom7ROaVLyVmT7zksBeSAAN2ZQBzcQUtKpJlK2SDiG2Pz0OmUQnAxhy9giAQldahnp0axIHjmT4vCVRMIftMbGJ",
"part_5": "hG6GZeZepOuj5CASoiXoLB8OUTfDqvtuWTh6rDiVZF7nSbTiOjnL2xB07SWJiKZNfdJEGJHAybrDcdqI1qWVJYGkgVgXKa4xUn+cyCkVGjm+Hc/aOYS0DRxnbW+GvtSmUOC8HxMyUMxea/O1Nl9r8yVrE/06XU+SGK5DcRX+b7auy36nmsUohgM6Igvhf2z6GEMkaVSkEN1F0mxbrDerw1CL3d5u5yB2gqpdEFjjkyf59rCeC8zsmK5fb8Jfx9/X8ffim3D2f3cPXhj4XZQ9iXTImoVhUPJRTsWUoBmma7XYg+d/RMv/mLXyO4Ms",
"part_6": "gY/pxmDPzTdJ+qMa2BV7mwqDLKaJsQCnKAGXkQRA5eWblXq4PjbJE+dI5yuxTr3oI5tK/f4AehrFL/QSJjx/UeADliSqj06W+gnRUf/0AnTQ6YrGJtNHp2hSWN3tpSXVyv20rNI7zG3SC+S/TXC+f/d+u4vxYTuiUa8t88sntjpPCsBcqEm2DJtQq1Vptwjt7tCzHXzIoProUxBhAIJCIxwa1w8QKaYgesIkiKeqUI3UYHNI47zVaz/WZsVdFb9h5Avo0tqjaaHigamx0PXNfl3Lkfk1jX2RlXtGxnQxGEhEfgRiprYUedepjz8g",
"part_7": "prRIxSNYIDd1+CqqX7EfhTKASymGdKfX/hK9FYhsxFdcCkl0doTN8SFmWqe8k2kDCuBGe45OijAWFXNWkVNpdcgyIv+pA1gksUGVUwLyoKf8QCpfsX8Yp22N0U16vjHPzB5xOi2zzrMt7/zbwU9Si5nEuqM0hqNPZgEYV23iOFucamynt8ZnXidpV05b4wPHeO0kP3DWsbh9w+0Bt/vchjout7vc7nAbmlR43HA24KzPWY8zl7MuZx3OHLiTswPMbZjY4V3uwtA+H3AIsqp6sYO/5/OEqlrhjlbe1Yb0tVE33LlA4vHf/fq4vPZ4",
"part_8": "tokWrBrAuh64dWGtw58dihMML+SmOVAQqtmraY67S2e9DmElMq4W2tU87NPSLU557vB2h7e7u5wuzVGTUd08fiavLs3WsyLbdqGr1tgh7ZG4RTZfJGg/c9R49fH8TCx++E3xs3k12Lzq78o57fLC6Ru3P1dR1+Jdi3csTnhWMftLqmM3uzjFrcfbfd4e8PYNtioigDMMcMOAOgzgw4BBzKZMhmCbJFM+Q/vL67ajqwUJWRF4TqWdhqNDMkuPk5E5FOMOZPepiGwNzK6G5JtnB7qEHzWvGOzoXJLaiInJapbntHnu58+9i1Mpj7Sj",
"part_9": "g93R8e7qkCPevZr1A61iT//v6v/O8ch0dXYCpGrIewb42lTHFh9YvG/xnsWPVc0XdPucz+Z/zVpjm30cxByNDgYcrXqnMu5ytFJlfvbRVCSwMWz16xrLTe/Z4XeEJWkG1+EPfQzxqPeyTUQ7pbheMCudWSlnxuJoXPbreTSNkDqOS0NXT3t2A5fuHnD8YvDLBfVdktXTmToARLuUxK5by9eO5nu2x0+DfsWOFwF0kzomcZA2OtqWnjYOpdAmOhuzNpbZR+pIzxcbY6zaLYGrGXZLwHG8Y1ceLzDkOnp0122mp1vFoDaU2tq5FY6n",
"part_10": "IKijYc21Lm58ZaToHhqV62jROSvwZ98gHNIN9zLIkw481dVZa9VGAuOwnv5veqFzFjDuA+qj2dXXlC7UsSmP0eSrDalXMHEK/9jl3jbmjVAorzH8tPeLf/SWfOjR2090z451x7LdtjVoW31mWUP9i2OBF80n9Hbn5nPLl3h/sPzNGPoUtYPZ5fW7Mq8fFvzvviujvHnWGI4a5kNQln8KyuhjUOzeibn2Rn75HWUWnvPDd8JL/QWuf5D0zruOELSiz+uw+Au9eQVWd/o7tz+LdC5QM6lqjD/zhswm5n3vxlClS/H5v6/UP+CxKwAA"
}
|
{
"ground_truth": {
"compressed": "H4sIAD38N2gC/4WPwQqDMAyGXyXkZCEbKmwHwafYcZVR2jpltUKbHob47usm244mgZ+Q74f8C97DnLy5cUg8YIOLxD55zePslZPYgERje9CD1Y9CK29Go9iKRkoPuVSMNjD8DoVPU4QWrieq6UxVJ6DNW01V7rKDPdvh6yi7fZT+NH34bbZfL7NL7xSFOOqckC+Tcs4GIXFFwshPZ3PckLKsL1pykB0GAQAA"
}
}
|
codegen__leetcode2k___56
|
[
{
"content": "You are an expert Python programmer. You will be given a question (problem specification) and will generate a correct Python program that matches the specification and passes all tests.\n\n### Question:\nGiven two integer arrays nums1 and nums2, return an array of their intersection. Each element in the result must appear as many times as it shows in both arrays and you may return the result in any order.\n \nExample 1:\n\nInput: nums1 = [1,2,2,1], nums2 = [2,2]\nOutput: [2,2]\n\nExample 2:\n\nInput: nums1 = [4,9,5], nums2 = [9,4,9,8,4]\nOutput: [4,9]\nExplanation: [9,4] is also accepted.\n\n \nConstraints:\n\n1 <= nums1.length, nums2.length <= 1000\n0 <= nums1[i], nums2[i] <= 1000\n\n \nFollow up:\n\nWhat if the given array is already sorted? How would you optimize your algorithm?\nWhat if nums1's size is small compared to nums2's size? Which algorithm is better?\nWhat if elements of nums2 are stored on disk, and the memory is limited such that you cannot load all elements into the memory at once?\n\n\n\n### Format:\nYou will use the following starter code to write the solution to the problem and enclose your code within delimiters.\n```python\nclass Solution:\n def intersect(self, nums1: List[int], nums2: List[int]) -> List[int]:\n \n```",
"role": "user"
}
] |
codegen__leetcode2k
|
codegen
| true
| 0.0625
| 0.25
|
{
"part_1": "H4sIAET8N2gC/+1a7W7bOBZ9FcL50WTBBJZs16mxnWK209kZYICdRQcYLGIjVSTaJiKTGpGexFv0XfZZ9sn2XEqyJVlKpBTon3VSFOHX4b2H915Kx/48iAIbGGEHs8EvQtj3OhI/5D18EMnlUobb2O4w/CEwO/RJFYnHwcy/fs0HOpUrqYL4Nkn1JiGMf+ktC1LBAsXEYyJSy37d2bVWDDNWabDZiPSK0aQHGcfsTrCV/FMoFrA/tsJYiYnnmHkXiw0ziQgltg+o+wKIUbZoJZRIA4s9WKjTVIT1PZ",
"part_2": "hdB5ZtAhuuhUFDVKEcUhIYg8EAeBYbm6u5mquzszP2z9yO2Vz93ZlmHzSTyoqVSOFZGuwMU9uN8RwM/eVzlgq7TQk4m8H0kraVqVuYGpgIxCv2IQjXTMA3oSyGnGmpMOCXbbbGsiBJRIBdDIxXO2blhkw0TFpm1vrB0Jo7bdeFHWTBDlxusGVuQglSkkGwJY3A+Vz99z9z9eEx2CSxYN6M3P1ZJVs7y715y2487uPXW/DMLepCx2Ku/rG1bmbePOD4jThj/oZPyihvOHVd83EZC10LQkriQLlzmbmJ",
"part_3": "CybpWIxmQRiKxIrIHQ1Z/14rY9MAnBq3r8f++jbb9SoWamXX+ZZ5i0a94XA4V8P9xBtZ2IW/DhMy/B91HOsHtk0c+u8URNIdZBGk7mydeakIoh0zOoV979hPWPWgt3F2GjrBwcl/C2rgMOMVssSuN+8OkM6UV4YZmgU8s6E4DJFCSJ2IWZ2ZmM94x35fSwTOHomW3AmLyCph5mFlKPYy4ikNjdWEiKCPpLnnLmLIoY3Y6NT5EsNWOMHMFlu4xCEfwkApbVmsg8jlyB4d5OsyAuZrFYp3xFiRQj/qFM",
"part_4": "kHEvd5vjXCLVo6hqVawbAA3KVwOhLk8AM8y+YYHW9dmuYbFeWATBcqjLXJmXVLH0AIAj0SmR8pJfKnT58SVxDmmI48Zx9zSJjE8BOJ5SExz42Il1lMeDP2izT2BmNFlJR6Ltjld4dWDkU/bkMUxiQVS4nKOJCbBIEB++I4y3wzV3kf4hfe75ugab1voBALSnmicYl6yuwuIary4b/kvcutCq3WsakPlParDxEzjWvWIkj+qHfeSSKm3puZXu/VCdVindb7ybNSH5xUS5SCJSLKnr9C49UF9YK2ovDf",
"part_5": "WmljAfpOZfdUdk9lt3vZRQ6h8ogUxZHS51uUvBCJ9Ja911uCPHdAF4fRAAUI4bc49CxRIB4pM7IdDgP0AxaBd/O4qPXnUFeUnio6f7w4Hs7WsUsE1GFwXxWM48YksaQnUxfCaOPZ9v5WRlSnS1XiUi8vUXIusxS/lBIzKTJiQaMnWo9oRVimu9tEwwWwU/ByfnG154O4RmnHKNGEZ/Hw/hwBHkm66C5yq+gxnO7Kov98X86mqFxvyuXMG3LP454P/t4eeGgHwFz6rUCgma32OPOeRRhhvV9eP+KjfP",
"part_6": "3o+e1R4qrmo51vTn/29p9K+TRHeMPZNWfTDhyMcAlMqj5M+BTIuR+cTZ5FGXL8ljGyjgxhyBn963QcfpVOuvcOlOJC9zug+C0H2ulA+P6/+tGURg6HxNnh/y6mwZcSLIjnr7tGa5XfgtsOUQICq3Ey2kfJqFOIVJjowSb3h3w05OMhn1TZnHB/wkcTPp7wyeTrsrWSr11SdorYnpZBXMeekSkY6Zo3Pp6KKrSOXfzuqR13ideqP/4+2F+SuXnXPqZASGbGpH8l65M4U0eG53YuQaBJBuUwE85ew55O",
"part_7": "fmUFqFIIxgC7Rvp1p8c/Jgghl5l6sGnsOPK7hE5TlSvVuD4ZUbu2RpQifHqoLDDqxXhj1+cPD2SNHR68dJXqZdS95u6+6XMClQPsc25+Pc39Q0D7/cts5k85uTx34qOXGOO7Lr/nldT0/tYD4Yk3t/11P+5PTNczGblLuPkxp0dKNyR056joeDV/1f1M98B17WooXQsvvqHqd1SXWuO9vBbXngr7PWTw/PdrH+aOA6YeMpmyk+5OnwmcxKmTOHX6TCD7TID9H30kULj+vTIPIp2x88JlmP+njMDv0p",
"part_8": "HiDGZ3QXhvZXhvLnJFzyQIbRL02sT9XCdq/LCAjJp/I2fPMkuy00wFirYKXbkTtdLm9iipXbTKe0LwOmM/K2llEFNKlIpY7Jw76FKus6qMVUBsdjXYdaq3q3WjWX5VVENXm6wGvCz/9wiuBOfOUERKpIRr0tAKVYGCGlmk2PBIocs3Kq3O/rzBwIJ9x4YN4h0iykl3FSvyzGhkqMpUIfxhh4sm8B9ECJvzUM380DWPC4MblMOS9VX58EhIzKxxwS7psrjV7hYYzG4+Zx0I/Q5iIJYXCwc3i8EX3rC6",
"part_9": "RQmsLHWPbc3LG2XAyuJR28ZNGmB1W9fTuLhFAKwsL3TANr9b1b+q+SQhNEO0PC1WlhcPje3kt+h+FRT3ptQG4T99dk/Q30nxOzqSyotFq1FNcl+XeKxpfVUyW6OhUeirn2NrKFRVvo70dZT4Xp6DTVnYnoit4l4Fo9D42nOiRdmrczluj8hjWa8bB09oenUeCmmvY03qnBTPqHkVjELUa3fnKSmvGyVP6nh1a0pyXvd6dVytng/4NgWvVimckNcLrCzfVcBqKl4PukraXSfKq8Jd11NqUO3qIet3LZ",
"part_10": "Vlye4I5KmAa9XrelwlTe+zXZc/8Rpbv5fHXcnodAKNGl29YD2TqE0CXafT76XOveQubZTmjop6z5ul5W5prx3eC+tpoyLX6TmgXY7r8YDVqMU1hcaCDzbCBoPZ58Yv9pLGhddREd2S1od+f+hNLofXl8MpGw5n7h+mxYFa3dKL9jf6UkT5K2L0tY0RCvHpS2MnXe6ky33ll8ZssDJ42x58T1Sh/VNg1uy34A75xAe/IZN+1VlKoPk3qQIgfETIh2u0P4JNqVaDxRe8vZvbrZLIyMHMplvx5X8SNVSBUzAAAA=="
}
|
{
"ground_truth": {
"compressed": "H4sIAET8N2gC/6VXXW/qMAz9K1GeQLKmxEloQdqvuI8rmlDp7tC4RerHwzTtv89Ju7YpXJEUigpx4dQ+PrbTL/63urTl8bWp2uad7/hXxt/aMm9Ol/JwzviOZfxYvLH8vcg/VvmhPJ6Oh6ZY77KsZPQ61HVRNWy4sCrbf7Vkz+wlgRS2e2DWgNYgBUgJEvdr9kzL/V0E+rE9PAxadn+XwOR9CEUAOAVQoHoAFeCAEMKPgNb97e3XeA62ZEh6iC2wFFgSwoMCDcYPw0BC0H0owMx9GAF0TEE6QwchgNl3WFLQ55SWMPKKwDAEBv+T17C0wHCaJ2hyZUwViWU4BzlH4UxwiX3YBOvWJ/mX4BC1EIu+XtSgFhUmFY+NGEoBBSgBWoDxKTWABpQBbcCYB2vXq96gAk5I5skUxRkGVhJiJbiGELTPrXZKHvjVQcr1Q8JB94vquDcN4iJSOkfMgt4WVUSJI0S6e08waGld6nEMsA15FBZa15G8vqAJLaVajKAIr0ki7XXOjl5pxxMGSehW35t0vajimM0zZasFkrHTkFvLAbWzoRgJ0w6QAnWtayF9G3BjKCoNXhqjsofzosdR2rig9XYhTQtNusSrRe6gM2HsqLoBEwWhiX7j7wOsKR0KjfYCegE5wZlRbkDf3gfFFPiN8g5XR+DYfmx22+mQzgbGZFgsn1zz2RXUe+QD/Xm2dYzcg0B/PLzhuxbOlXS6d/eI8Odybu3Dw2r9dCqboqqLvFln/JsDr5vPc0GPGFVLH98/BTkbmXoMAAA="
}
}
|
codegen__leetcode2k___65
|
[
{
"content": "You are an expert Python programmer. You will be given a question (problem specification) and will generate a correct Python program that matches the specification and passes all tests.\n\n### Question:\nGiven a string expression representing arbitrarily nested ternary expressions, evaluate the expression, and return the result of it.\nYou can always assume that the given expression is valid and only contains digits, '?', ':', 'T', and 'F' where 'T' is true and 'F' is false. All the numbers in the expression are one-digit numbers (i.e., in the range [0, 9]).\nThe conditional expressions group right-to-left (as usual in most languages), and the result of the expression will always evaluate to either a digit, 'T' or 'F'.\n \nExample 1:\n\nInput: expression = \"T?2:3\"\nOutput: \"2\"\nExplanation: If true, then result is 2; otherwise result is 3.\n\nExample 2:\n\nInput: expression = \"F?1:T?4:5\"\nOutput: \"4\"\nExplanation: The conditional expressions group right-to-left. Using parenthesis, it is read/evaluated as:\n\"(F ? 1 : (T ? 4 : 5))\" --> \"(F ? 1 : 4)\" --> \"4\"\nor \"(F ? 1 : (T ? 4 : 5))\" --> \"(T ? 4 : 5)\" --> \"4\"\n\nExample 3:\n\nInput: expression = \"T?T?F:5:3\"\nOutput: \"F\"\nExplanation: The conditional expressions group right-to-left. Using parenthesis, it is read/evaluated as:\n\"(T ? (T ? F : 5) : 3)\" --> \"(T ? F : 3)\" --> \"F\"\n\"(T ? (T ? F : 5) : 3)\" --> \"(T ? F : 5)\" --> \"F\"\n\n \nConstraints:\n\n5 <= expression.length <= 104\nexpression consists of digits, 'T', 'F', '?', and ':'.\nIt is guaranteed that expression is a valid ternary expression and that each number is a one-digit number.\n\n\n\n### Format:\nYou will use the following starter code to write the solution to the problem and enclose your code within delimiters.\n```python\nclass Solution:\n def parseTernary(self, expression: str) -> str:\n```",
"role": "user"
}
] |
codegen__leetcode2k
|
codegen
| true
| 0.125
| 0.5625
|
{
"part_1": "H4sIAET8N2gC/+1abZPaOBL+KyrnA3AHLMxAkvFdjtrbDVep2q17CffhapgiGluAaozsleTMUKn8l/st98vuadkebAMDM5XaeylDQnBL3f30i7olkS9eyC03wnq+95MQ9oc4FD/mlK4XyuVSBmlktxj+WYQy3YAqVSgePP9yPOx6sZYrqXi0SHS8SUjKP+KUcS0YV0w8JEJb9petXceKYcZK881G6D6jSfcyititYCv5WSjG2S+pMFZiYhszby",
"part_2": "OxYSYRgQQATuQOJIYZ00ooobmFDhbEWougroPZNbdsw22wFgYPoirKSUq4MRjkkGeh2PTnaq5evXrF/prj8OfqTzk0Y7VUK7JHC2NIghb0VShLdK5vpdVcy2jLFJhFCJFacb0tsZguE595lBJuQrQb6To8WthUKzcEOnzO4iWTFrDIWQHcyaN7vgViY9KNyEyk2Zn/StikYVAkQyc2VgAVxMpyqQwLES0LJK1JCx8+fcxamf7WtMXu1wKRA4lk",
"part_3": "WJ2KxxE8L3lkRJ99Tw6DWpVuboU2TKqaOS76sRI9p+xxXlv2Rb9bTNdcrQS7HnTZ1U0HNs5AA8pQkud5VPYbW+k4TRgSbW17Nu5FYmlZmxuWmhQzIXATG8siSEz5SphOZk/VkTWILo1yf+6iEjMhMVEj4g678w6LNXkAGP/1z7l6/8A3SSTY0Kd0+aCS1Pplwe/Y3JtNLvzLuTdXf06tG597F/T4/iEBSJeBPvuwdA7uEjJVAIWXL37HYsJwL4",
"part_4": "0okS9dehbaL57QPp0M/dlk5I+rCEZ7CJ7p8j77u6FkTxBeBYRGIo+kA6cFD78r3Ii0MwTPa0/ZhA2Zz9ozfBnhy7jTmXus1/sDK42OdjSHEe4+ybsjVnl3Hrp8Mj6zydQf12M0/fU9RHa4j6kzBh+XNSunVZrDeDbjuM7oUvgHwEe1kso6FGrMfv+uZFo/Empl10QcDkZzVXIefAGbrKEF9VhJqH5gfeQ1xdULn1bLB2c4liSWuhVUEqlgVcsU",
"part_5": "zwvVfrXMlzBx8GCdF5GMpV5a3Mooivc01ij7flY03SpPTVZvl3EUxfcUH2O5hkaYE7pFf69lXpNNHKWuQYBKz0UjIjBCBVEMWds4zVnvUSxQfUIRyQ0kaGohnz59SlwrmmM6KjX7mIsEJIZXKJaUH0bMMpPbRkTLbslwn5pNhyFo+Nd3AtFyMbqU6Lme3CQxWmoAY9D2KBPnKqdlTerxEW5YPz6gyQsrN4LctESnZnabkCvy4d/k1GWqAhvHka",
"part_6": "kPlPTVh8jygzxrwZNf6sRblDW06xo17681apxQl0c9qNHJshINRqolFvYyirltt/DQ6hAVbiu2FAsrbSTgvqahNw29aehNQ28a+n97Q0f1Rs9D9VIBFe5v00xZ/jL2DolzfbOjUFaANKWSuKMukbsBFaSdyGvf7w1vSrLoJZeY9u4dOao2kstGV0nFEZ7JER7CM9N1NgGAB+aTNLAcGKnomrWOzKDXAxTCM/0kTtqd49POnMKTRKiw/XBk2hE7",
"part_7": "zlRyOFxnyC4hC0qy816N0evBjUs+k0SSrjPcwsKz5eZuIUOiZMnW2+VEzyWhxqwgpmJFKdrkbJOzv3bOoknp7SKJ0QmQfkXitTv9csJRLmNLiwmUisFaBHdtbEZDSWeETg6B7sbomFHQ24d3RB0KUL4ZOoettJXJWUfnspZ6fM7qOmC2ydfb5uKxOac055TmnNKcU5pzyn/y4pH9H907FqZ9r8y90FgShUmA91mG8OzSGe0AsVse3FkZ3JlOfn",
"part_8": "gzCaL27c9uxFgkdNv9FNmp7ZtesT9yIA3w4dM2kiAHqaa1gf0O0iKwRUizcFKhnbW+c8mUd0Np93a+ThdtPZCnpd0JIKJgQERpv51N/S0b3hzfYeeK6lw3XVZwX1SZ6kb+KGDGRqosJo9N03VLcm22XNzYXpZXZRHvgji62EU82EVuac3NhKi2tXW6cs6l+xl4j3UnsPO0Oe/Le5QiXKeQIyx7Djx+aCh2OjtzS6DPOrLkEo7YvZtf3qVTJ+2y",
"part_9": "Rdkpg/1tfDbPLR1JzWMRu/7g+ddfMgIW0uF2D45irucavve1e5Sn1KSrfKOn+Uqtq8o3PaUv47zy3/pvqrxvntZHnI7Lf/0MPuKq/h34Qx9+8mGz/xrS3vpXVXlX58qrSKrKeH3KFmj1h/vxujrtA/pbseAl3vCHgxeEIHtf+YNDYTjDbRnsA+k2OsULbeAb+6Mq3/gcvI9pA3eNoP/CH1alDJ/WPn1EPnomagoz6Z3uIx+d1lnS+6JU3dlfvI",
"part_10": "eIXO39DE+QPYTFpd8zrKkuwJPRuDhDFvljMiOPvCB/sww+GNGTy2/q+GaTPc7L5xWhPR/UIzE47QUqIc8thtn7ZaXjQE7uFb2brrcRlnv+lyP/V4xuNDZ09FjQpQ6FezAc9wZve4M3bIB8pD+YRmfoBW1uv9F2sfzbL13aji6vml+Dm1uW5paluWVpbln+N38NtnxlcBryPloe3OH5bwKHRJKF7x9dAfduvuLwZBapkij1nk8L8Ou/AZXsvcjhLAAA"
}
|
{
"ground_truth": {
"compressed": "H4sIAET8N2gC/5VQTQuDMAz9KyUnC2Mwp5eC9OYfWI+BUdo4ZVKlHzAR//sUx2A7bSHkhYT3yMsMNz8kZ6/Rp9iCgBmhSc7EbnC6RxAMwVLDTEvmnhntbGd1JC4QHVtDh0A+svcio8foKYSVziqGiKBkLs5bw1m1T/Kt/Myv5UkoWYjyQ6P4S0NJJWtRft1RvzT23B1ehj5t3jN+HLUPpMg77SeOsMABQpx6Wp/k0wrLE/MJYSQ8AQAA"
}
}
|
codegen__leetcode2k___93
|
[
{
"content": "You are an expert Python programmer. You will be given a question (problem specification) and will generate a correct Python program that matches the specification and passes all tests.\n\n### Question:\nYou are given n points in the plane that are all distinct, where points[i] = [xi, yi]. A boomerang is a tuple of points (i, j, k) such that the distance between i and j equals the distance between i and k (the order of the tuple matters).\nReturn the number of boomerangs.\n \nExample 1:\n\nInput: points = [[0,0],[1,0],[2,0]]\nOutput: 2\nExplanation: The two boomerangs are [[1,0],[0,0],[2,0]] and [[1,0],[2,0],[0,0]].\n\nExample 2:\n\nInput: points = [[1,1],[2,2],[3,3]]\nOutput: 2\n\nExample 3:\n\nInput: points = [[1,1]]\nOutput: 0\n\n \nConstraints:\n\nn == points.length\n1 <= n <= 500\npoints[i].length == 2\n-104 <= xi, yi <= 104\nAll the points are unique.\n\n\n\n### Format:\nYou will use the following starter code to write the solution to the problem and enclose your code within delimiters.\n```python\nclass Solution:\n def numberOfBoomerangs(self, points: List[List[int]]) -> int:\n \n```",
"role": "user"
}
] |
codegen__leetcode2k
|
codegen
| true
| 0
| 0.0625
|
{
"part_1": "H4sIAET8N2gC/+1a627bNhR+FUL5UbuVAlFx2tRoBmTdhg1o0V36Z7ANl5Zom41MKhJVxyj6LnuWPdnOoShbvlZykF0wGwVbkef6nYt0pH52IqZZxrXTdd5wrl+riH9nd1wnEuOxCPNYL+D4LY9EPoNdISN+73QvLl+6jkrFREgWD5NUzRKU8rvKCUs5YZLw+4Snmvy80FMlCVBMUjab8fScINFcxDEZcTIR",
"part_2": "n7gkjNzlPNMCCFtAOYr5jGQJDwUYwHC7DRKjgmnCJU+ZBh0kVGnKw00dRE+ZJjOmwynP4IKvizKSEpZlcMhAngbF2Xlf9uXZ2Rn5xdrR7cvSl8JEEK+E1BkR0shMYiZ5oco4DJIiAawy1C6ZTznsFQw9MSDXpHcvXLIQg3NyQ0ZKAQ5MTogAE4jOk5gTNS4VtIDyo0tu2yTLw2mhAjWieCZDDrDpOQeThHHl",
"part_3": "I+F3OYuzQzS3pIWnKo14iprwolALMGmeZm0A4Feu87RwTuazUUG5tBUh+vOPvvz+ns2QkXYRsp9kkutuaTm42fNdf+D2qFkDWAd9+S7XhipAbsTNxKFL3qMVc1XRYaDsWW5/JcM40atILU4HJmylRcEei6hLDVcA64V7sWHRiv/iAH+Fx0cqROK1kplOGdIZTkmury3feczlRE/7kpJX15A6sFz6wLjMCEuA",
"part_4": "HGCDR/0O0hQ5gv+Cjb68weyclnlksMmlgEoxbpcZ+4NKIYg2X02F5Bk3fGMVx2ouIM8gKVIIMxRMBEeKzFOhC5pMxbmpCtg1umz1IeBchrECWQuVW9a50FPI/4jHYiYwb8CSDx8+JKb++kAOZUV+syLBJAK/iI9tPr0bf7uMdCvj8di1rnXJG8jbnlngejBoE+8bKDRtReDPKIL+k6R8LKABOWKWKOgvITgJ",
"part_5": "PQD0ZX1p9yAs4PXyEuCZLi+g43EtZhzhG0PbInqRIET2+KndHedQyEpBWW0cVPRtHiEiO3mmnCV3m5sjkWHv2tgtTN/cVQm2PJVu7qNnlT1wUo4hZ8exYrr1BC6etHEXYCv761ALHfNKpz51t1N3+xd2N0hZKHTIMwg3ZOtjdhYmEQl/tTGGQksoloIVsjrCXyg10L9WuYTcarXXDw1vsJfXmA3cmMmthIKZ",
"part_6": "QXubAi16do2KetFg+7jYRwq6OkyL/EbWV6/wABDMkljgU5mJI1zDk93tUESwU8DmqbG3Sk8gCBXmCkJ8wvxIzLnU6WJoDAEMS/Ra7fNt1DAi0JWBDFGFp9XwthVCLxB4j2pbL/BBFW9z5X7rUO23bcl9jbHaxnxsAHUZ6ZLYr69ll5GduuyBXQNjamDZr5ppp4a9FFW6QGv44FHXo0s5XuB6gTWnMQwl2G4F",
"part_7": "xcZ+rEfsSBjomgs0aCrFIOIvMbViOkeJ8Syy5tLmYUNQvSq2fjM51OZlB9ZL9zmsL9wrWF+61K8PcjXH6Sa8z+t4U41uicsKq1UWrjCzdVQ7BUp4gvUHmGPyaFXMbq8D0DXAaRfaDTvCVhY+hP8IDKrBog8tRf9BpVhmXAMM1iNYBKLBncOrPqUuLxqDEGw0tYYZFJjUK8zvuJdNvF9pvzBrx6yXx5TCeg01",
"part_8": "vO2WcWig16tODrSJYmprf/1Wuma9f+ytpCH21RpqxL5LeyXvixk3XZxeQp7G9NOY/g+9hCT/g3eQpcs3MpvztEtapatg9icR8QjnUQDDGEpGLLzVIrzN2vadRpZAxPCVxr63iXbI3fl2Eq3rP7KTf/tofg/sCe35A+IBLfy9g2ZR0FBLQwd7Rvx78hSXZ8jxFBdyRjLoTCmEpWxLjzL7oyJogeITg6LSmMmz",
"part_9": "PNYiiRcYvtECK8x8PYPyHSpTxU6397nYgGw41CqAr+RwAueLu5Nra6SvxUU3Kf2vyT9gW+cw79YkX+W9qqN3a4yvSqB7TT8wwzdyfWOAP8L8ncFp5DrdZTkN6onYnNvXZHQayFgf2tcyrRaKOyb2ekIOj+u1UN0zq69h8Xy/E0cM6ms18pVo75nSG+fL1oheE5ud83mDIt8ezo9lbur31lj+wPZyVI1VBvJa",
"part_10": "fu+Zxmv17r2jeAPHt+bwBmmyNYTX9PjABN4oZDuLo9b9sTJ719K4PXjXvrnunbqbNc2NkbsB0lvz9hH1uPN2CbwD15lxzZzu5z3/WQjHWHgU5tEQp3njKb30/CvPf0F8v2v+ABlMY5MhPtw/8len6ndw/AzW6bw4fRk/jdz/uS/jmk0ymB6cmzRlC7j+kWVT8p7B0AwXb5meOoMvMGtkw4LN6eo051/+AuSTq1/uJwAA"
}
|
{
"ground_truth": {
"compressed": "H4sIAET8N2gC/6WWzW6DMAzHXyXKqUjJFKe06yr1shfYYUeoJgb0Q2vDBOEwVX33ZSFA6HrAtKqMUGs7/vnvJBe6L4taZR+6rPWBruklprtapfpYqOQU0zWJaZbvSHrI069ZmqjsmCU6D9ZxrIj5JFWVl5p0P8y+i6PSFdmQKAIGWxZJJo2ds/l2G5DNhsgRnoIJ4wPWChNlvCd0/xaIPPfWGY72l85Ku1rp/FfI/GD921htFTCmDA6MQxeIS8alWxAeRYuceSjxpQwbNxUFDKoAiQ5jqYgOrIsTTovDHV776hSJJct9wAIZCJxCQ2MXbGnsM1sZ+8JAIEj7codbxstRBflNbtn0vHo59tzcTI1XQotIdqn6Dq4mjzaLQoMPw+oecuwG8U+ODwWYwsFvGTw8l+KxuWylh+EwbGTTDsyJwsHbqrsXPAh5s81hpSStCJsKQrZAEejzz60NrV1MGovhQGHP5LYbmMzd1icG6OTo5oubY3ZQgJh8xGA74A8Uzv9efn8Gmm9z03ovTvXfHWwWPKn6/JmXb7vXojjnZaL2VRDTK2W00j+n3FzZyto8rr/CiTSUygkAAA=="
}
}
|
codegen__leetcode2k___97
|
[
{
"content": "You are an expert Python programmer. You will be given a question (problem specification) and will generate a correct Python program that matches the specification and passes all tests.\n\n### Question:\nThe next greater element of some element x in an array is the first greater element that is to the right of x in the same array.\nYou are given two distinct 0-indexed integer arrays nums1 and nums2, where nums1 is a subset of nums2.\nFor each 0 <= i < nums1.length, find the index j such that nums1[i] == nums2[j] and determine the next greater element of nums2[j] in nums2. If there is no next greater element, then the answer for this query is -1.\nReturn an array ans of length nums1.length such that ans[i] is the next greater element as described above.\n \nExample 1:\n\nInput: nums1 = [4,1,2], nums2 = [1,3,4,2]\nOutput: [-1,3,-1]\nExplanation: The next greater element for each value of nums1 is as follows:\n- 4 is underlined in nums2 = [1,3,4,2]. There is no next greater element, so the answer is -1.\n- 1 is underlined in nums2 = [1,3,4,2]. The next greater element is 3.\n- 2 is underlined in nums2 = [1,3,4,2]. There is no next greater element, so the answer is -1.\n\nExample 2:\n\nInput: nums1 = [2,4], nums2 = [1,2,3,4]\nOutput: [3,-1]\nExplanation: The next greater element for each value of nums1 is as follows:\n- 2 is underlined in nums2 = [1,2,3,4]. The next greater element is 3.\n- 4 is underlined in nums2 = [1,2,3,4]. There is no next greater element, so the answer is -1.\n\n \nConstraints:\n\n1 <= nums1.length <= nums2.length <= 1000\n0 <= nums1[i], nums2[i] <= 104\nAll integers in nums1 and nums2 are unique.\nAll the integers of nums1 also appear in nums2.\n\n \nFollow up: Could you find an O(nums1.length + nums2.length) solution?\n\n### Format:\nYou will use the following starter code to write the solution to the problem and enclose your code within delimiters.\n```python\nclass Solution:\n def nextGreaterElement(self, nums1: List[int], nums2: List[int]) -> List[int]:\n \n```",
"role": "user"
}
] |
codegen__leetcode2k
|
codegen
| true
| 0
| 0.0625
|
{
"part_1": "H4sIAET8N2gC/+1bbY/bNhL+K4T3Q+w7eSH5Zb1rND0EaXIXoIf2rv1y8C42Wou21ZUlVaRiL4L8l/6W/rJ7hpRk0ZZk2XfNl3rhIBFFPpx5Zjgzy3E+dzxXuoLLzrTzPefybeTx77IRq+P5i4U/TwP5gtfvXPGCMT/0+LYzHdkDqxMl/tIP3eAxTqJ1TBj/iVLmJpy5IePbmCeS/fgiV1HIMGOZuOs1T64ZTdr4QcCeOFv6n3jIXPZryoX0MbGLmU8BXzMR87mP7V0a7gHR04uWPOSJK7EHm0dJwuf7ezC5ciVbu3K+4gIP3IRSSLErBF66wJPYWFzfh",
"part_2": "/fh1dUV+1cmx/Q+/BkrQ76VbJlw7JcwDrF4KFm0YCJa8+J5y3xCheKJ+8J8vefCT8ThUiUazYjUJPC3UngKQonqAlgBQaScTU2S3ETM8yFdCJXtvjIE97BQ8iW2UIsEC9O1cJSO9K+BxTYrDgg9jJ1dJtInmJd2VTOwz/sIErrzFbPZN6+Zz77R068DHi7lyoIugCPp1J7sF0BgstJFTZz5D+z1aw03++VB7e5x6L32Q64W1vFYLIH6Whr2YUErIDKEDaPKlRbN0Hy5odjgxQIayBVWwI8SZYO+A8X+zWWalGyD2bSr1stQsqQSJpFCmR0rJXcF9BPzxH",
"part_3": "+CAdyn6BPHZr//dh++27rrOODMmZJDfQjjVE4z7l+z2chyrMGDpTWlAccaWiMM3Yc/pFLNnfVprO88EFYcuKHy2SmrdcZFbrtPbpDynFNtaoG3QRBtBKTpsxGNpbBgEsAsXkF5WZBr2ugI9yIqM59T3WdOW/xqRbB4qHAGf6icOxsNKm00sEamhQa0ZdlCf5B5mtXWUrShb9QW50z6yM3fRqGQiYvQIxSJDsUN4zhlz4PSs2Pb9n1oF1NxyDKi6bipCaP78A1CchbSRC57KZ6peJiGPs75tZ6s41K2oODXDSC/G8fcTXaxJRf/vaKdpfGUvY3SwGMvCLQ",
"part_4": "qyCFS/NA1FPmroUcPtAQp2fxvecZA8ESumeporTJUKnTQ09b1wyUT0k2I3DnSK8X+TeJLPSeHyzNCnv1IYR7OgwhYkC5buvER5ELEnsBfAyGhvPXx48dY5b97TEdaYz9lkBCJ4cfjC2Xhv2sDv9P27QoeLDT9zpR9j7QyA4m5QUojPdb/dveUYdKP2hkFQZzwhY+KoOOv4wgJfw6tkZQhgLgPszE4C2goHsHXqnhAAcKlv+bE5wJ1BJMvMXGWvf5LNrpIkfaiKBD7L0r77b8iiirXrLgb/7o/+OQLKib2RrXo+6NRTDUIzvbeOGlWGoOS4QIHbxFEruy+",
"part_5": "wsOrHo2CtrzgeZS+DDjou5Qbl3LjUm5cyo1LuXEpNyrKDaQMJFqwGM4pW3zVVC/kM5nzYTfi4fnzl90z+d220Hw2ncJnSwD0s1n5OAUERezib8Qe2IFt9+ZlG17HUdztma/8Bb2pmO/NtkgJOaj5nrDIMqHX3ZbwEh2rZ971ksvu1oK/9Uw1CAisizjw6WpDOSCepSueH30PI0R1P3PkfubIfR9T5hGdeDLMxVJf0VJgMHl5jCNwAt5zxru960OmyY6ovzCNLDFf8flzdw5tfapGe5ncdEdEBW0+3i2itgps5bg9xICDSNejwgSJl9Hn4UyYsXWTAY0tR",
"part_6": "p+jQLWZXsMgybMh8XYUaIjNb02giaUGrbudTLcWuzsKNYEAe8qNrElJokkbimjvSRnlDgKNLUVUCUv/aUH4AZ5Gc6w7y3EsZ5hh3kFD/TmKeQduJrBYCfMGA7eEaGdwjq3AwNvkuIy2kujOsIJtEZ1jYA6BXLarhm2jexlwTMYxOGxjiTLCraLSKbvqTQv+b0gN0yvUUIU9x63UUkxXlFB0irQZMthbxVV7JzFRc7c7dLr2zmdI2Z54uKWNj206BA1Zme9ZhTkL+f4fZ6JS1Zb+u+e9O0HNSJnjtoyVZrE8qgkDZ1gj95kMa9CStb3qvWyIPNJNVKDLPu",
"part_7": "fBHh7W033Ptga2NTR8aKjGihh1AlrNLy0aZ9jS63LGqxQtosoNokrxOR4LauPAKaft4DjsAkKh4VjZ8+7MDH9O4mqi63/wC2vYFvMo1rjpRJ2r48HJVJXMqG12OOZmhWec5mh5RDMkdUoR+cyYdBjjzLNVaN8qX5MVDbVvzjUtJQTn+OFS7A1aVKsHsplqqoygVB20KL/ybNWiBiDgWyXlqA12FotNbG3h46FK3/EmL5eu+OWa+nJNfbmmvlxTX66p/3RdcfZnbIrnHLxRTjJl3Vx36PHJ9+B9C8WOkpw9ufNn6c+fRU/VDAkXMfyI7vgruuG05/3XVuq",
"part_8": "KfeerBruLJAKTCBklDQmsONzY4InvHG0HSMse82Xm9fQV+0mCENrmmfOY4TzhCQ6coQsFv1n5wN9w5ffkokRRnUDl23ECM+/Hy1t/kLqGkqskSperSi2YsoouUSBkwBfSvFzHLJqc8E9wRe6pczPo7V2FX7Efo7ikk7I0eb6SUF/A0/M8RS0XykIIUSiHpKxzffbKlTuAV1RKxdWX+oSfxQ32rX6eHbYACraqLvevsmokQ1PhUjK+juWLqkFo83IEbvQUyFHROgBuhURlv5lhoe4kZBqY03kgeEuEvnNgm1SsquiPwiwgqU33mxfEVta+wPxetYu9rz4c",
"part_9": "TqmcrKQqFbmLe8VZLLdIRBpI8uxDBUs+mfdKDgXLeiwaR8UhnyqAx0il98509lkPUNfraBMEq/N1naIX0vlitcegDoiBkjdCqlFqK0gDY9cFqUZp7H3sS6NaINU4NY2PA1km9bQ0dj0OgLJf4usYPtryMABLnY9qwOZ+h4FVbnvUSNem2XGgcNHzqAGtvtDag6mnvrrNse8BN7WEN/Y4Kq03btCmRYPDwCz6HI3+UNfdqHGuY05mtjbaMX1iX8P0rLO9vknDRic92tGoBG4MfNXtjDMErL4xNYAGjUw1NjIMHLOfcQJm7UFs62NNLYzTYmLNb7MGyLDRu",
"part_10": "440Lwwk82Kw5pDXX662PUwNbYt9xfLuxSk5+eS009iwONMF6rsVp0k3bnFgTlOt7tSZ7Yrz3GnfCdo41PEOxRlhpr49Ua10Q5Kt7U2cZsgjjYkDMNWfqCsia7sSBzB5c6KuQmrVkjhALXUm6svCFv2IRmd5sDprLt3O9HPlf++je/41fnnwHqkVgvGB7Yz79m3fnjDbnqoPpgVuuHyk25ev/QW38jfn6Ut4o7uby3fpL02KS5Pi0qS4NCkuTYrW36WX7lJ0prOOum3G8xsKMvj7H65YsZ/dJ6QRq/PPKIxkFPpzfSndefhidXzxqHXoTGWS8i//BfRNYWRCPwAA"
}
|
{
"ground_truth": {
"compressed": "H4sIAET8N2gC/62X22rjMBCGX0X4KoHpYkk+Bnq59AH2ch2WkKgHNnXAsaFL6bvvSLIdKU7rsXaDQohCPs/hn1/2e/TUnLr68KttuvY52kTvVfTY1fv25VTvjlW0YVV0UI9s/6z2v1f7XX14Oexatd5UVc3wtTufVdOy8YdV3b2eObtnPzkIkFtgekPoDYkbHJLtmt3jtwSYXttQTgpZT0qB6TVPSvBvwiVxkJDgluXccWAS2B2fJ0m8fOGTcjCbUF6iKoCV86wcQ7jKL4HciSknlUlfPXcxJYaUgimWA7NvStUnQIvjUALnwGUPLTFJu+ahJdYnx7450Aw3Co2Mex6PDQ1rlxOijE1MpdeKGHRJU4RKRLvdtVxS+i4x1R3y6khqh4soTDm5q9mM0oRMZ+KLw2zd6GpKy8yU25euMGOAA2V70XMLU68FWvGxg/ym4lsgQi/OBdVHfca4Yl8Xegt6DcLY1DHC/zIdN7OlCvlKxpdQfescwFTzxD864OQTTwhpySCdHiaolRN+SG43BufLjfH1K5A7HdwADcYgYpCelKTZGy1rCe4qwqE/FiSp6hvKfivX0WMy9JhxEYzhU1NYNHiTwbi4w5hkarpahp79QcfZVyX7F3mApELnYelXwxWc5mRKzW1OQj4x5uQ2CmSh4AaH82LljkeHWtTU8/wxGwtAO8h1L73Ms+AG60OCz8+ZqaCg3NBOovMzNaeEyVZQ7s6GM4xwd6DJhYkzIcF7d/bhts8E57LLPoP8OB07/XSyWn+r1Vv70Ci8UPP9qF5V3a6r6COC6Nz+OSp8mGk6/Pj4C5ZvgejkDAAA"
}
}
|
codegen__leetcode2k___115
|
[
{
"content": "You are an expert Python programmer. You will be given a question (problem specification) and will generate a correct Python program that matches the specification and passes all tests.\n\n### Question:\nYou are given an integer array nums consisting of n elements, and an integer k.\nFind a contiguous subarray whose length is greater than or equal to k that has the maximum average value and return this value. Any answer with a calculation error less than 10-5 will be accepted.\n \nExample 1:\n\nInput: nums = [1,12,-5,-6,50,3], k = 4\nOutput: 12.75000\nExplanation:\n- When the length is 4, averages are [0.5, 12.75, 10.5] and the maximum average is 12.75\n- When the length is 5, averages are [10.4, 10.8] and the maximum average is 10.8\n- When the length is 6, averages are [9.16667] and the maximum average is 9.16667\nThe maximum average is when we choose a subarray of length 4 (i.e., the sub array [12, -5, -6, 50]) which has the max average 12.75, so we return 12.75\nNote that we do not consider the subarrays of length < 4.\n\nExample 2:\n\nInput: nums = [5], k = 1\nOutput: 5.00000\n\n \nConstraints:\n\nn == nums.length\n1 <= k <= n <= 104\n-104 <= nums[i] <= 104\n\n\n\n### Format:\nYou will use the following starter code to write the solution to the problem and enclose your code within delimiters.\n```python\nclass Solution:\n def findMaxAverage(self, nums: List[int], k: int) -> float:\n \n```",
"role": "user"
}
] |
codegen__leetcode2k
|
codegen
| true
| 0
| 0.1875
|
{
"part_1": "H4sIAET8N2gC/+1a647buhF+FcL5cexEciVb8g1nA6RpgxY4bU+RAEWxu3C0Nm0TlihHlPaCIO9ynuU8Wb8h5YsuXstJ86OpvVlvxMtwZjjzDfnZn1vzIA0UT1uT1i+cp2/jOf9T3mK15mKxELMsTJ/Q/ZcgmaNNyDl/bE18x7VacSKWQgbhdJPE0YZk/DvOWJBwFkjGHzc8SdmvT+kqlgwjlkkQRTzpMhr0IMKQ3XG2FPdcsoB9yrhKBQa2MfIu5BFTGz4TWD6g5g4kzs2kJZc8CVKswWZxkvBZeQ2WroKURUE6W3GFB14UpSVtA",
"part_2": "qXQGUBeioVV90beyBcvXrB/5npMbuTWllxFyYRM+ZInaEyCJyazSEEDqQQmyCWLFwxGQ3MuU2XpVQ7mrLHCO0FtNCcVyyzOFFPZnRH2sIoVZyGXy3TFhGLLhMPEhEyRLE4Y/5QFUDVma2PdKjCWRcGjiLKIBffwyZKz+yDMuF474WmWSAyCNN3aZW/kE7rUA+Q+CKwDVYIQ22vcwpMEC4VcKbOq69j+bpuC2YxvUj6HFb//diP//BhEm5Azd0J++6vcZOnEOOSKXbuW27Ns37IHlu9Y/VsLSl8x70b+I0v1QLfXHfqO45CcTRjIIH",
"part_3": "e4zf614lLbtfeEZ22NU3o3rp2ubxkR+IOHW21unTMwW487ItkvS4Y0T8scPS8TA46IHJRFjrvuYDAYPisvH3MjP9T3P9A6D5zNVjEFSbCPGoRcvrbH2qLLu5YJ9+wuj9Fr7ATDVjDsBfOd2w6EidnqMHx2K+UuVTGtlUdP7r6/x0g3HXfomsdMxqmJ/LkOUb7TSB2o9DPzdFZtY6VXFyt+Hh3uPjr8ruPo4DCh9hbrpEmAPFJagGRXV3p616xzI1328xWE4E3Sm+sg1Gy86xYMvBa3u3bzQ4n+Lk4AEXma6zDPFNfGLOIwjB8opVU",
"part_4": "aJJSFM6AiJd9DIlIzRsVhprMGrfS8BS3aZi5nIW3UU5zlUynbhGRzHooIEhKCm48fP240bN1gONCIvc9FQiWG15wv2AKA8bfg8Y3Zobbi4cLSJk3YL0CdaziF/DchlOkw+zVbhLG2ieUvvQxAe5PwhQBqt0S0iRPavDAEcGI1dSPzNngZNu8e4ZzV7gFFgqci4uS8BbCepU8bclDe/TJvXWRylsZxqModB+uVu8gftXNWPNh8KjfeCUWAX2o1qpdb4w3VCWBaqZ0sO2iDkXKBENS+a/+Eh5861Aq3bYvSNBVpyA/K26UkXErCpST8",
"part_5": "KCUBmQ585AmAm5L8+8ExCcGhdLZu309Mpx52B/g7GEUv8oTKorZWdrLGLtmw5yW7Lw4TC4x8fcWc0nR65fv1Icl4sTOF7EjgzSm2LwgqoTtLAgnz1hZtm9ag06mRr9irvTPtsmZmod0IUv/IKK1KJGQ7EojVTnXA1shI1GjxrKV5x7sgVLp0bdv5hvzrctvft4UWS3JFtMkWZYL5734QUgVhm8CQkDSCnJJKkZhDSDtkr1jSYX9gvcp+mf3HuDqfhlqDebGDQ/u6/S2Pza0NdUCrTSjoQqbzBM+40q2nYo6WHE7sPMntbaLaQmDcL",
"part_6": "KbMpMC/ZMIlE36ETMDZK3mabmKEIkJ6G8ztTrcYxJQjOO1hyD42ZyjRgs6+Ww2JNaDj87a9vS1ajlX5yctYv0PVyTkx36X6hpqc/617LMjr49Wlt77T643GPW90YgHbtWwcwfqW7eUHMXto2SPLHltYpSDb7ply6w0Ho/7Q9Ue9U8rXn+60MDoueOPx2O/13UFv5Lmjk550rZ7VtzzLtwbW0BpZ41ygrwUOumP9crxBv+cPRt5ZhueiesZQt+ufng1/4LePX48OTudK8CyyCLZsjzV6om+s8HrD4dj3XOe0i0s+sUqbNjICG7t5J7",
"part_7": "Bgj3fSHPgD7oA34AwcDXGGHFpsZLExRWlho4ZnblQ5cXqNEqcu5ZrNbJQRxhS7bzLCGfv9wdCDi881phkK+MUYObkG2/87a526mV5DnIJRfROEhSXztBw5497Ad/t0dzk/Lff48/Xp8I3B95XBVM7yHKWNFgN35AOnh33Pa1QGctivPnxbCTiOrP1DnzWGkLLNvRzZvKLN5wBKQR/v/DAoQaJzJgj6+a45/5VtMtJcOMM4tud7Y88dn1GwKrWGpPdHrjcYD5FmgzNByG8IDsfc6jr7ImHYseTp8pnPheC7EHwXgu9/6TMf9sN/5LM",
"part_8": "1+I3O/Alrbw2F0vfYwTlRHBHtLWHCXTBbp2K2pvu95kLVBhtAVGjNZz2kxc13tUDfvwONnFshuN2foIlesA+EeiYFVBrDCGY+9SL2SBUHm46p2la8W/aStXcUD3uFA3iZzJDT/aRmc56llJ7lkw7UuxYk+RYrFhpv0bonnCo8yYFD1pwoHiTTbE15qgFASA03e/cwxQE3QIFFkNRJustSkxgUBzJmPEhCsa1Ua3TRGnccNpoom2Wo0TJl+rsitTSWINJofYTFKnp77wJDjRX7EEoVd2mKrYY+O0IfnViyuFx1ep3D3hJ9RHYShMNH",
"part_9": "C3MK2Jd+XYpzEH59Vb+DOzfBHtecYKqBYR9R/QgVegZJWLXvBfujkEGC/EIAoKLEphRuYqUEoLB4IDlIOUCrxVZiuWrIKuqhNk1jrzU3eYRaRP8rPfgIv1jBkFqiEVKaU407K2rYxvhBw6egajeNdWVrTa4/mwaAaQOuENO3E1tO64tVnXwGUXgorHpZrJXejCU8FFwlC+vVrj8fHkqqMoW1kp7hBw+lVWjCBvZur1sF+3DrOjb1CDPYaHqFFjycVWEHj/j0OCd4KK1CDT4vrc4M74gVjdjAQ0HDRttS4WBO50UtdXN6WjMSsLCjV",
"part_10": "S6wkQ0NctuvjYUj0mu4vyZeqiH+moBOlfWrSbY9+dc82Spgcm6of0t4fU3EVJi+AsxWCL9nQPwkzfcVAP4Mx1fjpxOQUCH4ihhV4vlOA0SdJl7THa9HNqcRlvnFPXK+YVMKoqrc3qnAP1YjSsReI0Txm+T7cS6vgu+3ViviadCafK794jdxZLgy8vmU6EK09xzXt52R7QyZ40z0PwwLcb+Z0hX4u35/4PDLefSthoHnXb6ud2HzLmze/8fX9dJgqXC3ar0hlfGc30vf63spnn811Mb7LGrdfsGVTE0zKQAPrUmKW++X/wARselK9jIAAA=="
}
|
{
"ground_truth": {
"compressed": "H4sIAET8N2gC/61W24rbMBD9FeGnBEZGl9EtkId+QJ/6WJdiEu9u2NSBxC4ty/57x5HZXTtZLCdVrBhjdMbnaOaMXrLH46Gttz+bY9s8Zavspcge2nrT7A51uS+yFSuybfXANk/V5nmxKevtbls21XJVFDWjUZ5O1bFhby8WdfvrxNbsu4CL3w9gz/RKL9l6zcQUgBQ0gPH+fu1xAKhp5N2fFkr5oNBPReASuAKugSNwA9wCd8A98AAUZgDOVd4FFOis104aryY/H6TqUY0A3aPhGU2q3GEIwSgtrfIo/bSaEhRoQDBgwYGH0COaM6LNw3kItFoZ63Ee9x5LRa4yNwnLSROamibSnA+B0JEiOv1KeV5pIhFUzgWDUiToPNIFRlvnI2K61m+IA0o4zYg0IUlIERLEALPAHDAPLHTpOtguN3e7xjWk0mroWvklLk0qjsiG61gcIhhtHZLOs/kkeoIZ5sp0FPZ+zYt0bSmmGhcR0zEdB0H7IvUiKGskSXVTkb4b0h2lcW8a3ppV46LvrTt+h5XekHk7jZjWHPpmcPlwZ2P43G31R93SLWVMW/Veh0Paswxm8EV4QzaMXFLM9UXT7534P5sV4SQJEtVVBgPKMKeTXfSgDl57iTY4Kjk715VMqld8pq0UH3pHvOJB6tth33ZHrMUyf9jV26/lny+/q2P5WC2L7DWD7NT83Vd0Gju2dHv9BxfknHalCQAA"
}
}
|
codegen__leetcode2k___158
|
[
{
"content": "You are an expert Python programmer. You will be given a question (problem specification) and will generate a correct Python program that matches the specification and passes all tests.\n\n### Question:\nGiven a string s, return the number of different non-empty palindromic subsequences in s. Since the answer may be very large, return it modulo 109 + 7.\nA subsequence of a string is obtained by deleting zero or more characters from the string.\nA sequence is palindromic if it is equal to the sequence reversed.\nTwo sequences a1, a2, ... and b1, b2, ... are different if there is some i for which ai != bi.\n \nExample 1:\n\nInput: s = \"bccb\"\nOutput: 6\nExplanation: The 6 different non-empty palindromic subsequences are 'b', 'c', 'bb', 'cc', 'bcb', 'bccb'.\nNote that 'bcb' is counted only once, even though it occurs twice.\n\nExample 2:\n\nInput: s = \"abcdabcdabcdabcdabcdabcdabcdabcddcbadcbadcbadcbadcbadcbadcbadcba\"\nOutput: 104860361\nExplanation: There are 3104860382 different non-empty palindromic subsequences, which is 104860361 modulo 109 + 7.\n\n \nConstraints:\n\n1 <= s.length <= 1000\ns[i] is either 'a', 'b', 'c', or 'd'.\n\n\n\n### Format:\nYou will use the following starter code to write the solution to the problem and enclose your code within delimiters.\n```python\nclass Solution:\n def countPalindromicSubsequences(self, s: str) -> int:\n```",
"role": "user"
}
] |
codegen__leetcode2k
|
codegen
| true
| 0.0625
| 0.5625
|
{
"part_1": "H4sIAET8N2gC/+1a/47bNhJ+FZ4XB3tTe2E7+6tGN0DRXNoC12aL9J+DbTgURdvclUmVpLJxg7zLPUufrN9Qki3bspNsGuCusGDZ0pCc+WY4M5rR7rtGzD130jcGjX9L6b8zsXxeUNqNWE2nSmSJX2L4B25j0JSO5dvG4OKq224Yq2ZK82SSWrNIicd/TMa4lYxrJt+m0np2u/RzoxlmzCxfLKQ9YzTpQSUJiySbqTdSM85+y6TzChNbmBklcsF",
"part_2": "cKoWCeE7kU3CM80UzqaXlHjKYMNZKsS2D+Tn3bMG9mEuHG7nJKnBKuXMY5ODnIdidjfRIn5ycsF8KHIOR/r6A5rxVesZcm1npM6sDS50tImmZmTIykrRSe6aN7kjYYQn2CewEoyjBXBY5CfW0gEClmTtjrxRuAhuu3QPYLPiSjPFG2iVLuJ3JlSwFTUycJYb1ul+zr9gVkH5b5UkQVhiVYybyXGkZs2jJYplIT/TfpTXMQI7B3og5t1x4aR2bAm",
"part_3": "JuobA+510yBrOqHmpKYEDEOIfZTL6wnG0l0DsZg8evD4atVea9NuP9Njs7Owumj3AflfeAs7YfJIClDZKdWeCXTQH6Ya7EnHHF/nHDIgX+f/x3pP/1li/SRLLegHbuR51mfsAcu2GjRiRENGqM9MvMB+olzU4TrsP2D9ivgH35adtGOJtRs82agr6i/DK/FlH+g19g+9l4mTtgGCFVhMm0x4YYnSzxJbC5kjwLPpvN5mRUI0SG3fAPSsjgiaV2/",
"part_4": "V3teCTiQ2csIn7orFqm1z2/vuw+veztWohiGOfTYsp1/5MM1i42DdqvZOz6cb6T3xkN74PPehe07bFvbhAkidQzP6frXrfbHWk3VOPgfYp8hDV5sHq5JXCTZtwMPMtIfmEscgBYrtJN5vKgm5okMQ8hpj23CARsUSzJox+s8vkcZ5IsZIvCz8usRB4MFRMDXkuTFUsfAAqhjXhTC0WRBSSvX79OQ14aYTrSDXtVsAQkhiOW09w1btdGfFWxYcvJ",
"part_5": "ZNpmbkDBeco6z5A8SB3wRRpOrZwq5OGGWqQGaVZAJ6RCsHcjXdDyoF7dwhrz1Q3SPlLDQpK18iywTEMGyYefFNRppoU3JnHbAxV520NkgNo1c8nT37aJkXKUwreoZT7bpJqUMj/2eotOmlVoUFJPESzTxHDfauKmeUpUmK18zEy88omE+Y5J/pjkj0n+/y7JI5SRAAmpoCj+SxMsKw6owgjYkydBl/WABhnIW+50TYtTEIfDYXfMnrDz4NITSgS",
"part_6": "W65ls6dNxDWm9msZUmwkalsg6ocAF/wqaXAjsQx9j45YAZEYXsBLYA+kmv2QtC4GooUJvm18QW4EEhkndPDruIEFhMMGk3u4wsQrwm+SfzRoGdNyDyQ72+qnIE8EbbuAnw7vwK/ZwXZvmbjy8J1P0AdRlixZRSSGMEOzxHll4bK+lfbyU4i5wBuUg77tH8C6QH+Lt5GM47iIuHkSFzbrjYQfGYv+kGAjB5tJEUX8XYhj36BDvJyqm0KMI66zyRq",
"part_7": "eSLTrVbIFFwlC+owg9huwxZI8h+2VDFsFol5PUIEIQbmWgtU7PDgUYhTYqZCwIoTiX4r4lUNAp6hdKH6N3J9RylPQWFS15cXRKJrs8NO1zS5tcRKWoyat6uzy+fTo2JsfG5NiY/E+9fWJ/v5dPpYbfhuQxYK1SM6B8o2K42jToHnCxiIt7r8Q9FV6haXMpLP7FerafXj7/+AJwfXXCbpHKUZ5mxQ5o+dbnqRqZRZnM5VFiy5wnOfxrlcoqYrBuU",
"part_8": "plKBSaeyygw9XY1eV6tJknMY9ZVVXhBblaCrzIr9digWcuXbrP8FFUhW0UK6QpUYm5bZREIA4ut6gxb6jGr0ztctNYVq9VyDrL21EiFALU7uqXgUIwDt7Bic/ajIFP91cYsOr8E/K092wO/ut3Pb5nnSAuUJJynR+tmZZBphaDZmyR3+qBurbfpfd72o1ZegffvuVwwydHQ+o2nF6AU2XSr2znkEWXbtNkj1Xr7x0h+ttNp5fRHtVv50g/1XPms",
"part_9": "w43Xnlj7tJhb+Zackm/VOlL9Cqtmc1pSEzp3e5bsbfyC9GdQH7rlfL9h6kCjc8J+httm1SxKFqENDVZhQzTX+1AE4xiN4jKTB1q43CI3OZ6DWF7mxZH8LERl7waLtlbX5CZoyvBcelQ/eMJ+yiMbLc0XwofLYKjQZ+ZbR70m7vs7yHe6z7zzDNlxHB7wiqrFiQklXmMwfJcT8Lhf94iYVY43Lhvv21tzPrtBrPJf1X+1cg58Nrlc9fvdGg41x8a",
"part_10": "62kUfltbv9/YIi1ZfO5ebkq8u+/tY0CHo2BR6UQc14tVzc8HTy49RbmPNRfd8rxXX+mwsOb+ulRIdOjf34OuLiw8j3dq2q9oFgswgtl3sGjqN242F9LwxeFf7PzPU1KMilvGE3oMECb2LTve6071i3e4gfDANLdBsQiX9X1sdV//sSa9sr552j38IPb5vOL5v+Jv8IdTzmcOjtvEqeDUIz5eaE8bb4q0nUcfv8Wx2k7wpaAy8zeT7PwFn28Rp/ScAAA=="
}
|
{
"ground_truth": {
"compressed": "H4sIAET8N2gC/31QywrCMBD8lWUvtiDSohQp9B+EXgOSbLY2GBPM4yCl/26k4LHLDHvYgZnZBR/BZ6fvKeQ0Y4+LwCk7SsY7aQX2IFDzBDQzPSuSThstE9e9EA7KyBg5JPgfqggDHBSROtQwDNDt6qQivUdNSu5x82iby7Vrzl1bvDZsaUdv869HVZ+odEw3aY3Twb8MjVlFfmd2xLEWuOIRY/pYLg8Iuaz1C2BRxiYYAQAA"
}
}
|
codegen__leetcode2k___196
|
[
{
"content": "You are an expert Python programmer. You will be given a question (problem specification) and will generate a correct Python program that matches the specification and passes all tests.\n\n### Question:\nYou are given a string expression representing a Lisp-like expression to return the integer value of.\nThe syntax for these expressions is given as follows.\n\nAn expression is either an integer, let expression, add expression, mult expression, or an assigned variable. Expressions always evaluate to a single integer.\n(An integer could be positive or negative.)\nA let expression takes the form \"(let v1 e1 v2 e2 ... vn en expr)\", where let is always the string \"let\", then there are one or more pairs of alternating variables and expressions, meaning that the first variable v1 is assigned the value of the expression e1, the second variable v2 is assigned the value of the expression e2, and so on sequentially; and then the value of this let expression is the value of the expression expr.\nAn add expression takes the form \"(add e1 e2)\" where add is always the string \"add\", there are always two expressions e1, e2 and the result is the addition of the evaluation of e1 and the evaluation of e2.\nA mult expression takes the form \"(mult e1 e2)\" where mult is always the string \"mult\", there are always two expressions e1, e2 and the result is the multiplication of the evaluation of e1 and the evaluation of e2.\nFor this question, we will use a smaller subset of variable names. A variable starts with a lowercase letter, then zero or more lowercase letters or digits. Additionally, for your convenience, the names \"add\", \"let\", and \"mult\" are protected and will never be used as variable names.\nFinally, there is the concept of scope. When an expression of a variable name is evaluated, within the context of that evaluation, the innermost scope (in terms of parentheses) is checked first for the value of that variable, and then outer scopes are checked sequentially. It is guaranteed that every expression is legal. Please see the examples for more details on the scope.\n\n \nExample 1:\n\nInput: expression = \"(let x 2 (mult x (let x 3 y 4 (add x y))))\"\nOutput: 14\nExplanation: In the expression (add x y), when checking for the value of the variable x,\nwe check from the innermost scope to the outermost in the context of the variable we are trying to evaluate.\nSince x = 3 is found first, the value of x is 3.\n\nExample 2:\n\nInput: expression = \"(let x 3 x 2 x)\"\nOutput: 2\nExplanation: Assignment in let statements is processed sequentially.\n\nExample 3:\n\nInput: expression = \"(let x 1 y 2 x (add x y) (add x y))\"\nOutput: 5\nExplanation: The first (add x y) evaluates as 3, and is assigned to x.\nThe second (add x y) evaluates as 3+2 = 5.\n\n \nConstraints:\n\n1 <= expression.length <= 2000\nThere are no leading or trailing spaces in expression.\nAll tokens are separated by a single space in expression.\nThe answer and all intermediate calculations of that answer are guaranteed to fit in a 32-bit integer.\nThe expression is guaranteed to be legal and evaluate to an integer.\n\n\n\n### Format:\nYou will use the following starter code to write the solution to the problem and enclose your code within delimiters.\n```python\nclass Solution:\n def evaluate(self, expression: str) -> int:\n```",
"role": "user"
}
] |
codegen__leetcode2k
|
codegen
| true
| 0
| 0.375
|
{
"part_1": "H4sIAET8N2gC/+1c627byBV+lan2R6REFihKsh11XSBot9gAC3TbBFsUtuEdkSN51tSQ4YxuDvIufZY+Wc+ZCzmkKFmOUxRYUNnFSnM5l+9cZ8jN505MFZVMdaadnxhTf05j9hc70u/EfD7n0SpRO5j+keYxjHERs21nOrkY9ztpzhdc0OQuy9NlhjT+la4IzRmhgrBtxnJFft6p+1QQWLHI6XLJ8gHBRRueJGTGyIKvmSCUfFoxqTgs7MLKWcKWRGYs4sCe4nAPKMZm04IJllMFPEiU5jmL6jyIuqeKLKmK7pmEH6xKSlPKqJQwSYGeAsZycCNuxHfffUf+buWY3ginixNRqpyLBeqVMymRUs7wKxMKxyn5icvsLOEPzF+jUlimVrnQknCh2ILlZE2TFSPpHPh+RAF3QtEtmac5rpI+AUm4dCJIWJEk6caI+074fGAV47A5R+wtmz5JmPIW9Qm",
"part_2": "N48rvJRi3MpDq/YAOXwgWg5w5p2COAfnBk4gmG7oDfqgFWgJ0BHgAhKTQECTsvisEAUutkhjtnaWSK9AGGQm2oPh90ANlaqISRR+s9QCVJbnpdHHBekjYkKxDwkIyGAzIGjAwMPRuOn2yAf2ZpsQLKbUDGNPddGAK18GYtgd6KvybCi3PMoXvGeW5BMvAdsVyQbVtHQxSO49nHECQUYFLtNNpcWG/KnagxCiLAxRXOOPrH57KbNg30rIoFbFHIjydRNjXIsoUlAJCEFbgneDmuz/qcae4TwBo17Dn8jgT+DrQ/ld1pwab6QVgsxDMY62DQwesA1PWOtYwbtEmrUQEAgUOYBWC+JLoxlZqIMJ1nDvBjZfaERDGbatNhKhSPSAaVDIrqjotLf8mpXDu5VohFZ4lLod9hW5/1ckFyLlUC+HCTEpdScymcgl+ArEqVzNI/7iv8EBBl0wOyLtyRCqaKw",
"part_3": "nb1T1shZzE8giqBnqSwsSjHe2R5WkRWPU1EmdiKCAKKVujoaf2dR7cpStMGwISH2ciYiY0tCClpxQBjXo7qDXGUAsUlAYIl6JwCLYG7SAHgboxJtOaegARtwIYW1noQYiIZRoQGaUZ5MJ/onK0kn4xYVQJ6oxsM2Tc10hx4QgqtlXGiJA1SmP1bZGACrdMIYtofqSL+2BEp6UMtBO6SMgesoAiFz2APibt2Arihy4tk1G/zAHpSqGpkb7UgDk6fs4YkPfaARcrmlOQWScfLTDLd7WEkUAyTwbk54ShiSVjNmvQZYZ5c+7cIGaK8kRietJhohHFcvaff9+IH8xyMpziyHuRrdTU53Pl6sCWhMRE4pbYgRHZkTHRGWdLdj343HRuxN9WShMZjpF6llChgZ6S96Ke1oqtuo4IgwjGcAOorLT1tn8jNhY/ModGqNGGUCJxWMOuh5t8waO6MalC5TtdX",
"part_4": "NLClQCrDxwcEiS9Ap05QrsS1v79qpxbnB5pdB2y4dPIjjS62wp8YQ29d7oYLcFRUBHcBwlBMRzQDQuEXwSU6/7kSzJ6WpIhmDRECzvLeOb1pZvUpPtYlOFyp8MPCykZmUioVNWUbF03Zurvob1vQpBxUvjsnyF3q5xCpyO1RkPy/ZWnzyBhYgFJEgbDIAg0B1sHRArI0RgNjB4GNBL8LjMK2CGuHhWoTdirpg9MmHiVDDIBphYy25Xdl967txWVokJudHMY664XG7N8yWKO/VtEE+jyNXiySBpuA3bAXvyngKw2OiWj8Gymv7uO72M1oGqZI8Xcq9OE6aL87lF4VMwfbMahZEEbb1vxolKZYox9sEYLC5HuMGNNapNzZdbINFkp24Ljb3ew0MxFlKRAy1aZmLn8HLOELzmWJ5Dk119/zfTR4gaWg6eQD5YkiETgE7N5oUZXsmTe99SfYgvQI2d/",
"part_5": "QtWmmhgcn2B2zuH81OHLLIXjUQSKQJ1C5G+EHTOtQ/ETILgvfsBxjSm+ZAiRSTa7DGGw06/t6HwlIpWmkGdrEx6/+hRq3bjnntHsU31wxiUevWqjtuupjUICBFcFH6+No2beGCgp5hBb8ySlqvsKfrzq4SjA5nqWO8VVwryDZns4aw9n7eGsPZy1h7P2cNYeztrDWXs4aw9n7eHsf3k4g24czjAAE/g5NOIvPxgR+8FNAJtkv9C82/Mm8CNSkaQABeHV8d/A3LWhzT3HVpd8T0StI7zmt0BIAwSVCLy0xgQ/nLy5IsPquD0jeIR+m/JbBGNP9vdCnSw7OnefrEEDaC6C6hyf1+S+wtA7axQZ6QCRs+Fp2hzFZ8ClLvt7SuAHRV2T12QYkDdovG5la+9ZYGqhX5N1HUV0m5MR3EPpDzpBNaLk+GLGvy797Pb6bHi7Rwhg0C1RF/JLIpln25oADQo",
"part_6": "2my457G3jBqSBH4B9fbs/Zcw3bCBmN8K+Ur3mVc0iNgeE+0DKAcoGPuCicTu8epYz+nBQRDmgWcZE3IXvh0RsQLZw+EIIR8d4zVeQAiQwIxww/pNwGL7PhgGbljWmIcRielTJ20GWZnUW6JMN27AmXjVZlmJBbvY9REAfBNHNJw00j2h5CNjZkT0GNwoJZFZhTSEZzJ4OLhvFFK/LyhneJ5gBA7xTEV5W8vibTu8KcwyF1jTmkeomXCpviUvzVnIodBIOdfhag24h4Lei8uGOxzCiI+wswUulkh2siFLsn7AUtrWxrY1tbWxrY1sb29r4e6yNTKh8d5elkOug1Lki1+0NXHHDeskkTmLu0lcw3QiSKsdnWM598D08fAzmxrsvuFDqoUGH42cRLu9T9O7wWZuPX4FoghP3+Crfta9Htk/g2idw7RO49glc+wSufQLXPoFrn8C1T+DaJ3DtE7iXvh",
"part_7": "5JfidvRzq13mlkp6Tr1AHR1jzGJK4VNlV1RqMHxaMH2bOPJGUG5vn2TyQXTN0Zv/LPzrULBut4+5dSs9VcR2z9jiGGinmPp/LqMKbS6J7mVRdtuhubm3VwwnwFf9BoliTQPHBpYoR0t0Ig2YG7mUMyH7lcqYvUfXXkdsgIevjaCXzMI9V7mtTZQVKoCjBCYnv3kDDXQPkpkNxhVS9rup9FB7srbdc1K/uuktU9BwQxK64DfR/1CrLqq8M3tIc5XA9vSybkzbGVobeyfne2Jw92Ed9AoNffTCCofU3yCLa5c93ClaM2gOZi13w71+gz5fU/3pUZvpAXnrhRtvLxA1e+qK+3Cmxz6HLY00Hf4Nqrwjpq+LXvLz52txt+jenO0HaHGRzIAtCNHcDJcsTHIoUxG4RmW32S+AUbtB/yPM2Pk3NQFSSbHzvVoWtO4dVr/0A/LmnOY3tPvA7UgsbKcT2cA",
"part_8": "rjNSeV6T1y9vWc6bPyq22JNsqKq3hffVbrEY6o3XuvWXWGPaJ98/mKKLceu9C7V7WVnev3ZDEDpfcFZBMg6gp3huPOl/xTVsg/3t4Yn7DzeN/vUJk9So0BtRuzX0BCC1q/XI5EbHVv1KZnAsPlu181g2Z7yYXAC14mhPis5moGoYDazakXwbQ/h8eXJOFmBcegRQC+hMmObQr8d2ewzCscnKDMq9Rj3airgCnvYmAFYdi42E8ypGMMppMGPRhfH/QE3F8rqL1rjmq5OvUfk0CvNOkMrFKLuaX5xAsQTIOuCI7QG2zkBLuzUo0P60izYwNLevraXwYneGgJgI4BwDPhNHPAWYYun/o+FnRn2c3Ju5ZmbgQUKiAsW5LLnPjUDBJMTQAg9EMCPHx0M40q0bAF/Unq/kbopeYxOyQHnVeAf/WRgwLZCPDohNmZibSYewdnNwMoMrHFg1YBBOBqfbhjj",
"part_9": "kTX3NwEyLpPGHo+3z8lTEfAp4mdUWnNMFj1n8XmRqTC2eh7rGthP23cJbiLQdfFHSt6SDN+R8BRdEuGYpSRrqgbnJ0WSjd8q8dKijw5eF8hVLufHvaZMglvHaOLIlWl9C/WoYGf9aFT4z8YB+aglqGl5GQQnqDl+od9u0U3XTQUhOMGSIVjSGW3SA3NpmoIsLffMDKSlRTOY2+M1PjUzGolNTrBJOCwwrJWfDWJfZzU6P6nONaT+gnjdl1z0974+DMO9LsAGpsnKXuB9hT6YHf22oCynDrpZQ9Nx+W1wqnZUB2AaPiMf2p6mACou0HEdD3PFqmgOWBNyw+DyVK8zukEeeex5lq+3hicpEaAWQWHeAO0beFj5bVqj0M+r6U82l29fVokKDz0o8duT+8pK6vL7nKfLXTh8uQPVkf+6xj9swMWnfziSnzjj+PVmUjSiFr9Ap7oiGoMiOdoR8LOGxuh",
"part_10": "tcFKFuWisMDuMt00hwbBYApUMa4utvSO3etOrNW/r0sq7/YrwNjw/JVMbChOsPbY6ABbDoCy5e3na5qew6WwyCU46LQZlJZrUKlEBSGEDA4ht0712o9ZsjCfPiGt7BhqVnfgYGrTiJMS8/mw/4kfPNPmodzgyN97EZk+pi8vT6rrn27uyJxuVjdO44Dp5fkr0j3SBHx3emdWUyOHETzG1DHPCITwDKp+KNgdwyw29jHyyfKQZ+ERyB6Q0EzYqciJ7RDXo+DYE/7jtd5ZM0c70c+NfxIdvKSzxCdcdvqGGMgfDyVlweRZckCCY6n9gWULF4g6f4XyDJyP+X8SAb8FfjM7bv5qhfTGsfTGsfTGsfTGsfTGsfTGsfTGsfTGsfTGsfTHs//dXMyi6kJ3pdeeDotED/P4Hi1a5/X9Tf6TynnzEMIEfH3Sd7dx+6Xe4vFsJDu7Wmap8xb78F5qOcvoVXAAA"
}
|
{
"ground_truth": {
"compressed": "H4sIAET8N2gC/5WQ2wrCMAyGXyXkqgURNvVmsKfwNiBljQesnfQgG8N3N/V8u1BI2iRff/4JD6HP3u5SyOmIDU6E++y7dOq9cYQNEFreQ3fk7qw64+3JmsS6IfIgYWLkkODbUDxcA8co69ACEaFynGCAGtQlu1K9H1YwwhqUsVYuo5Yo0xraFqr1XPrq+cPwQ9RzCZXIqYu6j6A/aV/qRqiv8/Jj27tcnFJ6yTfjcnGG8I4LjGl0LHaGLOn+APupRs9mAQAA"
}
}
|
codegen__leetcode2k___197
|
[
{
"content": "You are an expert Python programmer. You will be given a question (problem specification) and will generate a correct Python program that matches the specification and passes all tests.\n\n### Question:\nAn integer has monotone increasing digits if and only if each pair of adjacent digits x and y satisfy x <= y.\nGiven an integer n, return the largest number that is less than or equal to n with monotone increasing digits.\n \nExample 1:\n\nInput: n = 10\nOutput: 9\n\nExample 2:\n\nInput: n = 1234\nOutput: 1234\n\nExample 3:\n\nInput: n = 332\nOutput: 299\n\n \nConstraints:\n\n0 <= n <= 109\n\n\n\n### Format:\nYou will use the following starter code to write the solution to the problem and enclose your code within delimiters.\n```python\nclass Solution:\n def monotoneIncreasingDigits(self, n: int) -> int:\n```",
"role": "user"
}
] |
codegen__leetcode2k
|
codegen
| true
| 0.3125
| 0.6875
|
{
"part_1": "H4sIAET8N2gC/+1Z627bNhR+FUL5EXuzA1mO4wvqAkW7DR1WbEN/DU3gMhJls5FIlaSSGEXeZc+yJ9s5lGRdTKX90Q1FEaFNrcOP5/qdQ8b95EXUUM2Mt/J+Y8y8lBF7VUpGXsTjmId5Yvaw/IZFPE9BykXE7r3VbH4x8qTiWy5ossmUTDPU8pfMCVWMUEHYfcaUIX/szU4KAoitomnK1Bl",
"part_2": "B0B1PEnLNyJbfMkEo+ZgzbTgAB4C8TlhKdMZCDg5QFA9BY1Rs2jLBFDVgg4RSKRZ2bRCzo4ak1IQ7puGFtVVZTRnVGhYp6DNgWJ9diktxcnJC/iz9WF2KF4JwYdiWKbKjmqRSSCMFA2GoGNVcbEkE8RtNeGyVSpHs8TOj4Q4scEUkLEQfaMiEqbD3FronGpzR8R7en63JHuz/UmSiNipGRD",
"part_3": "GTK2FjSKjagmtE5Ok1LNoYuSYJ0xgjbJOKsI85hYAkEZAqs3vEZbD3z9+X4qd7mmYJI5MVxv9aZLlZweY1mfiX4vfc2PclrlXI4AgZTM9rbPFWw6dd+HQa1OhgaXWjJy+l0EZRiF3bLT6mReCPiW9BVYF+lgpKC5gDi3LNbIZimSTyDmPUhioDSQqBz5iOO8VNgdEyyS0JQIrvFdmwJkyEi",
"part_4": "QRde5mXWzGJXJCIJTwFDQrT9v79+8zS7RLgwCLytlQJLhF4IhYf8v76kPZXNusDzZJ4RMQKazwk4+f478rqhM7KFIs5tJbH00xC54QQD7AbVOtLUcogR6Dt8AqZ2B1eoJeZ4SnDTMXQkMTsM8xGufxDKY1zERopE91daNjrLmHwzj07RrOPXeE119iVHWnhelcqM2xm4G5HjpE1ZBCkiIE+",
"part_5": "cSKpGZzCy+kQpZC2anJsDDcJg/Q99e231LdQIeA1U9BdWJyv1jOkfDQ4l3BtBuDGQAyH9QrHKOvXux2HwDh5BrkXA12cKPodJ2MyuUKH4fNVQ3Gh4seWDiBJraCDrfS31D53abVuV4g1NsYAYhpUoiH+HB5vgdWWMy4HXYG6raPl0+Wpy0xbZcll9PD09OyD5KhzaAurs4TjqW8JAO9wc7j",
"part_6": "Z8AgkVTXHNYPHBYMBFkrkGNb/iRDfFyFgXqr9JgMR0qIq6mB41ldMJA1MRwBjyeHCFt4MQkgYx8OschTvangeVvJBMemGZL3GIdcPgaFmQcV068XBbLMwO9aKE0Xtny6zT4fi/3WZJd/XXbaK7oXQd0ytyKCKCjy85RGLIDyMu6jrNQ1vDA9v9LC8LOgM0vef3BVOCFTmFhsZvanIJ6H58M",
"part_7": "BAgiOpC1LVu0qu950qMFO3EMbaDtcC21htGn+LpSTF1RzsM+yyuOgHNI91S+Utsxm5oypq+JBSdQO+rktr9UKMV2cIkygqtmxQOgPnxYj4IzKedIc9dHThIw78Z4fP9pxxnAsn5HXhYZjDdKoav92rRWXZLZe5hrHBRi41d5BvBpWHbEfMVo21NxaKr/eooTgymXEpwilXd0dZG9DqPLpa4",
"part_8": "TVO1pa873g95Jz3lJMZ603pA42NHWWs2th1qlOqAjUqK9qtU12kzqnc9OBXOGhr/iBtkPCyOXcxk9WBbR49w0vqFl3IcchtpB1t3urdp0IAPVnMU0BUa97Sexh11mFuNhH2vQuC2dnEwPQ81uP7xZ+WufI5Qs/Op0Hbs3M3cIKP73+hWvSgA3RrbKFKSReILuLfJnTaZzkIptPz89ns4mI+",
"part_9": "XywA0ExXd627eTG/mC9aW+aPpW0J+OPUOTdMz20MrRCmPblbLttZcXnqyofD6AzjmbTNWqFLZ+D7Qbu+kx4Pg1Jzl6+F0AHveDsJgh7WlI+LZK5aB6ApOPbY5YMP7rXJ9hn+uJnjKldp89gNh37kzKxbvcUjjXTYUHxyZqbXmMu35aNdOznO/TH78TmHx0n+frr4Lr44CAPJngbTdv77h1L",
"part_10": "PGHGOEjvD7I8vy8iseprwWujI92KxmM/nX1bcurROfM/YOUp6X9/7PY1/vKFJsK6J2edI9ngNvIerkZcyQ73Vp57/HMFft+Biy6IN/nKJ1fYns7G/GPtz4vsr+wdgCVwANngr/3qX3OYXofgNzHy6ePpq9Nv/atTQrYb7lfeLgsvxHgRvqNl5Vw9wA9ObXHCooLcyKmcP/wKEWUR/rBsAAA=="
}
|
{
"ground_truth": {
"compressed": "H4sIAET8N2gC/32PvQrDMAyEX0VoiqGUNumSQLYunbsairGVxDSVwZaHEvLuzQ90zCHQgT7E3YR9DJndS2KWARucNHaZrfjAZtTYgEZHHdiB7Luwhp13Rkg1WjMsMilRFPgfCoYWrhcFbQv1IVNWt41azRFYVeXGlfX6b589zTOMec1ZqPMncJDA9GAbySTP/d33XpLSOOMJk3xHWsrFvKz5B9u/i9r0AAAA"
}
}
|
codegen__leetcode2k___198
|
[
{
"content": "You are an expert Python programmer. You will be given a question (problem specification) and will generate a correct Python program that matches the specification and passes all tests.\n\n### Question:\nGiven the root of a binary tree where every node has a unique value and a target integer k, return the value of the nearest leaf node to the target k in the tree.\nNearest to a leaf means the least number of edges traveled on the binary tree to reach any leaf of the tree. Also, a node is called a leaf if it has no children.\n \nExample 1:\n\n\nInput: root = [1,3,2], k = 1\nOutput: 2\nExplanation: Either 2 or 3 is the nearest leaf node to the target of 1.\n\nExample 2:\n\n\nInput: root = [1], k = 1\nOutput: 1\nExplanation: The nearest leaf node is the root node itself.\n\nExample 3:\n\n\nInput: root = [1,2,3,4,null,null,null,5,null,6], k = 2\nOutput: 3\nExplanation: The leaf node with value 3 (and not the leaf node with value 6) is nearest to the node with value 2.\n\n \nConstraints:\n\nThe number of nodes in the tree is in the range [1, 1000].\n1 <= Node.val <= 1000\nAll the values of the tree are unique.\nThere exist some node in the tree where Node.val == k.\n\n\n\n### Format:\nYou will use the following starter code to write the solution to the problem and enclose your code within delimiters.\n```python\n# Definition for a binary tree node.\n# class TreeNode:\n# def __init__(self, val=0, left=None, right=None):\n# self.val = val\n# self.left = left\n# self.right = right\nclass Solution:\n def findClosestLeaf(self, root: Optional[TreeNode], k: int) -> int:\n \n```",
"role": "user"
}
] |
codegen__leetcode2k
|
codegen
| true
| 0
| 0.25
|
{
"part_1": "H4sIAET8N2gC/+0ba4/buPGv8JwPZ7faheX3GucCueRSFLjmWmS/FGvD4UqUTaxMaSVqHwjyX+633C/rDEnJenplZ/vhUhsbWSKH857haMx86bhU0pjJzrzzK2PyXeCy92bE6rjc87iT+PIZpv/JXJ7sYJQLlz115uNZ3+oEEd9wQf11GAW7ELH8J0gIjRihgrCnkEWS/OtZbgNBAGIT0d2ORZcEgR6575NbRjb8gQlCyX3CYskBsAuQtz7bkThkDgcGKA73AKOrF22YYBGVQIM4QRQxp0yDyC2VZEels2UxPLAiKoUppHEMkxTwSSAcXy7FUrx584b82/AxX4q/K9",
"part_2": "ZwfRQEkgQeULwFcaNnIiPGyOOWgaTsgcGAAM2RLQWMJBEchCEP1E+YokWJpNGGScKFZBsWkTuLREwmkUauAQE7PggG2osl8Rn1NFIZqAmD4g6Q6GfgAJj+aOABiupFO0aFlhoeYUYku1ugCfiZu0F9RPSB+cwlgUaUlwiwRIw6W2D7WWMzbClq5K0fBxbQUXzxmDigPuamhDn8SaUDERBny303YgJY/OP3pfjlie5CnxF7jnpein+IMJFzrdcFubGtoTVYWSDdgthL8Vsi1fQAF4Y+Fcpuc/ILB14iMiBBRIbIQBuNgQS2sm7Kw6CBhyp9u0T/upac4UPh0QMyZr5X",
"part_3": "oDlsknsAko8skfh+7jLWXxPD0WDP0bCGoz0nj6Af405D0kXXE0BHNsFMesi72HuQUmcJaKDkQBu+C0QMzgNOHCtplDYy58J1cd45Ebd5jKjYMJSW2P1+fwUYbfLTgnyEJZdABe9xYineYjimIRHnnU8lFR1Zl4o0Rt4TB77jYGe4zhPXsZlRWCzI3aU2gQ7zD0EECQLkyHJREjO13At8P3jkYkNi8CAJ0jnGqR4jLjVMHPiJSiVGaWnKQpUz4fgB4HoOErMUtQm8ucznO8AQYbL5/PlzqJIWsEPeM48LrhB64NrFLIOiXSKU40POItcwhmLNcQg/LvPIeo3r1+suOp",
"part_4": "6F6lv0LTC6JxcfA8Eg3fDNVt/3soX4UY6qFISLKjOIAabwqzKnUMKk+l4Kzd0noxggkvIGornvUCOx/BW80LCIETAnv4UITP2bVCr0+DnmyR65+Bt+G0T4UUqDDSiMQF2wA3X4Lgxgg3HAYLAJAKJ4KcwYOCpYMHsEU2+zB9jymOQ7hq7gwb5F5HOI5jbTfzGjXiIcGQR+XJ7I0StPoXVr12wZDe/Lg7c8xs2rNKpZL48GIe554BylcZQsNwZCCg+M4vkBld0f4eHHHo5WfOdEz2nym2avOeQzS4EsoJev0cu7OuznxIe4TqlxTyUxM7XHZzZQZEwPmpyaymiQ3fRX",
"part_5": "PYNI53a8hSQCmW0BCoC7bi83eEnDkAm3i8jM+CPsZEzP5sirhLMwi8IgRGFTTIZtTn4CHQjDiC5gDFN8pTIvMIz859CmqFMdlqXhq14RuMB1tjLPCPlrJvdrMJaa8ATO1NIG1ow5Ue+pX/B4HdMdW6N/dEOL3JdcIiTpDndf9YvrKDF+AVk3hYfwaQD/QP04Dx8q5/4BDIw3L8DHrApQZF4ZBSTQxlF8lwCUbhAiVdJSQKpLi+K15NJnkPLOJem5JD2XpN9XSQpxDhUNzAkHQ/xcDrYrBxGZ68Xd5qUerRvvlXY1yBEKRXEUP5sbnFile5hHe3UwHl3VVA35T8ql2Q",
"part_6": "VegjJbgQHbA25UxeLRxJcud2RXVUk5fZj1ltq6cxP3WaWjXNJTu6D2zY3eS11mttKca+YQPEDYLMDKsnufG9V1kV1TI2BdVFcTZXu3y2q0bWaMky1y1UYNcG6nTbmuAilJn6QS9AbBVg2YkPSTVJkJYEHcBjijjEvqQkXzVGfETOdZ4aPAIMTj0OfYIFPpCp4lje/W3IURR0fDBSbECy4u6IWO9wuMd4B0AszX6Mbn7HDODufs8D1mByZk9LwOA3BiCPI0MLq9y1JAYOKAW4BBB3e2zLnrOmAdjk2N1HextY19kXS8a2q7/Ys21j0Diwy1N6TXkUXGFplYZLrqWVjl",
"part_7": "DXuo6nFrrEOFwFY4AD1klVmRwhSIGNxjhXtyPMd7LhX6K6zg4B9WcgBgA4QNIPbY0JkqOvbodQgZpJNvYz6vkpy6R0diHShdl4xoTGlQDrT03+YXmXdUB6vXcTuwSfPUtB0GfZ0dA3x1DHBmbG2W0WvEVtnwFVmuWvAzPJWfSnzr2Jh+u2QncpY58OigJ00avGRWIDtsTXaqCA4r5rBnOaL2tKz+XFKxdfayx6+UcMuCgSMUMs3sWJWeGP6HMormtRAT41feb0anptX2MVaIt9PJAs1B6gtHel+V6RrXP9Gz86F+KKAK7vHtrI+Lmi7G5exk9KcqoWAYO22kRs/n4w",
"part_8": "nnXvC5F3zuBf95jieQ8+mEP9XphNR8b0X8yKI56aZmAxM8cBeSkacMqz34ljp3kjt3cc/8CBCH4MPfz28ATaclcm0qS/ee9kcU/pcmMr8DZ8227PfjfWOt1NrJ/SpdbCLt794QSDwPWEmkWxTs8eE215jDx8PNuWrbEi1sQRUAW1T18IWRRc/WdSaR4k3a+cr6jxoeh3pNa/Ygq8Iv99U1+X7cvL5dmc1bCrQBQVMPL8NgGp4lFNXOZq/eOj9/+IRGQSeq7sfKQ1Vyvst1RAunQ27uVsVmJ+RI1zQ8a0nWnxfBj5NEqN5Dx0ZyNFQf0SwpQRSfwAOxD4gaTSmkG78u",
"part_9": "fSqKx8Mf2uBmwUqXyiogUhw/LDK/rzGPiQwDfJi9ty6EGQMz3gZRnG5KSgVFSNWRNXCqLVtgsaEpnMLv27OovIYWbfFMillaa0Uj34WNAlxvQZc+F7C1boPER2kg4vH1QJWj4A9YXGLthEoHhXFXZXQ1tA5UcdSZ33zRA5DfiwXWvrIaQW01saamsBoCinRxZ9z5alURDGGBDUsGVt+a5RBNrZFBMs4jmdQiScs8RRvQXFl237Jtyx5Y9tCyR5Y9NsimeWT2qDU2s3xyDC97YfYaGb2MAHguqFTrNS1VC/wfYKC8vjxQXxE3Xia1o9MXVqnLrA3QVRugzAwFLY5aaa",
"part_10": "FikAKHV4fpDdvSK7p/wdmmbdlsT1N7SuPbTdVaszrcw1rcEH8FxiaWPUsx29OCkvbRZRdi1R63tsykyKZ1VRdvs2YltI+O+uhCFup86xgJjgjxHIJDfpnz0GNw5171X7ZzgZWyI7V3l5Yv2qfwM95rpdZ/Zy/iOUKMOsWBI62szo5J2pl/afg/RdjTgtci5q6xpwczg749vujPLvpT0u/P1R+A+fCivsaX1vNBiNYvPflTpHjcZDoanM+VnnuJ517i/8O5Ukk3Mbx4dK71SbL3LJTbiw88AlyfQBfOFgZ/hjBwa4Z1rKiVq6/wLhOvNU+duYwS9vW/OTjWnjs6AAA="
}
|
{
"ground_truth": {
"compressed": "H4sIAET8N2gC/61W0WqDMBT9lUueFMJY1Kgt9GmvYy97nKOIxrVUEtD4MEr/famxzuhWNFUkheb2nJt7z7nNGX1VouH5XlaNPKAtOieoaHgmj4KnZYK2kKCcFZAdWHZyspTnxzyVzN0mCQf1pHXNKgn9hlMJIWEHsmJsz0XOnA+CwcPgY3gTnN3WAAPFEGKIPl18Uj/wXdjtgM6H9VsE0oIo/GcMsUkRKZYOnLbgoUXOv3m2+BvFqJiI2icqgKgIokII7YiilogEKzF1qOGD6Q+rMih5sBTWa+s96mTXzw7T0wV4UB29RqZfTlc6Lyz8fyuah6DXeEnwZklw32/dmGAVi417PznMZkZCvnVCE59rh0QrnM02t17FwV01hf8oJTZ4/fm8UcvoT1pC4gEricYtGEwXoucYoWsN3/HRlBqMkRMvrqrtGLg3WnS2hjfo2n8/gfWInW82w3gP8CpS76aIpSKcpv2HBWwVPnT9PWcZIlkheWpW23RobI9vXQejO1cX6Fdfot5F2VyvV477VBx5/lKKmtXylaWFm6ALwqiW3yVTV7GqUR+XH0S8uoiiCQAA"
}
}
|
codegen__leetcode2k___200
|
[
{
"content": "You are an expert Python programmer. You will be given a question (problem specification) and will generate a correct Python program that matches the specification and passes all tests.\n\n### Question:\nA virus is spreading rapidly, and your task is to quarantine the infected area by installing walls.\nThe world is modeled as an m x n binary grid isInfected, where isInfected[i][j] == 0 represents uninfected cells, and isInfected[i][j] == 1 represents cells contaminated with the virus. A wall (and only one wall) can be installed between any two 4-directionally adjacent cells, on the shared boundary.\nEvery night, the virus spreads to all neighboring cells in all four directions unless blocked by a wall. Resources are limited. Each day, you can install walls around only one region (i.e., the affected area (continuous block of infected cells) that threatens the most uninfected cells the following night). There will never be a tie.\nReturn the number of walls used to quarantine all the infected regions. If the world will become fully infected, return the number of walls used.\n \nExample 1:\n\n\nInput: isInfected = [[0,1,0,0,0,0,0,1],[0,1,0,0,0,0,0,1],[0,0,0,0,0,0,0,1],[0,0,0,0,0,0,0,0]]\nOutput: 10\nExplanation: There are 2 contaminated regions.\nOn the first day, add 5 walls to quarantine the viral region on the left. The board after the virus spreads is:\n\nOn the second day, add 5 walls to quarantine the viral region on the right. The virus is fully contained.\n\n\nExample 2:\n\n\nInput: isInfected = [[1,1,1],[1,0,1],[1,1,1]]\nOutput: 4\nExplanation: Even though there is only one cell saved, there are 4 walls built.\nNotice that walls are only built on the shared boundary of two different cells.\n\nExample 3:\n\nInput: isInfected = [[1,1,1,0,0,0,0,0,0],[1,0,1,0,1,1,1,1,1],[1,1,1,0,0,0,0,0,0]]\nOutput: 13\nExplanation: The region on the left only builds two new walls.\n\n \nConstraints:\n\nm == isInfected.length\nn == isInfected[i].length\n1 <= m, n <= 50\nisInfected[i][j] is either 0 or 1.\nThere is always a contiguous viral region throughout the described process that will infect strictly more uncontaminated squares in the next round.\n\n\n\n### Format:\nYou will use the following starter code to write the solution to the problem and enclose your code within delimiters.\n```python\nclass Solution:\n def containVirus(self, isInfected: List[List[int]]) -> int:\n```",
"role": "user"
}
] |
codegen__leetcode2k
|
codegen
| true
| 0
| 0.125
|
{
"part_1": "H4sIAET8N2gC/+0caW/bRvavDNQPlTaywHHkNBHqBdILW6DdowkWWMiCOyJH0sTUUCWHloVu/0t/S3/ZvvdIiteQouy62xZ0Ysua4923JP848IQRkTSD2eAbKc3ngSe/SFfGA0+tVsqNfXOA7b+J0IM1pT35MJhdvX41HgShWist/NtdGGx3COM/QcxEKJnQTD7sZGjYPw9mE2gGJ9ah2G5lOGF4aK98ny0lW6t7qZlgP8QyMgoODuHk0pdbFu2kqwC9wOURQPSSS2upZSgM4GBuEIbSreJgZiMM2wrjbmQET2QZFEHaiSiCTQHwDCCOJjf6Rn/00UfsXykdsxv9lt2rMI6YigBAKIWn9JqFYqc8/zAmKIcgDhkI6w7PmACYEKHQRmlJaJVeAXXSQ4kItjzAQmQAJcLZwyNifQ/n9kHoewhiC9L38XyEAtyyB6bZEgQcHtg6",
"part_2": "VHjk6xTkmO03EuScr8zVYv5hwa6vmcNCCfRGUpuIxfpIhSsBZUK47RovXqOzIF9txBYIwOt7ZTbEFkllwt4SD2yI8ALtH+CHpKURc4H6pczYhbtLafYS9awPzOwDNr3wFGoOBA0HDkx4H4QLiDMaQUuktw1IDm4HsfZACCCuL+8lCEOr9caMc2JS/ZAOkCYt4cASrBMEnXCiNG2sUGFH1CgdX0YRW/qBe4eIgBJiYcK+kxGcddFGQMy+2iqQwYR9KdwN8wToH3RPfKZMJgqFw0hrLo9Qrsmo1UROEoLFqmgUQxSx0nEQp1SwYMXKGhsl9mw2cN5InVj0NohMTbe0swp8P9gj5ySl0YS9J0sh39ES5IeqEcwoCfL8Tpo4TISt4+0SNgF/wkocAdyyUZO7FA07YQ+M4esVbSSWnPq2G2yBnBj1q45mG7YjBJJ++RnU/CC2O18y",
"part_3": "PkO/vNFf611sZgWzZddsPnfGfOwc//HF2LritK44i8WN/kdsCD53EPXOF5oixSwVHVrAZdkZMsbhbsLMSoWgEbIM4XnsKuWpHhTAYIWf2UVq575cGdITmDpEWbARA4Kpm7eKSB4pyggkDLb2SJwhWkeC9BjmEmURo3DVmyTCz5Rx2aoMDqJH8fJUzMnzgnCnFdl+iYEf4na8prBCwSx3HDRoFol7tBlz1MI0ZXEZK98AeX8PjHJl4iCZA8oECB1pCCRocxiGML8B6CzuTIrcvpyd4LVkRCnf9J3+y2TQaGwv68ZmsYucG4xvQLSW+2P2SLzlc7BEE4LKTGIfWwjnv/yc0zzxpV6bzY3WlQ0I/sc9zj69ZtsxZBx4vAJHqOUIUI9UqAvIMEHIeJK9Er0Jfy8OEaVkMLs1xbOS1UH4Qk0HsSHOPBm5oVqCPCFpuxiDEx1i5EiC",
"part_4": "BQOWlGuA920AOGJd8r8ILVxSXKdQIh8Mo9Cb2mySzL8KQigDQCbHigNiTCVKQvQO0dtcyL3oOvsQIn1iNIEfU8EAq/g8K0ww4Unt+gHAogqArmJ6BGoggVOuCFE933///Y5Kkxs4DhUHe5eCBJIYfHlylXnbv9EHh5H0V+OCtc3YNyoyc/oB6l0sRuzir8A08gTAoRyDyLBSUI8N1HYXQLnlAmNpdgMVJmsoSb0+PgWRbI5PoPyTRm0limwFVRwzhx2KJd3+S7q6AvmbIMBMWt4o4KtuoRSsdzZS7H6oLi5VhFqvrCakV1eDHVaAYIOVdeSssHaD+REcduUHwgw/hicfj3AVxJaVm7dGGV+C+Ppiry/2+mKvL/b6Yq8v9vpi749U7EE2hxoINetiIv/1Cy2WfiEQbxUN1Zh9GBXW8eteRVlyZe/DWJZ3MfpH8wu+mIjdTmpv",
"part_5": "mMAYlU+tQM5izJbIJ8Y7BhfGDH+hxws+Zg7+Qo+LCgH49QCJCvAr9gLhfICHZf2QWoFGQesP7FOW1LL09ABPtQVmeqVgHw+L+SGtIfC2DgxxT8sNAEh6IDkkcGQ/AmWzHYvTAtNFmbIXQErzmTQMKJkqwAPpEx1UCmanyBeuwQf1MCdiNK4szJ1FgXwB6Rnoyxf2G5WmsYppUBz5SviRXLC/ACLU9C2qGeL2Wg63o4XFXvBSZd21rOX8WTYREZhaGOwRm4QkTKPTIo8W8eKtD2N2X74DQEbNBnJftwjyhxbtEZeZR8wXoy46zI5H0gxHLTfc7KAzajdJcsTyEeAGWSDyLOQvYf2ucsN7AOEXqKQh+XArHob54pjdycM1GFSVbrQjsGF3DmAs+rsbJ9VjSRlEnE0dQPwdqgJgNYg+tYkPVCYDmBYN1TsHiEn14xIM++nInhz+",
"part_6": "zg6FXcNitYvqFJssMkzvFaNVWiEL7NYhkUU7X+HLKJTg4Tm2m7fKw7SWZK8LKt9gB+ptKFwwxfU5r895fc7rc16f8/qc90fMedCRh4fbXQCJB1JZlsSGo0kxeWEulBEeoLS2ke7d0AUSFc6vM5vA1/RxBJ6tD59nhDQit3e64WyYlBCM6RkgHjeASEh9mY28w0P/Fo1+at9P7fupfT+176f2/dS+n9r/Xt6iwf6k79DI2Hyro70MZ2yYsQek3isPxLQiASSpeyncO/CWu2iUvqwR7cBu8FUNy1szEOWYvZPw430M7tD8hgxP/hDTGzyed06UpfRoCIzC9pi59EjH6TbROactAlRpJdLEMx+GL6DhcUdjNgwvjr/B4wue/XbBcX5Qxr9cWTEnSEFONfQkvdpqlSqVhxXqwMu7Wc5v2gfJxxK2SAfDORE/qvb99ypSOYaGQ8mk",
"part_7": "heA1z8Foe7ILdhiXhpY5QMZNeShk60s1bGqsCwqKpfPNAxFqH3WlndR5PzlMYI5o1gCAU75bOsr0REJtertlulGep2loPnU6tzvRtSZyyyaVpxFVR3cFVKca5Nxi2rhKfSGvyvJrNbvHxHNL+Waojj5rM22L45JlUVoujfUyIyCzUjkds9/MVs4XbsJGfTKaipK2q7JLyrZbKq+GuYgbxDdrFlDhrsXprPOQp01iTQA9zW1BddWZLI7kawGWSmLL0LQcgSxD+rA4um2wAjc/o0ed5urhYu4W5upJ4OseHWzegUNJTAQIqflm1hwcX5uwQGrz/0xe/70+ElHUQGGkmmJqHqqWN6AiUiAJkxeaXVtLq6onERQAQxrCiu3SE+xhxi7QrB7mfFF+OSDB/hkGk3KnfMSYEUFDFoJfyYUFkwQ3LMallBww4bIVV92odK6bJ11wpPtb",
"part_8": "Ed4RpXlf5R2JrDL5jry+0L3RHBaKz4Bq55QIy8sKuYHzxDvToyObuZdiS8YY1Ol8UZJ71m7nwqPiT2FbcxtQJzKYzX9MFvCNvs/SYQPGDNeAO4Ofxo0IG7rIIoDpyfuP68xKRL5sQ1LhL0WTIcgfnbq8Tpytwy2R9fKE7DI+0+8j+sJ3SR7Pde4cfVXMp1Vo+ToviN0p4HYqouQVFTWdtcG10WCjt8Tt1WW75fAawMwKnNQ0czLsNlRkhNtIeJzxtq0WvKUkxaoeiqycOtsEtwtlZac4GRDKCuNHqVdX2wg4Bg8LY3V2+Zl+/epMjTUDthDinPKBjndOUdCsTW7VficLsAjrpHnbGagw1skM0x0LabW0dMnPyku17GTbabpjIdwS9/iZd7ow7TSLox6I2j2zUw61BeLGc88Nr5zWzomyJRTlDMNPnGnSSV0XVh1cdiyXioVX",
"part_9": "7kHlUomX4mTuM+Xsc/n/zD72cPyM2WfqdMs+vFAsFfKGpVq2rfBajV2FXFb6q8fqwG5/9uqqyVZPZgh7dmg4+yswZk9p9hRYsfYziX1yDV+vWYvEVwvE03HDSsLly6eUG0X52M2EWysi+51mjVXla9Mar3RU9jsdioqr6eNFUjOZSj3sWETSfOfPg6ck4FdOt74obypLGbneep40cn5OW1BsDer1GC+0ak5L4/A7r8emnYycW5pjXvG2qj8XAxOveWYdbrlieP0I32u35Oay39L380fePbsrau+Mzr77xC6p1inZC6am8srqEkVDtZ1vg1+n51GFVjV3nlttOme0iPxkXVk29DddY2BrE1ifCD2BsV939YxJ7285RP1NhrPTN+cMOp1Ct9W8WuzD6kGjusqbMmPjajVnfnJaY/b0YCsGW3uDindyS4611f+vu8mYV16xsNX0",
"part_10": "tWKm8awNbpmsqy5klYgpklBZb0DCX583YLIVM/YXP/iTvPzN6bhcHG/zBgXVJcBr7W4Op0zCtJvZcktVY+8guLXk4yVy6/mOW+qexmQwPWcwUxkE2Asy3jIt4a2t3CMK6OfOKvYJOreMd5wO0/Yusa9zfVF/CaHeBVijY6VErpNweUbNVq+m6nVXI5m86eWry8uza/GmDrCpZzxxvtskvKlX463nO9TN05N9Km+YVvAaI9wSX3l7zK3nlcV4sJVGDGY/Wv9iKn5aZYtvib3FT/eQHfOrC+f1hfMJc5wZ/YdjvtDrW3yj6jN8oLf4F6/w48SfTN/0fwOr/zRN/2ma/tM0/adp+k/T9J+m+eP/DSwj1tFgNh98IXdmc/EVeec7KUJ3A5ufoTvVl9+GoTjA47cCUD/AL+/UNvZJO4PFT2MorW4h5EKdMJiZMJY//Q+RfW79Ll4AAA=="
}
|
{
"ground_truth": {
"compressed": "H4sIAET8N2gC/5WQTQrDIBCFryKziiBFaVeBHKDrQjcxFFHTSoOCP4sScveamgYKobSOgzgD33u8Ea7eJasu0ad4gxpGDn2yMhpnxcChRhyU7pG8aXmvpLDKKBE1rjm3KB8RgvYRrYvKhKPttYxaoQa1LSWM0LVYRzYn9OuEdh1GTYMY/VGUZYkZwxZc+RfI4R/Gh4mF9+ql3uwts/ssVG7J7uSGNKda4Z10Ngpjz8angDlMQCDEx6Bz/D7lZ3oCS9+CRZYBAAA="
}
}
|
codegen__leetcode2k___201
|
[
{
"content": "You are an expert Python programmer. You will be given a question (problem specification) and will generate a correct Python program that matches the specification and passes all tests.\n\n### Question:\nThere is a safe protected by a password. The password is a sequence of n digits where each digit can be in the range [0, k - 1].\nThe safe has a peculiar way of checking the password. When you enter in a sequence, it checks the most recent n digits that were entered each time you type a digit.\n\nFor example, the correct password is \"345\" and you enter in \"012345\":\n\n\t\nAfter typing 0, the most recent 3 digits is \"0\", which is incorrect.\nAfter typing 1, the most recent 3 digits is \"01\", which is incorrect.\nAfter typing 2, the most recent 3 digits is \"012\", which is incorrect.\nAfter typing 3, the most recent 3 digits is \"123\", which is incorrect.\nAfter typing 4, the most recent 3 digits is \"234\", which is incorrect.\nAfter typing 5, the most recent 3 digits is \"345\", which is correct and the safe unlocks.\n\n\n\nReturn any string of minimum length that will unlock the safe at some point of entering it.\n \nExample 1:\n\nInput: n = 1, k = 2\nOutput: \"10\"\nExplanation: The password is a single digit, so enter each digit. \"01\" would also unlock the safe.\n\nExample 2:\n\nInput: n = 2, k = 2\nOutput: \"01100\"\nExplanation: For each possible password:\n- \"00\" is typed in starting from the 4th digit.\n- \"01\" is typed in starting from the 1st digit.\n- \"10\" is typed in starting from the 3rd digit.\n- \"11\" is typed in starting from the 2nd digit.\nThus \"01100\" will unlock the safe. \"10011\", and \"11001\" would also unlock the safe.\n\n \nConstraints:\n\n1 <= n <= 4\n1 <= k <= 10\n1 <= kn <= 4096\n\n\n\n### Format:\nYou will use the following starter code to write the solution to the problem and enclose your code within delimiters.\n```python\nclass Solution:\n def crackSafe(self, n: int, k: int) -> str:\n```",
"role": "user"
}
] |
codegen__leetcode2k
|
codegen
| true
| 0.0625
| 0.0625
|
{
"part_1": "H4sIAET8N2gC/+1bf2/jxhH9KoQOxdlX21iSctIYvQJB0msCFOiPC1AU54PDkyibPZlSSOp8TpDv0s/ST9Y3b96StCzbBzR/pdKZFHe5Ozu7+2Z25kX5aTIvuqItu8nZ5M9l2X21mpdfq+ZoMq8Wi2q2WXa3eP1N0cxRV9Xz8uPk7PSLcDRZNdVlVRfLi3Wzul6bjH+uNknRlElRJ+XHddl0yV9vu6tVnaDFZVNcX5fNSWKNbqrlMnlXJpfVh7JOiuSHTdl2FRoeoOW7ZXmdtOtyVmH4wqoPIXHunS7LumyKDmMks1XTlLPtMZLuquiS66KbXZUtCuVdUZS0LtoWLwvI6zBwe3Jen9fPnj1L/iY9zs7r765KzKRCq6QtFqWJ7zBaOU/e3aLORNysmvlJgoZ9Se1LzKeelclqkdTJHKvUtckN5ZXF7MprkhlWCUtQ1VSyKerLMnkTjpL3yXGSvj2hBj70VWFSMYvNsiqa5Ka4NcmY3+x9VV+y+6DOP66w",
"part_2": "ordY47LuysbEDwodJTau9fOVuV61XYI1RNNBUa7fDZU1CZgwle6q65Jyu9u1rT5bc+FerRpsd3G9XmIAExs3Zrwq55N8eno+4fLf0e58EtKM785M2Hl3Xn+5sHcYx2YXju6pmkdVKTecT46wuhV0RLmqNfrJlpz0STnppwnKnhaUfZqk/ClJWJhPkzR9ShJW+NMknT4liVs1khQ32za2i4jd1MsVQEZ42L+/l92mMdu7TdqusXEA4Ouqrq4318myrC+7K+HObNx7D9JQ366AvvWqgjroSfCYFCLwP/8+r//o+EtSgujber3pzgDpl7bt7/GVndd/2XSsxbICMtZlvSxqOoWzXUYM+RDIqR9hfCF2MOATYSa5WW2WczgTtNnSnPOPqmXbqmU7VAtpGu5rRwuzgdertq3gH3tdIfPYuqGPqW22OTerarui6WyFFvDN1GfaXfU2exxVf7xLCgyMu6RPj5Jj+e50eXqUrB66fHe1aYdV2ImGEyoSUlqrgc4G",
"part_3": "CZ+yEYaTr1Y1AFgARy23I01+/xKbgdtUhfd2w0xV8nfhi88ilO2YwH7ggIGA/izbtCUHW6yWy9WNzY8TBWBmOFOTbpXcNFXnbdrVcsOjCLX03TrybDLw0stVS0errjdVd4V1m5fL6hoSGjOq77//fs1D7xzNgYTktURCpQSfeYnjoSlm719j7gdtuVwcJYARZg3I8fswOf6DmeIZheFgXzflosLJPqmu1ysc3DNMBGYNme15rTo33b6IJbjqCwgkSjsibIl8a92f6PUL1S429axbrZbt9ovReNuvbNY7+1yVxfqH7cp3VWvuaKtWXmerdrW2WALGtVVvMxvVYZL1Apa6WK6K7uA5Cs8PrRbLFgOXi67qliWWbx827MOGfdiwDxv2YcM+bIhhA84JnK7wifClOCL+9yM70cc6zRftweZwVGmfBXb+o60bz4eD99vv7VMCRJvkBZROfpt8vP++gsEk9aozMR+qdocE++DNSTGfH5SHD7zHKGXyG3iG+e4G",
"part_4": "pv+HBzoXNYSv12U9P8DEDz4e8tiNbyHSLDUkL14kB7UdfyMx0Asv27I7GFVCHirfvB2tIEYPd1vEEXlEJL3oUaPG3RLsbXLyLziXA/Q65Da362VlRAixgnJXtO8vqrltuu0tAHwMbB0btvB2tjILNxDsUfFrRgWOgOb2gscQNjpu8cHhSb+1BhUEknjLHbdQ6wCB3ryysDpuk5FWDQNArz8YH1SHycuX/Rn1YOvsbuv+2PBItrndc3j7YHwfjO+D8X0wvg/G/z84vORXQuHFaX1Zt/D7Z8lBnA5U+1DNsXELTpjKJO8guKtg3YfKTto1FvWXTU6eJd/WVVcVy+pHLVrZ2Xq13aox71LhPOtPtbb3PX/cLOEXcK6uSS+OIrfKDu570Vt/UHsINx7/m3KJAMY5R20WyrYOHOnrct1dHb+qGpjI67JoYJsHX796fXg/kq6xi7uC6eqpYHp+aXpZd0TTFqxWh7tDams4RNU204cja3vr0TV6HT4cP9vrN+nZ",
"part_5": "2weaxIUbx9LV3Vj6WfLaTMBX69Vrx44VKt9Zn5lFSMdp8mPZrNrRvljPCzZ4mTwPz5Md4bhpObTbGpqhU9zc2aruYPGK9/DGJtdy+csPsCho0czLhk7+BktZAirY7viy6saSDWo+accl51jLyCm8Zu8eKYsNRo263Iv4nz/3eD82OORex1nRwCo7MS5WPCImZ29+8gqY2/h4Q7vYYuKOevLz0d2m2c6mcrX3Wn+2o3WwT8pP4B+uwG9zwJTEKv5Zia9ZyWd+7o10+sBIwzghDiBR6W5BUjm/p3LGT8o/XCm/s5TfKatT/lmJr1nJZ37YPfArsG9gXaDAQDGB/QMbB/6hNlB24ICBkgMHDBwtcBxOk11YHyg3UEpgh8DXgW+ylFqk1CKlFinfpNQlpS4pdeGi8S3vJoziU/6ZGtSOorjMfA68Z1x43jNtAp+5D5wllaUo3yKuCbWmQG4ZnwPvGTeR96zfUArkPy4sZxY4s8CZBc4s8H3g/ALnFzg/4oNt",
"part_6": "+Mw7F42zDJwl4cI2nDGHSDkEkcTnwGfeuRycN4dwELPNgG/OkLPnED3isyDccxJcCQ5EHPM58Jl3asH14EAhWksWBpuhAM6KA/VWlIXHbGnqJnC6ZQJTfHL8m+a444MiEoJphqoMpQz/pjlqctTgGxfq8Q9NUJuhFt+48IhafCAghYAUDymEpBBiSVwKQSm6Yfp4TiEUrXK0ytEKz7ggB63wjAvC0ArPaJmhJdYLFwZDSzzjwoBo6XYLqWhpm4dB0Rrrigui0RrPuNAZrd148QqtZcJQN0DdAHUDCgEqB6gcoHKApAC1A9TGoqOMC6oHKIWFRxkX/k1zSMghIYeEHBJQxoXpQALKGcq4MCVLZyEBZVxQGRJQDihDSgYpgAIuaAspKOPCVCEFZex67t6DEMKUIcUdgcEIGkGKQQlLAEmAEy7MFZJQxoVlgCSUgZk8k+nhwnJAkswPF+YFSdEEsSSQBnDhwnQhDWVcmAikoQzU5W5ghCQGhDQHpsESXSAt",
"part_7": "COK7gJnvdPLuBnY0z3bhmPA1/E2JA9sjN5mHzGD7SEl1YqUPaal+061+ZjJmD7nQH3EcMZz3eI1YdZxGXEZM9ngcI2eMmjFi8jvIGKNijAhHw3jnx7s+3vFht8c7O97V8Y4+vpufPxQcKDqQg09HKx4DBXlSOc60x0A6nO+949VeycXKwcpXyk3KK0aH+GB0sb2l3FNuqfs7ujvusG+xVXKTucvcZu6y1dF7cevtybZfGCAIiAJ7Ih5Sd2ZEB+Gh2MN6W197YUjxoISYIWiIGnsifgw51oc4I9CINI9Ycg9fMveDBBwR5zFMPsQxuWBH3BF4RB6hR+wRfEQfwWeNDZg5fRthSpwSqFa0W0rcErh2M10NgtbYihn9IGFNXFvRsG2dglBOmBPnBLoVCXu72QKaVoZ2Kwb3mDQMWgZNw4MjjyDyVFGaBxGmiOlnPcxm7JYrEvPYzfTz+M1DCtPalLQeZjF2yz0A82jD3tLgaHE0OSvSAO1m22U6G3qtaIZl",
"part_8": "o5ji1s2MM6d/VijmcUnuoZvHddbNYzv6dZo37ZsG7jGahyp5DNPcaPKgSM2mYN3MUOyWeyTmoZJ186hHxpm7U6BXoFuwIp2E3WxT6ZjomXiU8STiIUI/RUdFT0VXFWJEF+itPBJiIJR7QJYpFsrpdOxmS0XnFRSq8YxJFSGl7pRSBUk0/pxOym6mFF1ZUPQV3Jt55EQXkffB0wPZQ7bLUeRu6ATwzpPm9IGcY8g40phqyCCzPqVwvA5QHRA5gHHA3ACUASMez/dQGFDg0Xm/2cM+D/sybMmwG8PKD4s+rPewtsOyPrai091rkykJy7QW8ViLR1rWH1/x6MqUJfjo8Yh68ni6nwgqE1QeKFcct8nTvLTfsZgdZtG/age9Uqmi/Kw21ktKHTW5dJRI+hBKJZVLKplUNql0UvmkEkqlk8onlVAqo1RKqZxSSaWySmWTWl5lkD66hxBa8ugOBT8BUBAUCD01TZXUKqtVWqu8VomtMlultspt0xi+eJKo3fYX",
"part_9": "qdx3NAg3iWgUbhbRMNw0onG4eUQDkdH56nqOrCRZWbLSZOXJSpSVKStVVq6sZFn+WYYn05PxyfxkgC5ToFX2rfRb+bc3UTaudFz5uJeUnfdGHXor8I1T7q/kX9m/0n/l/yIAxACIAhAHIBJALICLTUUFiAsQGSA2QHSA+AARAmIE0kgDZfI3zg2koghktpEqEFfgJTEH0UW5X/KvbMQriRXwSTurIFpBvIKIBW8iLyfmQdRDqhNPblCO0JuIlxAxIWZCbtJL7jQz8RX+lcVwNtIXaX+m+mjR1caINxuoDXEbIjfEbojeEL8hgkMMhygOcRwiOcRyiOYQzyGiQzSHj6dTV05ebt6pEi+JRPEvN1txUeKcROKImhI9JRpJFJDYKtFV4qvkxB3JQSSQA9oPFx/PW4qf8VI8hEKIrl6nRRDtJd5LxJdOChFMYsBEgYkDEwkmFkwklNgw0WGixERniToSQyaKTByZSDKxZOKyxJaJLhNfFjOdLIwTnkxEkn9l",
"part_10": "A2Eq/kjskQ/rBJOXRDfFo9hLYp/8K1MSFcmocUqViZvyrywmWJGtEl0lvkqElRgrUVbirLylAgBRW+K2vKTgQFSXf/l+i4gTGSfCTKScWDnRcuLlRMyJmRM1J25O5FxMErMwzhUzkWj+lfUEtIKVUR6ZRYpNHJuXxLjFwMZLIuD8K1P+Gfm4cTaaiZ7zr0y5qX9l4fFMNd8ZtWQxutCpqZVMH5Gwxf4592ekn3F5Uya9U09zyeIZjTZlImt0nOeixrZ50mnkmXFDxowZccbMiKnb1NMi6jVlQuHaTYOnB4/quJWPO8HCJJvZNbNjH74frx+sH2k8zNujyXXZFZOzn3b+v4f2s57roivnF/Z7JtRD0ulx+N1x+DwJ4Yx/aLYs6ssL+++uv8B/zRz/wt9+xvf5ab7/zf/+Z0b7nxntf2a0/5nR/mdGj//mvysu28nZm8n935ng5Z+aYm3f/c9dvqqa2abqJm9/PppU7YX/PmZy1jWb8uf/AqBVwXyoPwAA"
}
|
{
"ground_truth": {
"compressed": "H4sIAET8N2gC/32PzQqDMBCEX2XZUwJSEo9CnsLrQgn5qRJZISaHIr67EWkPPXQZdg7DBzM7vvJa2T9LrmXCAXfCWNmVeWW7EA5A6EMENwWXhLPsZ29LkAMRQzu7bSEX+AaCwYDuIDXrJRgDRIRaXf8f0v8iSmv1oW7dFcZ1qVc5IR8uW5dGG4MkPLDDrbyX0Cbk2uw4AdEWuOXaAAAA"
}
}
|
codegen__leetcode2k___204
|
[
{
"content": "You are an expert Python programmer. You will be given a question (problem specification) and will generate a correct Python program that matches the specification and passes all tests.\n\n### Question:\nYou are given two integer arrays nums1 and nums2 where nums2 is an anagram of nums1. Both arrays may contain duplicates.\nReturn an index mapping array mapping from nums1 to nums2 where mapping[i] = j means the ith element in nums1 appears in nums2 at index j. If there are multiple answers, return any of them.\nAn array a is an anagram of an array b means b is made by randomizing the order of the elements in a.\n \nExample 1:\n\nInput: nums1 = [12,28,46,32,50], nums2 = [50,12,32,46,28]\nOutput: [1,4,3,2,0]\nExplanation: As mapping[0] = 1 because the 0th element of nums1 appears at nums2[1], and mapping[1] = 4 because the 1st element of nums1 appears at nums2[4], and so on.\n\nExample 2:\n\nInput: nums1 = [84,46], nums2 = [84,46]\nOutput: [0,1]\n\n \nConstraints:\n\n1 <= nums1.length <= 100\nnums2.length == nums1.length\n0 <= nums1[i], nums2[i] <= 105\nnums2 is an anagram of nums1.\n\n\n\n### Format:\nYou will use the following starter code to write the solution to the problem and enclose your code within delimiters.\n```python\nclass Solution:\n def anagramMappings(self, nums1: List[int], nums2: List[int]) -> List[int]:\n \n```",
"role": "user"
}
] |
codegen__leetcode2k
|
codegen
| true
| 0.0625
| 0.625
|
{
"part_1": "H4sIAET8N2gC/+1a627bNhR+FcL9UXtgAsmXXIxlQNZ1WIEOu/4ZbMOlJdpmo9tEuqlX9F32LHuynUORtqRIsjRgXYE5jpPokPx4+PGcQ+mLP/R8ppjkqjftveZcvYh9/o2x0J4v1mvh7QK1h+aXTO7BJiKfv+9NJ7dXtBenYiMiFiyTNA4TxPgt3hGWcsIiwt8nPFXkx73axhGBHpuUhSFPLwl2ehRBQFacbMQ7HhFGft9xqQR07EPPVcBDIhPuCZ",
"part_2": "ieoXkAiH42aMMjnjIFcxAvTlPulecgassUCZnytlzCBS9CaaSESQmNDPAUTCwv59E8evbsGfnJ+DGdR3YtmYvqMSYiUnzDU7CmbC9JtAulq+HwryF53HLonv0tJHLAIqY9itdZ50vyday2dnzI9rCESDEREX+XBOggR1d+5mqX4mii2YaOSSKiTTbucLUG0o0PKi64YHrMxILckbck5CzKiBAwOQdyeaQA2i4gSThLpTUMCVNm3reX5NUaB+KOIi6E",
"part_3": "gkgC3F75yFNJSWo93eMaoWcI7t9HxlP2lAZm21bGrRX2CZnPyWpPUiAzDsUfuDz0N059oDtDto5rRxlM89ef8+jlexaiQ+4UN/BVlOzU1CzrjszcIR3e0PEVHQ3pxFlQsz5omTgUGsEMjcObxTz6Yaf02JlLx3REh9RZIHoSgO86Hsi9PPDqIK8uhK/HdpJr55wcs3a3D8wCoXrmmQs+YLxYIBeBxgUgV6oWQGMDJGMSRzp4LRPDSiZuxrDSPAGZIb",
"part_4": "duIGSBI5HVF3EkVQphqaRGc8mXdyaAAx5tYKlw7TrOPNJ41nhX7DSPnMM4CEUzOQalHj0xo+tSBSe2WfltnEI+m5zUVcDStY6DIH7EeJGKpQqixYMShgnxmAqV9ZFxsNOZD1a8thUGCeSRF8SAtY93ZugjJAkmJA9ECAgpJuSbN28SXWPm0B1KB/nFQIJLBL58vrYL+D7bWtmXPFhna3an5LWQagZ8WhZylgG5+Op4ZQDxS08LFTdJ+VpAye2JMImh",
"part_5": "onqwZKh6MLucR8YG2wWTHi6BrO3hAio8VyLkSKauGWqv64dp/sJY17vIU3EcyHJDbr5yE/JTOWbLWfJ72bgSEqt1yZq5XrbGCRb5OC3bcWU5GywyWkM8r4OYqf5zuHg+QCvQZk+UpRIq4Lmz6VzPz/X8XM//k3oOaQnFDMIv8jAjP10txQ2CyLtDdAZR7wtPAaoaHLussdhoSAxIDr/1bWZfzzHIYR3xZtC2uGS+3xc5IJNDs3yfJE76Az2FwddrWW",
"part_6": "hGJFQKvHfWOwTXcPf9sBQ+WNaQtheGiwsTYxJ6eDGGBnJ2JtGQCOmV7pdJDC4DJ5aN/uCyxALyC+cC9EGK4AnBe+h7kHkCT0nrID4c4EFr7f1D3l3TG3pL4Wch9zITvQbqIGdmQ0ocSlxKxpSMFqcgIVGhPI2gTE3yoNpAdaOBHWnAiQUfLk47q195VGvKEA1QGy+hOsAXVF38eY2/CrBooPk+ZoYM3mkLny03Bzy0oC7NQY7aosIwNw+XGQqLPwky",
"part_7": "ofpVOG2MqTOLE73Pw6JTcKnPKIs3PiwQgBftItItbIfrgOkYjxma24axGjQd4Ue0trs6oVe0BvEK/YMGu+iJRs08HbfBzqWNnSU/hV4/NEzM8X+Mn1tKbii5puRKJ9OBbbddnFL9XVpNZusWV+DyLR1PqAshWQxSNFDTfCwpWfq3ignIGTqE9wje4ywj8xOMs1zVzZOs6zG3xjb0WtUEat5FPo7mbpTU3NUcQRat63M5Go6Fu1CYbEltV6adcjUp1S",
"part_8": "Uni6UWdami4B8itVwG3I7pUAl6cLNzyE+wZtJR8WxC06R7QXC1l6UKP8wV5SzO22/1k03ufu7YTCks0ITwsPNB1lDhoalwkret8HgswisPaE3/4ACqP84qDjTw8zSFbR/K8iVm1HF/7GbkST2ac6WmUxZW3x+U7xAyXjNFId2fRe6zKHIWRc6iyL8mcpP/ncZtCbjXCTclfbtwWMQ74XMfn/mBGu02WTHvQQnvQQ6MniQT2EmUkyrEbZyzXsbO6Rjz",
"part_9": "T7rsz1lJEZhVy1inTG86+5AZgN62Ighg2NG9khbS+0gr8FooIAXMJ0JINWyD/FGAyx3z1UCdtY8CvL1zbMRuFj7KeKNmyGrVo2rNNQgNkkc35k7oHQWwouxRt6UNYkc5RuwDTieoTOkoQzXvYSuZowD5RO04mRhtNY7CNI1SR108NggcHUKopbpRrhU5kaM2X7pKG+XsySkc9XOc0DU6MFFzV/IEoTFOGxWNqnJzFDbqQ6tGzijD2eepumrTqGVUp7",
"part_10": "jbKubrhIxyKrWBbVAxuiV7g4RREcynNvapftHt7DglXnRAO6FcVJzAzbW6Qbboeog0ahY1YChd1NDW9oGponCMWm1IC7Wia5LVShX1XC5oL+SK9aYfKj/IhxIA3FRzf4myCNiHjju5cG4unGviOFP9Dd3g2XCzxIeGT/qvxvznN/BfoddXzvkTHWfx4ixefIaf6FBsI+FBsXePUQPX3zG5Jb+yFaTo4iM8T8rlLhKQu72pSnf8499Hv0nKcywAAA=="
}
|
{
"ground_truth": {
"compressed": "H4sIAET8N2gC/51W226jMBD9FctPiTRa4VtCIvUT9qmPC1qhhKbRpqTi8lBV/fcd2xhsNtnagQDimByP53LGn/TUXofm+Ltvh/6V7ulnQV+G5tCfr011KeieFPRYv5DDa334szpUzfF8rPp6vS+KhuBRdV3d9mQaWDXDW8fIE/m1hRx2gPcSiAa5BkcItuWaPOE7B5IBYUAkEFF+y5kBAw4CJCif1QBgBkdeYRiVY+dlhLnm9GkdZClHpig7WaYPUOa+1Y+AVwPgfzNOYfmzaH67Yo+ZO1YGHqeIpsX/MZ/PAsH6v2dRYE6fx0HpnlQm2jw0C18RFBOhnNaIzGVkZrIgJixDaM5LS8eivHaHzqT6TBcdWwUbuEO50RbigFu3MrTWVhlF7hWQm8afw7gAB5RxL/fSaAckB7IFsjFlNXmcReYrmN9iPRZLTC80egdSAcPUDJNVAzAOz/pipSAuM7B6gOMl8JK2OP0ZpC1bM6zsp3OVSZeBcfoA4xW6ZIYTvZJLkJtAaQ0ws5Txgr3MiVnJA5lyEhup29lSWhYqldmUilGpGy1gytilJLDUurjJOhmanvtKayiIsF9pSD0gDszYudB87qm0TfiEgP8T6gd6kauZYI1jLvP07vYfzcehoMNHa75ulnj6jA56pCnd73E3uhxaGuFGjGOOJQuCo7YExOhIrmEc5HkgOCI1SC4ivmNn2BOetIK8vXFYbh1G39qf3VA+Xy+D3mqu1j+qpjq11dvP6v393Jy6dUG/KNCu/7jUuC1tB3x8/QXFO8/+rgoAAA=="
}
}
|
codegen__leetcode2k___208
|
[
{
"content": "You are an expert Python programmer. You will be given a question (problem specification) and will generate a correct Python program that matches the specification and passes all tests.\n\n### Question:\nYou are given a sorted integer array arr containing 1 and prime numbers, where all the integers of arr are unique. You are also given an integer k.\nFor every i and j where 0 <= i < j < arr.length, we consider the fraction arr[i] / arr[j].\nReturn the kth smallest fraction considered. Return your answer as an array of integers of size 2, where answer[0] == arr[i] and answer[1] == arr[j].\n \nExample 1:\n\nInput: arr = [1,2,3,5], k = 3\nOutput: [2,5]\nExplanation: The fractions to be considered in sorted order are:\n1/5, 1/3, 2/5, 1/2, 3/5, and 2/3.\nThe third fraction is 2/5.\n\nExample 2:\n\nInput: arr = [1,7], k = 1\nOutput: [1,7]\n\n \nConstraints:\n\n2 <= arr.length <= 1000\n1 <= arr[i] <= 3 * 104\narr[0] == 1\narr[i] is a prime number for i > 0.\nAll the numbers of arr are unique and sorted in strictly increasing order.\n1 <= k <= arr.length * (arr.length - 1) / 2\n\n \nFollow up: Can you solve the problem with better than O(n2) complexity?\n\n### Format:\nYou will use the following starter code to write the solution to the problem and enclose your code within delimiters.\n```python\nclass Solution:\n def kthSmallestPrimeFraction(self, arr: List[int], k: int) -> List[int]:\n```",
"role": "user"
}
] |
codegen__leetcode2k
|
codegen
| true
| 0.4375
| 0.5625
|
{
"part_1": "H4sIAET8N2gC/+1abZPbthH+Kxj5QyQXOpMEqbfxpeO68SQzycSN8yUjaWSeBEk4USADgr5TPf4v/S39ZX0WJPV2ukuc5Nw6lcayicVi99kXLBaU3zdmsY1zaRuDxrdS2pfpTP69ovDGTM3nalokdoPp7+RMFWtQlZ7J28agE/i8kRq1UDpOJplJ1xlJ+SktWGwkizWTt5k0lr3e2GWqGTgWJl6vpblgxHSjkoRdSbZQ76RmMfu5kLlVYGyC8yqRa5ZncqoAICZyCxJn5aKF1NLE",
"part_2": "FjrYNDVGTo91MLuMLVvHdrqUOQbyUJSTlMV5jskY8iwU5xcjPdJPnjxh/6hwDEa6tqWGmKfGyhlT2sqFNJgy8Yb+BgxtY6WVXjC/lG7UWjJdrK+kyTm7WUpyCekCmGp9ztK5W00qCq3ggNIzzn1JntZ69VbjCihfpYbJd9JsmHKqrivpHnt+CdJzEJ6T2ItE6oVdQrkkfLmaQQCpn5t4WrrBmKEas2fu4XoM2T9IWxjtuFZ2yfI1IMMbuyW1IDm7YBXzJi1ggs5vyCM5oS39AuP2",
"part_3": "Dc3VPyULtq5w/ENvzC4vaxxkTEX3t3QH69//GumvbuN1lkjmDyhQ3+issAPnvUs29HnABY/GnK0wFCP9fWHd/DAAldZmSaxd7Afsxz0XIDlSysGdWcBchzk1MxdkCY3+s4gz/5ngLCifYImgJwIdPBMASXLtUpnZzlsqJ3aXWTX84CT8bgXd34NOVOIl418CnzXIMJu79QHFehdjGvme5wFnNUH+xJNgTzERjjSRSmf75QDzQBcfJCqbI7UU+5J5gPyiStYqh+/mqjN9uyMY8Kmp",
"part_4": "TZCVempknNNecB68qFCtjjA/Zc29UZv5LWRiUFv8Kk2S9IYV2YC9jF2SQVfyTjpMdYG4UVh5Ja11mQ2275s6aCGa5OpbZTd/rTc1Ng3KQbWlXREp8lLW3CkitLmNDUmaogZSXtwYZUseaC5cQEHd108ekHqapJDltoFbSqjgkJlM1BoSDJWWt2/fZq5EjcCOysPeVCIBieEzk3PacW+qDfeaovKqSqNmLpM5J9cN2Lcqt0OkAeXLgPZXi7W/3FEHThNqdGbkXKFIN9Q6Q4gADHLL",
"part_5": "lB/pikYR04vtEP5Zbgc4FaQFBvLfHKWd2U1GPqqmn1bUeaGnNk2T/HhiT9/xFLnk5JqljLOfj4lXKqf6fkQtoR9T04yOBcrhQzpZtkeDkXqOzTZP0tg2v8DgixZR4bb6DJpYZRO5d5qdT4DzCXA+AT7HEwC7GrUQgdVT2tCPXH1Z9VlSVJs+7Nlw5nHsyL+QeeTea87IRTg4irVrY8kJQ38wbo331qMWqvmmuWztaLR4QitNrBeyuXIe29NJnwlnirRdOglZmh1IoI/CpiQwVCaO",
"part_6": "FteKsyJfNlE2HDDHvCsRvFwNHa09waYsBEPiWSLNsH3HzmflKBiPx66+5lmi6JLgMhljXDRWEzUDZdW2y3ZdbdouJ9v1LgJjGVA3OMfwvxtDqa3ZTLIU3kIs6ig0Wxf3eZ/iDBqYKUa4kk1XzSlKh6ImozaebmPUp9T05unC3qICVtX0h5dtC2q5pKyl5RFvNud76rlLOXcp5y7lf/Weyv4frqm1zS/cXhqwZm0rcL9Dls8ozvBG5b54urJquspbrowbmWdINmrpTtxPSdP2Luvu",
"part_7": "laPHN6k+SDU2CLKFsmbveH3CvlO6TVgoPDmuqfKgyuU71rXSE8eIPbfXT+zL+kYrq+KEahUJcdzOTS4Pjsth7naMjKdLVjUsqTnsSdSuJ9GnehLnw4ttY1EjrPuLuji7tWPXv5RiWqfhf3VrCdq9aF1Ea7tWbZ/Ru4j897RRFXg0UzX2uz3VNYlBWVH39FS/wgHXOwdcP+QAKsLU8t61fsf1EQbs926q6tquq35NUQ2fpK5cNwbD9yUB++b0oYQVNW/DHUuND/zEmu1JcMBP9NP8",
"part_8": "Tgfvct/nvuA+Hvo8EDzoc+Fz0eWhz0PBwy6PwNfnHZ93urwLeYJ3+7wneK/P+1jlYb0HAR499yEOzwGeBcmlf0EL8Y0wjjDuYB6S/C4pBb0Hep++GJO8fr8yJPK8Q9Nxhnbus0ZwZwCUAij0VzKCQxGYZh3/UR2yVXwEvv9xmk/jpwZCPOQBsQVdZ0N0mA7Uh/Q/u4zgATAFhAVygoBg4RlyAmAKIvqCDjlBBzRACroYQ07QI/yCC2ARkCGARcAyQRYBiwjpCwNhkoBNAjgEcAjg",
"part_9": "EFgrYJIAhhA2hbAlhEvCgPxAXzgDGEJyCmSEwBDCKSFwhJATQkbYw7+wJez370kMhBTK7o3pnzseO58c7RawM/D+FrfUZdM7qoNM/LFpX2+wI+j+wxs94i4Dqyrl/BRRTDwkVeBRNnlwT8/5uyPgMRF0EZtOFAUEDzEEXyegmEVBGPQopGEv6opt0TxA06GCR2sfLpuwzHfZKygbXIoDU9CJ7qlDkBqJj7CxlhLdAUel+hOUY3EUJfCx3h+TEKcdjzrr/7Jl2xy6U+X9X079j198",
"part_10": "LvCfoMB3o7snP9DcE5LIBaNbh4FicHrLUfcT+p9rL+cfV/io/0Az93jmVHDC43IANOD+FJXIv3v+/4qG7HQ3h7XkwjFvrKWNG4P39/z/IHotiWu7nE3ojSxmAs+P2l6v7XWZ5w3cH7AluLpN6E3EY7/R3/9dl35r6PY65196z+9Qz+9Q/3y/9Np4kTcGw8YLykqMf7xJ2Wv6pQpWYfg3BX9s2BsZm+kS4zewCNjx9DW9aGqixKQGoui3lUK2GuMPvKHySemDxsCaQn74D5zEWhwyKQAA"
}
|
{
"ground_truth": {
"compressed": "H4sIAET8N2gC/4WPwQqDMAyGXyXkZKEMpoyB4HXngcd1jNLWKdYKaXoY4ruvzrHrQiDkCx/8WfBJcwr2wZS4xxoXhV0Khoc5aK+wBoXWdWB6Z8bC6GAHq9mJWqkAuXSMjhh+h0ITQQO3oyxlJU93CWNeKwFNhmUGf73z1znuzgays/eeop192vIV4jBy307aexf5SsPkLqQ/0YXCFSVGfnmXn6KUx/oGFgc0tOwAAAA="
}
}
|
codegen__leetcode2k___218
|
[
{
"content": "You are an expert Python programmer. You will be given a question (problem specification) and will generate a correct Python program that matches the specification and passes all tests.\n\n### Question:\nLet's say a positive integer is a super-palindrome if it is a palindrome, and it is also the square of a palindrome.\nGiven two positive integers left and right represented as strings, return the number of super-palindromes integers in the inclusive range [left, right].\n \nExample 1:\n\nInput: left = \"4\", right = \"1000\"\nOutput: 4\nExplanation: 4, 9, 121, and 484 are superpalindromes.\nNote that 676 is not a superpalindrome: 26 * 26 = 676, but 26 is not a palindrome.\n\nExample 2:\n\nInput: left = \"1\", right = \"2\"\nOutput: 1\n\n \nConstraints:\n\n1 <= left.length, right.length <= 18\nleft and right consist of only digits.\nleft and right cannot have leading zeros.\nleft and right represent integers in the range [1, 1018 - 1].\nleft is less than or equal to right.\n\n\n\n### Format:\nYou will use the following starter code to write the solution to the problem and enclose your code within delimiters.\n```python\nclass Solution:\n def superpalindromesInRange(self, left: str, right: str) -> int:\n \n```",
"role": "user"
}
] |
codegen__leetcode2k
|
codegen
| true
| 0
| 0.375
|
{
"part_1": "H4sIAET8N2gC/+1a/W7bNhB/FULBUCt1Ukn+SoRlwNB1W4Fu3da/hjhzaYu2icqUIlKNvaLvsmfZk+2OkmJJlmPaSfdPLRSBRd797vtoXv3JCqiikinLt94wpl5GAfshX2lbAZ9O+SQN1Qq2f6ZJAGtcBGxp+YOO07aihM+4oOEoTqJFjBh/RimhCSNUELaMWaLIbys1jwQBillCFwuWnBMkuuNhSMaMzPhHJggltymTigNhCyjHIVsQGbMJB/EUl21ADDKmGRMs",
"part_2": "oQpkkEmUJGxSl0HUnCqyoGoyZxJeWBVKI8VUStikgKdAsDwfiqE4OTkhv+d6+EPxhqlnkki6AklxJLkCVQkXis1YQjgwE5mCiWcxDcEp4AHYnRKusr31altLzNdDGWUq3abop2haIQU1ftIOUXfRhkxJQjZVGgz8PlckYXHCJIPdgFDQVCVczGQb1lWaCC1GpIsxaAti6rrKNSzPaLmYhKlEgQkVM0auUVw7k3UDmv37z1C8WtJFHDLi+uiw1yJOlZ+pdUWGVndo",
"part_3": "5fT61XUcZ2gNxdtUabou8schFToO8N4ml23iem7moe5FV+eO1rSkKIj+NYJ467D2B330o4hU4f81pU+8PjnFP1dI1ybjVOHbPX3F0WtjvEZj3KoxXtkSFxnQHy8jAW6n4EqpQVzy7ZWGOA+ZmKl5jpC/4aZ7MRS1OE4AhEuFUYpEuCIBVJVOyTodFWjHnEKIQkYDiDb5myVRA+l9amxEOY8t+Nx13AtyRtybgp1jhkksGSjfKCEMchTqI8ptQPuKMvkxSqDAwOT7",
"part_4": "Wk4l0/jTKAyjO1RNKpooSL4J9BREuUu4ymhkFKa6FFVWDEXJo/4MsjACrFWU5qx3XM1B+YCFfAEICZr7/v37WBf9EMihlsm7HBJUIvAEbLqRR6/FH2h7S7Jw2tZB8rFm8hDpzzY5+w49lqPgo2VB3wN/Tjk0Posv4ijBoIUh9B4QKYciX8sq8P4VPDS/f4E+yxRfMPTgFPQhahWjl/Lt03x1moqJiqJQ1jdK8upb6JRGnjmj8W19ccwl9szaaqZ6fTWKsdVCKtTW",
"part_5": "0bLSGhgpplAl0zCiqvUMXp7ZuApuK/r6SHEVMn3KHLvqsaseu2q5q0KdQHdhCfQ+LJFYgm+ub6DWsPJQhIZvafTT0x55Tlw7b1FICr5qcTt7Vy4uXPv+mXuTr3jZCiyUl2N5TuOYiaAFtrQkYCrXtrfuebaddf8v3G4RicvRGqe19JFEk46hyZVo8Vm1CWaS0ybL6sbdnEMSqhq5ZgH6FWS066Bh5Bv4sEmkyIsXVxs7eQ9YkiuAQG8UGyGYBbDoLrTUbuuP2lJ7",
"part_6": "TZWzy3TRCjFrl/gnyRpZ1WabYOyXGPsFjVshXYwDSsAVS1B82YYIYTwgb2QccvzircsF3uGr+4cRD2BlozXB7iTC0sTAHdPsmGZ7pBn0vGQ1iiMQB5lThKVln28JB2YiHPxAi56Gi9jkQwsabcDxa1CRVHgHS3QDztZb206Jy41naNnonIGzEwkPyzpWzu3tZq6dVgimWd1drD0nezbP7uqT4/UGuwGrUL01s7enOze1cB7nz/twGHDvdEvh4c6jrTI2quc0fcUy",
"part_7": "zZFmY57SJXumymUtQvvmbEOmbUTn4vF25VCmSNtwCo1cE5wGkJzfIEl2qtDfheF5jyhi56lbiut1ur3+4KKeLxeDfq/b8dwcqHNgCRhXQJ3ZVG7vgXDuX7de2XeHmbx3KI2Lvnu5M7WaeLeWcTVvdzaUzePX6HjeWVOdh5tnf98D2jUvZ3eXv7YHYyd2d+tx0t2zGDzTEEEtVzmLyjZ15MPOeCjE2ZQnWR3H/8dB1XFQ9TWN/8nXMf0vrP5eyDuW+KRVWAuaf+QB",
"part_8": "lN9U+0PrSsZ08kHxyQdp54M9GUOAca73v880oPxtv3G0gLMc3MUWXnwuj20y28vIRd8t4cuWjkldRLnJZAOm8m7TsAkf2yfkhLyDLgTtxfnrEtMRfbygS/KRhilkAvQzBs6GtNElE0B2IZq8TXTxAFdxLSk/9dFV+Tkhb4OA5NVZ0nuTstyQakMreX3madfZjRJeYUN/tIhGAXkwr2Pthxi9WunwU1jDhoRRagxs3u3u50mlGVLe+ZrmSxqvvHd66pz3bJwXromq",
"part_9": "WfBA9jTpNYlSoedt66UmC2uJlx+qV0B3SuLqHvhCGwvuyMlwJqaN3JyLZRR2w1AvU+z5VdnSjcGbJtLFz/FQGUX62LD860/ZArSCfSZdgFMgWAPH+txugmkec5VZvW2cDTOuMp/bzGc+4CqD9Qbb0JouxibqG3xpP9iBdedvZTUYalVc2jnQGDNbmsdZRrmw7Tr2RG7YJyU2p1h7ZOXDI6wK0MWh5lRxHobZPjmq6OJuB2kcN5SZtyaDqfB+M0DzzMosm56yReye",
"part_10": "VpVROntluFmCb86pDCT2dkfOtBq9BmftY+Z+Udu3jruXW/LnoMGUQa0fMJUyqJeOUQ/smx2mrmGRHjaMMgDu7joJuka57hkFZOsMyshz+w+gavbftK0FU9TyPzX+cBUHO3BJY8EIR19YAHABPnMuz9w+cRxf/wOyEK4lI7x5fvkLW/nnUfhf9pdO//iDqeMc6jiHMvnBlKIzCVcq6xeq5vD6TmcdfHgFuYZXTfyNy81nuILJUSo4VJXlqyRln/8Dz0HED/IuAAA="
}
|
{
"ground_truth": {
"compressed": "H4sIAET8N2gC/7WW32rCMBTGXyXkyoKMJP2nBR9gt9ttYJQ2almXSppeDPHdV1dWnU3tSaxBFCr8PPnOdz7PEe9U1cj8Q6tG73GCjxxvG5npopJpyXGCOM7FFmV7kX0uslTmRZ5q4SWcS9SetK6F0qj/YlGKrUYbxDnH9Py2RKrY7f8erQfn/NRDmw2KCQRJiBnaYxiIMoSwjvzLoABGSLozJFFye3pwGIPIQ2Z4TWFu2g/rIjOJf9VEGAYk3aUd/lwXtrtvOFKhpdfG7/kU2Vwstzb01WkaRqxr6Olqtiv3TAvkPeClRgoEjtB6EMxswKIiAIyxOSKEPC3iKPODMIpXJt+t4igMfEZ7ov/YlNkNmYliVUk46Qbn1GD/hX5IFjcnWGZPsIZ41Qy4EyK3EwEJONPaAV5NIPPrQ3I+clxOqGWYUIim9zoH+ZFg4t8xcJs3ZtXYNkmGiEu2WKg+LdiEQ7pXtyi/V2VzXqEX3kvdHIQ6pGUhc1V9ifpVvqVyJzyOT3iJa/1dinbtVk37cfoBX+KXn44LAAA="
}
}
|
codegen__leetcode2k___278
|
[
{
"content": "You are an expert Python programmer. You will be given a question (problem specification) and will generate a correct Python program that matches the specification and passes all tests.\n\n### Question:\nA game on an undirected graph is played by two players, Mouse and Cat, who alternate turns.\nThe graph is given as follows: graph[a] is a list of all nodes b such that ab is an edge of the graph.\nThe mouse starts at node 1 and goes first, the cat starts at node 2 and goes second, and there is a hole at node 0.\nDuring each player's turn, they must travel along one edge of the graph that meets where they are. For example, if the Mouse is at node 1, it must travel to any node in graph[1].\nAdditionally, it is not allowed for the Cat to travel to the Hole (node 0).\nThen, the game can end in three ways:\n\nIf ever the Cat occupies the same node as the Mouse, the Cat wins.\nIf ever the Mouse reaches the Hole, the Mouse wins.\nIf ever a position is repeated (i.e., the players are in the same position as a previous turn, and it is the same player's turn to move), the game is a draw.\n\nGiven a graph, and assuming both players play optimally, return\n\n1 if the mouse wins the game,\n2 if the cat wins the game, or\n0 if the game is a draw.\n\n \nExample 1:\n\n\nInput: graph = [[2,5],[3],[0,4,5],[1,4,5],[2,3],[0,2,3]]\nOutput: 0\n\nExample 2:\n\n\nInput: graph = [[1,3],[0],[3],[0,2]]\nOutput: 1\n\n \nConstraints:\n\n3 <= graph.length <= 50\n1 <= graph[i].length < graph.length\n0 <= graph[i][j] < graph.length\ngraph[i][j] != i\ngraph[i] is unique.\nThe mouse and the cat can always move. \n\n\n\n### Format:\nYou will use the following starter code to write the solution to the problem and enclose your code within delimiters.\n```python\nclass Solution:\n def catMouseGame(self, graph: List[List[int]]) -> int:\n```",
"role": "user"
}
] |
codegen__leetcode2k
|
codegen
| true
| 0.0625
| 0.6875
|
{
"part_1": "H4sIAET8N2gC/+1cC5PTyBH+KxNTKWwitiz5sbuukMoWcEAVd1xgr65Sa8do5bE9oNdK4zUOxX/ht/DL0j0PafTyysCRVMp7x1rq6enXdH/TIws+dhYud1PKO5POS0r542hBnyiK1Vmw5ZJ5G5/vYPi5myyAxsIF/dCZnA7GVidK2IqFrj+PkyiIUcY/ow1xE0rckNAPMU04+XXH11FIgGOVuEFAkxOCTFvm++SakhW7pSFxyc2GppwBYxc4r30akDSmHgP1LpJ7IHEhJ61oSBOXgw7iRUlCvbIOwtcuJ4HLvTVN4YYWRQlJsZumMOiCPA6K05NpOA3v3btH/qHsmEzDC7JyA0rEDLIJFwx10QUBHfGasJTEvruD++sd4dtI3iWpRX6ONikVWh673CLbdQR6OE1CNJpvkhC1XY",
"part_2": "JZmSAVhJQsI9+PtulEDl25Mxx1ic9STqKlMDeEFUrJNUk33lp66l4LLoj4YkWRjWvZSk8gDEq5m3Dg40IEsYWFqwiELVmSgqE4DUJUZnRyxpR6UbiwBAG4YZ2FeevIpxl7H5Q+2SQsXBHqgokyLPdT4blQsiPBBvzhiXtLffApAtYopF8+V+xXKwl5mUIYUZ+YDgl28uUz+SlKIMncIPapRZicJmPPDDdhiBcUcliOcCdHWagibc/A7IvFguHaQ5h3YhrICSOOYY+2sNBLUIhKYFlRSi4Pic8xCF0Zgp4MvHRXZpGH6wNhA418nVDwduvu0gmm3Yslobc0Fx153iZmOnVxspDqprmHVsa8ZSKdTBkyBglGXwlB2yxjrDTJJXGUCs/R44TG1MU877ITeiKnqdwWpS08UIZl81zM",
"part_3": "gzihtwwUqKWGLPnyWUYxn2BmA4YuiG5pz4iTSKhF4m5FRT5T6CAWSeYdFO4mwOy6jvg6Mww/SRRzFsjFSygqQBE22CBzI8h8z9RZ09DJxj0VznyURMk07GcMNQZ++TwNn8ocJLZYTQhrGG+4KmHyiFxdOdZoZl0N4E/fGoprW306lqTi52wavtpwMbWPYrRYp0msLSdnoh1ThK2texyFKWQqC7nMtgH56yOFDj4NVxBDuB/1RaD0yBWbZYMFXogGMZiu3s0qDObYnx4RllMwdJuQAdIXcEmBiQg/VonrY2WIxDhBB+R/iM1Q8IDq4EW2geB8nCtxE7NCgBfktIclA/m1TRiXPGnkb0SuqoLV+wzqp6HnRyBrF23U1C3ja8j0BfVZABISrJe3b9/GYqeZAjvkIXmjRIJJBH4WdI",
"part_4": "leiBp7BrnSTam/tGR8JuQlgPiV+AVrMZv1yMO/QS2hOyAXNlaoniWDnbXDgjiCjdMDn2DDAfHpNFQ0WElwMruFaKyzG9jIKeQ/xWgtYT8mfBdjRNTwA0VdbkKPR5GflgcMfeUhDEDtnDV145sy8ZqluCmXqNL0MjWKcS8HXC3R0TODBk6GS0j6pR+5vHsfbu73kAph043DnDPuUwjfcds+btvHbfu4bR+37f/ytg3gDFsalH/oIS4/f/XyKaDsq9/ePJ2/ubx4fWmRxxeX8hIC07ew6J1pKDkuf3v9i2TAKzWuB39/ocbExeWLpzCOky25BN95eybqB+evKJ9jvcwBbeHg2BUfPYMJfwKLeFAbYJQYLg7GSOfkX+hNgQ41CukxK1IhhXHCoywSJVX4g/gWezkoerMaJi3Mw9XF",
"part_5": "pWjgUaacuHEMuNftgi8xOBPzXq84gfopbTImyI0JmowxlcQyYlUlEg+QF1dVU0MIFORtV2gwZiSAm1hhUFSkPxOmzNGSxA1XtBv26kjm8q4A4L9BAI4xc6zkOY6/y8chYSssuR2yFK/yYpiZTsNo746ZOmGK896V52VGyXHMjNmkteiHj8w0vgFVCwpA0e0Vo3KH17BugIdVd3O66UwGAUUhN1k2weK900CDk8pJVebUwnu9xrVsshriweqslnTTaoVWTZYwaFza2Sw562zerhnsOzclMwUEgQE3J3EE+9KSd0uiubJZMEK8Z+rKzq7EDlUp8gwFRfa0wUVR9hmggNp8RpURwAqtioPZVezBHz5DGASsb8ATaAFAYleAZZYi8lmfQRMxg/6AdJvhL8PbogAd8vqJvUbIBcP2YG",
"part_6": "3FR8KbmbMsyAPXoLcBnUvlbCoulnKNHzVzICr9PVoO9u9uH9WGgFKNTkKWmro0qlH0IGnsM3w0LbopuOdu+n7OFkCBZuAhrO9D0dDAiBdh54Ydw7FdObYrx3bl2K4c25Vju3JsV47tyg9sV2jIk908jmAzhy5E9wTd3onZC2AbQ1NkEF3Cmnrvux6sPVsYeYxfcSfi4Yykdw9+tNUTIbtTWs0TLTHT1g/ok93x1YDjdwzH7xiO3zEcv2M4fsfwB74aQP7/3gzQHl6E6ZYmE9LVnoGVt2whsScQ+Qlrcu167znz3qc99f1LGsMi49cvNa8EoMqmtwL8ZDP3ECb+sOcTT15f/G6R6hMS8+HKXUfo/OrvmcHdX2DH6BWfgyyWaVcij0gsaK9gMwbj8aLc9mNFIwJBA+OQB6SuG1Zt",
"part_7": "HXpAyD3ywsCANcDdCgzA3gA3BedBKDd23DXua4CoaMzMampSlcr8qAB6q2iO2+1+2crpZg16FUD+Y1F2ea8kBBUnFu+8DTRdISgQ0AtrNu3IOZ0sqn+GoKKLouWHcZA/7eyTCRPLYg25NX6ouJQ2kjp/043P87MuzrzAHUTDPaAIntJ0BBGB7nNcVA8bTByC9a2upj5xhvSDCLXxcEkvRNNDJjEls0snLfkLVoMWl+dt4xGuIMY4Xu491zWlF+Ku4XPT+a2qFqtj/0lSuqmrqKquPrb5mQrmt3rIJzK5fT4UgqAyQjcIeU6oPenbMkIt5Z4noNmcOw6v0H1zFm5oXrdoGnqqd7UqNrRJOwMvtSmtE08V1t1pV8GcH5RyZWUHJVzllI+BUzuX3H0ZtmXzSLRdncnVR0mAvfjg/g",
"part_8": "+EaTGdfueTVSeqpuczp9kN08ACa2yd4jT12bf0lQ3a5dUoGxtmVzg6gPvi3aio1mm0dqjck06DSuH0UBkg1Z8KGv4eopntPAJLlBApbCRE20JgHlmntTC1EEqY+D2WwpR9Q+tMhO9M2HmuwoWfp0BrqUZaiQEZq4AMFc0pffZVpMf74r7XHylaLVz53q7cO5X7QeW+mhajyv24bUZmBlhn1rlli5wukSzb1otcZi2YXGI3jK8dGe4ZGe0ZGe8ZOd0zcrZn5FwO2FUfW1ZYQVx5rRXFrqE4NZRBDWVYQxnVUMY1lNODa1mV3iDDSafyiRV/eIoVs0tDccG3su9lv8s+l/39av8dAweKZfk9i7SxRJ19m4bEOWWMAFakGOIVQB0MtGqli5/Ko8NXWk4f5JYqgM3htA5Wa0G1f1eW",
"part_9": "FuzVqD3O9hy9W46/ee9R0R58BejnSGXZjmUPLHto2aMqPDRy2S25nJZcg5Zcw5Zco5Zc45Zcpy25zlpynbdk6rdkslsyOS2ZBi2ZWlagrChZFAo1lHRdh0bFtRWpkU0jmHlvNjJFvMuR847WpL+/kAx7s4LIkz4X3c6bHOFzpNeQNMyucvzL7G5S5OxRZKoZmmqK5WjAbO7XYW1HAUYN3DDRodGzr4a1BhxrAK4GpGqApgYsagCfBrRpgJcGPKmvw3bhyZsWs51puv4hbZ7z1Uc22VM5avvEgsfzVevTlT5LD1VDPSqctU6z7RRjgopODypdtSrWnfcyOG0oAqRaUFRi1WVVXe60Bwp1UtYR08JUS4cPGtqGPgv2UK1pXwnV7Z3cE9oHXJ6F9dHIeIzQzzYT/UDhkPOAXi+jo1",
"part_10": "Wro08BX9N8jtUBY5QtiabZBs3JaAODNsxoI4M2zminB+xad/SRyrMD/NJe5W21woQSnhbHNdg1H7frm7jiKaU8VN+slQrQIFeaMd1C5J0X4kzBtpYHo8aDZRaJPcftQtHWg8K4FgQOBQb7cFDQJ7pB6Xgmn+TJDFMA0b7oRurJ4zDbPcyOJ+/m8oiYDzLMjDMP2gN1ZTcetmdWJ6Dc7Uw+1v4jJ/iiT4BvOszxVScMSt8+e9g/fzjok35/Iv4HNt8NV3P8UhhfJv9+35Gaf6sZX1Q/h277+Pecj+8gHd9BOr6DdHwH6X/x7zlzd5V2JledZygL7i+jOPKjFfNcH7aEBP8trZ9pELF/i9dM8c7lyPdkF7oB88iv6hVYSByg4k5BwIIo2XVmn6wOS+fSsM6EJxv66T8O4swJtUsAAA=="
}
|
{
"ground_truth": {
"compressed": "H4sIAET8N2gC/4VPuwrDMAz8FaEpBlOStF0CmTt16hiHYmznQRO7+DGUkH+vU4esFRJ3SNxxWrC3Jmj59Db4AStcGHZBCz8azSeGFTCUqgMxKPHKBNdylNwrUjGmIRZ3TlkPxyHrLX8PUEPTlPTa0uYcJ6eXHy92LGnabtgSqGvI/9sVSXRYlru0iNLUKePDTGFLn5GT4P5uglM3PivCcEWKzn8mFd+0IcL6BeK9FSz+AAAA"
}
}
|
codegen__leetcode2k___282
|
[
{
"content": "You are an expert Python programmer. You will be given a question (problem specification) and will generate a correct Python program that matches the specification and passes all tests.\n\n### Question:\nYou are given an array arr which consists of only zeros and ones, divide the array into three non-empty parts such that all of these parts represent the same binary value.\nIf it is possible, return any [i, j] with i + 1 < j, such that:\n\narr[0], arr[1], ..., arr[i] is the first part,\narr[i + 1], arr[i + 2], ..., arr[j - 1] is the second part, and\narr[j], arr[j + 1], ..., arr[arr.length - 1] is the third part.\nAll three parts have equal binary values.\n\nIf it is not possible, return [-1, -1].\nNote that the entire part is used when considering what binary value it represents. For example, [1,1,0] represents 6 in decimal, not 3. Also, leading zeros are allowed, so [0,1,1] and [1,1] represent the same value.\n \nExample 1:\nInput: arr = [1,0,1,0,1]\nOutput: [0,3]\nExample 2:\nInput: arr = [1,1,0,1,1]\nOutput: [-1,-1]\nExample 3:\nInput: arr = [1,1,0,0,1]\nOutput: [0,2]\n\n \nConstraints:\n\n3 <= arr.length <= 3 * 104\narr[i] is 0 or 1\n\n\n\n### Format:\nYou will use the following starter code to write the solution to the problem and enclose your code within delimiters.\n```python\nclass Solution:\n def threeEqualParts(self, arr: List[int]) -> List[int]:\n```",
"role": "user"
}
] |
codegen__leetcode2k
|
codegen
| true
| 0
| 0.5
|
{
"part_1": "H4sIAET8N2gC/+1a7Y7buBV9lVsHxXoSeVbyJJuNkSkQpFlsgG27RX8VHsPRWPSYsSQ6JDUTN8i79Fn6ZD2XkixZljzjWaNoFnbisUjeL14eHl5Z/tKLQhsaYXuj3i9C2LcqEn8uerxeJOdzOctiu8bwz6GO0CfTSHzujV4+f+X1lJY3Mg3j6UqrZMU2/qkyCrWgMCXxeSW0pV/XdqFSgsSNDpNE6HNioTsZx3Qt6EbeipRC+pQJYyUE+5C8jkVCZiVmEu5D7j6DxS",
"part_2": "hXuhGp0KGFD5oprcWs6YPsIrSUhHa2EAYNsW3KWVqFxmAwhD0Lx+b8Kr1Knzx5Qn8v4hhdpeVcihDxX+twzX/pbiFnC7hPjYQyqTmpNF7Tv4RWxtlXqTAeRfJWRsKFkOvK1Co0tRCUqnQgkLQ1YtGwYTJYdJFzULAILSOKQS1WGq3U5tMJE0HXSLxe020YZwLRv5+TtCQNrZQxEgn0oGQzzYGvaSw9+jhB/uyCJD2jgF7TR6/yOeLpI8SxP/E41HGAz/Pz87whJ2yY",
"part_3": "Pc+lNtbF5OXyzlihw9fDut5HGmCw1DUC+YpyZc5RbuDjpJTNDW2U8T6PRXqDiOtW7ELq3Agm/YaXz2UzT9MivBUkPmVhvJWefHU3GUqV3c3SeBB4NAgmEP2rsiJfCXaIpEudO2DlzAjgcAFAuNWPhJbpDTogXXfJrjaLZs7pJ6WxIcJkxS7HgRd4/qQmQD8AGhQBpUkYey7Ci3N6ExvlUSzCiH0U4OLNFcfqTkRYP0VjH7aQHgbd2F21YKUEyX/+fZW+y6OgAGv+Pl",
"part_4": "1lduQQfcnabAvvyVX6t8y6IZi/mFRKwxalXG1LCbkcBDW1iw61HV/DCa8Uh/kW2bU6xIYxDpwX9PqSaphA64KeUuA/L4DoEOIT8hywfLmfkfjE4XtDOljBHMuK08iZNRaLKzRWlDerojstbS5jVJw5znDbVlDJTZxtkc5iBVtrlRWqvL3cMsYygQXNuPvw4cPKsdMVxEE69I/CJEIivCIxzyH8jmH7K8O4b0Q8d5tgRL+AX8ZIwuSMBn+qWiNnGGyMpZ5L0HFPJisF",
"part_5": "hM4wKTAi7JurtOhDHjHLTRPpWGwaYH9hZSI4XXOQONn1ilNSDD8teudZOrNKxaY5UPPXHOIMtOosRLj61Oy8loaZvNGbh97sVSs+ALDSjX6eWa0Pk0znANs8VqHtf4fGd2fci7SVp83UShuL2rl14voT15+4/hvjemxo0KDQYGTey8flWSpebGCO4rf/+azWyy+DSfrbXXMmJ49ueaVFmiWuYO3DU1M31392Sbe7/XLOpi/pc4sOvwo0S05B2ZciFmTNuap6Zym2Ya",
"part_6": "IiDIKmcNE3WeJkPLqoycEjBhvuGptmSxqGOUK/Q8UHvN2OrofI9OTRkomZ0xkgBnfBtsAL9eZTGrquShlkDIwtQWl5HV/A4fIyJ5bN1XLSCKny6mgMrfxjyR+VaBm55LAdj2KWS7aKhYzB0VUagDqziiXf9Tjwoo37puVURtzDUBs4eho4vsLoTPEGYUyeQHoC6f8MpDgd9Hq6UoAKcFcirn923kAa4xdVEWQYRbh3ni37M4QvuUYsIcG3zVxmlv39nfPkjOMojpL9",
"part_7": "GuVhkmuU58j9OnUvw0lZz+n16euHU0l6KklPJen/4dcP9Dv89qGc4pvU3AkI98upIUzmnYgLDEw+3/bX4Wxp5Wxpzop63ayQYi7XW752YE9XR4+5PD6tsmE8ZYoEFMoaoxqurp7Qe8eDjHnNlFnw6p3go4lc9ddkV6a7GidsFSJ1x3vrkeFkXzi5HULFdg3YOPKHxYJZmPMdtdD1mi7KWHmkEW5XZH8EsP/QHd1OgVWP710IQndUlWQgaseHGxbYjrdSY/lyNWpxfP",
"part_8": "89XbR7+QmVV26Wd05xVtXOhkrW9U2dA/fYYrsGnqks3Xiu9bu6mAlRh+mN6JeVarMqRtqqwi5oKX9r9lE7B621cz2Gdisd85APMLfJbIfZay3C5SE5rp2hlXDe+Q1luQLcs86Mt01KHimLVQ1R4yTu+4ZyOMTh95A8tszr8DS+5XsRR1Mue1XBxazs6q32e0tUbk3/W6zX39lXz6D/umbA1Yn7cXGvCqe+6WjU5nlzX7jjZNTqdiPfnORoctbB3q0TdjeR7R7a1mPn",
"part_9": "JHAPhVFCTZWrpHqj8Ze8A4f7Tm0H4VKs56q73levRbys6rbE87quW6HF/rBV3M+tl0q7V9tmfvAoGHb4LebV9t4JnjqjL53v+TzAWlCbkr97faClDiv59batF/cmqvXvQYmqNHeuDrbzwKV7jmk90tCjcPCY1Pje3n/NfUHBi70byfdarnaz4t+DwCZmggMR6NdyUfvc1keV++M9+G1cbesPu/T34L7NTjdMfisoHvA+aFMfg2Z8r2Nx2rDycg8x1LPqex3tnRUPhg",
"part_10": "/N9PEyfkBujksMB9t6sTdB95w3vzWsB+7Oh7DUqwfwyzZeDt0IrX8P5qfjndz+UQ5K/6jHbbB1zD4exHuKrkOOls7z6cDixm+QTKP9iGP7eFtrDzgfBdRgP1t3Wpp4vUTYsDf60vpjUH5YkYRWRFN+TIP+oR/8OAj8wTAg3x+5/xCLcXs65S8pj/zgs/5LHn7s+mr48vTbntODlNODlN/Vb3tseGN6o3HvDW89tP8S2kVv8tXrSTPNUon93htZnYmv/wXa04Y6zS4AAA=="
}
|
{
"ground_truth": {
"compressed": "H4sIAET8N2gC/42PQQvCMAyF/0rJaYVONr0NdvQueLRDQts5sXSYpgcZ++92DsWbhhdCCB8vb4ILjSnYM1PiARqYNPQpGL6OAb2GRmiwrhdmcOZWGAz2apGdbLQOIhfG6IjF51AgkWjFqVaVenUnRZv3Su26n8gKvZGyVmX9H/Tts12QVevTx9GnJU4hNzyQc/t7Qn9A4ig1zKAg8sO7HJ1SHvMT9a4LSBIBAAA="
}
}
|
codegen__leetcode2k___289
|
[
{
"content": "You are an expert Python programmer. You will be given a question (problem specification) and will generate a correct Python program that matches the specification and passes all tests.\n\n### Question:\nYou are given an array of points in the X-Y plane points where points[i] = [xi, yi].\nReturn the minimum area of any rectangle formed from these points, with sides not necessarily parallel to the X and Y axes. If there is not any such rectangle, return 0.\nAnswers within 10-5 of the actual answer will be accepted.\n \nExample 1:\n\n\nInput: points = [[1,2],[2,1],[1,0],[0,1]]\nOutput: 2.00000\nExplanation: The minimum area rectangle occurs at [1,2],[2,1],[1,0],[0,1], with an area of 2.\n\nExample 2:\n\n\nInput: points = [[0,1],[2,1],[1,1],[1,0],[2,0]]\nOutput: 1.00000\nExplanation: The minimum area rectangle occurs at [1,0],[1,1],[2,1],[2,0], with an area of 1.\n\nExample 3:\n\n\nInput: points = [[0,3],[1,2],[3,1],[1,3],[2,1]]\nOutput: 0\nExplanation: There is no possible rectangle to form from these points.\n\n \nConstraints:\n\n1 <= points.length <= 50\npoints[i].length == 2\n0 <= xi, yi <= 4 * 104\nAll the given points are unique.\n\n\n\n### Format:\nYou will use the following starter code to write the solution to the problem and enclose your code within delimiters.\n```python\nclass Solution:\n def minAreaFreeRect(self, points: List[List[int]]) -> float:\n \n```",
"role": "user"
}
] |
codegen__leetcode2k
|
codegen
| true
| 0
| 0.125
|
{
"part_1": "H4sIAET8N2gC/+1b647aSBZ+lRryYyAxDL50dxptrxRldkaRZrSzs/tjIxp1KqZoKm1sxy7SoCjvss8yT7bfqQsY2tCGdKTdEVYL7Ko637nUqc+uY/pza8wVL4VqDVq/CKFeZ2Pxo23xWmM5mch4nqglun8VYzmfoVWmY7FoDS5ehl4rK+StTHlykxfZLCeUt9mc8UIwnjKxyEWh2G9LNc1ShhG3BZ/NRNFjNOheJgl7L9it/CRSxtnHuSiVxMA2Rr5PxIyVuYglDODU3AHi2AjdilQUXEEHi7OiEPG2DqamXLEZV/FUlLgQm1",
"part_2": "AaKedliU4OPAXFZe86vU6fPXvG/mHtGFynzhdrIv6Kgi9ZNmF5JlNVMplq9H9337I84alw7fdTUbiLoRyxKzZcSI8t5QhqfhdqXhjBmUzlbD4jJZxgebpk5A9PbxPBJlkxE2M2QWhpdOkQPYRBTVkpx3AgzRRLRSzKkhcyWcKvAj4JeJUZ27S3bxlfiLLH3kyoEbZJI0kKy3k8XWv1cKrt68PUV2l5L4pS64Ovfr97RmYSLo/VnCcAoBGryeRxLHIlxpD94z/X6d8WfJbDE39A0b1O36T5XA1clBCVoe8FI28YeD4+fa+Pzz7O",
"part_3": "R9fp3+dKjw16fToIi0KsJ3DA/rUdvHXUsjiew2QkwA5wGz49nSbsgZ58Z2yw01gtvcJbowb4rJjsf5XJ/RV4YD/7NSb7GyaHe0wONR4FIrQmhxa7YnKNsS5JgFaWEguyYjByi5LzYWpqq2jmX2dpqQpObdo2n/3lyo1JRHoLb9BwBr2rVeLar65YcJ32qd8sGjqL2HOkX4SUpAU7dWvSekqLdJ5KUEjPBMIs5Z9gI1d2IesUncNSkp5kSZLdy/SWlYoXChkcg/nIr/tCKjOmzJK5pgu7khwt0XoSaZxkwFpmcytql8hYJHIGhI",
"part_4": "JC8e7du1wT0zWGg2/YPy0kTGI4xmJCKfEKc/pTIcTviG+7FMnEs34N2C+yVEP9gevRqMO6f2WTJNNOMXtoPeDlvBATCWJuyVmegXdj+AhEqCuvU9uGOYHTq0tEZ7q6wJ1AKDkTFD0zscucImS7n9vWyTyNVZYl5XZHRd92FwWkVmYqeP5xu/G9LInTt1qN6dutWU63gqzYbifPKm1wMp1gQejYtb/HxfcdakXY3H3nRkmViMod7MT6J9Y/sf7/D+tjLYMB4UEa0zL+hoxLQf7cXsDKDkWE0RmxgsH4sh6YYiD8a5uOzroDCwhd",
"part_5": "oKF1EwFJQikQbdFOOxWFdCx8aPHZ1ZpgNvtJ/sMeeTrkBEO+g+KaPq0jgI5grePDqH4c6bpb6/rAXjBYV6uyovpun+qVCSFMCNcm3I0eGR9h7CJgXQQIZizC/cOXNHxJw5c0fPnIcFjdXkSwKOqQu+UjxtPxKaBJaluTPKes00AyNJKhkwybSsJMqB32R1gvQKGTF7rFdy04wQrrN7CfjnvYUX4sVNuhPmdBBRFXnWZA0xVQuAEUHgpkFgyWbhtnIEa4Na2IursXRUIP1YuLiaSknWipyaHME0k7VE1QuMYu9+5GjtFiCbpLNN",
"part_6": "td8V1XSoyKM+JaopATp5w45cQpJ06pcopIVbG80WkFenDE0O70tgiB6AbbDIwhtoinIr5rx3hEl7TpcilOFSnat7n2duWJLvJ8ekS80A9zl+bxru9d0JfvXdJX6EX0FZnHvTMz3r+w35e6NzAigX3SDLRkEJpnQ6siODOd56bTAgQvDcCl7gwNTmhwQoMTGpzQ4oQGJzQ4ocUJDU5ocCKDExmcyOBEBifSOCBLxP0i7F1uHI8HzK889lrD6OFXw0W9flOAwD5Dh1a0gWDX97pGt/7q+qudwwHa+3ZHYLQH+lwHzkyDtc1ZZbdL",
"part_7": "6yNq4l/tHuwr8Pyt3YYJ+5l3phP3TJ9f6POLQ0JhM9qkt0kUnBuAy0Nieex8Bl43MBOpJ7Qezlhl3G0M/YRQT25PZeu8ARvavHER9HtPAvxkYIFtCY6F3I7hkbO5Xr/rddUIZE+1oblDm/Tnb6zGg0hwDRDZEsLBSfnQimA1O0dRcTW3veG5d97coo37aKDlDaVeeC/x+VITlLlZRoZ2+7gpHQBvaM7In2vrDG1fHA5ixB3g8cy8txrkjDKV0GJ5eoV3KuaeirmnYu7/1is89ud/g+c8Ngt2wNrOU1j9CTwx1vOFBNN59J7Hd0",
"part_8": "rGd1QA0oXvMsd0Ud275tUdqd/9kg4+8HmixjJWWy8Gv6nThDLGEJ7GuFv5EA62az2WxsiYnt7xYxzt+LsYi++O2/pTs2+bfdusX+9t6MoU/UplPIe1e9XltuihdQA9tyUPDV6dNHf2jP0odUh5saRUK1VGtw4uQQjrGw0lHaZTIttESvlKDXa9WEIeS34LlKRiuG25mfEcZFCZqnaC2HXqzNlZIMSc3Wjy2X4PWufSG2Vu0NknMhULb9sfIhAJF5yJZfOy41ZZUe4p9ZmZqlYovX2FRBvaK+ZS5YVLlR9Y4LlEeeES5YfaWpEj",
"part_9": "sQfp+XBodX6GRrln5Uc9nuciHbed9I5Av6Zi0GaEVyE1a11TGZ+Jh4mzGfL2pgEdzyISqVXs7IHcZmW7blIq9VedQSTeqZsWGpysB9+ZGdwvQ4eLBU1FiLOoQ1NLIsO7kbV3mOwoz7pYyYlJCwIICMTcySq343p5uUkCsMCSCWUK4VkSoRzRFkab/VG1v/NY7dOutM0cCkFOW03RnmplZcVSmdJdehq8Np8cZTpBOVmff7e57k0l0zz6S3rquMn0o0RrMPxsGnA3OZUgRyPEx0Wm9aAS2fri1UZrR/2xioW9737pSnWkKrdTak",
"part_10": "/lsaHexmXHKt7DPelut2q3CseCHVRwbBiBHdXGqvTl4/E7avYOrzM2wn0qnKe1pEF5sYrp974C9WmQKoXFI/AeVBWPmLutkmJDhD0b3oZ+7C0mNma02kriAZm3o4x4JKPW1BAb2XJkAbEh9p7q4UEIW6XD4wh2b+Fhy5yR15oJxVuDzzv+a4AqctjIifENlSfJjr7/susH3SBk/f5A/2FYgue3G9qOf9tfW1R/90k/Abk8D0+/BD0VD0/Fwz/LL0EVvy2xkWn9LDLwUrFE0ytavPj+latpa/QFm57yxgi1BqqYiy//BVdJ114NNQAA"
}
|
{
"ground_truth": {
"compressed": "H4sIAET8N2gC/62WwW6DMAyGXwXl1EopIk4opVIPu+wBtmOpJkTTrVpHJwqHaeq7D/ynZWw7AGuE4ogkXxzbcfIpnotjlW+fyqIqX8RSfCZiV+VZuT/m6SERSy8RW7vzshebvU6yNN/ut2lpp8skyb26pKeTLUrv2jF5P+7z8uStvPXaSBVs5DqSqq5jqetaBTJqhJJxI7Q0jTA8QoUYryInY+4lTCHFg4h4JmnGkVuCQnTO0ekAtAAg5k4NjgZHg6PB0Y6jwdHgaMfR4GhwDDgGHAOOAccwZzP1Visv0n7cKT0sBqaCTq5Wjmf8oDeBJDkC5vaZOVNyhtVZzC66DFs/kOw6tz5xm40HVzjtLnqRH3SL6bVFuqIULxdclRwJVM7SXduHMuTwDbkdcTsaZA0X2IhyxEvdBiEeZM/RXiU5I7iT3fo3D3phx/3Zt2TdXqM2NLpc7cLnYkXl34Z8Oxq5PzSa+dOOY33anuX2iPWjqG9HtN1lQxyyp24+VJ2TOSwrtgSDm2NEdP7Wg64+Gpedv0e5XM/lfIBOnduVGIAkG8lFXS84YeEKNUjEQX1VDeEj7wEwZ/2QyaMRFMy/EP+RrAO8I5wJW7dQJ0Dx4dHyeDxUzXNmMvXf9vldYdP7wtoHm5XTRJyFFKfy42Drp09R1eL8BR2iw90SCQAA"
}
}
|
codegen__leetcode2k___309
|
[
{
"content": "You are an expert Python programmer. You will be given a question (problem specification) and will generate a correct Python program that matches the specification and passes all tests.\n\n### Question:\nIn a warehouse, there is a row of barcodes, where the ith barcode is barcodes[i].\nRearrange the barcodes so that no two adjacent barcodes are equal. You may return any answer, and it is guaranteed an answer exists.\n \nExample 1:\nInput: barcodes = [1,1,1,2,2,2]\nOutput: [2,1,2,1,2,1]\nExample 2:\nInput: barcodes = [1,1,1,1,2,2,3,3]\nOutput: [1,3,1,3,1,2,1,2]\n\n \nConstraints:\n\n1 <= barcodes.length <= 10000\n1 <= barcodes[i] <= 10000\n\n\n\n### Format:\nYou will use the following starter code to write the solution to the problem and enclose your code within delimiters.\n```python\nclass Solution:\n def rearrangeBarcodes(self, barcodes: List[int]) -> List[int]:\n \n```",
"role": "user"
}
] |
codegen__leetcode2k
|
codegen
| true
| 0
| 0.0625
|
{
"part_1": "H4sIAET8N2gC/+1a63LbNhZ+FYz8o1JDuyJ1saOpO9NNrzPd2WzbPx1bo8AkJGNNEQwJRlYzeZc+S59sDwBeQIgXMK1ndlsLEWQC4ME537mA+qL3owBznBI+Wo1+IIS/YgH5Kh9xRgHdbqmfhfwI0/8kAc32MEqjgDyOVlfLpTNiCd3RCIebOGH7WEj5hWUIJwThCJHHmCQcvT7yexYhWLFL8H5PkgskFh1oGKI7gnb0HYkQRm8zknIKC8ew8i4ke5TGxKegABbDE5AYqJt2JCIJ5rAH8",
"part_2": "lmSEN/cA/F7zNEec/+epHBB6qKkpBinKUxikMdh4/TiNrqNzs7O0L9zPVa30fdCrwNYc8+ylDhCElhG4S6UsANiW3SHEx8gSx10kHNiL8rvi3GxtlhyQ9ewx48EJwmOdmppMYdSpnSO4PPAEA7+g30S8WqBgJS8zXCowNvjI0oIzxJhzBHe6YEkjjSMcrHrLsOwDSckEJ5Q8+AQqiz9/bfb6OtHvI9DglxpaJzxVbXbNbpxHdE80da30b8yLlfceHJQvteVDK9LhpIyc2a6HBcG1FtKWw",
"part_3": "v0hVavWJTyBNOIpysx5qLPr0uZFyGJdoAuDLlTeBnTgLA2pZrw6DcsgVgAcWXYgTcl/lsWhuxAox1KOU44QCS9xhk6JJSrNSkLMxk1nMnrIjoF1iTyQwayjizLbz2A92mEAhLSPUhIBNpv3ryJZXzewnIIO/RTLhJUQvAKyBacmcfFP3JjxikJt05p2wr9AL67AVzWE3T+RXWVyxAvuRMkaJyQLYUMHdF9zCABfbASkgQ2TG+jfAxABrPLS8DnvryAkkA43ROB3xbyGvFjLDDKpz/NR7d",
"part_4": "Z5HPGwtSc0PYzpwQkjffcExy/NQfvaCqS2xhVqpujLBY1gSXmuLBMGwMjoy3E5jZkmI8/gYtPJmIUYCsK0IZTHhKA7zn9/6/TH1wKiQBuiXzhzSdNPR+cdY1esQwwT8bFnZNqQWlDCoE4fiDH6xDv7wKMHldofA633zyuHfQ40W6JQCJY3CQNHCoAnq7Rpx1LblYrb400gGCrCL1A7gR99hkSoOuLXXO1vhattNVl5KUS5DQOqTj5pd/gGp4eHjY0gJEAkIIoPC9EwqTPRMQIDzy75Olc",
"part_5": "ArUjOW5iBpAAzAXA48nFCbDCX1D2hLMAd3he8h/GPtQRKg6BSQ6neFQS50gxPq5nucjuubNwls6lc+W8BJdcy3G0dJDnoEsHzRx05aC5g146aLG2ELoAUaItVctFLqUwo7eSV5QivSTpbWa0eb1VJoEl9r0nbbbt15Zge7kFom6Wenlyz1q/tndezT5bXRZO0ZSXLqX7qwBYKPdIP5X9VdEvZTAsbTa6lEfFTJ5FSrRXKKo0vhwWApXL580A6m6c2yJZiLJZ7OVuXFT2qM0X1n47jeQye",
"part_6": "vuNUuBV/TB3607X26XeqpQt46Cxv2zqjaC5tE8NHQDDSneIlXpAQ6tC+koL49KIK6nplaWmDYljpozeD8SgVosdd9pXjgGYqW3MtqJrH7OelsZ/oGKVqeMW9XMxSA2jDujiuiqB5XHjlWVaR8yrJ55rH5Xmk3SXrsMisFY8qijMS5HWz4reG7yHWapqR2zXnvOid+t9rYjZx66eF9pJorZrSA4bycIG9+R8an4IsPV0FZXzk1r0Uua0mdZ6cutW6ImupfuArNfiriXq7FBSyC/hcy6RKo",
"part_7": "7LudRcuVWPteXAWlo9rOmRPK+HkepnRb+wjuRZ4d+8uc0ZPdOgWXx8LVJe1yrSooCn7JsfMYcEmGc8LZiHZdF7Hxm1Ziboj7p5ORl6HneclOXTwnJYeXY7iqmwXNFCyfGZ2H5mtv5niW30d+C1C5u/lB5foXFhK+j9jgYQDluJhtQUxPsPnPoPgn6RPGAaA/6CBmxjqHOiqJHxFkrdPrWVZ0oF5b8EUgKccBSpSLBf5p1Gb8nFnQTXGaiaaKl2d9QEj2EEMjEAM1UFgn0jsURLX/QOhxl",
"part_8": "BY1yuPGXPNoI9A/SvkfpjXFWOE0pNqHpKqukKfx9RTnFIf1W+Bb9lIUehxL/iuuRgD9mmS30dQtGRAvcs5QUIGjIQ2eQdlHnERCVEMUupqtjT4tS6uLjQhMv/AgUNptUQRF9VHCMTHs3P8v5tLuILg0801ul7udKhIp3RFnJdhCcLAjFNfWHCVpgQldeirop1JKiLVOjdSKkat2joJ/d8cY28JkDz+qwkyfyiokRumKyBo9XNezUA2dZNFMKdxT2jDr5w9MFplmiyhDV5LWRhq7A/ShGa",
"part_9": "xjwlU9hhRJ0fNJVqogk7hc2aLevWop0ZrImyIwhbd9FpwZrcE3bQwuc6J9gF2gk12C7bkNO+smIDTTM0UtDahjoVaGvLCSNo4Vw7HtBMyj+DDuyJ/wbTT7jAXvtMBtAM3T4icEh2tORFEwvYl6117s+uwkoyoDM8+xDtC0/vNEsH1yEzP+rM37Acb5DVR/v1pq/bhFIL59erbfHNwkJLm0ir03xmtPWxfRYbdHN8/RvaUX09MVon+Ew/tPN8rWJNdq/1jLc7m22pvYas/UiGzyIte2KsC",
"part_10": "5xTUq8mqpPb640pk9EzRfcRex0bnNJ5XTlbZ/UG1pmCyzMxtqb0esPJaz7r2/m8IQHaEvFNZJ7Vgdp/2mlMnkXFdftLpDB47Yz2hOPR6n3Lb1oFM7bH8EVtI8hCmPGm7svz6eLcW6LpdCX/wbIQvuNvhBpP/eMV/edo4qc07nQxf/6F2l/wF2oc71L4xjz6NgEkjjDwJaAvPr/D6T36Gd+Bn52RJHngGz/8KSgd9dd3BMdo/DqhLKH8KOjdjExG6w/wdTzdZBGFaBmteJKRD/8Fv61A+OYtAAA="
}
|
{
"ground_truth": {
"compressed": "H4sIAET8N2gC/6VX22rjMBD9FeGnBIalkiXbCfRlf2Ef67B4bffCBgcc+6GU/vsqkiWNFDeRtpnkBNIymsuZM/JH9jKe5qH7PY3z9Jrts486e56Hdno7Dc2xzvakzrr+mbSvfft30zZD99Y1U7/d1/VA5Ks5n/txIvYPmz/N2J66/kweyRMFBjlwEFBACRXsDlvyqH4nBRAGpASSA6mAcCA7IOIQ41VIXxcrtC0+C+UtwDiHFHxjgeWBcd9cUjKXeGQq61g8xNabLSnIjwuMqUM9PCQ00MswOhoBxnSnSsUBxwKhW6R6ZbEyWChGFFEnlTLbS2OYzZmZUHXMZSIPXN/5ehFxL3l0NY2vqP9mSzOFS0kfL+K7d81oy+L7eekCOkxsOm49thKbG17LhlUs1zCgTpkwI7gEQZ40KU9MbGmO2hWis02jUrFWsbGuTFA4OxhTy+BJM9CHe+osa/MQTd0vK5xAXYYm+jv6ZWeIGj0VaYEEmoD93VKF2AXErG7jqjF/BGkCO3HM92Y9kYmekDg2LrqEMDfI0g8Jdcvbu7cO5Qapj56iJXAYDwjaLfq8lSmJcn3Jgl6trPW7QXS7HTn5lTDt1HiHE47nHOeBZx5NfooAIPZ9wb3IQunqF/Kbq2KZFcpV7Lq3mHFFqrS6exwmNPfJpDE3KOIJnZsmL0bXZztH1RHf0CXdeqROwlTI4vr9M4lmLLhDhAvUIPtf8oYTgW/Ci7IkL+kb29NeIopEtaY3pFUlr9/62enX6Thfnqo22x9j34xjM7z0Pxe32zr7zCA7T+/HXj6DjbP8+vwHUH/uJJsNAAA="
}
}
|
codegen__leetcode2k___344
|
[
{
"content": "You are an expert Python programmer. You will be given a question (problem specification) and will generate a correct Python program that matches the specification and passes all tests.\n\n### Question:\nGiven a single-digit integer d and two integers low and high, return the number of times that d occurs as a digit in all integers in the inclusive range [low, high].\n \nExample 1:\n\nInput: d = 1, low = 1, high = 13\nOutput: 6\nExplanation: The digit d = 1 occurs 6 times in 1, 10, 11, 12, 13.\nNote that the digit d = 1 occurs twice in the number 11.\n\nExample 2:\n\nInput: d = 3, low = 100, high = 250\nOutput: 35\nExplanation: The digit d = 3 occurs 35 times in 103,113,123,130,131,...,238,239,243.\n\n \nConstraints:\n\n0 <= d <= 9\n1 <= low <= high <= 2 * 108\n\n\n\n### Format:\nYou will use the following starter code to write the solution to the problem and enclose your code within delimiters.\n```python\nclass Solution:\n def digitsCount(self, d: int, low: int, high: int) -> int:\n \n```",
"role": "user"
}
] |
codegen__leetcode2k
|
codegen
| true
| 0.5625
| 0.6875
|
{
"part_1": "H4sIAET8N2gC/+1a647buBV+FcLBYu3EntXFsiyjE7TI7rYFujd0/xQzA4cjUTYRmdJK1E4GQd5ln6VP1nMoyaZkSUMXzZ/Cxsi2KH7nfg7JM/40iaikBZOTzeQfjMl3acS+rUfmk4jHMQ/LRD7D47/RPIIxLiL2cbJZ+8F8kuZ8xwVNtlmeHjKk8a+0JDRnhArCPmYsl+TnZ7lPBYEZu5weDiy/ITjpiScJeWRkx39nglDyW8kKyWHiFGY+JuxAioyFHNhTHJ4Bx",
"part_2": "agC7ZhgOZXAg4RpnrOwy4PIPZXkQGW4ZwXcsDYpRSmjRQEPKdCTwLi4uRf34tWrV+SXWo7NvfhrLVrBxS5hiwh0lYQLyXYsJ5EiI5/SZqQgSfqkBvd8t5+TnMkyF4q9KA+PAEljIvlBiQTyRSQNwxJgFP5IQ1xJdKTIKzwXYVIWIA3Jqdgxcgec5orNA8j97z/uxXcf6SFLGLE3qMffRVbKDXC4JfZciaW+IAC/uffip1KqKSuEZgkVyjIb8itwq0RR4EbEVS04yA",
"part_3": "N0bAsu/HTgckGCH1PwhlJK9uPlEw9Zo01tDdtWNm8kd7qSu0fJLesou+NZJ+Fdb1R6t+Huepr4lju3bbgcuFwLLnt+c3Mzd9w1XMHcWbpKLDTqu1QUMqfgjUIJZ5E/3QJleAvuhY2fKCB8KOHg0yGvgcEa5zbh9H2aQyAC/BjzZcGUGeI0ATiEFikkzSVYJITcIzIlTzmX1ZwiTUoVsjCK901qYJQxCIoUaD2nZQ194nIPKkYs4QegkGNQv3//PlPJcQ/TIebJP2u",
"part_4": "SIBKBV8TiymTFu7QUclqwJJ6TaIMxqBxQf0MV1dcZWbzFzxqPL8UFKkOWs5hDaZjwQ5ZC5oegIWQnMCvuRT0GBgWVj7dgm/3xBioRQ0eh7WIoKEQ+Z2if+vHrejQuRSjTNCm6DzR+3Udojl7MntHst+7gIy+wqnRGK9G7o2mGxSjNu+OomTYGSooYgjJOUiqnX8PN1zMcBbM1lW8ruUwYmO9ad65157+tOxBPkIUsh+qAofTFcr6OMoTexNMq8iKY14yghAt0WqTC",
"part_5": "vGEb18wEPtDI/TmksFif7pWIcTHN0mJOQiUWoxG8Y2XTgfjiMYF5aAir80STFIi0n5UZ+IreAfIBKSjKhCVQUYP2RArlBEi3B2PMeHSsyowpEHtD7FkPeyDNyS3gVYqiFj2TGjZvbhutK+N1NVc0FLkym52TQekvow5STxW9aDYn31PAv8ypNijFqn56QsFGd9YDRqJ9Gk3alnvac0g50ZExQcnsjtHvkgfACvIVRHb7kSDffHPbGq0lQuWSOYGs/TUvWfU+UylRZ",
"part_6": "AnH3anKKriH/e2HLY9gROXBIsQ8WHCxUN6ECWGKxQFz5ppE1yS6JhEmDRMyf95mKcQwJEWTDtPZjZYGmFuwm8HEguCDaAw/TEOwAse9XeNZPHrh9rAZn+KqGTTLbnBadYNghsZrbNGLs3qXa8tSSMcxQp62KBXMNpPT0nA1Q9uxTLA4vwWu0K5vWYaqtnSt0ZY7AnZeAhspbXd9M6qv18A874jzPK+ylLceQfoN0vePSN/3a6ca2Xgd6BauvWME1Fzj1MClkZaaYT",
"part_7": "2vQnr+hbI2Me+YWAd2k8sTy5W/rrHB0si2mmkr4OpSwzYJ45rZRzOPwvkm0e5ZZ470L06yIKgN+0KO+X3O9Gu2S/tCNe06ChzDCtaNguDi5KrYmZpHr0LB0UQePhgh0Xu2U8ix+Bk6V1Ve8cx8chaxZqU66CnVpj7prdSOby0vlbjW1Mg3kNfe6ghdeUvXsSvGK8fxfaPsPjNWcOHyeyybl0bvhcBLon5oCTVZjnq3Cqele+1eulkw0FJzx4nn2mi34BntFqoGUv5",
"part_8": "87b1fe2DXHlhf7538v7feG33/Ioonlm/ItNETZP6dRyzCgzZYQklJHmn4QfLwQzGru4VFBrb+os1CdRZE9FZRmooao+6GQPhSoPO+QZaCnts03toWOTv0QtjlTKFE+0F1bm4ev+3tc4AFENlMOj836xy6J+hjW6NMkm34HCasONHqbWpUCXPb33PpklqcqXoyEZz99amvdRP1claKvq090M/7SHmUFkR8TQ0bICbksB2he/BNn1r6hNfnZm76UUhTb6Do43WwaW01",
"part_9": "fbjVW1P/1oa6tk1VeZts7j5VA9jIGGxOAKqZP7Htyed5GzTUmdBhjjMC09b8FqszyGBPogVzrGHg+RZDh+JOY1S9dkOhBbXcM6RjiBxR1B5wQ4+OA02Ilmm89RlsoAPRdt6IRdvth7YjRlCt3kMLtRzRrN140GGebyRiJ5idYXOctRzawGA5YknNkC3UysyMnTRwxwyi2UMH+cNh3G4zjIOGewwvps1Qg0EHLm0j1ey2q53REjTg6sAwX1qMxu1x1lRoxaOqLV187",
"part_10": "05Zh51HyNAWteUAb8z8Q9E4Vl+D4fo6bv6x8orNBDNB29qNuKGvf9BiqdoII6k6ZJ1gbPEZrHhmkXkJyjichxsGL6wbg92Cloxr12wBf0mzoT7BSyu4d8kK/jCfHJikk82n3l/24eEbjgks2mIPQlnFDhaWt3BWxLI26g+mwZlvt8VTz5c8Mui/i8F/1NrWyr/+VObaJvjf/lRG0l0Bm/3JD1Tu4fbbZ0EPPCQ/1/0yCKrJw2c4GxTbUnAIvslG5iX7/B8ZaCe9NSsAAA=="
}
|
{
"ground_truth": {
"compressed": "H4sIAET8N2gC/5WW3YqDMBCFXyXkqkJZ8mOMKfRqH2FvhUXUtrKioJFlKX331SZq2rrupBQqyNfJnDMzmSs+t01f55+67fUFH/A1wae+znTZ1GmV4ANKcF6cUHYpsq9dltZ5mae6CA5JUqPhk3Zd0Wo0v9jl6IjUHlXN9/hA9uhSni/jowrQ8Ygo3QLJBFKykIyQO8oYDJ1BajgKPCpxQBuSMgKCR+CBNjiXhEDTfcjX4oRv0ew/GpY4fbZoO2cxcULMoBDCyCXiLVROqJQzKqW05sKUjpWrszUJRjoOMUuGsEwdeYUwqJC+x50agIEkooyHS9BIxhZWIUxhR2BDRt7yTu3DgSI5Gt1BCSp9QV4Mlf49p5SV97+Wk2umShs4pL6pUlsODDrWnstB+feaCQjWyJ1MatZJjC+2/oOuzFN+Rzcria9OcKsSF0BrXqoXOMPVygwHW7M6wpkkofehbbYwi4ZGF9HMRiLkjJrQEWNSwtr9RTHlez/P09S7kn1Jrxb464oF3VWr68Ryucfce6GAZOq4skSNYRuFgG0U5mt2so+m6sdtbRe85eW51N37sM/pIME3vMed/qmKYatr++Hn9guisNLH7QkAAA=="
}
}
|
codegen__leetcode2k___354
|
[
{
"content": "You are an expert Python programmer. You will be given a question (problem specification) and will generate a correct Python program that matches the specification and passes all tests.\n\n### Question:\nGiven the root of a binary tree and an integer limit, delete all insufficient nodes in the tree simultaneously, and return the root of the resulting binary tree.\nA node is insufficient if every root to leaf path intersecting this node has a sum strictly less than limit.\nA leaf is a node with no children.\n \nExample 1:\n\n\nInput: root = [1,2,3,4,-99,-99,7,8,9,-99,-99,12,13,-99,14], limit = 1\nOutput: [1,2,3,4,null,null,7,8,9,null,14]\n\nExample 2:\n\n\nInput: root = [5,4,8,11,null,17,4,7,1,null,null,5,3], limit = 22\nOutput: [5,4,8,11,null,17,4,7,null,null,null,5]\n\nExample 3:\n\n\nInput: root = [1,2,-3,-5,null,4,null], limit = -1\nOutput: [1,null,-3,4]\n\n \nConstraints:\n\nThe number of nodes in the tree is in the range [1, 5000].\n-105 <= Node.val <= 105\n-109 <= limit <= 109\n\n\n\n### Format:\nYou will use the following starter code to write the solution to the problem and enclose your code within delimiters.\n```python\n# Definition for a binary tree node.\n# class TreeNode:\n# def __init__(self, val=0, left=None, right=None):\n# self.val = val\n# self.left = left\n# self.right = right\nclass Solution:\n def sufficientSubset(self, root: Optional[TreeNode], limit: int) -> Optional[TreeNode]:\n```",
"role": "user"
}
] |
codegen__leetcode2k
|
codegen
| true
| 0.1875
| 0.25
|
{
"part_1": "H4sIAET8N2gC/+1dbXPbRpL+KzjlQ6Q7wIXBYPCiWqdqL7lcbdXt7t0lX64sl0KRkIQKBTIEGMeVyn+537K/bJ/uGZAACAwoWpRlm66YJoGemZ6enn66e17y+9lsUk3KrDq7PPuvLKu+Xcyy78wT92yW397m0/W8eo/Xf81m+foBT/Nilv12dpkkkXu2WOV3eTGZXy9Xi4cl1fJ/i7UzWWXOpHCy35bZqnL++311vygcUNytJg8P2eqVQ0Tv8vncucmcu/zXrHAmzi/rrKxyEJ6D8maePTjlMpvmYGBCjy9Q40wXusuKbDWp0IYzXaxW2bTbhlPdTyrnYVJN77MSP7J2VVzTclKWeDlBfRUaLl9dFVfFV1995fyP4ePyqvhPZo3KrxaLylncosUbdHf13qlWWcb1oJ95UWV32cqZ5w955TqzbJ4Rc6g5L8o1iTDPisopINsSj7hCLl/mDxDupMgW63L+3uX6Vlm1XrUb5e9ZCdK8uGsyAJ7/zNU6edluK791sl8zkHEd1cKZZ5Nb9Lm6Z25XJYRGlVX3KMk13E8gDKdcQ+zVKp9W8/coU5L00EPuGbfG9eREyqXe5aixWDjT+3w+W2UFaP7x/1fFf/w2eVjOM0dcklSvir8Uy3V1qZl57bwRbuBKN3S9NOW/sZu46eaXCFwh9bfwravbRilx",
"part_2": "Vfx9XXE9mwqK9XyuP3QV/BWlqM2ah6CfB4XiiSuEKRPjZ+yKRo3KlY3Wg6DRfG/ZbUldvMWEHBaEh74qXUZ3qNGq1+40E4Fed5AE/e2iwHBNMKYlt/AjVKVYP9xAG6E4uxqXb36uJsVdRpU6yvf9txg4T/jK+dNr528o9erXyZy+4xG/SOmH5oqfpro7esZ8v1hhrqH9zbRelxk3cruYzxfvSNHKarKC3mHCQmugj+9WeaVpysV8zbMST+l3PftpMmTFdL5AXe8Xa1OUFA49wBwjZqDIYPynn35a8vwHO8532W1e5Fzh7WLVmbAkkFdENZ1j+js/4hn19pIe0Z9ZdutcX1P56+vzMpvfug4E8drHiGS31eu/LYrMdWDy7vX3i01B+kP0LLfXVGjnDdWAV/TPzjuuEi/536tCc/eDEQwaqXnbzvAf1jew0YZHUqdL5+9Lop7M39TdqhXpkub8heN900NyyeKDVV+uIDiY9bP8YbmA1Z5i6MhIQMGuCvOMLENxt/mJQb/f/ACOZFX+kJFS3AIMnOr9kgbevP5X8/R2XUyrxWJedl802uu+onHuLXOfTZa/dB/e5GTcuk81692niyUBCdSk8/yBDeXmGTpZ3GJ4bueLSXX+NX58fUFPd7ToQB0a0qBh/bFpz1VBLJC+X5O+n6MqQNoldKGs6tZy",
"part_3": "Mg6VY15t6zPoQ4zph8ZS1X00lb3x316YirRlpq8A8HWGn7MM384vGg9fTZbLrJidU2Xm+TsARqbfNppnTHltCi0XS+psXZNhO3f+BBkUhhHtFRim8rcOo1nF/DeqrauuZdjtTf72ok3c4npTssmI82+bfj8FY/UQHsAZFx1gzQwnyb3Wi7y8LicP2TXpx/nSdX7pqMSSGadvv+zqxY+rtdEL2N+aHtNngPz7ybxs0i9Zuf8FA0xfRujLbJegzTwPCnqgB4f57hCwbIiiFtJVAVNXe5rXVV7NM5i8k5938vNOft6gn4cpA+cgw7BPabZ8aT5WG23387Z0mWGfq4EbrCMYrx5o2EFj+qNHx3vNBV+1/ARTmxaDqVIbG3qqBTDaEtWi2/jG8dkOG/zY0G6aeK0luyOxDYURyUWncD0UltLGcu8Ub/O5b2+b3YA2l8t5TrkKnlH4XU3Kn6/zGTm/DePq8bTy8sKjgl618MgoemRcSxSaLmjG09ie5sRpTnzycwJtrd5fLxcYKOhzrQPnFzu80HyB/wQi0ozpfTb9+XyKJnKKAGtnkpJrq6rtjm2Izg0sbkOUx3gKFw1XAd97KuHpwh+6Gv5KJS8OY27jBuiKahdi2wy5EBdNH6LNV2/5bWldxcHcbX0Lrkh3v8mOtyMmJmT/4oJ94sOadQLXka4T",
"part_4": "wrNwnch1YtdJXCd14TbgL95j2ByMmyNAIkAjQITeOwJkAnQB6AKqB3QB6ALQBaALQBeALgBdADoJOgk6SQ2CToJOgk6CToJOgk6CLgRdCLoQdCFxBroQdCHoQtCFoAtTcoTwlxwi0CnQKeoC6BToFOgU6BToItBFoItAF4EuAl1EfQVdBLoIdBHoYtDFoItBF4MuBl0MupiEAroYdDHoEtAloEtAl4AuAV0CugR0CUkPdAnoUtCloEtBl4IuBV0KuhR0KehSEjPLGWG4Ww+z8rvDfBqglzBAh05rn4eNhkXy0PFg0cC4jvYHovoLD2Va/2p+Bn0P+z8bmhSojiZtWdH0DW46TBzcXcmKSQrXZIyajPs4pqZ7nqZbfbX3mLR5hCIcpVCjFNEoRTxKkYxSpGMU0h+lEKMUozKVozKVozKVozKVozKVozKVozKVozINR2Uajso0HJVpOCrTcFSm4ahMw1GZhqMyDUdlGo7KVDXxTHbwbCMJMhIWw/ABFtfXZpvNd2zMuTLmXRpzL7T5JxhgOIgNPCgDF9LAh9BwQrDC8BIbuFEGfqSBI6HhiWCK4So28KUMnEkDb0LDHcEew19s4FAZeJQGLoWGTxI2w2ls4FUZuJUGfoVWYVJ0hufYwLUy8C0NnAttPsjIMNzHBv6VcQekcQ+EGZjUoFRs3All",
"part_5": "3AtpMENo9yNlXyRmAFHso0iGK9HQAAxIF4hOI/QSRujgSMXxUIG38Uk9VO1tvFKPWvWoeY/48IghjzjzhGr6uTturrcxoxtbSDV+EJ/sIm9MvKeYX/NDsihGPKwGx7uOubFVfqNWU90HBKkHuPgWc3tgfRfPFE1axfvYqp7KRe/3TSNuXoxibGs4An/cB98295gmLj5ivG8LMtr1bzq5bcJ0wVL5xSmVsVekfMoaNGXxJWpNy8v6jDTgQ+Az1EZ0C88xP4sbKRcTpjTwX4yGgZ2oR3Q8BiEtRtHK1WDsusvbHjx8mbbTe/kfzamqxqbq1vtty7812nvI/ilkW7vOTyuMT0FPHzVkR+XjI7jjO1H7B/nXg1Ho/pnt9qcnbKNzrBYPRyXJ7ASN2JZHoDHbLVAgxJjh7/wOd/Pvrd/RrimxpeW7qxLd/H7Q4a+buO+m6btJ+W4Kvptw76bXu8n0buq8myjvpsW7SfBuyrub4O6ms7vJ626qupuY7qahu0nnboq5m1Dupo+7yeJuaribCO6mfbtJ3m5K1+pYPr8yf3JooYZSRbJmYtvVuuGtpn8Mw79vxy2dfFn40MndPQohPiUv+nDpvPzPI8woEtrBw6sz2zRCHtXkhRuPlnIRHq0ueLQU4aWcAfd1Hpw/uZDgUoKLiZaNRS2dDj55W59TYNiQ",
"part_6": "XNSb9tgsI6iezGMPe1u3YKzhT0WMthz08/Pyhefm4qHocZOIilqOVCvaH+rBM2TTLCsju9uX2gHCfmsgj6/1xeUFd91Z+2rckyQC+xr9kO0Sivdi+FqxaOVc0Behv2nlpzR7wpzzjON1KvqW+o10FekqzSDSQcrTE0wRSqW8DMur0lSQSETIi9a8gk1vE17TDux7m2hmko7T+gDvCBRmxx8vdvMH2QKeQLxAToWEZPvA6+M02rR4IGjlQMS8hs473mQz1uvfekSFlWUTDu80sLwXPrHg20KjgGe+ZbOQIPaEbWuUoDkvlMU1FDH33dYKba4Qia0vtF1DpBY+gtauVhH07QE5qd1J7Y6hdi84ag79vV2BxobcoJlZa9b7gnv6bAuSL2YvhDhChw/uXGB2Psmtt8UrQoq5SrZbv1mYifF8tQ+m/ZHU8CgNT/WubGk853RrHNlDTi0roB+Fm6N4vRaoCA92eu2VHu7zCrPHNjAYy1FOHTsos9dCmb0UypywUOYEhTInJLgevwYSrbqM0H4N2FSthgiqWGOexnbWafoWqRpxGd0ZdhNlgJzNetthCPxd1/lJe1Nb16N256l3WHoJZXzqfY09BsQjC+LRBPFItTyaJt7BmQPRu0fTa6LVhrMhjrYrREdOFrT9SG0F2HvUGV42LpEOlWkrEfuIgVaK",
"part_7": "Rugdal6l2bFLQTRtRGKVSsyO4sTsPo4aR4lGjxFZkpkvnvOnPPsU+MNh/nbpRzRtqUhGbOnj6n1qWBhZZhgo8xGW9GXfio2+SGX1/nTn3+kumNNdMF/onX/O6cq/T/TKv3og/1yU77LVpXNeDyAG49d8ls1IlhhiPd1vJtOfq3z6c3lhrgMql9DCL/E2oKcQf80JNTC7LfkeN9eZroFrRXUNe3zRuYrE3LVWbG8ZHL0Shf60f33lfDuZT9fziZmFRfaubpMxIIcU1jONENnmDbXZrqfBJ101VxjTYW/6L0CQ6mvCEEYT02O6PIQ6x3pHQMV8lA0Uojcs0kGB6GGuL63bXok3LCiNnretjnxTmzq+FWVclP+boXQJXwGYiRkzJYY3jGjlKtc3NAXK4XsI67E398I0FcByR+CmlLkPZrhYzyDcLCDlGrnZaVuu1kU2cxtuQXm/WM/h5czLBTlrmqD3bpxakttO8WWAG2Z7hLlzbw11h6aT6/jauOSEl9cLhsCzyze/6wcwNR/mSqDmus6zUWfi7A93t91Huw+tJvdzIHobHncZOp3bOg2D9VHvlRuZfiMEAGdadHD/EXeIiHhECClSFyESIkSE4YjCEYQj5ERYiQgcATjibwSOUrgSVUpXhq6EFCIXoahMXMSToe+Gwg0DF1FoGLohxBC5IXqf",
"part_8": "uGHqIoJVwkW4qaSrwJByEaiq2FWJq1IXIWgkXES0kXSj0I3Ab+RGsYuwNMKw+24s3DhwY+kiSEUQHKM7sYtgNU7dxHcT4SLcRdyaQPLKRfCKwBjhK6JXhMCIXxG+InpF8IrYFaErIlcErqQ4cI620lV+R7qne1VewL0q/YoNdSLllTQxA9ZePRciM+sEqXNn0gXdBz0fzWmt2urwiMtRenmGAtIE27aHqnYMA2rrPknNnBzkG5o1/C60vFOWd5HlXWx5l1jepcPvpG95JyzvLHKRFrlIi1ykRS7SIhdpkYu0yEVa5BJa5BJa5BJa5BJa5BJa5BJa5BJa5BJa5BJa5BJa5KKahlu2DffeF4gMmBafoIEAImawUAwckkFEEKDAghG4xAw0ikFHMgAJAiPYQQKmmEFKMWBJBi9BQAZrSqAWM8ApBjvJwCcIBGGTCRBjBkfFQCkZNAUBKORBYBozsCoGWcmAK0hNoEUExDGDsmKAlgzWgiYX5h6BeMyArhjcJQO9IJsEG0MmNGZnQLFjINmuCnIY0F0YKnAETwKFXNH0tvwOaJ5u7ngJN3cMeIMeu5fkD3qR6xl3GjXRZRx0FwddxUE3cdBFHA2/qOsWDd3DMdQqOZ3GjsG1VRuvVVpwudH+jltmuVVjwJ/fy/0dtiiH3ZFxqEtu6/ojU/ujztOu",
"part_9": "0xFR8GKx5i05Bf6oj3TQ5RVPFM1YvLkPv4Xic4m4ThHQ9o6IFz+mLej9fAbr8DyMeWdxk5tepGhijZDD9uH5LmR4+WbE+/h/m2qvRtT+s78a4Vk05jESP+aZ2SdworoxyqBXtBPo7JEwanx4wiK0I104MGA3EY+C/3BjHEWdGOsPxYUYtpHNH2E7e9X40XQYRTyU0Grl5Fq5sKDJQSvZ1cputdJZrfxVK2HVylC1UlKtHFQr6dTKMrXSSq08Uitx1MoUtVJDrVxQK/nTyva00jutfE4rgdPK2LRSNK2cTCsJ08q6tNIsrbyKzaX4CAf5n9u2qYHg8rHn8I/D9zCjx7JhndD7MVbs+TyZR/fohXw8vd7xftheuXNaB8Kkw+F0NpwdKUQ7dDCczoXTsXA+Fc6HwvlMOB8J5xPhfCC8seyoOgj61GfPX4AP3Ohu1BdYHe3A+HP13ZK1efbj3p9SmB0PeL/PdDJ77wxeewG06Wbtla979EHrI0bsHXfUmpc91mnpwbUhmDk664FhjDEG+Efwv6RYUUALQ4IVlpKo+Dc13UxIXaGNGGGV0EIQzGNKaXFaZAEtXtHBUzp3SqdG6LwIHTodWA6FTkNdlODdEYJ3QdBKDf3FTKE5Qys6IKQjpnQ8hQ6Y0vlSOl5Kp0vpcCmdLa292N2lSxRQ/et9tJzV",
"part_10": "/4bO/9A50t53Ac3k/pVHOkojBlZP6dgonRrtfRdTbwbqTNDzZIDPFO2l/e0FrS0hIuhZ3jodSj4dSj7CoeSjhxChvy+S7XGw+OjcPld6+whrTeLpOe/nMuCFVWm8AVghKHxAAMxbokiuCbtA5B0QEqfcBcls621Fkj2m1IAK+UfpcFL8Y5zRfYT/0w+X4aHuj/XI7YD3Q0qiWK0Ve6CKPU3Fi3GKF90Ub2dUvG1R8fZEKuVr7GQdI2/C154FqmBsRCWM4ux7kOLh30hpT4G8D/IWEsXeBtmaNoYF/o7T9Mmdk91zP4OXIK7V+w3aU5VOvdKhVzrzSkdevccFTKJvB8SRT7n2a9jW8aTJSg4nJXtoskcUy6iIfcvArf1OEkVIXZW8QwiBhQpYDxPemZTw1qWo3iw7uFN2OHPx0o+m7rN9lKbbbvRUp77bu8sTuwV51EHTfW2bPSHXf3z0CdZN5E7K8a179pBVk7PL389mOZ2XWc8rOhf612yWrx/ofy5bVvnDpMpm13Q6FW8CX6SeH3l+6vj+Jf8HsvmkuLumM1+nc0UHnCvSB3L5HCv/z6yFD6u5fVTl1ZwEezrgejrgejrgOnjAlf938Hfl2eWbM5pa+Pldtqzuve/zVVk5P2ST1fQeD/9dKyyTvP3DPcvL63WRY7KdXVardfbHPwFvTvpAWY8AAA=="
}
|
{
"ground_truth": {
"compressed": "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"
}
}
|
codegen__leetcode2k___360
|
[
{
"content": "You are an expert Python programmer. You will be given a question (problem specification) and will generate a correct Python program that matches the specification and passes all tests.\n\n### Question:\nA string is a valid parentheses string (denoted VPS) if and only if it consists of \"(\" and \")\" characters only, and:\n\nIt is the empty string, or\nIt can be written as AB (A concatenated with B), where A and B are VPS's, or\nIt can be written as (A), where A is a VPS.\n\nWe can similarly define the nesting depth depth(S) of any VPS S as follows:\n\ndepth(\"\") = 0\ndepth(A + B) = max(depth(A), depth(B)), where A and B are VPS's\ndepth(\"(\" + A + \")\") = 1 + depth(A), where A is a VPS.\n\nFor example, \"\", \"()()\", and \"()(()())\" are VPS's (with nesting depths 0, 1, and 2), and \")(\" and \"(()\" are not VPS's.\n \nGiven a VPS seq, split it into two disjoint subsequences A and B, such that A and B are VPS's (and A.length + B.length = seq.length).\nNow choose any such A and B such that max(depth(A), depth(B)) is the minimum possible value.\nReturn an answer array (of length seq.length) that encodes such a choice of A and B: answer[i] = 0 if seq[i] is part of A, else answer[i] = 1. Note that even though multiple answers may exist, you may return any of them.\n \nExample 1:\n\nInput: seq = \"(()())\"\nOutput: [0,1,1,1,1,0]\n\nExample 2:\n\nInput: seq = \"()(())()\"\nOutput: [0,0,0,1,1,0,1,1]\n\n \nConstraints:\n\n1 <= seq.size <= 10000\n\n\n\n### Format:\nYou will use the following starter code to write the solution to the problem and enclose your code within delimiters.\n```python\nclass Solution:\n def maxDepthAfterSplit(self, seq: str) -> List[int]:\n \n```",
"role": "user"
}
] |
codegen__leetcode2k
|
codegen
| true
| 0.0625
| 0.5
|
{
"part_1": "H4sIAET8N2gC/+1abW/bNhD+KwcFWORGDux+GWo0BZx2GwZsXbcAG4bYcBmZtrlIoipSdbwi/yW/Jb9sz1GSbfktLrB82eQYiUne63PHO1LOF28srDDSej3vJyntWz2W78qZwBuryUSFeWQXWP5ZjlUeY1YlY3nn9V51XgWeztRUJSIapZmOU5byp85JZJJEQvIulZmlDws70wmBYpqJOJbZOTHRXEUR3Uiaqs8yI",
"part_2": "UGfcmmsAqEPyptIxmRSGSoYIHi6BYnjgmkqE5kJCx0U6iyT4aYOsjNhKRY2nEmDgayLcpJSYQwWBeRZKDbng2SQnJyc0K+lHb1B0idjM5VMSYGQPotIMV8mE4hk5mL18cEfy0RbOabfP1y1SE2cAp1EC/6sLKxMjIIO0hMaeP7AcwQDr4VP4UxkIrQyM44j4KUe2/KjZbVsvASyi1JZQDpzayEABnrzTFnL+JnHh/",
"part_3": "4lTOk/PkAdHJWJYJPmys4eHy5bAc1nMpOgenyACkzhL+IEk0/NIal+v8broACTw+sPyRyPD0bFKhIZHB7LiUqkMzthHAHeWKZ2Vvz2AY9meBYsgq6ggCY6ivTcOJ8LooEHaOiCOtVEn87okmdiceeXUzCq+HTZquyjvsP1kpZ+rSQy6GfEghzsLKyLwUpYJaHm3/c6QxaLOI1k8PhAbBj+QlrLhxAXq3LIM5haw5R",
"part_4": "8hr6OgqFOQF3HRy9bQZUGq4zwWa6zHwlVyIEh0JH8UG4Txs3ITwFSOkJq8Tuxmuxc01iZvzRGZPIbkOQyCZGkJShgyMOZ2xmI4yZQ5DtX+ueRTKawGnhXHy9YXTlowZj3eo6k1dpIF0cntZK3pmJPqKqcjlWi4jymVBujsNt5d+US4n+TNs94i+Jt5jKDjZlYkI+0KQ1aM6fY6PATZcsU2gXyf6ZVKDnRSrt6iF0h",
"part_5": "7VoNObF4X0IMj2APtrR11AHJyLm1Iu2eg/c9NnepioOAUpNPZxSjMCpkRklvkJ0LZAs2ekALFDgeZpU3C1YAx+MynN8VWUXdYq8naW57bBJUuixw2TRIfsmtW7nuBN3ypzNkjor/5U5+zkeXojUJ/OMk8G8nhS15i+JkM4G8KfZgl14XITfqb8mfux28eKWqkNgVqK0gXpbx3BRbvtjLnO7GAlREjyNDyE+uKAWN0",
"part_6": "VHuqjBnLcZVtedIIZIRJxbgK1l5D6kE+ROhxHCVBH4fP35MXb0fgBxlnK5KkTCJ8EIN4krxjnOuPwHTFW8V38hoErBnPa6lLWq/oZ8QrGt4Piw5+eXko82lGUoZ+pyn4lRnXMSjCK0GalBWyrmiJi+HQGW2HKCxSqtiyahN0B3JLlLXS4rlF+XsJE9Cq3VkNhfW9G0uMRA7eWZSpJ82J2+U4Ra5MVt1tvqsTrmzou",
"part_7": "ptzLNna3NwMpkg1SaRFtY/xeC0xbOArWrjI6tsJAFf00SbJto00aaJNk20U5ZINBZsE+QVquMzNDAgCQeuO0N6wdEG26fWavWuqAnVcMK1PqAQGwApkMfuYuVY1iTyC8EO6eKiKL0ba6XWIth39A11t9fv6Oxic54TpbeLtH2xS8Q+Fcv8MA5et6cBrYsHxrjN3o7UGDPAlPdLuywnbbeh2nrSxsZvu87UXutM7aJ",
"part_8": "ZGIgINecJR6gJ2XOEDJBni1HKdRcAV9D6rfNtSDmgCB/IGHJc8MNbH+1zrPi8VSHAd/vMNeJi3q82tWtaQHr4BF3RmwpadJvy/SRXWXKWfN2199PcNY1H6NrWdBTXbs6AvkqKX7Xr3f526hKXk8fhsBv942PgH7TqOA+3ZXwlt7+X/+h8qBrQBhI1iIfVqTtbNE/fmotDc3FoLg7NxeF/8PSN/rsP3ypP+y6yPfIr",
"part_9": "D2HtZzVGWZ04DJx9dCPCW6vCW9MqL1cmBaZ8t9rx1I11Dp7HdChGStLqcFmIhKyRwGzx6aZ+lK8f6rkZ8aGeVW2f5HkRx4BT/3TH+RsElarXS1076FaGnos0lcnY77R2U1Xiznae6/dcA7bFdw+Kv9l3wyA6WXncOj3o8Jt/1d/28/pbF791ISqEuURWXFVG2hUQr3f9pZhAWq/uMqCq1r3roXcfbBMVvbJGuHaW3",
"part_10": "s1S1r9NpvplZo+2Hbr2atmr4wDLQbbaHWavb+s3l70+HrzA7EX6ANZPIe4fY88hx/YKOIrVf4r5ibhXLW+39/Ubi3c/DLxYWuH1vuz5HwM+tsV8gh7xlQgrLzvdV+3Ot3hTp9Nzb5BFIpmOuFU9z2OZ9a8z+AFSF6/mG47motJcVJqLSnNROfANhxVTgzOLd2VxOMf4yhUlb3iPY40Z5YlC1nk9m+Xy/h8Qu7/GgiYAAA=="
}
|
{
"ground_truth": {
"compressed": "H4sIAET8N2gC/5WTUQuCMBDHv8pxTxtE1KvgQ9A36LGLGDpTslnzBkX03dMUy9Ca4z8G2/6/2267Ox5s4Uy8Z+s4xQDvhIkzEWeFUTlhAISxTiBKdXQUkTJxFivWMiAyUDVVltoydAui1BcIgYiw7hLCELa7/5uFFPJtWMyglY+19vbNyw95Ib5i+0UdiulrHbO/NAnVSsqxHCz62G7SOzdjbzPphcSf83lfeAg0HSF+QKb8m4Y1kJ1e7mtUo6aONkXu6goTcn5S17U+c7pKWNvNOc9YEj5whiXfcl0VpHXV8HgCQhnSI6gDAAA="
}
}
|
codegen__leetcode2k___369
|
[
{
"content": "You are an expert Python programmer. You will be given a question (problem specification) and will generate a correct Python program that matches the specification and passes all tests.\n\n### Question:\nOn a 0-indexed 8 x 8 chessboard, there can be multiple black queens and one white king.\nYou are given a 2D integer array queens where queens[i] = [xQueeni, yQueeni] represents the position of the ith black queen on the chessboard. You are also given an integer array king of length 2 where king = [xKing, yKing] represents the position of the white king.\nReturn the coordinates of the black queens that can directly attack the king. You may return the answer in any order.\n \nExample 1:\n\n\nInput: queens = [[0,1],[1,0],[4,0],[0,4],[3,3],[2,4]], king = [0,0]\nOutput: [[0,1],[1,0],[3,3]]\nExplanation: The diagram above shows the three queens that can directly attack the king and the three queens that cannot attack the king (i.e., marked with red dashes).\n\nExample 2:\n\n\nInput: queens = [[0,0],[1,1],[2,2],[3,4],[3,5],[4,4],[4,5]], king = [3,3]\nOutput: [[2,2],[3,4],[4,4]]\nExplanation: The diagram above shows the three queens that can directly attack the king and the three queens that cannot attack the king (i.e., marked with red dashes).\n\n \nConstraints:\n\n1 <= queens.length < 64\nqueens[i].length == king.length == 2\n0 <= xQueeni, yQueeni, xKing, yKing < 8\nAll the given positions are unique.\n\n\n\n### Format:\nYou will use the following starter code to write the solution to the problem and enclose your code within delimiters.\n```python\nclass Solution:\n def queensAttacktheKing(self, queens: List[List[int]], king: List[int]) -> List[List[int]]:\n```",
"role": "user"
}
] |
codegen__leetcode2k
|
codegen
| true
| 0.375
| 0.6875
|
{
"part_1": "H4sIAET8N2gC/+1b647buBV+FcL5sXarGejuWSNTIEhaoNhdbLfbP8XYmMgWPWZHlrSSnBkjyLv0WfpkPeeQlGj5IjlroN3Wg0QjUeS5fOdKRvk8iKMqKnk1mAy+57x6n8X8gxqxBrFYLsVik1RbeP0Dj8VmDaMijfnrYPLt3Z01yArxJNIoecyLbJ0jlb9nGxYVnEUp4685Lyr2l221ylIGM56KaL3mxS3DSS8iSdicsyfxiacsYr9seFkJmDiEmfOEr1mZ84UAASIcHgHFWC564ikvogp4sEVWFHzR5sGqVVSxdVQtVryEB75LiijlUVnCywjoVcC4vJ2m0",
"part_2": "/TNmzfsJyXHZJr+iHLZN6Qwj9kde4W/SLOcZ1ERW0gaVF2ArqDIGoASecLZPIkWz6gPT0vilaWcvawESPws0ifgpEHSursfmEgr/sQLGC6irV78QvTlw4OYsXv28PoTPgmLbeXNjBU8L3jJ00qqmmelIC2zJT2LamVKBMLQcKOGNAfZLCkzLVPakgglR5IJT5+Aoqtko2EU6zu4AaHwV6dIO1j8lVebQsmUZUUM7gQG0VN3sCSzItqxQKsnWxZVFb7HmUSOVFmDuEVDNUrLF1BDoFJbBhzAA6fpv/45Tf/4Gq3RYM4EjT9N/5zmm2qiuYFWD7blzKwHx7Lh6t",
"part_3": "PVtny4epYHVxfuZ1aNgQ0TwGk2FVHZXYwLZsgxT6KUvHDC/gbCxSIij43m2Sdw01X2IiGrVgXnvfUmLzu6LM2qvQVDcctvLYCqeOYYVmDSAm7iqAS/GFEwaHTcE+jYpKBDWLikpkQnILx8ugYmRoiDiZG5DBf8xjBCL3qfpWVVRBAuJSHlsLf3ivytipa3LPSnaR3Hevj+Xnpt8+hOUxuXt6PcYmaAAb27afoOU9dKJxEdYyVF8iYVwO1WGk7mtT9lBWTEiUw+lEc3JScCyyxJshekW1ZRUUGsLKAMsCpjLwUGKiXQLNlQCMMohbTK0QgqTxdJBrS22UYtRaw",
"part_4": "g3mKeiDVQKDC7fvz4MacsPYXpkHzZz4okiMTgJ+ZLhdo7sgNwQV2HJU+WlnozYd+LsnqgC+CtHUsN48iI3fyhPWlCzKFyQVJaCihdA7HOM6hMC1AcfAVRm6ZqDEwJFOtHgGxVP0Ct5JVYc4R0CQWPVdscYVOvf6dGl5t0UWVZUrZfGPzarxClg2tWPMp/aQ/ORYlVrzUqRW+PZjkWy6xoj6NmxhgomS4hQpdJFlXDb+DhmxGOAmy6Mj9Woko4wHeti9e6eK2L17r4m66LkNigHECspgvMaWfVJPkWf86rTnLdkRqlSabgD3cGB3j8PARN/zGCSg3xCncYtJLn",
"part_5": "l2ZiJL1v1ozg9AjnFlH6xIc3jsXckcFJz5l3zMEfsQRSOPfAO/x5BRswabfDEyC5QdBIK7LfA7G3TO7EaGgLQ3McOkLeYEGrLbni+GSQd4gLRqhbeYKqgu42ynOexsMHXDQbnZ4/L3j03ExRSTXCNgLcqswTgVthcn54hu3086OIYUTa7AaD6waC60ZGFjzzGwQO5i4yzC3oglefvPrk5XwSeo5i+5hnYFhwLO1Sw9HtAVdCl4WOD+ahr0FDtHgegrfGAvtfbQc8PimoRMjx4a/pDkaY4w82Bt2svqrUKoYHqqzsd4vt9Sjr2rJfW/Zry35t2f9rj7LY/+lJl",
"part_6": "obhHWWDCRtq9UGVTyIGuy4JIGnnOUogFs/lSO15yhygxS3PgSMsZDX9j+il+5Y3DJzwExZb1CiBKZg/tYtnUGFKXlGH+OPQGbEky543edmslzMfcdI9Th2uo3xYbSD6tYgjo5Ey+X6gaJOHcykm9sVK1nJwSYzGVkw1S+NmIaQFaldvnJHF6M7WNzByrIEb2mqFOXBqfs1BMyD6s0N6SalB3scm280OA/AeOz3GI9C7VgkhLyHHiKXqEERZg1LnqaPIoJliaF7jLULa4NRqfY/26Tv9OWQKszeHxwMdNDTi98By/8WWXmwPbiKaprzxniPdeRvOXi16qzXfb9",
"part_7": "JbRClQBdaox4zKy2Dy8FkO1JvIr6vpQFdTHByo6oMv1hE+X1Udd7nt1cfj3FzipnVo+IRwDawxXEOSaKxmarl2+Pt7/BnQwjcsOMVcYuISSc+QOCDmITEfE3MJSrgPtb/H3FPM/Q7mY4NkYDD3iLlLzB3F/CTaBsOThvWJYUAMQ2I4rp0pIFYhsR2rmd4+1AEs34PaReYOaishH+PvANLUKWFCYjEmFtIpHRLGJWE8EsYnYUJD7B3ox7B8VxhHMR9bLDzFPCCSvmF3l5g7xNw27B52OTpALrV2z4spr46mgMQJSU9Uqcu5PAVvD8+29zSUnu3vaHgEXv9oWPn",
"part_8": "K1gE+X97DD2Wv2q72KYae4beeAbNnOJVHDL1+MPsN3N6lNLV6OaDdCsImQuxOl6SA3HFN+btXlrCVG1pKrfGeFwWHi4B/JDa08bQgZETtPT3y5Dmxo3EOFJ5eP6z8xtwnHNozEpVniGIWSK/OrL38y+tVqMYqJe1qphm7yptCZbIuowR9vcC0vwS3gf4kE8PinmlxvyNfeEZUNGD6xDowMBirmbJwO7tQB/s1QceDLlChEmZ8uZD2ulytX/j193NbiWP39nD/FFtbQdmkIs+oFEFdKfYc7ICe7tc7WDfgJ5nbytF2wJYOOL5k+t6tmY2pXKOT6jaM3xK1F267",
"part_9": "nm/VScmMlNAwmt+JmE5Edh0dF0vGfl01ejmpd1Y61j7k0NWlq1dHhqyx9iGntQ+h4KpS5Xc3rWfY/Xjmd027d+6PHKNP7tU5onX28qCjdNT50K6T9K+oBFoM1xA17NE390hL59W9fcfs63Q9EnPXJiUw8sK4M+RCxdgxIz+4SGW4AOx998VdLbtzma13k80CIy17Rg50egSd30osvTYw5yQYvd8yN7WuihW7tds2WxrzkCNsxVmvYmc3fXbYSuXUhYXquasInpfaXRWVvtq3XNDvHKO4Oca2yDHqsLOD5UnjO02cOXXjJ/FwLtcUhOrEKjjUIHvd/uhfpim0D",
"part_10": "4TVudtFv3/t3e/fnBq1sC4FWnhXRbFbC39kQ/G1/nOeC/fG5hxMdPiHrTNTXS5c5b59+9igLg0Xy9s9jhR3vKHzIC1spTrfqNj6wGX3xMNgjhbZC9hQJS7dvV/wgMC+TJHUWybb0No29ql2n3Mt5+R5lj7Q2E0szZF/02/Z524DZ9ZgzatoMPl85H9+4dck66ji8SN+hgNvXNv59saxbxyP2faE/sC0JEqfHvFfT8/9hO0C/5Bofq6On9w5rutev2C/fg5z/Rzm+jnM/+AX7FX0VA4mD4N3GMnw/ENUFeIVbn4WkLQI6cHsizUQ5aNcOJhUxYZ/+TfRWsha+DsAAA=="
}
|
{
"ground_truth": {
"compressed": "H4sIAET8N2gC/42QzQqDMBCEXyXsSSGU+NOL4KHnHns0UkJMVZRIdXMo4rt3E0uRnhrCJJCZ+ciu0M6Ts80dZ4cdFLBKeDirsZ+sGiUUTEJjHkx3Rg+RVrbpG4UmLqS0jJZaFjMj+z5ET2eMXVjJqkrwpOZVwgVpHlTwnDTjGWlK95qzobetdwsyxKz8zXlv/RdLhEwSmtOQ3FnnQM+Dno9EX/0hHhPe64n73v99m0bnJxLFp515QVR6wM5cqSyWsAGHBV+joQnOjo7tDSvvGy1ZAQAA"
}
}
|
codegen__leetcode2k___403
|
[
{
"content": "You are an expert Python programmer. You will be given a question (problem specification) and will generate a correct Python program that matches the specification and passes all tests.\n\n### Question:\nGiven a rectangle of size n x m, return the minimum number of integer-sided squares that tile the rectangle.\n \nExample 1:\n\n\nInput: n = 2, m = 3\nOutput: 3\nExplanation: 3 squares are necessary to cover the rectangle.\n2 (squares of 1x1)\n1 (square of 2x2)\nExample 2:\n\n\nInput: n = 5, m = 8\nOutput: 5\n\nExample 3:\n\n\nInput: n = 11, m = 13\nOutput: 6\n\n \nConstraints:\n\n1 <= n, m <= 13\n\n\n\n### Format:\nYou will use the following starter code to write the solution to the problem and enclose your code within delimiters.\n```python\nclass Solution:\n def tilingRectangle(self, n: int, m: int) -> int:\n```",
"role": "user"
}
] |
codegen__leetcode2k
|
codegen
| true
| 0
| 0.5
|
{
"part_1": "H4sIAET8N2gC/+1Z/W7bNhB/FUIFVruxA8tO0sRIAmzdug0YsM9/hthzFZmyGUuUSlK1vS7vsmfZk+13lGTLkuwWRTesg92gjo6/++Td8cS8daae8TQ3ztD5jnPzIp7yL3NKx5mKIBB+Gpo1lr/x1BQ0Iad85QzdXq/fcWIlZkJ64SRRcZSQkF/jlHmKM08yvkq4MuyHtZnHkgExU14UcXXK",
"part_2": "CLQUYcjuOZuJN1wyj71OuTYCwBaQ9yGPmE64L6DfI3IbEqcZ04xLrjwDHcyPleJ+VQczc8+wyDP+nGs88F1RVlLiaY1FD/IMFOvTkRzJJ0+esB9zO4Yj+XVuGqnw5CzkLA6YFr9zJtmKRR0smFRJqyESUkRpxGQa3XNFQCENn3HV1WLKp0y/ThEWnZlmBGQR10Yy1P/150h+tfKiBGvukMwZ",
"part_3": "yW9lkpoh1N2wfodF+BqM5PepsdQB4ZPQk9YrPG+U0AZI7nOtPbVmJkac3sCoqsY+axUcsNddue2RdAsakfqrfntrVL9u1Hlm1OXWqHNCFByDOofrZixuyZELwpD7L2KpjfIQOW05XXZ9wyQxXGcc2T/appexwgYDtcmlVGcxDeIwjJdCzpg2njLw20dSUxSWSpgMo+MwtakAKj0XKUeZwaUf",
"part_4": "xpC1jtOcdSnMXEg25aGIIEFRsrx69SqxSTcCHLnEfs5FwiSGz5QHtM0w46ci4i3Nw6DDsFNwEE7Z7zbr3tL30IpEfSWKBwIF5ogoiVE+PtyBBEjWI5nTECQI3jwiEPPNA+qZGxFxClSAqmRmnVAw8uVnOTVIpW/iONTVhZK+6hL53sgz517yukq8F5pKs0LNTK9S44QqOlZVOnlWosFJGSB5",
"part_5": "gjD2TOspHp62iYqwFe1jYoQJOcJ3LN7/XvFin5DdXKHEaIs+VuGw/EOs00C3RA58yL9NxlBC0kfGMox9L0TR690VEbAHdnMDRbt0u8ZO4E2dDgbWq4kRJEY2iIFOMJj6QpaVNUEBOhyf3okxu72Frs9sklV5re9wm50wbJRp7yLQvRBZWmPXpL9BgIJNft0R+gQozgXCyBS2hJMa2W6QsGvu",
"part_6": "4qC5xedecW/RvKz2RLtizQOS4t3WZMFbfLg1/h5rohVipkiTQmh9RBrHh99s9XJrNRXTivZjn+kVL5ftA2YXPkLeknWZO2Z/3NBOX7MW5cOi/V6siwqbFbWHtZRty06WWO1mn1c7eUN6otUhn9c7O/twEF9yYDVmv+XGr0elEspqTbJnLNoSMx7Q73pjrJTg5Fevw+in5E9+WthegTamk1DQ",
"part_7": "uGsbHp4xMS8mYkoU27u6XnfTrLs0P3TRv7sBX+KU6uZ9G2x+TK2Wut+xHR7b4bEdHtvhp9kOuTRqPUli9BU0sqKFtdqnldZFnRIdEBhqTng99xctHy9dgt5aCp/ozZxefAp6qzxBt6mFDA4Ai6nWAs8PALfDrIVeFK8Ran28xji+Cf271xjsf3WLUTj3udRLroasVTgFA9/YNAqs29Ykdu/5",
"part_8": "CyP8hW7nL4g6Qfz+qfdDq03hv9aci9ncaOCRVXrvOISKmFhEbQhB0bXmdqKxbXpObToX2tSeN4KQNvi9tXkuLHi/6admRibz9marYPghkpCLAnljtynWwuYVaoeekYhoJsy2910mUpm5nDtV+L8LC3lAgHzx1F4ht7a8FbTK5RHX7spyTh0nW79mWaLnQu8sdWzn1I3gpkBY5vrgUg3GL+g4",
"part_9": "aEq+rcBtd6Ebcbq/MLaBVnKCssD21c15nWnrWlfsGdptnG6KZMpdseE6YRjQTjJ510WOia1oWmjvGwMkX+Yh0Nu43w3H+4eMquQD80VJeNnUG2trM9u26krMed5XJqXtb+WC2b3xq4vNxpaocUgpVbD9+wWa9SS2PdsZ3r3NCOg25dMJuALhDJzHzi6qOC7KqPMaantElHEXddwgx52XcZd1",
"part_10": "XL8JV9f7PIedlWH9Guwyg12VUc9rqKtcWL8MO9tv28Vh3FWTC2d7Xegdjtxlk3H17bpokrZfqfuO7eo1+TDYH5Id61zncdxxIm48Z/i28e9rNLbhbOTTCU2qtHU996rr9rr956zXG9ofwDAvzSZ0rn+0c7J8iU43GW7/rHe8V/9U7tWNN9NoZ84XRUvExjvjR/Q7PUmlwDY6Q6NS/vg3z22ZwPIdAAA="
}
|
{
"ground_truth": {
"compressed": "H4sIAET8N2gC/32PQQuDMAyF/0rIyYIM3HAMwT8xr4VR2qhlXYSaHob439etsKPhkXfIx+Nlwykuid1DYpIZO9w0jomt+IVN0NiBRkcj2Jnss7KGnXdGSHVaM+Qx60pR4H+oGHo41/DKdlHQ531EtoW8/cj2iGyagjYl9ZrZotJsWEL6dq7USXzwPN3JiuEpkNK4Y42rvAPl/2LKtn8ABfZcYvcAAAA="
}
}
|
codegen__leetcode2k___413
|
[
{
"content": "You are an expert Python programmer. You will be given a question (problem specification) and will generate a correct Python program that matches the specification and passes all tests.\n\n### Question:\nGiven a list of words, list of single letters (might be repeating) and score of every character.\nReturn the maximum score of any valid set of words formed by using the given letters (words[i] cannot be used two or more times).\nIt is not necessary to use all characters in letters and each letter can only be used once. Score of letters 'a', 'b', 'c', ... ,'z' is given by score[0], score[1], ... , score[25] respectively.\n \nExample 1:\n\nInput: words = [\"dog\",\"cat\",\"dad\",\"good\"], letters = [\"a\",\"a\",\"c\",\"d\",\"d\",\"d\",\"g\",\"o\",\"o\"], score = [1,0,9,5,0,0,3,0,0,0,0,0,0,0,2,0,0,0,0,0,0,0,0,0,0,0]\nOutput: 23\nExplanation:\nScore a=1, c=9, d=5, g=3, o=2\nGiven letters, we can form the words \"dad\" (5+1+5) and \"good\" (3+2+2+5) with a score of 23.\nWords \"dad\" and \"dog\" only get a score of 21.\nExample 2:\n\nInput: words = [\"xxxz\",\"ax\",\"bx\",\"cx\"], letters = [\"z\",\"a\",\"b\",\"c\",\"x\",\"x\",\"x\"], score = [4,4,4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,0,10]\nOutput: 27\nExplanation:\nScore a=4, b=4, c=4, x=5, z=10\nGiven letters, we can form the words \"ax\" (4+5), \"bx\" (4+5) and \"cx\" (4+5) with a score of 27.\nWord \"xxxz\" only get a score of 25.\nExample 3:\n\nInput: words = [\"leetcode\"], letters = [\"l\",\"e\",\"t\",\"c\",\"o\",\"d\"], score = [0,0,1,1,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0]\nOutput: 0\nExplanation:\nLetter \"e\" can only be used once.\n \nConstraints:\n\n1 <= words.length <= 14\n1 <= words[i].length <= 15\n1 <= letters.length <= 100\nletters[i].length == 1\nscore.length == 26\n0 <= score[i] <= 10\nwords[i], letters[i] contains only lower case English letters.\n\n\n\n### Format:\nYou will use the following starter code to write the solution to the problem and enclose your code within delimiters.\n```python\nclass Solution:\n def maxScoreWords(self, words: List[str], letters: List[str], score: List[int]) -> int:\n```",
"role": "user"
}
] |
codegen__leetcode2k
|
codegen
| true
| 0.5
| 0.5
|
{
"part_1": "H4sIAET8N2gC/+09i27rNpa/IrjAxJ6rBLYT594ETYGZzhPoYLrbBRaLJEhpibaZSKRCUY6dov9yv+V+2R4+ZNOiqavYStJiHAe0RFEkz4PnScm/dGIkUI5F57LzA8biexbjv5iasBOTyYRERSKWcPkfiMdQR2iMF53LQX9wFnYYJ1NCUXKXcZZmspP/Y0WAOA4QDfAiw1wEPy7FjNEAWkw5SlPMTwLZ6IkkSTDGwZTMMQ1Q8FjgXBBo2IWW4wSnQZ7hiMD4SFb3oMdY3zTFFHMkYIwgYpzjqDpGIGZIBCkS0QzncII3u1I9ZSjP4SKC/gQMnJ/c0Bv6zTffBP9l5nF5Q/9uppaQXARsEjwxHudhefrlc5ATOk3wl88JFgLzPOimZDoTEiqOMwyD0Wnvy2c5XA4zhYbQCZ5jvgyiGeIogptg3P/GouBUzTNFC5IWqW4uh0R0GcxRQqAHvJ5DMGE8xXEwXgaFnIO6VyNyNRXV8JrcBhGilKlJFTncI54YzIMHqRxBkBTnPZjDP0VA8kC2ozjCeY5gjoLJOxSKVtPNA7IeQwKGUTQzFXKkgNFkuRqL0QifBD+VwJj7vnw+Qkd",
"part_2": "hcDSWRQTFyclJEB49H8kpaCjGyy+fFQ6u+7ehxsb14Na0NOfD0S2gWVJWwD3JEqD48vmG/nWB0izBweBSUvSfNCvEpcHaVXB904nZ9KYT3nSAF9R3jGL1PWUMDmCMEjrVGqlruox0e6fU/bGyLCcsOxiE/fAiHEHZD09Vuf4MK+fmc3tD/10INevhqQQnSxBFhiM1KgN0NQiD6OoiDOKrURhMr07DgF0NS441EITBE1Y0kdyiWESjwcAcdEcfBh9GemGV8Afd0w9D+ED1ExEzYP4VKw5PAcP/u9GDvlNhVBN+Ckxq3zI4WRNk6CHIYrF41lheqK+x/ooWLjWeLWqMLZosNkubAmeh/PQbfiSlBhsk+OglwVkYjGURyWIh6fB8Neg3poGENuieAabDQAOtzwxSo3WFQ4iPhhBBibztyB9ZyD/1ID8BmR+BzHdxnShsYlUKC9es5HwbyxJ3A/WxsTmwys2jTT7vV3H8g5YnaniPVNGL/XtGc8ERoSJXAA6Cb680eCcJplPAG5wPzuwLIBLtayNzzcBuX+rDvEy1ddMVXLmhCvJ11ZfPw/Mb2pe3aeEEcld1cUPLQVfoheMvny",
"part_3": "NGBUw715Al7EmJT5C2fwWNQvLZaj4SqlI1/Q14CAkAdKU/pXyWTDVhCfQhNUEuEFeyGIgqJfgTJ0K3yVlSKPUHtfK8VLNKitMoYdDXkhXmVsl0IOpjnJCUmJn8/PPPmVK0N9Ac9Gfwk+kSphTAX4wnUoOpFaIERTfHySTUeL8MfgC9eQ3kWqNio04hztQAQW97wfF3oG0kvDAwWB4ZxxMCpkeHpBkDwyICoKXwBx64oaYOugIsrE4BXbPVCVg6WCo8ic4J2CuBWGYSZebyH03tpKCRYCzJqxes8aqXJIa23jPDKHusVo5JLo2WSq2eerWWZdLWAX1dqZeQWXUAJJ3ASpwkDInuEZwc9WQtoK00rO4EEQkG9B3MmoNZczBrDmbNwaw5mDXvadaAbgKNjjkYH1ItNTQpdL3828e40L1YJkbZaUQFUP57VlDoo2u66q2v00AilWo9ZNUjKhmsv66YSJ0t1QpHdIq7QI1vA9qzRlKjgbm1Hu3o6OSeEdq91si9v1Wd3K87ob2ATKDX776D2j8Eg9teb7M/uAp6rTuXVAJIriPdRRQGc9kLDHcCpkqad3vVmcg/CXlepHD7Hw29Y",
"part_4": "R7dCLAUyANQbz1/f253GiVAvS4chYGwmnBtGyBpuQEb5FlCZPBI8TycC5Q/3JEYaozlcKymc6zwcqythOPx8tiQB+6ImJQHknEOnPSfzEmYCr68ywB2yU8lC3R7JxuklywGRjG0kFwRzXD00AV5HBPpIpTwyACh9DLK+u7vydrqSYEuDa2vQfIbNFP03D9+fe7vqOXVHPulf8WXh8j3wUU8uIgHF/HgIh5cxIOL+FqR7+A/MPBdouBPNAdUXQbdEnQAY05i4IqJQo5eLGMUPQgSPUiHQvnXeQaMIt1rXwjbuAxbQ+JySjdvDnRp2ssBZGd3qq1S6+a+uxRlVbfDOALS61i1uZba2zgacCQ1uOzFch82R4MFdyexacbS876LJIaqw6mJqSuW21XpvHTe5NggLVVjMwV9a+nybPGgyGRjeAPJt7qXLe0tFPwNJTneipz/4QX2wV5k0ry+swft2ieasGGA4vhK9lOddBXJ22GCuz2T3wLtByVwqg0xQNe8j+ONPjZBVosFrLuHrtrUEkovlIMHqRmunv7Se5Y3Sam49uK3zMugfqPrzVabZ7Ck7krtUnNTJShgAFjPxMNTGxxu",
"part_5": "C+ftUJZ/zZhD9ycZRLFgb3tfNoDSpV+dhzZBgg/BoEIQqKqIAz3gWiRUgOm1A4zi9jqSGRKvANnGb6tJAtS/RDOuICxjIb3LtfKsEHZ43vt13Ys9zdrgkhMgWaO2Hwb9CqKUriDSRLpjyjLpXF7/oitAc/yeXAiAo4SgMzzt/BpuBeM3aHhvTPyjb+LvaLTaE+z75jfDYI6pEaEy2cISsTXNmSoTT8mskusuLZQvVflcZZhT+Axh4mdQnsH3J0CvrD1T5aCEeqgo9ElWb8A18CK+jOHIzQVyZGMOysN7NDcsnoPGyZosg6kFP9GdqDJVJXVKGxeZU3KrzC0GWL4ZdnT03SyiGUqkd6BpbGxtPS0wxOcKgdsxZC+vyBEauLZ0MepyVOrBsQ+7jx7s5g6mdVmocv5GvHr6yUcNQimbK4dSo4/kvMhWpwJHM8oSNtXTmhSgHsAIJ1E94yJHDrqlj3S+EjcoJxZ5feXMKckLS738HpwyacBKae3S9TFafZk1YMZ6xnTZU3gYtngb5t3UIB+93AtGCs21S7viYDzHCctSsAQ1joCbU/K8boAKwcr2TZl4t7I5u+O9y4lHsjUvm8v",
"part_6": "Aejat1zb5C9nLZrL92GvgY6+R10KJ+DITTPsVkR59nLDoAdQWKbktkllElNgcBoq/RnM1F46vIQRne4i51xZqtvB6bCy8moutNxNYZxc+jnosEBWFQRgoV0RJpMHIZsu8PBYzzPjSZaBHCxhkodUG1SYGtphp5txFrKu5RYCZhZrc01JYLbFjfC9b1wBe76ygZA74IULPVxqXhYxQqqlGRG4X0ghBgFQp9iWK6xbmuIExWb+UdhOeWS3DvyMzD/0OnLQMOQLO1TAhyioGo83umjRbBePMwoPt0E0tPCAPh1KHr5mFMXcF0NqxlpbwabLObL85tWZYWO2J1cO0bepceP0slIGbpVkaAWmMSznDnC9NOEbg/ZcCdpaCy+Aua4vWdXgTgas5cK2nHZGLQTygZDfFHbWkpmd7qObming3c+6xgav721LEXtmVFVmmB30gwiiPcUGpPprqq1U+GFt0Ihb2qccPqzdwl3vpSu9SGJ77YJZGbAS+EY4JMt6+Su8hIxFgDeSo4IUmZIIXJNrmJGEL5siCJHJkambxe2xhDTk1kSMvmSN3bWsjt/opLE4srKt2lHPhjLXqv12OG316PX",
"part_7": "m8T+TLXuR8kznbZb/BWeN472ZodHuo2gebLx5cb1iJTW+y1Ribf91lBCwjI1eIQHoqc8KS0onkRbrFKs2cFUMde6Ww2girJbfkLHEsHltRx87qScs1ZKPnNLxYwX9uUDQCLCjUlDkAnXq50AmXDeScewUxXgi5SxFcbPlMG9ITNFa9sbZRghaleZ+n24KP9iIXjtFom4K22sKO2uIOyhMLMbbbNHf6zB0Hwe4BOcrOFkO5hfiVkGpXMJ17DcUn8oy4ZgOUgEBK9fzSpQ70hkpxgKcqdEytivsna9bPDgvGDiYiR5inFlZSx/kUjuh2FdDMY6qnTnvRumvqXfYPiE4RZ5rCDwy4WMujBIllVmxZ8A8OFFMHn7Zke7CObfcocXh/6bgmleWtYR6Z5Vx+KvLekvnh6aadNfBqvTFHEYrll+GwhAnOjO31vJwyYZI/mGeYxvINIlJC7h6ZrTfKp7Wh+sRjwvicc5+xu3zNeOWpdyXnBWARPBgy4WhKEpWpwQtQPwmJWUSYsewoLjhTofOUiDJYks2YYPmSSiOQ5FurXjda3lakvUmqqUnCaf90FN7DGdwnQfXSWG7yCumrdhNaz",
"part_8": "ZNbbaW7mmQo6nMWbv7iydkMstwmLV5DZnzqN92sUEnJV7cufH2/Aq4Nadw7nOWLF9XL3NZDzP4NC54gppwi4hJZIGjTMnsONuy4EDhuV1rWy7R2ZdQ+mcT7xunwl0qJfZLcL13RbYen/Jr8fKdgQdOYrS9O62LdXWvtr6+zFsJSrxWK4ta9rxqWapd/zs4ap8VATBmRTiiYhaLYFmxq7uYSx9iNnChD4qgD7EQfXBdPOPkT3Dra/N5KMmWciFlaRuQ0KUGqF5EoOM7LSNVX8/uRs221yX6zJmlBnyVTvGJsa+DNr6RoSuUjo6tEK15EWBoQUcltEYeFPQZvxPBiQcegMfEcjZNG+acmNvw+Om63vTFNNBprnMy19U7rCYHR0Mvu6ZiIlVsYYyAD2IE4Lh3yXD6Fi1YpdCbIvHbjVGoRjHhEpx2hjx3pkjoSwg3hxY5AdwNwrtxCjqqwg0/Mme3cGZ20kDfwE+n0NfIG453yA764edGyVBnVxjEoAolr4sHS0KZym59R6ZF8z6wJTZJpusUvyS1mc1nFZa3CYZXEuhd5GIk5rIscy8OWVoV1VTjYJ5ZUWvXWcnrq4i3TU3Fj",
"part_9": "M7QN09OfEfXn5LiQyqtMOxAqQHeRqbVrKJqBQDT5UMSb7uvb39fbTbtNWo0g3TeOF710m1NbHpxoHJN5C29uuKtZqanPOVo2Z6648QMNqccY4bWPJhStr8K+P0cQxXgynZH7hySlLHvkuSjmT4vl8272oS8GMnlhrPX+hftgm/N88y009Tui6yOKz21tqtkMJQ79qdxibNmLjwV5fi5DZfdsLtMQxgfIOMnVZsx99lrts41+0uDpkOYi8v6Fz4Xsv226Pjj+2OpTIE2C3S9ix9cQvoO+V7yMSXVbqnw1kih3/qUswSbpGKrGutn2vV+kpR2mU8f4w55kd+7I8MQZt3DSvtzxxGrm0/JGg0+7pRrKN29s5B2274nhtXuEU48nOfVsGHCjVdShUe7gsKgNDWYWre0w4SvtOjv3mvUzlD+ATfvi51BtBOWWMMOOb1QD5EooIseltpl75jBuVn1Ier0jQR6P1B6jc/jWexb64UeFnU9qU9JFZXPCqGZzAorQghhTn06N1ilr63xqGwrkbDFMa3dyNOynyiJmb0YfgNR7ri58T7a7T7f7dTadE87o6nG5vMjlG3eQFbCbcoyNl4Z",
"part_10": "lpP6rPtB4D/U8aZA9fJstz7s9gfQu25xPvXkA5+nHDHP1vGRppOURSmxiR4yun3drSuTdwrJNEo33LzS7X0rw7IUEf3dS18QyjPAyX1H5Ha8O8EtDF7ttq9nzae52H3z3yv4JogLl5VZHMVtbhyiegzQs3XK5DRJvy7pOPHsObZ3p7ml09aTPRLTd/Pm2fYyVqCWu3T+JXzO36zc/cjYRT8igsvpoNph+hGLMaxTKbkrEJ1OSveUIa7xN5W0TdP7tPTU2n6nLI04y0W6opfnTkve1fvT+j6OzBp7ybt6xT/6/R1DGn9LWrxfeyFuHTkRSL0zMm+e0X/pWlX32es3fVa2+UopgvLfN1Dxidd84GkX3Xl0vfRHOu79dRGZeb8NOigXqXP6y9Wcs5auuUyRwfCezYCqWPbg4HgyOB/2g379U/9AsARfyTj7G1PxnBVp5C6b9u03yhxAGw9Ho8FNOh/d0H97TfXhP9+E93Yf3dP/2fspJoGneubzu/JmI4F+IkqxIFLLg0p9kGhy+f1K/cAgHf1lSlJIo+HGdPYDaP5evKDWnRKQof+jc/hp2SH5XUALqr3MpeIF//X/WMB+rt3oAAA=="
}
|
{
"ground_truth": {
"compressed": "H4sIAET8N2gC/42T0WrDIBSGX0W8SkBG0m6MBfIUvdjFLMPqaVrmIpgTalv67tN002RkI/nD8Rej53xqrrSxpm/VO9oeD7SiV073fSvxaFqhOa0Ipwr2RB5AfmRStOqoBEJecd4S/4iuA4skDmQnY1VHavLGuZ9pmtCwEKTA6JVQ0TfGDJ0tIxoQwcbZIn6TnExr/OtSXjN1Pk0njYWQpGQFe2FPPhZsPcSk1a/+t7Y5qWuyWi/Cd85dEoOLdpesdPPslxn23cwuuL/cmPORBRULFfaj/AF9XgSqAVAaBfMsOlYG0eEMi5me45gg1FUOGldajuLUxZMqfP33936DN0b34W5n+cOncJuw/msgyTm9UUY7PGvwf4HtfXP7AhoPxyEdAwAA"
}
}
|
codegen__leetcode2k___417
|
[
{
"content": "You are an expert Python programmer. You will be given a question (problem specification) and will generate a correct Python program that matches the specification and passes all tests.\n\n### Question:\nGiven an integer n, return any array containing n unique integers such that they add up to 0.\n \nExample 1:\n\nInput: n = 5\nOutput: [-7,-1,1,3,4]\nExplanation: These arrays also are accepted [-5,-1,1,2,3] , [-3,-1,2,-2,4].\n\nExample 2:\n\nInput: n = 3\nOutput: [-1,0,1]\n\nExample 3:\n\nInput: n = 1\nOutput: [0]\n\n \nConstraints:\n\n1 <= n <= 1000\n\n\n\n### Format:\nYou will use the following starter code to write the solution to the problem and enclose your code within delimiters.\n```python\nclass Solution:\n def sumZero(self, n: int) -> List[int]:\n \n```",
"role": "user"
}
] |
codegen__leetcode2k
|
codegen
| true
| 0.0625
| 0.375
|
{
"part_1": "H4sIAET8N2gC/+1Y7W7bNhR9FU7BVnuTUn3Y62osBYq2Gwp02IbtzxYbLiNRNhGZUkmqqVf0XfYse7KdI9mp4yTGhhXbsMWIjsDLy3M/yEtSeRsU0kunfDAJXijln9SFerqRhEGhy1LnbeXX6H4m3RoybQr1Jpgk8TgNg9rqhTaymje2XjUk+al",
"part_2": "uhbRKSCPUm0ZZL75b+2VtBDQWVq5Wyh4LKl3oqhJnSiz0a2WEFK9a5byG4gCaZ5VaCdeoXMO+pHgIxqIftFBGWelhQ+S1tSrftyH8Unqxkj5fKoeGukrVMTXSOXRK8HkYdsdTMzVHR0fi+40fk6n5unfNCG28WigrTCis8q2lcI0wrVzDBeOlNt",
"part_3": "oshBGt0Yhjq++Ea/Nl7w28wIiiEG0jfC1i2Pvt16l59kaumkqJZEL7z03T+gl4TsR4ar5tfdc8jR6EURImYRaOZhzSVNJ0kUzEj4hQ9Z4wGFf3yc9z1XhVYOi4H5qG2UyEaGdsp2GUgquLeetBuu9BtutBEsZhMtvVz/b1kx39uFNlgE9q47xFg",
"part_4": "rzrBiTiyxOoA5I4jinZJv6r2mLKoHS5OlqExtkr66qqL5hh56X1mIgcy5RpvLDa9zqurtpuciFle7uIONfK5FUNrnXdboZeaL/URhSq0iswWE7/y5cvm24ZTaGO1SF+2FDCJYFfoUrM5+pnZeuBU1UZCuQfcQ1F9Ei80M6fojHbKPPXUaJiGqtK",
"part_5": "jZIJ9KqpURA5wsGiBbObmo0MOUJ8l00kYnnZQIUqr1eKiSpRZ8KvGyZj0/3pRlq2Jvd1Xbn9jh17+12M/cYxSyWbV/vCM+1YbHvS3vV9ad2wRmu7L2dkOzIEaUosnrKqpR/cQ+PekFKkbbshzL32lUL67srx7yhHZB7rVVkUDZP+YUpBYumdiNP",
"part_6": "Ze0nJpYExwkqzUAMjHj0SyXBnyGbYsWwaZYqBFp+h/9buaKOwo6FLBPZJN5W3DIp3tC8XkutS4JpK8zjrcoU2TsTzuS4gKXEARibql1a0XVoR0hG1TeTr6BdkBSPymvPCpP1/s6iMt+t5UyMOJGEb/mB4vAmbiUWRo4+5wGmdnw9y7NiaW942DB",
"part_7": "7U3DW38kG3uofi5KRf2LfqpL1OEoooOaSXxDuKoUjxwpPhhWeEF54xXuNDJNkVjviwvT9qMBSf44XnAV54vsALz0O88CQxxwOSjgiQkIqQkIyQkI6QkJCQkJKQkJSQkJaQkJiQkpmQkpmQdk4CUjITUjITUjITUjITUjITUjITUjITMjITMjITM",
"part_8": "jITsi4BgIzMhIzMhIzMhIzMhIzMhIzMhBGZCSMyE0ZkJozITBh1yQWMyEwYkZkwIjNhRGbCiMyEMZnHB6d0fNOEckR/jtn13c347ij+qzdj8Z+6GG+De2zchbITMdgGBQdf6wJTVHZhdy6JM5mfe52fu+HmhuIapI8XlBtuxLQ5/WDeHonnPAO1",
"part_9": "E3VRhOJCsfYxIq/agpXG857JdbBe6XLdByF1f6F/fzI6fEfvHd+7Rh4XRTcKZmCuXZ2xSroCgbfkp51bT37sOkbcvy/S7vzeO6x725d3gOGh3mi3+9YksFzlnkfdTeFjePDRiYgPehDfaGKzf/Sq3SxrltC87konmJy+7QWY866ooLDtClBWwbv",
"part_10": "wqkJ6RaG/BVxTSuLrWgevANcYspsI4pss/UlTd4f/v+nwvzaf4wOzSfVZGKyUl8Hk7Y3/RuNRit1NFXNeIiBP4+Qhpg+JEnE86f6ghvNsMefO/ME+Ina/rPlBk2Tx6O5j+5/72PZy4bC5BY8ZB9rfSL8MZu+w+7l5n9Jg4m2r3v0OxR5QeasVAAA="
}
|
{
"ground_truth": {
"compressed": "H4sIAET8N2gC/43TXUuEQBSA4b8yzJWChWdm7EPwV3RXRoi67ZIp+HERy/73zqsQBWEtO8+52PFV1D3b13FY+uZlHpf5aHN7Lu1h6ev5NPRVV9rclLZpD6Y+tvVbVFd9c2qquY3zsuyNfqppasfZfP0Q9aYwEpuiME/p894mt22SxFzJ7kZJv+1MjNOhy+vQFXToynRkuxX/I5L+ccb/njIxNzp03erQdadD170OXZJyvCJrSBFSIMRAyIEQBCEJQhSELAhhcJTBUQa3XqTiKIOjDI4yOMrgKIOjDI4yeMrgKYOnDH69AYqnDJ4yeMrgKYOnDJ4yBMoQKEOgDIEyhPXmKoEyBMoQKEOgDIEyZJSz/Wea/fZE10O27/aCPwzdwqsfxdfT8v7YjkNc2otN7DR/dK3+PcZFx+UTjuRt1TYDAAA="
}
}
|
codegen__leetcode2k___443
|
[
{
"content": "You are an expert Python programmer. You will be given a question (problem specification) and will generate a correct Python program that matches the specification and passes all tests.\n\n### Question:\nGiven two binary search trees root1 and root2, return a list containing all the integers from both trees sorted in ascending order.\n \nExample 1:\n\n\nInput: root1 = [2,1,4], root2 = [1,0,3]\nOutput: [0,1,1,2,3,4]\n\nExample 2:\n\n\nInput: root1 = [1,null,8], root2 = [8,1]\nOutput: [1,1,8,8]\n\n \nConstraints:\n\nThe number of nodes in each tree is in the range [0, 5000].\n-105 <= Node.val <= 105\n\n\n\n### Format:\nYou will use the following starter code to write the solution to the problem and enclose your code within delimiters.\n```python\n# Definition for a binary tree node.\n# class TreeNode:\n# def __init__(self, val=0, left=None, right=None):\n# self.val = val\n# self.left = left\n# self.right = right\nclass Solution:\n def getAllElements(self, root1: TreeNode, root2: TreeNode) -> List[int]:\n \n```",
"role": "user"
}
] |
codegen__leetcode2k
|
codegen
| true
| 0
| 0.1875
|
{
"part_1": "H4sIAET8N2gC/+1d/XLjNpJ/FZ7zx9p38hQJfrt2rmpvs7m6qr29u0r+uRq7HI1N20xkSZHoTKZSeZd9ln2y6240wAYIyqLH1kyuPDWyJJJodDcav/4AYP96dD3v5tumOzo7+mvTdH9eXTdf85XZ0XV7c9NePSy6j3D7P5vr9uEerrbL6+aXo7MkztPZ0WrT3rbL+eJyvVndr5HM/64eovmmiebLqPll3Wy66L8/dnerZQRP3G7m9/fN5k2ED31oF4vofRPdtj83y2ge/fTQbLsWHjyGJ98vmvtou26uWuBgjpdPgOK1bnTbLJvNvIM+oqvVZtNc+X1E3d28i+7n3dVds4UvjUuKKK3n2y3cnAO9Djrevjlfni+/+uqr6H+Yj7Pz5b8Ta92HVfQehNx8jLbNfHN1F3WbBppuVqsuIVr4Sc2iTdM9bFCURbvtgLVlN2+X7fJWdwJctMuuuW022+gGtBW9X3WG1Ha16ZpruB/Nt1fN8hobrTbXoKrz5T/+fr78yy/z+/WiiZIz5PJ8+R/L9UN3xhy8jd6pWTLLLmaaEbyQzOJZenG+/K+Hjp58F8MTyUzNUngOKRiKaoRiMls+LBazShKtZokkiQQreAKbI5N/Xi233QZE7rZE9DuQePlw/77ZRKubaAmmtUUJmzlrMGrpOypmM1/eNshklMdxfAFSn4J9RX98G/0Nmr35eb7Az3BJM6sH6pvVBoYYurLW9LBtiNzNarFYfUAlbrs5",
"part_2": "aHYDg3ENt1bRh03b6We2q8UDGQNcxe/G6HA8m+XVYgW0Pq4euOmHtrsDXq+bRXsPFDZoLt9///2azA7Yib5ubmCsieDNagM2wBZDgqLsb/CpqwVYXfQdXEO5zvAS/rtubqLLS2x/eXm8bRY3swhEfgvqWDQ33du/rZYNDEN7e6c/n9iG+A+fJw29xUaDO0gBbuHb4B6RhJv0fr7U3H3LioFODG+3TfenxeIvoJ4GBpc5JFM5s8KwnfQXTqLTf43+CjPhHVjEBVPDf6Q5AJL1BnQGSHLU3q/B/kHRiwXMZeh6e77ka2BQMIz2K4z3nf0C0NV07X2D9kATqvu4xjHn2//MV28ellfdarXY+jdEf/4tHOJgm7tmvv7Jv/i+3SIGeVc16/7V1RqhCyzEu46SiWsg5PIGRuZmsZp3x3+AL384wasDA3qi+YwZz7jp7DKc8yWygKZ+iaZ+DKQARM8IB01vLUJAF/Gtnh6DJjKmL6IZAWkjIxN7F1+cMCG4meiP4DIeGvh63cCn4xNx8c18vQYcPUZifP3DXQt4R3dF98gvUNCN1qs1CmsoMdtt9EfQwZIZ0X6ImWovEMRQLuRfkDWkjQ59adqLE/dhh2vbUjIS/YuV+zkYM0P4BM6o6QhrPJyod2MX7fZyO79vLtE+jtez6CfPJNbEOH76aWgX320e2C4Aes3zMH1GHv9mvtjK59dk3P8EA4wfHnl+2wwfcJmnQQEJ9OAQ394DpBt8wijp",
"part_3": "fAlQZ2Kby67tFg1A3mtk8SVGFjBS4JOaDfh/HKRXrz7BqyPF65stIe4s6k48zIG5SMAOIxNApH7CudcNQZ53nQdNnYR51NbJSHOelXo+So4hG7ltjrsE7imf5TnEBWCbF54gcO0HeMXuZe1dDCJ3iQaHH8z3AXHWSZcgVIMFdurdDxeBZ5gRIyg9fxJ+zPcQ5p8HbGOUkYERyj8EKA8EDnSxB+PtKOndutuD8xDXBkgxxOzv6PGnwZ45A24MCO8nJ8Priuxm4DQcqyJY2a4XLWbHhGLwHVLsHy/ba7gCCH7a8Bw8bZen4BNONcqcap9wSkAOba5WiKs4iV+x6RWbXrHpFZueB5tghm0+Xq5XMGkAWMxkPD55405CRC2IYuERNM6ru+bqx+MrMKQW83CjBiyqYSpvrh+bsK9PDjmkPOnDP3FPR5cnJ9Hbt35kuS/5ZEboVY30gKEm05dh5r7U01kEqstmkYZIBb0EOlH0VG6ekj+Lvnd8RtH/lEjmeHd/VjJAawWvAl4JvFIKcmdRGROpBF4KXim8MnjlSB5eZR7muWASNZM1pJI41sSwP0Okgs8VvNfYUZwbmXLNSWK6Z1LERsysxPqF34ktpprzZ2Sj4F4KZqHkHkvTa2x6jnX3E8Yv76UzGsqEEpMKrsFwKHhPK6m5sNZyFqtgukZJpaBPouIQA70cRrtQehTYDoTCqHejtFS3plele0mNIqtekUTZKDLmXoxCladQZRQ6ZUJB",
"part_4": "I+Yr68eX2AKKMBJwAY0Zb8LXBL6rgow7JUMsqXmCM6dkERMWD5oouKbqkWkk+qJ+8Vml1YGXlCDHpFLqj/hJBT+p5UmRFAXxhJxnYj46M9EwXlkJcyYai/eC2TCdVvy9Zs5ZMcgAfU+ZZVYWMVVqxhgNtJqVZlKx7ku2iZKYIX1kxCyqgjTIgmIfU0Ak6cGCVZdajqyeSCIzvFV4rBJtDChcqjVmxDdGMBwUFwpToX09AHoMSjsGMRNR/Er5lYkZVPCLTY1etTG5CYrJGbdKtr2U8ajKe4XFQ1Cs47B6PgGsLbSaWeAjrIAZg7ISaSU4GGAoPKQ1KFtKbI8nqEtPPWKLGK01b+wlXRfIaCAv0ZwYg1giUBkbKfXgDz2rNtck9ign3iS38zzRJp7I+Y6tK4EsrFmBYzXbHCl/ij0Z5nsAGvHDdL8WvSaxYV+JWbJzokxgrNJaUAbOybwyF79rMXvz8flf6bmXCSKV7yWMlaBctYu9yhWtGIBwLSZAsgMLfDwwWFBP9Hp74lnZ41lQMwOI7a2rh1gBjioe+KQ9gTGkkJAiDCjGTwDGhGFIxa4Tzh3nK4MBHNpyRDdaJNXPcaVBTFufF11UIjKiiMjoSUwVoYVMSC4lVuyHud9SU1OMnEbHlR11SVBxlJbGE+e/ksDvAr5nFYojGWRoRG1p3EebSey5DiYuyVQmAHUVJnQWMwOhQFTxKxcKK4W/Ufwy4pQiQOXgNKumqkqGfayVVFhc",
"part_5": "Id06m8NYMibctTFcE1BLA05ZLDS9VOs+6HqVp6oiMKnMxGJTc2J5Y29sRdSfUWNqVDhFXUY+MTFtaOLZVSUMIt/DtrywJIkDdCoTWvhZ4JhNGXuK++RGVSKGMfZkYhlOxWxMk+tOM5PwUEzzSTGvGo9rw+7RdchexjCwFANE1fPgheqZLvfDCwGzLHFlYbZ3QWUPr2k6khblrvMZjHEpsjyJH8b40wB2PMXoMyZYiPA85wDWqEvYiKkkVCPhuS0LyNBekCfNqSG9Mmj0YrxULgBHBcoguZe9ewF6LgP02CQFJlCfUvgwVRyBEkYa343zBNNC7qh7mHzGS1oc8mg5MOA50kvHFDbmebysRmY0mSnOpKy4krMbZtzWklKZ4TzPBEwO77CTL9lha0xK4kdTNC6BEnQMkrR0r3yokvnQWHzshsWFjoQlYn1yhaQaqZBwWjMGwjJw5tRBuW4o6yMK7WmFrOkjQBxPyIdCqYCxmWpyXlvobCYseGm0hHWBkOe0SU2txZlU7Q9kqaNF+X68jKqsJ9cFjMoYW8Jj1Vf+lDWkZNJyRGyrzbKiREGbrS0xVlVksBRgUG0Rf4wVlIhcSd7FdGBpKjPzC1u/76lWmioGqLGsQcsyUi4B1CsNcdHdElVWnL4PK68QpLQS9xzE9hP1/iXWLSzIFjJnnli4GFQu40Dl0qQ1GZePC92ZrnA/cz5QilDskXzAZGOpXCFh8lXPtk0LUu1QMiUcffVI+lR6",
"part_6": "2YFc/igD2UEqsoOyzxLIgSkSZRKCBKN4XUcL20wiQDYLFZpkEcdiCg+8DiAKGYrbMWfhbdXBIE75XKXYsZ9jxdfMFGb0Y7ZsW4+74FKU61T+hFLpp0JmtQsyiXgIM52+BiBsIMpdtxvDzF146YFmFgDN4lHQZISPNUfTinc89w3a1TzHbHSVirwy37E4x0aWcjTMdCiqFYtjlYwrZGKpBGIOw5hQ5ZLXuCxJU1hRbpirmdaM2YXT9KD1gWJafcBWkV6knujg/HhoyprrASPVK5FVH/H2lTZZHpNhnBawFPL1xXMbbuYC4VNRByofqQNRmvI8lWoVruBzCmaLz2aNmF1c0q8kq+pLWrL2ravu1wPkonUmooxULF7L1Q2zSF2KxepCvO+3WD1cpB4kGTza5cutoVUyEpyyhIZ6/hIyxPDSim8k5cQMcZ8VdC87tINng7KLqVum8uFi7a6Iw9lAElq9DY/gC4TJe5bNd9drfRAtdRCbyZXdvK9vuPjpFFf9Ok9gZSFYXM29XUNToobKVK6Us4vBRi7efobahjm66Bg/vuHMlBB1eCeq1Xlfh63sjq8ktOFstGAoKqxy24PcWGY3lbnxWmxDQZ2gWZE4XpugwlqHCU71XsWuq3HWOdVjEfvwZ97nmqkbNjkbrnL2YMbdYqgUT1+69ngWPSW2iJL2aSwZa2acZ9/t2GbIzChGphPsuBileCrwJE1Yxpx3V7GHNWG62ZWm+J2db8K1efrO",
"part_7": "MK2YdXrnuqmz0scLJTZkSMQz9RMy9tLuR7EZ21gRy9sMU3jVUAmPeSCftRWyF4qGE7ZuW/IjE6jdZefgApLy9oZM3q+xT9KY+0kjgf/OpFHXqDTNQJGttKBU9rkZ/qANXwVZFwHSoNaW5m6+uLu2Roz2yWFpc0WbHGpGNWeWlczmioWRgPghvpGpJ26Iy/tdr1XAf/bLbeM74kqWXyfkklgiejBrYSUWZ1Pe9usWLkf3wol9cHL/29gOY3qlvUOgVyqcQm2Zm1So3OnnrOaMNZh9hEbOscU3uTfRqLyOnb2JaSX2Jmo73bVaOeI/7S5oX4Vy+2Ae9qVyk/ZUtY1lUmO7QLLdu0BMmU2lwi8l7AySHngGOUrt6ywJRGaZt7JSuHtBbMqneo9hfbFYFnedIwnzAtmR8ATk8XYWKwRGU1b5qYXIx91aZpaCYutxBqs1OnKyCY8SVaTMujqxapPJ/VzTipG7ysOeNWQ7lhmMlaT8fGIzdV0wKYh8ZsRJ3Opx5ReQtfRJv0bBaSezUeq3oq8B8IsjIp4EPKhPXe7j1brwircZ9dgapDt4ajyT4+hhClgYY/ByTPywi7/Mq4KbFsOASpnBwcU/faR/8/H19x29/laCQ/++o+j11x39/n7dkRnDPy23H5rNWXRsxg7G4ef2GubCDY0uaT56P7/6sWuvftye8O+k2K7B1l5/JcXrse/XY9+vx76f6dh3ix7wckXe7ejs3a/6AmDMY14W2ppW",
"part_8": "R46fPfptFqAy5lkdMsa3hkmkyIgmoyQZZDDX1/sfhU85eMw63BHku5CuQWYLMTLkX5DulvBzBoEzZGmQEEMeDOkvZLxlLvko6OmaGus2mPRCK6Cnn4fEGPJiSIfxtLLD3+c6Mj2i6Zxl0CJnRhmQwEKOCqlpWlklSA1Ai5QEhdZa6NLQAK4zsI5qlqtZoVBz7vh8nuPPI7aqwApRBJKZ2AemZ/UMsijIpyCth6wekvQE7B1EhIchi4KEH9WTkIayGeTxqnas1JBCmnBToR7hmzLNqE0K5LCX1PSS6o4UMFNAR8BDNrDs/zcHlkeGgycf6UYrmrWBytPj4eBKgqMF7KaorhyVm9A4uYoNAcQhDh+HhQSjVQgohDk5zjeYr1rs2AGQOpaiToEqH3AOf5A4LDpaPXSOY1SjNBrhBZbT/Oq/4nxxYWeGEzbRBqJ8T4CmksSyfRKaRM96IHhkjIlDnsqO54BLNYNJErus7X/YN9xphTCmCMAQeTKLWrWZD7k3dyqcIpl5uhLYp8cJeKxDGHSAg7ujeL1rvpc836WUElI0AhtIMRih4hGcffFDuCNCEjSouPcZufUW1ifBOJeOnIghiueHQoTA0ReujPwc+3QPIT7badqw/MpiXI9uYvgUeU8Q0ZE/jTkUSWIBiETANqh0YBIS/qAHbcbFtmEDyZkaE9BDnpjhc2Ni4zq0zdDw9paTkuxgCinqa5dfOMwp1xHRtQzG7tkPigGvzPjl4TEX",
"part_9": "ThBJyBYVusp8JAg/7InVPYIe5QU4PqaHPMb+p1H3n2+KmSnH5pvBG+K60njDuFoy0qTpzvj1ZU+WjuR7xHNhYq+c4jAtdkU2RxEWxDSVE3txlmSDNEMC5VdOu3KHoR3ulOhIrqdTVDPLNNvSx+Q4W0gOP9XTgacIMnsSgKjlLId26U7hD3fic38jT17MqSRfilPBmZzEoxGzLqDApHVj5jQcslaDkPXp5zH3SwArPwGkiNSFIRsrUQCoeiDlfFG7gwHfhztbOZ4iFBiMSnFKkhWyo3GcH5ydHKvCObG/W0VjlcZaTW5f085Fjg0j15RsqosenlNewhJIFRNyaPBCaHFzXWxYIuZqMtwY9zWpXKfAonlFzWdqYJtfzBnHl0zXcARzEyGiFp6Urz3DecXJkV1potNAZKdj4dSWIolExbEwh3cY0c4yNXA5hz97ODYDqUoO0hZUOawRPeWAJiRPSoOph5BCKRpIV6rnOVE4oSYT+uFWYjLKNOkGV2zqx1zDyDnB54KQagAhSMPHkJ6eCz8aXULF6i/kzN9orYDmkUaFmorR2lOnJnjP/fI0jXdKwQ81wLCGmltvmesJNnBCBz2/9+nZUvGUbKk/m/ek6kQPaV6YQqEJzzGEQR4ju86iBgn6gc/Z7V+MUn7FjYJhXW/SCxcE0wmvaajqoKsjv+uzcU8oJ1cmbJheTaZzby8QiftVSzmK5ZMi8ec5wza+2py7ywi+p7MrgOOLCSPn054S",
"part_10": "Fo0WvMKVGgkkJcZF2XBh4dBnzUZCXp1Mq34pi32wWNKq2a1TtSIOrrrrQgTFAqYKlXNRpso5ORhfdf8c58bC6qhnFPlxrU3FFkL7kr0aj8e8HzkFmGaulaJinBFmFxQbAEnI5ePHVkgEE4ZSQmUAs2JCRpppdGeSj+zC+P2f79oRPyccP7uJdr9aWYQqJ3uf3XpCJJSQUelyAo5ZHVr0mHAu6wlBei6DdIS6YZCuYtPYy/JLnsalDuDxgBMebcJDTXicCQ8yBeP0L+OM1WPr/jnvnalc/DeVZ2/hHyvUnMvYVomhkpOWy3RWpbTbKFQE+TznpcJKCGM4a4EE5b0PWha3DG23TWhl1bHdNgHeJxf4/3gN/iBnn/ZY5yvD63zZcJ0PI7AM8ZwhOKGAOOF1ekbknHcjBeU/7DmmiZGsdl4JxZd7pG2DU0p7FTdC4JzRInmsYTRYEf3Us0f7l4dmbk3ID68zuqPoKTB/aIQAj9l7imX+UM3ohc8RPVLaRsGc9RQaiViPf0jJe5wRGplU5GZlDI9vft+ZLGfpJ0adsjj/c/TbxezovunmR2e/jvyRdDxScz/vmutLPLEEd1Sc1KeJOlV1FMdn9B8eW8yXt5d44uJ1a/+0rf3yb6rin9GD8Dp//TOrv58/s9rNb7dHZ++OcKDh69fNurs7/abdgNq/pSGCi/+mh0x/j/hJvsjfvgW1g6qPLn6bHbXby4dlCyZwdNZtHprf/g9IOQyN3IAAAA=="
}
|
{
"ground_truth": {
"compressed": "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"
}
}
|
codegen__leetcode2k___444
|
End of preview. Expand
in Data Studio
No dataset card yet
- Downloads last month
- 34