Upload folder using huggingface_hub (#1)

- b1f9da41fac45ebab8a866ace7212130adfa968ea7ec66aa049bed8332b6455b (0e6ab97c793efa5427bd364df35732dbd5b084b5)
- 39a8ae557bafed1b5e5736c10b5897d38635ffc981d13fa842f1ce72e4046229 (f6ac8cb84924472aa350940691a602b2c9fa5d77)
- aa9f16787efe708ad3a07abcb7b77b12da828574e5773d4600a267c509cc6641 (9f3adc3e3ffb3cd8bf239fbac106c16d3281a224)
- 01f8c30643da4e616b39828bdd070cc9851cf24934ec52fcd98787d2c1446c33 (d35a1f6be5ae724b54658d87d78a0fe5b779588f)
- 14ab409edfef4a81fc639f38f617cb57b2898858fdb8b5c7793caef802ef3116 (2be5fb2a509981079573a1e4b27df7d97d5ffce0)
- 353c15902798457bfcfe773894f1f96829c77e28e06534d5893bcd1bf0591cb1 (e0824424f2b1ebba848ac753f4f0abed5c1c9e12)
- d01b35c5439261f08011d6fb1004bf5de26e932d5d4318d528035d5a82f46ffa (a53a3f92b38a110c318cec8677cadafb0d660a41)
- 9d278973e453cde681bddd7e6d18cf26ffaf0f9dcf031dd782900e43f3236f28 (ace9da1b5f2e055fb22068210bd98e5dce1a113c)
- cf801ce923240012fcdf362d277c93169e502580d006b424fe732e7547d7e77e (63cf3bb024699ced8ff28dfb0ad1f459f39ba4c6)
- f7d2bc3d9c9de3eb48f5a72335a4087e03fb4617f3c5ace04dcbcf0adcdb98c9 (c1074a7d4b265454810ed4f2b1f52e5d6e85f165)
- 7788aa3ea955f332d5b6cc7dd82d2ac7c59291971a8306f1ddc7300bf433d20f (f65a5b6c10a355147eb4a4b60cef636ab47bc6cf)
- a54d0744d3adeb64425139b993c3f0457b61ebc81d16aa5c021673f8c7973711 (b629ff67a075e67a5412677e3a3c5c8e651b6292)
- 28e253573a301e90b33ecaa8d9fa477bbb3ae9775c74dfd0144d375ddcc69e5f (540c128b2c6a364a73019da9cd1a7305edd7c7a6)
- d626876cf072af0b6013a204ca3af7b22fd6e14b0b49e196df4e4b44ef5e012d (4b2a0a085694df263b5edbf07c6e51e99fb0c303)
- df6fb70d49cdd32f373a6c52c198425ff3472d69b05820480ef7d79a6861e68f (d52182c74f7803ca0e4cf52404ec3e59d4ca94f2)
- 7120b0e378bb716bf1a5dff04491c44220f217e0aa5932e56a6de063a41aa084 (45d13632373d8e9f47aafda91d1df756cf2ae25f)
- 6aaf4ecffe98c75cec67053fd2414676b5b50d0f7ae22166b1300dacef6dec28 (4435dcad2c0be75f20f091874404c1c2fed8d96b)
- 2bdb3feecad6227632f0a134e313f3dcd67eb28c9615e0dac64375f537b1777e (13582ae84623a785e7e8d020f88a645f6e5b9b66)
- 3ed573650f14744b4664283a80b6909de8ec62818885e86cc43375fef9fb4529 (99c27a8735449db3ee82200b7a8396edffd954d0)
- 98518f6232b8c97162c9e2cf01e2d99952b5e61ffddb28be94c91646ab5c88f1 (cda9306c097d0619d90b7211b165221c0bfcfefa)
- 931860a9a1d95a21cf69aee18b8bd2cdf0af4907340b1a2808019fdac081e71f (198b7b24bbad80c84b8cfa9ebaada5f3f43b51e7)
- 7b7f3927df79d4d2c8ddcafeca2454d630848762383516f5f1d449d76bbb4d37 (bc331f9b7e91bf0c75eb3c3529f29a5705c37058)
- 52ffdb76285d91b56181b3df3261204b6c7d380857e42d4e219cd5a137f09866 (c2dc5100fa6134ec1ccbe0af50af6950c5b8a4b7)
- ee452106bc66ffde5b4391befe7f259d47f441ce3015a7d82acdbea3da50b6ec (a30be0396f137a9f12082223e76687fafaf41e43)
- ee6dde840dcc10881743f1bf0b2a5f4bcb7e3d5bb1904794b22863e0226926d3 (00d8e400e7f7ef7f21d734f39dc9213e8abc74be)
- 92988b1e4e7745ed81cac53dcd42a92de49fde9a78668977a27ff3a15c81c91a (6bad75bd4f2988ab47ccd0fde6bfd026997bf9d5)
- 2dc0f28d5f527335410d74b76fd7b2b0b98971f50a2870d6872a805213a9af25 (796c546980216d4c0715f89da2b97708e9438089)
- 50a19bd61a8e7d30d85ac2c2db11e620c1d1b94f685189f815467ae2019aa291 (621c2ebedcd7db888ae8730c9f1ff5597c31920a)
- 01a35ba565c422ec36f98a97d382fe7678d18342875849716a4de188c10fda52 (5b97c3770b3d277e423cf282246ecf871f3eb879)
- 602dcbb54a71f59d3651f8d95f65c2bd4e0c21cd33611bb84f618486360a41b0 (7a831d847c60101f3a045dfaaaab7b7d8148c1a2)
- 34ae1e5a7f8612fc25f5e2e83a5971f3540b6dc3bedf0dc25d7c1eb5a8215163 (5964563c84b9002cca7ce23f848c0f56bae3d6fa)
- 35196a8d623a29fd9d0888b07d48d576846cf1a68fff0b2b570d1f3187eec310 (d51917b81377f7fcd692d50283decb75413329a1)
- 75b226d491c5cfd0cb0576f9fbda1a33b06cbc80a09ef580568008fe60ff15ba (923c7903b1074e3c7e4122c9edbb4aadb9f35d12)
- 87988a2e0843c28eb891b6405463ff6582bf7d06d05ae8dce71469edfdee8a98 (38d82074852bdd08dcb097077405d2356f202f4e)
- 03ab2ccbb3c596f4b569ea29a1708c2f35c9615f61d50e8706d35be5ad7589e2 (2508fb274d7e67460521266dd88811ebf86f0230)
- 0ffe00eb80825987deb6309da960a8a9552940ddfc60de62fc1020028fb2c4ab (bf3bec34ffabd1f51648f7a982365c8d04b98719)
- 6eee26792c406aadb14f1a9f1a5570568fbd757659dfa2a1a89f4f1d3a5318b2 (a1f68ed7b6ae487da04736982748ca11e16230db)
- 89faea376bbae1bbc08075e7ee258df9dca329683f3b7ec070d414da7b5e4867 (21bef0d5d014fae6b4d25c7680537dafd3cdf893)
- 39540dc111a52de652e67196dfbc20970f9019caec53ad906dd02e94ff244fc2 (1e6908c5500e3c822f19b316a14bce0e6f4e338e)
- 7260b1a7e5f9ee987460047d0344a7f8745c5a35488691f344f81d40f6088db5 (5bf07651fd528774cd69caa5b39e470ce5a7ced4)
- 605caf3f91256bf157721222a7e30a5041f4a4cae4b7f4677de012105522d744 (7bb84d802c03d643da2b095ae5a68830a059c812)
- 50b2b52effdde3c2d67824682117ae3e467dd7ac5bf4c97ff29f4961603558e1 (885b1d8fc64133db9c0890b719c6a4892da7eb8f)
- da0138e5ceb25a98ca1595896dc61d6c144847c0f13acffc912f4b6047c7f4d2 (690fee243d3c04ca39417f4591198d93176071fb)
- b55df0184d27544bfbb29ce9da3fe89617b7aaecab49b5ae05ffcd8cfbc4f6a9 (1c27b01cd09957b01c1623e4477cef5c9f6cba09)
- ac370624dbb37c2b82d6fa17b2f5684f2586e27dfa3c1a8dd9a13ce4a4dcb0ba (e019b2123a6de8319d2d519ac87c75b37f3d97cb)
- 2119ef2c34ac8076fa9f1e0f627c1815f6e5c2b490d50831b465500f4352ad7d (6e2c15e36962190b60d31fd02f291cb9cc278dd9)
- 61a8d6905f485132fab70e578b5ea9f28927f34ecdc560da5fd03258129cca7c (383505c3897529bddc1b43c7e0fda754bbafc881)
- 009007153e1fb3c00adfa6056e3b4d69e5a432d0d5b347b5515111c51f9bc8ad (2b2a8a81a9f26c8f2dc496fdee8fc53efe177cfe)
- 47338eedd8ffbbb3f5a9cc47a6306c1932ef0fe42ebb0ea218abf7caa69875ec (da5f12f1ab50310ed990c95d32e57b1ec6e26290)
- 803548b7eea7d7363140b6f8aaf57360f973ef32663c952b21e1c1c24baa9bf5 (e34635fc42b8b461d5bf217ca0749d1d3818da40)
- fac2cf8dabde355cb397a478b1311e9d6272ab8af3ab7122f126710b3fd36b87 (9d040a0f5cbaa5e7f0879d049650b6c126d6f67a)
- 25c0f9f8e1f27f727e2ed32c449c9b0cb94ec5d2a15b8da916e63b13d895e141 (0bc0f17c7bbd86ea92f3224448448bc843608cb8)
- 6b09971df99a3b60672b21b6294001be8734c1264de3a1c37cb0dffe06141536 (b677a2e1389bc1a5ef4127c0b36baa040ce48a38)
- 3c84d0a839e6f58af193dbfafea5976ec5d5c2435f97ab08e3aa3eb4d3ff0398 (901adde839ee94caaa191a635f26bd7b1b544df9)
- 2ff8330bfd74005b3b7a257ffd0af75b0a960582de7112aa72eb30a11e704951 (61c037a1601e7887995830283710135fddb2b266)
- c0858bc5e7f8bd0ad3db5ff53452fafdaa09386d3c620ed5a58ef4fe07dfb1dc (22c282e349f3ae4d440da22e0c0e90af672f8b0f)
- 43e66b9e48cf858a1572894aee262c4c38e10faeac928b7ff2589934cc6f83f3 (42c91d625cfed7a05a3f662e2a1d6dcca475639e)
- b187339e7ae2f691d78aa1c6debf0346a26e463712ff7c1b589c6473ca9fdbc3 (43d9f7d648f74e266a228f5a99ccf9035431cab1)
- d3ec4bc329ab8e77c7f120993a0cac0ae097c2241e063ea6b785f2383e7bc4f5 (6e4e317d75d843bae6d457d3e26b948083492ade)
- c75bb478d76edd30f548673176503faeda3793d5a03e5a4667861245429d1b72 (e77522d23c26cc158022a86fb5093bee11f92f86)
- b26b736f375e0413302a3ddbb0316fa2227a55a60b1e7678117242c1eb756f8c (1c96a3cd0e980008cb9c6072b6750922ba2c4963)
- ece040cec26d5826aa5bd6f2dee393fb1cbbc5499c3603466ca7aeec86debd37 (530d897c60c4b060d5fb885abc8cfa2a76dc1714)
- 2b8985c7e56bef8e738a79e5d14608d0bf40d2b0e1802e3e23c6dc8df1e9ddfa (092aabdf1c61b49390560312d7a52b4a3ee69bf8)
- e30daceabbb304c9e1e1ca3775719e0203b57303d7c3a0403c3923132aee88cf (d55cb2b1dc5ab25de37cdebb3584bd6a90d7f15c)
- 626394dcaf3d5457e1a7f327907aa2c9c0bb93b638a2bdf566a3b653816c095e (e4c13af5b2e58aba01453e78ba94f050f2025615)
- 9578deb8ce7ec738ebf543063902b86b9771801b60b21845ee5f6f63530f35e6 (6b25fe386e0b50ceeedbf382c32d6e8a8d6963af)
- 05933c668d5658b5e175e4051064b54d03d6bf588398d4a7465916791a668795 (5aedd6ddcdd8a8e3b6d26b10d057148e1f4ff0d3)
- 4fd72f98993a86522f493405e676be94c9acfea805829bee0e1295ce16bba63c (f7c3523fc049a222bfe0057ac8ef3a5b056ef7af)
- 88172528aff7d5f4b03791c78a9538bd129960bea3241db0df6269e07e50df47 (0671164cd88d2c12a16e50acdf971b04df7f6c5f)
- afb8843ca3fd07f9d5c27d3591860dba0def1fc7f22ad33e21c1b791ff49812f (5f2a991f567c33ef3016a801223d47af47ff1d27)
- 300d9c548d0181e06510a93bf2caf000732c135de434e68f028f2cbbc52f3eaa (1529faa2a9efed99d9b9f0212706eb2d95c5737e)
- ae9c38edfd8249879219b0098cdc752da888d908e97d9e91b6a515cc5a19fa42 (6718cf655f843139065a028801df91139bc12f9e)
- f1e59e39e1d69ee71db2a85629dc85fe001b219003101e627766b07b932f3ef2 (3d109ba3e8a4984fc21b46b587125ef676d832d6)
- 7c8d8bdbe777790b6717da05f7ceaf72dfd68a238d3c65f4dcce48491a229656 (5788af833533c6bb07e6b5ed9f8e0d934b5c7e84)
- 0892eccfdf4e4f7d48b352527ffeedf8c34461476667e6f1db00f4459a1c9303 (20fd1ede412f0b0a21db386c56610d57decd1782)
- d2d40aab49b4a8ad1e98133439810184eac51541cac4032761d3ca8a595a5464 (fbe25d8ce536f7553791f6a80d43990fd291c04c)
- efb3e9bb735d25946f7656caeba94c3360da9cc8c1bcc646142a950b006531da (abac9f70886395aab744b0216d52ec5a4d6d263f)
- e772cc7a8a95bda60bf7cb1bb77defcf817c3f9d50800e835dc9b9b3aacafce0 (e5db8da65cffb6f9f025326604356361fe2dfa1d)
- ad921e5faff2f2cf3ba86483dabf36386cbb4b529efacf07dfa1b2d84aed393c (893bc912fbc065fa1e3ccdec873184ed324d4098)
- 76beca8b91163d201b98ba1949b7709c095718eced70f58e1d134245783b2a54 (548516062c7cdf6f9d2e14b3ded1440a80cebe93)
- fa1fe7119c1dbacf0132d1efb5678d0160ce877db03d9d118de4e14f86520349 (6103e328e1ff8562fe29edf5248cc63079fd2394)
- 2f22e8e7d9f2d14caf705c80fa50f8748b092dece0a0ec1e8a40b6161f61485a (7ad5bfe751b45451b70075e6a42b776c1290bf4f)
- b9c481a4de7aa7344a9ec7ea15860d8d933968e818d73288eec73b5626778aa3 (e1192c88c6666d91ae47de35d914718d7357489e)
- 2169f9355af969aa9bbb73abd14c2c6a2e7408e243761b28fccb0ad8ea84a12f (dcd20c09c07c01084e4519fd5037479d580c0a26)
- be8f1cce3a0f463240b62b24b9d4ef97b4400e560d24a55825db07a8bcbca50d (5a83f98cb387fb93ac697fb04f8f9c910ec59eaa)
- 03e2bd257936c8ecf513ba8e744afa5e6d4c1f4aebce111cbac0a2a580b7cd8a (77b9f67ce9422ad7e5f9ea29f0dfd85536afb12d)

.DS_Store

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:581110d059fa11e94ed9c16751b5904eef8afbb72f4a3b7ac783ffde1153c3d1
+size 358404

.gitattributes

@@ -57,3 +57,243 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 # Video files - compressed
 *.mp4 filter=lfs diff=lfs merge=lfs -text
 *.webm filter=lfs diff=lfs merge=lfs -text
+.DS_Store filter=lfs diff=lfs merge=lfs -text
+add_edges_to_make_degrees_of_all_nodes_even/meta.json filter=lfs diff=lfs merge=lfs -text
+all_divisions_with_the_highest_score_of_a_binary_array/meta.json filter=lfs diff=lfs merge=lfs -text
+alternating_groups_iii/meta.json filter=lfs diff=lfs merge=lfs -text
+append_k_integers_with_minimal_sum/meta.json filter=lfs diff=lfs merge=lfs -text
+apply_operations_on_array_to_maximize_sum_of_squares/meta.json filter=lfs diff=lfs merge=lfs -text
+apply_operations_to_maximize_frequency_score/meta.json filter=lfs diff=lfs merge=lfs -text
+apply_operations_to_maximize_score/meta.json filter=lfs diff=lfs merge=lfs -text
+assign_elements_to_groups_with_constraints/haskell_tests/Main.hs filter=lfs diff=lfs merge=lfs -text
+assign_elements_to_groups_with_constraints/meta.json filter=lfs diff=lfs merge=lfs -text
+check_if_grid_can_be_cut_into_sections/haskell_tests/Main.hs filter=lfs diff=lfs merge=lfs -text
+check_if_grid_can_be_cut_into_sections/meta.json filter=lfs diff=lfs merge=lfs -text
+check_if_grid_can_be_cut_into_sections/ocaml_tests/main.ml filter=lfs diff=lfs merge=lfs -text
+check_if_grid_can_be_cut_into_sections/scala_tests/MySuite.scala filter=lfs diff=lfs merge=lfs -text
+closest_equal_element_queries/meta.json filter=lfs diff=lfs merge=lfs -text
+collect_coins_in_a_tree/meta.json filter=lfs diff=lfs merge=lfs -text
+count_array_pairs_divisible_by_k/meta.json filter=lfs diff=lfs merge=lfs -text
+count_connected_components_in_lcm_graph/meta.json filter=lfs diff=lfs merge=lfs -text
+count_days_without_meetings/meta.json filter=lfs diff=lfs merge=lfs -text
+count_good_triplets_in_an_array/meta.json filter=lfs diff=lfs merge=lfs -text
+count_non_decreasing_subarrays_after_k_operations/meta.json filter=lfs diff=lfs merge=lfs -text
+count_number_of_bad_pairs/meta.json filter=lfs diff=lfs merge=lfs -text
+count_of_interesting_subarrays/meta.json filter=lfs diff=lfs merge=lfs -text
+count_pairs_of_points_with_distance_k/meta.json filter=lfs diff=lfs merge=lfs -text
+count_subarrays_where_max_element_appears_at_least_k_times/meta.json filter=lfs diff=lfs merge=lfs -text
+count_subarrays_with_score_less_than_k/meta.json filter=lfs diff=lfs merge=lfs -text
+count_submatrices_with_equal_frequency_of_x_and_y/haskell_tests/Main.hs filter=lfs diff=lfs merge=lfs -text
+count_submatrices_with_equal_frequency_of_x_and_y/meta.json filter=lfs diff=lfs merge=lfs -text
+count_substrings_that_satisfy_k_constraint_ii/haskell_tests/Main.hs filter=lfs diff=lfs merge=lfs -text
+count_substrings_that_satisfy_k_constraint_ii/meta.json filter=lfs diff=lfs merge=lfs -text
+count_the_number_of_beautiful_subarrays/meta.json filter=lfs diff=lfs merge=lfs -text
+count_the_number_of_good_nodes/haskell_tests/Main.hs filter=lfs diff=lfs merge=lfs -text
+count_the_number_of_good_nodes/meta.json filter=lfs diff=lfs merge=lfs -text
+count_the_number_of_good_subarrays/meta.json filter=lfs diff=lfs merge=lfs -text
+count_the_number_of_houses_at_a_certain_distance_ii/meta.json filter=lfs diff=lfs merge=lfs -text
+count_unreachable_pairs_of_nodes_in_an_undirected_graph/haskell_tests/Main.hs filter=lfs diff=lfs merge=lfs -text
+count_unreachable_pairs_of_nodes_in_an_undirected_graph/meta.json filter=lfs diff=lfs merge=lfs -text
+count_unreachable_pairs_of_nodes_in_an_undirected_graph/ocaml_tests/main.ml filter=lfs diff=lfs merge=lfs -text
+count_unreachable_pairs_of_nodes_in_an_undirected_graph/scala_tests/MySuite.scala filter=lfs diff=lfs merge=lfs -text
+count_ways_to_group_overlapping_ranges/meta.json filter=lfs diff=lfs merge=lfs -text
+count_zero_request_servers/haskell_tests/Main.hs filter=lfs diff=lfs merge=lfs -text
+count_zero_request_servers/meta.json filter=lfs diff=lfs merge=lfs -text
+count_zero_request_servers/ocaml_tests/main.ml filter=lfs diff=lfs merge=lfs -text
+count_zero_request_servers/scala_tests/MySuite.scala filter=lfs diff=lfs merge=lfs -text
+create_components_with_same_value/meta.json filter=lfs diff=lfs merge=lfs -text
+cycle_length_queries_in_a_tree/meta.json filter=lfs diff=lfs merge=lfs -text
+destroy_sequential_targets/meta.json filter=lfs diff=lfs merge=lfs -text
+difference_between_maximum_and_minimum_price_sum/haskell_tests/Main.hs filter=lfs diff=lfs merge=lfs -text
+difference_between_maximum_and_minimum_price_sum/meta.json filter=lfs diff=lfs merge=lfs -text
+difference_between_ones_and_zeros_in_row_and_column/meta.json filter=lfs diff=lfs merge=lfs -text
+distribute_elements_into_two_arrays_ii/haskell_tests/Main.hs filter=lfs diff=lfs merge=lfs -text
+distribute_elements_into_two_arrays_ii/meta.json filter=lfs diff=lfs merge=lfs -text
+divide_an_array_into_subarrays_with_minimum_cost_ii/meta.json filter=lfs diff=lfs merge=lfs -text
+divide_array_into_arrays_with_max_difference/meta.json filter=lfs diff=lfs merge=lfs -text
+divide_intervals_into_minimum_number_of_groups/meta.json filter=lfs diff=lfs merge=lfs -text
+eat_pizzas/meta.json filter=lfs diff=lfs merge=lfs -text
+find_all_good_indices/meta.json filter=lfs diff=lfs merge=lfs -text
+find_building_where_alice_and_bob_can_meet/haskell_tests/Main.hs filter=lfs diff=lfs merge=lfs -text
+find_building_where_alice_and_bob_can_meet/meta.json filter=lfs diff=lfs merge=lfs -text
+find_closest_node_to_given_two_nodes/meta.json filter=lfs diff=lfs merge=lfs -text
+find_indices_with_index_and_value_difference_ii/meta.json filter=lfs diff=lfs merge=lfs -text
+find_number_of_coins_to_place_in_tree_nodes/meta.json filter=lfs diff=lfs merge=lfs -text
+find_occurrences_of_an_element_in_an_array/meta.json filter=lfs diff=lfs merge=lfs -text
+find_subtree_sizes_after_changes/meta.json filter=lfs diff=lfs merge=lfs -text
+find_the_first_player_to_win_k_games_in_a_row/meta.json filter=lfs diff=lfs merge=lfs -text
+find_the_k_sum_of_an_array/meta.json filter=lfs diff=lfs merge=lfs -text
+find_the_longest_equal_subarray/meta.json filter=lfs diff=lfs merge=lfs -text
+find_the_maximum_number_of_marked_indices/meta.json filter=lfs diff=lfs merge=lfs -text
+find_the_minimum_area_to_cover_all_ones_i/meta.json filter=lfs diff=lfs merge=lfs -text
+find_the_number_of_good_pairs_ii/meta.json filter=lfs diff=lfs merge=lfs -text
+find_the_original_array_of_prefix_xor/meta.json filter=lfs diff=lfs merge=lfs -text
+find_the_score_of_all_prefixes_of_an_array/meta.json filter=lfs diff=lfs merge=lfs -text
+find_x_sum_of_all_k_long_subarrays_ii/haskell_tests/Main.hs filter=lfs diff=lfs merge=lfs -text
+find_x_sum_of_all_k_long_subarrays_ii/meta.json filter=lfs diff=lfs merge=lfs -text
+frog_jump_ii/meta.json filter=lfs diff=lfs merge=lfs -text
+fruits_into_baskets_iii/haskell_tests/Main.hs filter=lfs diff=lfs merge=lfs -text
+fruits_into_baskets_iii/meta.json filter=lfs diff=lfs merge=lfs -text
+handling_sum_queries_after_update/meta.json filter=lfs diff=lfs merge=lfs -text
+house_robber_iv/meta.json filter=lfs diff=lfs merge=lfs -text
+increment_submatrices_by_one/meta.json filter=lfs diff=lfs merge=lfs -text
+intervals_between_identical_elements/meta.json filter=lfs diff=lfs merge=lfs -text
+k_th_nearest_obstacle_queries/haskell_tests/Main.hs filter=lfs diff=lfs merge=lfs -text
+k_th_nearest_obstacle_queries/meta.json filter=lfs diff=lfs merge=lfs -text
+largest_combination_with_bitwise_and_greater_than_zero/meta.json filter=lfs diff=lfs merge=lfs -text
+largest_element_in_an_array_after_merge_operations/meta.json filter=lfs diff=lfs merge=lfs -text
+length_of_longest_subarray_with_at_most_k_frequency/meta.json filter=lfs diff=lfs merge=lfs -text
+length_of_the_longest_increasing_path/haskell_tests/Main.hs filter=lfs diff=lfs merge=lfs -text
+length_of_the_longest_increasing_path/meta.json filter=lfs diff=lfs merge=lfs -text
+longest_non_decreasing_subarray_from_two_arrays/haskell_tests/Main.hs filter=lfs diff=lfs merge=lfs -text
+longest_non_decreasing_subarray_from_two_arrays/meta.json filter=lfs diff=lfs merge=lfs -text
+longest_palindrome_by_concatenating_two_letter_words/meta.json filter=lfs diff=lfs merge=lfs -text
+longest_path_with_different_adjacent_characters/meta.json filter=lfs diff=lfs merge=lfs -text
+longest_special_path/meta.json filter=lfs diff=lfs merge=lfs -text
+longest_special_path_ii/meta.json filter=lfs diff=lfs merge=lfs -text
+longest_subarray_with_maximum_bitwise_and/meta.json filter=lfs diff=lfs merge=lfs -text
+max_sum_of_a_pair_with_equal_sum_of_digits/meta.json filter=lfs diff=lfs merge=lfs -text
+maximal_score_after_applying_k_operations/meta.json filter=lfs diff=lfs merge=lfs -text
+maximize_happiness_of_selected_children/haskell_tests/Main.hs filter=lfs diff=lfs merge=lfs -text
+maximize_happiness_of_selected_children/meta.json filter=lfs diff=lfs merge=lfs -text
+maximize_score_of_numbers_in_ranges/meta.json filter=lfs diff=lfs merge=lfs -text
+maximize_sum_of_weights_after_edge_removals/haskell_tests/Main.hs filter=lfs diff=lfs merge=lfs -text
+maximize_sum_of_weights_after_edge_removals/meta.json filter=lfs diff=lfs merge=lfs -text
+maximize_sum_of_weights_after_edge_removals/ocaml_tests/main.ml filter=lfs diff=lfs merge=lfs -text
+maximize_sum_of_weights_after_edge_removals/scala_tests/MySuite.scala filter=lfs diff=lfs merge=lfs -text
+maximize_the_profit_as_the_salesman/meta.json filter=lfs diff=lfs merge=lfs -text
+maximize_value_of_function_in_a_ball_passing_game/meta.json filter=lfs diff=lfs merge=lfs -text
+maximize_win_from_two_segments/meta.json filter=lfs diff=lfs merge=lfs -text
+maximum_and_minimum_sums_of_at_most_size_k_subarrays/meta.json filter=lfs diff=lfs merge=lfs -text
+maximum_bags_with_full_capacity_of_rocks/meta.json filter=lfs diff=lfs merge=lfs -text
+maximum_beauty_of_an_array_after_applying_operation/meta.json filter=lfs diff=lfs merge=lfs -text
+maximum_coins_from_k_consecutive_bags/haskell_tests/Main.hs filter=lfs diff=lfs merge=lfs -text
+maximum_coins_from_k_consecutive_bags/meta.json filter=lfs diff=lfs merge=lfs -text
+maximum_consecutive_floors_without_special_floors/meta.json filter=lfs diff=lfs merge=lfs -text
+maximum_difference_score_in_a_grid/haskell_tests/Main.hs filter=lfs diff=lfs merge=lfs -text
+maximum_difference_score_in_a_grid/meta.json filter=lfs diff=lfs merge=lfs -text
+maximum_elegance_of_a_k_length_subsequence/meta.json filter=lfs diff=lfs merge=lfs -text
+maximum_frequency_after_subarray_operation/meta.json filter=lfs diff=lfs merge=lfs -text
+maximum_frequency_of_an_element_after_performing_operations_i/meta.json filter=lfs diff=lfs merge=lfs -text
+maximum_frequency_of_an_element_after_performing_operations_ii/meta.json filter=lfs diff=lfs merge=lfs -text
+maximum_good_subarray_sum/meta.json filter=lfs diff=lfs merge=lfs -text
+maximum_matching_of_players_with_trainers/meta.json filter=lfs diff=lfs merge=lfs -text
+maximum_number_of_groups_entering_a_competition/meta.json filter=lfs diff=lfs merge=lfs -text
+maximum_number_of_groups_with_increasing_length/meta.json filter=lfs diff=lfs merge=lfs -text
+maximum_number_of_k_divisible_components/meta.json filter=lfs diff=lfs merge=lfs -text
+maximum_or/meta.json filter=lfs diff=lfs merge=lfs -text
+maximum_points_after_collecting_coins_from_all_nodes/haskell_tests/Main.hs filter=lfs diff=lfs merge=lfs -text
+maximum_points_after_collecting_coins_from_all_nodes/meta.json filter=lfs diff=lfs merge=lfs -text
+maximum_points_after_collecting_coins_from_all_nodes/scala_tests/MySuite.scala filter=lfs diff=lfs merge=lfs -text
+maximum_prime_difference/meta.json filter=lfs diff=lfs merge=lfs -text
+maximum_score_after_applying_operations_on_a_tree/meta.json filter=lfs diff=lfs merge=lfs -text
+maximum_score_of_a_node_sequence/meta.json filter=lfs diff=lfs merge=lfs -text
+maximum_star_sum_of_a_graph/meta.json filter=lfs diff=lfs merge=lfs -text
+maximum_subarray_sum_with_length_divisible_by_k/haskell_tests/Main.hs filter=lfs diff=lfs merge=lfs -text
+maximum_subarray_sum_with_length_divisible_by_k/meta.json filter=lfs diff=lfs merge=lfs -text
+maximum_sum_of_distinct_subarrays_with_length_k/meta.json filter=lfs diff=lfs merge=lfs -text
+maximum_sum_of_subsequence_with_non_adjacent_elements/meta.json filter=lfs diff=lfs merge=lfs -text
+maximum_sum_queries/haskell_tests/Main.hs filter=lfs diff=lfs merge=lfs -text
+maximum_sum_queries/meta.json filter=lfs diff=lfs merge=lfs -text
+maximum_sum_queries/ocaml_tests/main.ml filter=lfs diff=lfs merge=lfs -text
+maximum_sum_queries/scala_tests/MySuite.scala filter=lfs diff=lfs merge=lfs -text
+maximum_tastiness_of_candy_basket/meta.json filter=lfs diff=lfs merge=lfs -text
+maximum_total_beauty_of_the_gardens/meta.json filter=lfs diff=lfs merge=lfs -text
+maximum_total_importance_of_roads/meta.json filter=lfs diff=lfs merge=lfs -text
+maximum_xor_score_subarray_queries/haskell_tests/Main.hs filter=lfs diff=lfs merge=lfs -text
+maximum_xor_score_subarray_queries/meta.json filter=lfs diff=lfs merge=lfs -text
+maximum_xor_score_subarray_queries/scala_tests/MySuite.scala filter=lfs diff=lfs merge=lfs -text
+meeting_rooms_iii/meta.json filter=lfs diff=lfs merge=lfs -text
+meta2/.DS_Store filter=lfs diff=lfs merge=lfs -text
+meta2/add_edges_to_make_degrees_of_all_nodes_even/meta.json filter=lfs diff=lfs merge=lfs -text
+meta2/all_divisions_with_the_highest_score_of_a_binary_array/meta.json filter=lfs diff=lfs merge=lfs -text
+mice_and_cheese/meta.json filter=lfs diff=lfs merge=lfs -text
+minimize_maximum_of_array/meta.json filter=lfs diff=lfs merge=lfs -text
+minimize_or_of_remaining_elements_using_operations/meta.json filter=lfs diff=lfs merge=lfs -text
+minimize_the_maximum_difference_of_pairs/meta.json filter=lfs diff=lfs merge=lfs -text
+minimum_absolute_difference_between_elements_with_constraint/meta.json filter=lfs diff=lfs merge=lfs -text
+minimum_array_length_after_pair_removals/meta.json filter=lfs diff=lfs merge=lfs -text
+minimum_cost_to_equalize_array/meta.json filter=lfs diff=lfs merge=lfs -text
+minimum_cost_to_make_arrays_identical/meta.json filter=lfs diff=lfs merge=lfs -text
+minimum_difference_in_sums_after_removal_of_elements/meta.json filter=lfs diff=lfs merge=lfs -text
+minimum_fuel_cost_to_report_to_the_capital/meta.json filter=lfs diff=lfs merge=lfs -text
+minimum_impossible_or/meta.json filter=lfs diff=lfs merge=lfs -text
+minimum_lines_to_represent_a_line_chart/meta.json filter=lfs diff=lfs merge=lfs -text
+minimum_money_required_before_transactions/meta.json filter=lfs diff=lfs merge=lfs -text
+minimum_number_of_coins_to_be_added/meta.json filter=lfs diff=lfs merge=lfs -text
+minimum_number_of_operations_to_make_array_xor_equal_to_k/meta.json filter=lfs diff=lfs merge=lfs -text
+minimum_number_of_operations_to_make_arrays_similar/meta.json filter=lfs diff=lfs merge=lfs -text
+minimum_number_of_operations_to_satisfy_conditions/meta.json filter=lfs diff=lfs merge=lfs -text
+minimum_operations_to_exceed_threshold_value_ii/haskell_tests/Main.hs filter=lfs diff=lfs merge=lfs -text
+minimum_operations_to_exceed_threshold_value_ii/meta.json filter=lfs diff=lfs merge=lfs -text
+minimum_operations_to_halve_array_sum/meta.json filter=lfs diff=lfs merge=lfs -text
+minimum_operations_to_make_array_equal_ii/meta.json filter=lfs diff=lfs merge=lfs -text
+minimum_operations_to_make_array_equal_to_target/haskell_tests/Main.hs filter=lfs diff=lfs merge=lfs -text
+minimum_operations_to_make_array_equal_to_target/meta.json filter=lfs diff=lfs merge=lfs -text
+minimum_operations_to_make_median_of_array_equal_to_k/haskell_tests/Main.hs filter=lfs diff=lfs merge=lfs -text
+minimum_operations_to_make_median_of_array_equal_to_k/meta.json filter=lfs diff=lfs merge=lfs -text
+minimum_operations_to_make_the_array_alternating/meta.json filter=lfs diff=lfs merge=lfs -text
+minimum_processing_time/meta.json filter=lfs diff=lfs merge=lfs -text
+minimum_rectangles_to_cover_points/haskell_tests/Main.hs filter=lfs diff=lfs merge=lfs -text
+minimum_rectangles_to_cover_points/meta.json filter=lfs diff=lfs merge=lfs -text
+minimum_rectangles_to_cover_points/scala_tests/MySuite.scala filter=lfs diff=lfs merge=lfs -text
+minimum_replacements_to_sort_the_array/meta.json filter=lfs diff=lfs merge=lfs -text
+minimum_rounds_to_complete_all_tasks/meta.json filter=lfs diff=lfs merge=lfs -text
+minimum_score_of_a_path_between_two_cities/meta.json filter=lfs diff=lfs merge=lfs -text
+minimum_seconds_to_equalize_a_circular_array/meta.json filter=lfs diff=lfs merge=lfs -text
+minimum_size_subarray_in_infinite_array/meta.json filter=lfs diff=lfs merge=lfs -text
+minimum_sum_of_squared_difference/meta.json filter=lfs diff=lfs merge=lfs -text
+minimum_swaps_to_group_all_1s_together_ii/meta.json filter=lfs diff=lfs merge=lfs -text
+minimum_time_to_complete_trips/meta.json filter=lfs diff=lfs merge=lfs -text
+minimum_time_to_finish_the_race/meta.json filter=lfs diff=lfs merge=lfs -text
+minimum_time_to_repair_cars/meta.json filter=lfs diff=lfs merge=lfs -text
+minimum_total_cost_to_make_arrays_unequal/meta.json filter=lfs diff=lfs merge=lfs -text
+most_popular_video_creator/meta.json filter=lfs diff=lfs merge=lfs -text
+movement_of_robots/meta.json filter=lfs diff=lfs merge=lfs -text
+next_greater_element_iv/meta.json filter=lfs diff=lfs merge=lfs -text
+node_with_highest_edge_score/meta.json filter=lfs diff=lfs merge=lfs -text
+number_of_excellent_pairs/meta.json filter=lfs diff=lfs merge=lfs -text
+number_of_flowers_in_full_bloom/meta.json filter=lfs diff=lfs merge=lfs -text
+number_of_increasing_paths_in_a_grid/haskell_tests/Main.hs filter=lfs diff=lfs merge=lfs -text
+number_of_increasing_paths_in_a_grid/meta.json filter=lfs diff=lfs merge=lfs -text
+number_of_pairs_satisfying_inequality/meta.json filter=lfs diff=lfs merge=lfs -text
+number_of_zero_filled_subarrays/meta.json filter=lfs diff=lfs merge=lfs -text
+paint_house_iv/haskell_tests/Main.hs filter=lfs diff=lfs merge=lfs -text
+paint_house_iv/meta.json filter=lfs diff=lfs merge=lfs -text
+partition_array_according_to_given_pivot/meta.json filter=lfs diff=lfs merge=lfs -text
+partition_array_such_that_maximum_difference_is_k/meta.json filter=lfs diff=lfs merge=lfs -text
+paths_in_matrix_whose_sum_is_divisible_by_k/meta.json filter=lfs diff=lfs merge=lfs -text
+reachable_nodes_with_restrictions/meta.json filter=lfs diff=lfs merge=lfs -text
+rearrange_array_elements_by_sign/meta.json filter=lfs diff=lfs merge=lfs -text
+rearranging_fruits/meta.json filter=lfs diff=lfs merge=lfs -text
+remove_methods_from_project/haskell_tests/Main.hs filter=lfs diff=lfs merge=lfs -text
+remove_methods_from_project/meta.json filter=lfs diff=lfs merge=lfs -text
+remove_methods_from_project/ocaml_tests/main.ml filter=lfs diff=lfs merge=lfs -text
+remove_methods_from_project/scala_tests/MySuite.scala filter=lfs diff=lfs merge=lfs -text
+removing_minimum_number_of_magic_beans/meta.json filter=lfs diff=lfs merge=lfs -text
+replace_non_coprime_numbers_in_array/meta.json filter=lfs diff=lfs merge=lfs -text
+robot_collisions/meta.json filter=lfs diff=lfs merge=lfs -text
+shifting_letters_ii/meta.json filter=lfs diff=lfs merge=lfs -text
+shortest_impossible_sequence_of_rolls/meta.json filter=lfs diff=lfs merge=lfs -text
+shortest_subarray_with_or_at_least_k_ii/meta.json filter=lfs diff=lfs merge=lfs -text
+sliding_subarray_beauty/meta.json filter=lfs diff=lfs merge=lfs -text
+smallest_missing_non_negative_integer_after_operations/meta.json filter=lfs diff=lfs merge=lfs -text
+solving_questions_with_brainpower/meta.json filter=lfs diff=lfs merge=lfs -text
+sorted_gcd_pair_queries/meta.json filter=lfs diff=lfs merge=lfs -text
+steps_to_make_array_non_decreasing/meta.json filter=lfs diff=lfs merge=lfs -text
+subarray_with_elements_greater_than_varying_threshold/meta.json filter=lfs diff=lfs merge=lfs -text
+substring_xor_queries/meta.json filter=lfs diff=lfs merge=lfs -text
+successful_pairs_of_spells_and_potions/meta.json filter=lfs diff=lfs merge=lfs -text
+sum_of_distances/meta.json filter=lfs diff=lfs merge=lfs -text
+sum_of_matrix_after_queries/meta.json filter=lfs diff=lfs merge=lfs -text
+task_scheduler_ii/meta.json filter=lfs diff=lfs merge=lfs -text
+total_cost_to_hire_k_workers/meta.json filter=lfs diff=lfs merge=lfs -text
+zero_array_transformation_i/haskell_tests/Main.hs filter=lfs diff=lfs merge=lfs -text
+zero_array_transformation_i/meta.json filter=lfs diff=lfs merge=lfs -text
+zero_array_transformation_i/ocaml_tests/main.ml filter=lfs diff=lfs merge=lfs -text
+zero_array_transformation_i/scala_tests/MySuite.scala filter=lfs diff=lfs merge=lfs -text
+zero_array_transformation_ii/haskell_tests/Main.hs filter=lfs diff=lfs merge=lfs -text
+zero_array_transformation_ii/meta.json filter=lfs diff=lfs merge=lfs -text
+zero_array_transformation_ii/scala_tests/MySuite.scala filter=lfs diff=lfs merge=lfs -text
+zero_array_transformation_iii/haskell_tests/Main.hs filter=lfs diff=lfs merge=lfs -text
+zero_array_transformation_iii/meta.json filter=lfs diff=lfs merge=lfs -text

add_edges_to_make_degrees_of_all_nodes_even/haskell_tests/Main.hs

@@ -0,0 +1,27 @@
+
+module Main where
+import Test.HUnit
+
+--Program start
+
+--Program end
+
+-- Test cases
+
+test1 :: Test
+test1 = TestCase (assertEqual "for (isPossible 5 [[1,2],[2,3],[3,4],[4,2],[1,4],[2,5]])," True (isPossible 5 [[1,2],[2,3],[3,4],[4,2],[1,4],[2,5]]))
+
+test2 :: Test
+test2 = TestCase (assertEqual "for (isPossible 4 [[1,2],[3,4]])," True (isPossible 4 [[1,2],[3,4]]))
+
+test3 :: Test
+test3 = TestCase (assertEqual "for (isPossible 4 [[1,2],[1,3],[1,4]])," False (isPossible 4 [[1,2],[1,3],[1,4]]))
+
+
+-- Grouping test cases
+tests :: Test
+tests = TestList [TestLabel "Test1" test1, TestLabel "Test2" test2]
+
+-- Running the tests
+main :: IO Counts
+main = runTestTT tests

add_edges_to_make_degrees_of_all_nodes_even/java_tests/Main.java

@@ -0,0 +1,25 @@
+
+import static org.junit.jupiter.api.Assertions.*;
+import org.junit.jupiter.api.Test;
+import java.util.List;
+import java.util.Arrays;
+import java.util.ArrayList;
+public class Main {
+    //Program start
+    
+    //Program end
+
+    @Test
+public void test1() {
+    assertEquals(true, isPossible(5, new ArrayList<>(Arrays.asList(new ArrayList<>(Arrays.asList(1,2)),new ArrayList<>(Arrays.asList(2,3)),new ArrayList<>(Arrays.asList(3,4)),new ArrayList<>(Arrays.asList(4,2)),new ArrayList<>(Arrays.asList(1,4)),new ArrayList<>(Arrays.asList(2,5))))));
+}
+@Test
+public void test2() {
+    assertEquals(true, isPossible(4, new ArrayList<>(Arrays.asList(new ArrayList<>(Arrays.asList(1,2)),new ArrayList<>(Arrays.asList(3,4))))));
+}
+@Test
+public void test3() {
+    assertEquals(false, isPossible(4, new ArrayList<>(Arrays.asList(new ArrayList<>(Arrays.asList(1,2)),new ArrayList<>(Arrays.asList(1,3)),new ArrayList<>(Arrays.asList(1,4))))));
+}
+
+}

add_edges_to_make_degrees_of_all_nodes_even/meta.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:26b3d803db7b998bccd4920f2700d94c046456ec26a0c24cc4daeca7d5d672a4
+size 48906019

add_edges_to_make_degrees_of_all_nodes_even/ocaml_tests/main.ml

@@ -0,0 +1,29 @@
+
+module Main = struct
+    open OUnit2
+
+    (* Program start *)
+
+    (* Program end *)
+
+    (* Test cases *)
+    
+let test1 _ = assert_equal true (isPossible 5 [[1;2];[2;3];[3;4];[4;2];[1;4];[2;5]])
+
+let test2 _ = assert_equal true (isPossible 4 [[1;2];[3;4]])
+
+let test3 _ = assert_equal false (isPossible 4 [[1;2];[1;3];[1;4]])
+
+
+    (* Grouping test cases *)
+    let suite = "Test Suite for isPossible" >::: [
+        
+  "test1" >:: test1;
+  "test2" >:: test2;
+  "test3" >:: test3;
+    ]
+
+
+    (* Running the tests *)
+    let () = run_test_tt_main suite
+end

add_edges_to_make_degrees_of_all_nodes_even/scala_tests/MySuite.scala

@@ -0,0 +1,16 @@
+
+class MySuite extends munit.FunSuite {
+  
+  test("test1") {
+    assertEquals(Main.isPossible(5,List(List(1,2),List(2,3),List(3,4),List(4,2),List(1,4),List(2,5))), true)
+  }
+
+  test("test2") {
+    assertEquals(Main.isPossible(4,List(List(1,2),List(3,4))), true)
+  }
+
+  test("test3") {
+    assertEquals(Main.isPossible(4,List(List(1,2),List(1,3),List(1,4))), false)
+  }
+
+}

adjacent_increasing_subarrays_detection_i/haskell_tests/Main.hs

@@ -0,0 +1,45 @@
+
+module Main where
+import Test.HUnit
+
+--Program start
+
+--Program end
+
+-- Test cases
+
+test1 :: Test
+test1 = TestCase (assertEqual "for (hasIncreasingSubarrays [2,5,7,8,9,2,3,4,3,1] 3)," True (hasIncreasingSubarrays [2,5,7,8,9,2,3,4,3,1] 3))
+
+test2 :: Test
+test2 = TestCase (assertEqual "for (hasIncreasingSubarrays [1,2,3,4,4,4,4,5,6,7] 5)," False (hasIncreasingSubarrays [1,2,3,4,4,4,4,5,6,7] 5))
+
+test3 :: Test
+test3 = TestCase (assertEqual "for (hasIncreasingSubarrays [-669, 939, ( -671), ( -764), ( -122), 65, 433, ( -158), 532, ( -539), 634, ( -912), ( -271), 596, 397, 732, ( -474), 665, 518, 851, 3, 290, ( -172), ( -303), ( -856), 594, ( -99), 265, ( -948), ( -66), 381, ( -217), 765, 992, ( -799), ( -962), ( -359), ( -116), ( -737), ( -271), 441, 552, ( -845), ( -663), ( -415), 23, 987] 20)," False (hasIncreasingSubarrays [-669, 939, -671, -764, -122, 65, 433, -158, 532, -539, 634, -912, -271, 596, 397, 732, -474, 665, 518, 851, 3, 290, -172, -303, -856, 594, -99, 265, -948, -66, 381, -217, 765, 992, -799, -962, -359, -116, -737, -271, 441, 552, -845, -663, -415, 23, 987] 20))
+
+test4 :: Test
+test4 = TestCase (assertEqual "for (hasIncreasingSubarrays [846, ( -627), 915, ( -300), ( -391), ( -505), 507] 2)," False (hasIncreasingSubarrays [846, -627, 915, -300, -391, -505, 507] 2))
+
+test5 :: Test
+test5 = TestCase (assertEqual "for (hasIncreasingSubarrays [871, ( -896), ( -232), 537, 464, 728, ( -10), ( -927), ( -539), ( -113), 928, 555, 775, ( -900), ( -289), 795, ( -849), 450, 253, 450, ( -308), ( -589), ( -563), 848, 119, ( -780), ( -381)] 5)," False (hasIncreasingSubarrays [871, -896, -232, 537, 464, 728, -10, -927, -539, -113, 928, 555, 775, -900, -289, 795, -849, 450, 253, 450, -308, -589, -563, 848, 119, -780, -381] 5))
+
+test6 :: Test
+test6 = TestCase (assertEqual "for (hasIncreasingSubarrays [0, ( -807), 367, 485, 105, 174, ( -444), ( -479), ( -440), ( -626), ( -645), 422, 608, 881, ( -2), 147, ( -796), ( -752), 799, ( -782), ( -281), ( -955), ( -700), ( -946), ( -175), 134, 738, ( -983), 441, 284, 545, ( -597), ( -168), ( -53), 702, ( -845), ( -34), 126, ( -351), 842, 257, 59, 821, ( -974), 546, ( -628), ( -55), ( -452), 203, ( -793), ( -251), ( -515), 284] 16)," False (hasIncreasingSubarrays [0, -807, 367, 485, 105, 174, -444, -479, -440, -626, -645, 422, 608, 881, -2, 147, -796, -752, 799, -782, -281, -955, -700, -946, -175, 134, 738, -983, 441, 284, 545, -597, -168, -53, 702, -845, -34, 126, -351, 842, 257, 59, 821, -974, 546, -628, -55, -452, 203, -793, -251, -515, 284] 16))
+
+test7 :: Test
+test7 = TestCase (assertEqual "for (hasIncreasingSubarrays [-256, ( -176), 324, ( -573), ( -964), ( -489), ( -141), 884, ( -44), 137, 492, 813, ( -442), 608, ( -455), 971, ( -200), 940, 772, 359, ( -886), ( -454), ( -148), ( -473), ( -344), 18, 292, 137, ( -893), 238, ( -706), 974, ( -980), ( -639), ( -51), 267] 6)," False (hasIncreasingSubarrays [-256, -176, 324, -573, -964, -489, -141, 884, -44, 137, 492, 813, -442, 608, -455, 971, -200, 940, 772, 359, -886, -454, -148, -473, -344, 18, 292, 137, -893, 238, -706, 974, -980, -639, -51, 267] 6))
+
+test8 :: Test
+test8 = TestCase (assertEqual "for (hasIncreasingSubarrays [-744, 380, 344, 139, 841, 750, 102, ( -653), ( -428), ( -138), 104, 987, 604, ( -83), ( -428), ( -414), 664, ( -601), 663, ( -907), 190, 180, 926, ( -533), ( -872)] 3)," False (hasIncreasingSubarrays [-744, 380, 344, 139, 841, 750, 102, -653, -428, -138, 104, 987, 604, -83, -428, -414, 664, -601, 663, -907, 190, 180, 926, -533, -872] 3))
+
+test9 :: Test
+test9 = TestCase (assertEqual "for (hasIncreasingSubarrays [945, ( -656), 548, ( -31), 150, 186, 646, ( -910), 998, 336, 297, ( -267), 255, 748, ( -171), 488, ( -426), 826, ( -497), ( -228), 558, ( -875), 606, ( -372), ( -83), ( -63), ( -639), 195, 747, ( -795), ( -198), 102, 187, ( -546), ( -325), 414, 839, 890, 959, ( -581), ( -662), 365, 369, 12, ( -955), ( -657), ( -199), 56, ( -141), 382, ( -892), ( -461), 259, ( -574), ( -677), ( -211), ( -170), 889, ( -221), 462, 901, 291, 588, 863, 193, 376, ( -358), ( -677), 620, ( -717), 782, 813, ( -329), ( -424), ( -901)] 18)," False (hasIncreasingSubarrays [945, -656, 548, -31, 150, 186, 646, -910, 998, 336, 297, -267, 255, 748, -171, 488, -426, 826, -497, -228, 558, -875, 606, -372, -83, -63, -639, 195, 747, -795, -198, 102, 187, -546, -325, 414, 839, 890, 959, -581, -662, 365, 369, 12, -955, -657, -199, 56, -141, 382, -892, -461, 259, -574, -677, -211, -170, 889, -221, 462, 901, 291, 588, 863, 193, 376, -358, -677, 620, -717, 782, 813, -329, -424, -901] 18))
+
+
+-- Grouping test cases
+tests :: Test
+tests = TestList [TestLabel "Test1" test1, TestLabel "Test2" test2, TestLabel "Test3" test3, TestLabel "Test4" test4, TestLabel "Test5" test5, TestLabel "Test6" test6, TestLabel "Test7" test7, TestLabel "Test8" test8, TestLabel "Test9" test9]
+
+-- Running the tests
+main :: IO Counts
+main = runTestTT tests

adjacent_increasing_subarrays_detection_i/java_tests/Main.java

@@ -0,0 +1,21 @@
+
+import static org.junit.jupiter.api.Assertions.*;
+import org.junit.jupiter.api.Test;
+import java.util.List;
+import java.util.Arrays;
+import java.util.ArrayList;
+public class Main {
+    //Program start
+    
+    //Program end
+
+    @Test
+public void test1() {
+    assertEquals(true, hasIncreasingSubarrays(new ArrayList<>(Arrays.asList(2,5,7,8,9,2,3,4,3,1)), 3));
+}
+@Test
+public void test2() {
+    assertEquals(fals, hasIncreasingSubarrays(new ArrayList<>(Arrays.asList(1,2,3,4,4,4,4,5,6,7)), 5));
+}
+
+}

adjacent_increasing_subarrays_detection_i/meta.json

@@ -0,0 +1,603 @@
+{
+    "id": 3612,
+    "name": "adjacent_increasing_subarrays_detection_i",
+    "difficulty": "Easy",
+    "link": "https://leetcode.com/problems/adjacent-increasing-subarrays-detection-i/",
+    "date": "2024-11-03 00:00:00",
+    "task_description": "Given an array `nums` of `n` integers and an integer `k`, determine whether there exist **two** **adjacent** subarrays of length `k` such that both subarrays are **strictly** **increasing**. Specifically, check if there are **two** subarrays starting at indices `a` and `b` (`a < b`), where: Both subarrays `nums[a..a + k - 1]` and `nums[b..b + k - 1]` are **strictly increasing**. The subarrays must be **adjacent**, meaning `b = a + k`. Return `true` if it is _possible_ to find **two **such subarrays, and `false` otherwise. **Example 1:** **Input:** nums = [2,5,7,8,9,2,3,4,3,1], k = 3 **Output:** true **Explanation:** The subarray starting at index `2` is `[7, 8, 9]`, which is strictly increasing. The subarray starting at index `5` is `[2, 3, 4]`, which is also strictly increasing. These two subarrays are adjacent, so the result is `true`. **Example 2:** **Input:** nums = [1,2,3,4,4,4,4,5,6,7], k = 5 **Output:** false **Constraints:** `2 <= nums.length <= 100` `1 < 2 * k <= nums.length` `-1000 <= nums[i] <= 1000`",
+    "public_test_cases": [
+        {
+            "label": "Example 1",
+            "input": "nums = [2,5,7,8,9,2,3,4,3,1], k = 3",
+            "output": "true "
+        },
+        {
+            "label": "Example 2",
+            "input": "nums = [1,2,3,4,4,4,4,5,6,7], k = 5",
+            "output": "false"
+        }
+    ],
+    "private_test_cases": [
+        {
+            "input": [
+                [
+                    -669,
+                    939,
+                    -671,
+                    -764,
+                    -122,
+                    65,
+                    433,
+                    -158,
+                    532,
+                    -539,
+                    634,
+                    -912,
+                    -271,
+                    596,
+                    397,
+                    732,
+                    -474,
+                    665,
+                    518,
+                    851,
+                    3,
+                    290,
+                    -172,
+                    -303,
+                    -856,
+                    594,
+                    -99,
+                    265,
+                    -948,
+                    -66,
+                    381,
+                    -217,
+                    765,
+                    992,
+                    -799,
+                    -962,
+                    -359,
+                    -116,
+                    -737,
+                    -271,
+                    441,
+                    552,
+                    -845,
+                    -663,
+                    -415,
+                    23,
+                    987
+                ],
+                20
+            ],
+            "output": false
+        },
+        {
+            "input": [
+                [
+                    846,
+                    -627,
+                    915,
+                    -300,
+                    -391,
+                    -505,
+                    507
+                ],
+                2
+            ],
+            "output": false
+        },
+        {
+            "input": [
+                [
+                    871,
+                    -896,
+                    -232,
+                    537,
+                    464,
+                    728,
+                    -10,
+                    -927,
+                    -539,
+                    -113,
+                    928,
+                    555,
+                    775,
+                    -900,
+                    -289,
+                    795,
+                    -849,
+                    450,
+                    253,
+                    450,
+                    -308,
+                    -589,
+                    -563,
+                    848,
+                    119,
+                    -780,
+                    -381
+                ],
+                5
+            ],
+            "output": false
+        },
+        {
+            "input": [
+                [
+                    0,
+                    -807,
+                    367,
+                    485,
+                    105,
+                    174,
+                    -444,
+                    -479,
+                    -440,
+                    -626,
+                    -645,
+                    422,
+                    608,
+                    881,
+                    -2,
+                    147,
+                    -796,
+                    -752,
+                    799,
+                    -782,
+                    -281,
+                    -955,
+                    -700,
+                    -946,
+                    -175,
+                    134,
+                    738,
+                    -983,
+                    441,
+                    284,
+                    545,
+                    -597,
+                    -168,
+                    -53,
+                    702,
+                    -845,
+                    -34,
+                    126,
+                    -351,
+                    842,
+                    257,
+                    59,
+                    821,
+                    -974,
+                    546,
+                    -628,
+                    -55,
+                    -452,
+                    203,
+                    -793,
+                    -251,
+                    -515,
+                    284
+                ],
+                16
+            ],
+            "output": false
+        },
+        {
+            "input": [
+                [
+                    -256,
+                    -176,
+                    324,
+                    -573,
+                    -964,
+                    -489,
+                    -141,
+                    884,
+                    -44,
+                    137,
+                    492,
+                    813,
+                    -442,
+                    608,
+                    -455,
+                    971,
+                    -200,
+                    940,
+                    772,
+                    359,
+                    -886,
+                    -454,
+                    -148,
+                    -473,
+                    -344,
+                    18,
+                    292,
+                    137,
+                    -893,
+                    238,
+                    -706,
+                    974,
+                    -980,
+                    -639,
+                    -51,
+                    267
+                ],
+                6
+            ],
+            "output": false
+        },
+        {
+            "input": [
+                [
+                    -744,
+                    380,
+                    344,
+                    139,
+                    841,
+                    750,
+                    102,
+                    -653,
+                    -428,
+                    -138,
+                    104,
+                    987,
+                    604,
+                    -83,
+                    -428,
+                    -414,
+                    664,
+                    -601,
+                    663,
+                    -907,
+                    190,
+                    180,
+                    926,
+                    -533,
+                    -872
+                ],
+                3
+            ],
+            "output": false
+        },
+        {
+            "input": [
+                [
+                    945,
+                    -656,
+                    548,
+                    -31,
+                    150,
+                    186,
+                    646,
+                    -910,
+                    998,
+                    336,
+                    297,
+                    -267,
+                    255,
+                    748,
+                    -171,
+                    488,
+                    -426,
+                    826,
+                    -497,
+                    -228,
+                    558,
+                    -875,
+                    606,
+                    -372,
+                    -83,
+                    -63,
+                    -639,
+                    195,
+                    747,
+                    -795,
+                    -198,
+                    102,
+                    187,
+                    -546,
+                    -325,
+                    414,
+                    839,
+                    890,
+                    959,
+                    -581,
+                    -662,
+                    365,
+                    369,
+                    12,
+                    -955,
+                    -657,
+                    -199,
+                    56,
+                    -141,
+                    382,
+                    -892,
+                    -461,
+                    259,
+                    -574,
+                    -677,
+                    -211,
+                    -170,
+                    889,
+                    -221,
+                    462,
+                    901,
+                    291,
+                    588,
+                    863,
+                    193,
+                    376,
+                    -358,
+                    -677,
+                    620,
+                    -717,
+                    782,
+                    813,
+                    -329,
+                    -424,
+                    -901
+                ],
+                18
+            ],
+            "output": false
+        },
+        {
+            "input": [
+                [
+                    -344,
+                    743,
+                    491,
+                    216,
+                    42,
+                    -955,
+                    -472,
+                    -736,
+                    582,
+                    -552,
+                    814,
+                    538,
+                    35,
+                    -988,
+                    971,
+                    362,
+                    227,
+                    -42,
+                    709,
+                    -704,
+                    -529,
+                    -537,
+                    172,
+                    609,
+                    217,
+                    -73,
+                    -444,
+                    67,
+                    -820,
+                    -687,
+                    -158,
+                    738,
+                    605,
+                    804,
+                    -779,
+                    463,
+                    -677,
+                    491,
+                    -459,
+                    -479,
+                    -856,
+                    680,
+                    -499,
+                    -349,
+                    -864,
+                    -462,
+                    359,
+                    119,
+                    -916,
+                    43,
+                    699,
+                    -488,
+                    325,
+                    559,
+                    487,
+                    151,
+                    595,
+                    425,
+                    -785,
+                    706,
+                    390,
+                    215,
+                    -883,
+                    -693,
+                    446
+                ],
+                3
+            ],
+            "output": true
+        },
+        {
+            "input": [
+                [
+                    -996,
+                    361,
+                    -258,
+                    -631,
+                    -979,
+                    897,
+                    -327,
+                    -292,
+                    337,
+                    -78,
+                    -520,
+                    219,
+                    -781,
+                    543,
+                    337,
+                    -380,
+                    -594,
+                    890,
+                    364,
+                    384,
+                    -513,
+                    144,
+                    -925,
+                    315,
+                    273,
+                    363,
+                    -984,
+                    170,
+                    -841,
+                    -78,
+                    -801,
+                    892,
+                    -630,
+                    193,
+                    212,
+                    157,
+                    403,
+                    238,
+                    -718,
+                    -641,
+                    944,
+                    219,
+                    -227,
+                    -986,
+                    -432,
+                    165,
+                    629,
+                    -137,
+                    -696,
+                    865,
+                    776,
+                    117,
+                    890,
+                    627,
+                    -135,
+                    667,
+                    -507,
+                    -103,
+                    34,
+                    455,
+                    -905,
+                    -773,
+                    90,
+                    -340,
+                    -606,
+                    -129,
+                    -215,
+                    437,
+                    -61,
+                    308,
+                    -264,
+                    306,
+                    -253,
+                    -399,
+                    -677,
+                    912,
+                    -274,
+                    71
+                ],
+                15
+            ],
+            "output": false
+        },
+        {
+            "input": [
+                [
+                    188,
+                    642,
+                    -770,
+                    -52,
+                    -48,
+                    858,
+                    -237,
+                    449,
+                    -619,
+                    40,
+                    -469,
+                    852,
+                    836,
+                    40,
+                    -944,
+                    -275,
+                    69,
+                    -951,
+                    -455,
+                    822,
+                    -255,
+                    417,
+                    -139,
+                    -546,
+                    -978,
+                    200,
+                    378,
+                    545,
+                    306,
+                    710,
+                    617,
+                    585,
+                    -653,
+                    463,
+                    474,
+                    732,
+                    98,
+                    541,
+                    -47,
+                    -23,
+                    -550,
+                    -972,
+                    -50,
+                    361,
+                    675,
+                    -365,
+                    673,
+                    -866,
+                    -522,
+                    -879,
+                    752,
+                    -893,
+                    -458,
+                    -673,
+                    774,
+                    -721,
+                    498,
+                    -212,
+                    801,
+                    654,
+                    886,
+                    -257,
+                    489,
+                    -367,
+                    -57,
+                    -155,
+                    -139,
+                    -693,
+                    875,
+                    299,
+                    -426,
+                    -566,
+                    250,
+                    -121,
+                    677,
+                    -65,
+                    523,
+                    439,
+                    119,
+                    407,
+                    -715,
+                    915,
+                    674
+                ],
+                38
+            ],
+            "output": false
+        }
+    ],
+    "haskell_template": "hasIncreasingSubarrays :: [Int] -> Int -> Bool\nhasIncreasingSubarrays nums k ",
+    "ocaml_template": "let hasIncreasingSubarrays (nums: int list) (k: int) : bool =  ",
+    "scala_template": "def hasIncreasingSubarrays(nums: List[Int],k: Int): Boolean = { \n    \n}",
+    "java_template": "class Solution {\n    public boolean hasIncreasingSubarrays(List<Integer> nums, int k) {\n        \n    }\n}",
+    "python_template": "class Solution(object):\n    def hasIncreasingSubarrays(self, nums, k):\n        \"\"\"\n        :type nums: List[int]\n        :type k: int\n        :rtype: bool\n        \"\"\"\n        "
+}

adjacent_increasing_subarrays_detection_i/ocaml_tests/main.ml

@@ -0,0 +1,50 @@
+
+module Main = struct
+    open OUnit2
+
+    (* Program start *)
+
+    (* Program end *)
+
+    (* Test cases *)
+    
+let test1 _ = assert_equal true (hasIncreasingSubarrays [2;5;7;8;9;2;3;4;3;1] 3)
+
+let test2 _ = assert_equal false (hasIncreasingSubarrays [1;2;3;4;4;4;4;5;6;7] 5)
+
+let test3 _ = assert_equal false (hasIncreasingSubarrays [-669; 939; ( -671); ( -764); ( -122); 65; 433; ( -158); 532; ( -539); 634; ( -912); ( -271); 596; 397; 732; ( -474); 665; 518; 851; 3; 290; ( -172); ( -303); ( -856); 594; ( -99); 265; ( -948); ( -66); 381; ( -217); 765; 992; ( -799); ( -962); ( -359); ( -116); ( -737); ( -271); 441; 552; ( -845); ( -663); ( -415); 23; 987] 20)
+
+let test4 _ = assert_equal false (hasIncreasingSubarrays [846; ( -627); 915; ( -300); ( -391); ( -505); 507] 2)
+
+let test5 _ = assert_equal false (hasIncreasingSubarrays [871; ( -896); ( -232); 537; 464; 728; ( -10); ( -927); ( -539); ( -113); 928; 555; 775; ( -900); ( -289); 795; ( -849); 450; 253; 450; ( -308); ( -589); ( -563); 848; 119; ( -780); ( -381)] 5)
+
+let test6 _ = assert_equal false (hasIncreasingSubarrays [0; ( -807); 367; 485; 105; 174; ( -444); ( -479); ( -440); ( -626); ( -645); 422; 608; 881; ( -2); 147; ( -796); ( -752); 799; ( -782); ( -281); ( -955); ( -700); ( -946); ( -175); 134; 738; ( -983); 441; 284; 545; ( -597); ( -168); ( -53); 702; ( -845); ( -34); 126; ( -351); 842; 257; 59; 821; ( -974); 546; ( -628); ( -55); ( -452); 203; ( -793); ( -251); ( -515); 284] 16)
+
+let test7 _ = assert_equal false (hasIncreasingSubarrays [-256; ( -176); 324; ( -573); ( -964); ( -489); ( -141); 884; ( -44); 137; 492; 813; ( -442); 608; ( -455); 971; ( -200); 940; 772; 359; ( -886); ( -454); ( -148); ( -473); ( -344); 18; 292; 137; ( -893); 238; ( -706); 974; ( -980); ( -639); ( -51); 267] 6)
+
+let test8 _ = assert_equal false (hasIncreasingSubarrays [-744; 380; 344; 139; 841; 750; 102; ( -653); ( -428); ( -138); 104; 987; 604; ( -83); ( -428); ( -414); 664; ( -601); 663; ( -907); 190; 180; 926; ( -533); ( -872)] 3)
+
+let test9 _ = assert_equal false (hasIncreasingSubarrays [945; ( -656); 548; ( -31); 150; 186; 646; ( -910); 998; 336; 297; ( -267); 255; 748; ( -171); 488; ( -426); 826; ( -497); ( -228); 558; ( -875); 606; ( -372); ( -83); ( -63); ( -639); 195; 747; ( -795); ( -198); 102; 187; ( -546); ( -325); 414; 839; 890; 959; ( -581); ( -662); 365; 369; 12; ( -955); ( -657); ( -199); 56; ( -141); 382; ( -892); ( -461); 259; ( -574); ( -677); ( -211); ( -170); 889; ( -221); 462; 901; 291; 588; 863; 193; 376; ( -358); ( -677); 620; ( -717); 782; 813; ( -329); ( -424); ( -901)] 18)
+
+let test10 _ = assert_equal true (hasIncreasingSubarrays [-344; 743; 491; 216; 42; ( -955); ( -472); ( -736); 582; ( -552); 814; 538; 35; ( -988); 971; 362; 227; ( -42); 709; ( -704); ( -529); ( -537); 172; 609; 217; ( -73); ( -444); 67; ( -820); ( -687); ( -158); 738; 605; 804; ( -779); 463; ( -677); 491; ( -459); ( -479); ( -856); 680; ( -499); ( -349); ( -864); ( -462); 359; 119; ( -916); 43; 699; ( -488); 325; 559; 487; 151; 595; 425; ( -785); 706; 390; 215; ( -883); ( -693); 446] 3)
+
+
+    (* Grouping test cases *)
+    let suite = "Test Suite for hasIncreasingSubarrays" >::: [
+        
+  "test1" >:: test1;
+  "test2" >:: test2;
+  "test3" >:: test3;
+  "test4" >:: test4;
+  "test5" >:: test5;
+  "test6" >:: test6;
+  "test7" >:: test7;
+  "test8" >:: test8;
+  "test9" >:: test9;
+  "test10" >:: test10;
+    ]
+
+
+    (* Running the tests *)
+    let () = run_test_tt_main suite
+end

adjacent_increasing_subarrays_detection_i/scala_tests/MySuite.scala

@@ -0,0 +1,44 @@
+
+class MySuite extends munit.FunSuite {
+  
+  test("test1") {
+    assertEquals(Main.hasIncreasingSubarrays(List(2,5,7,8,9,2,3,4,3,1),3), true)
+  }
+
+  test("test2") {
+    assertEquals(Main.hasIncreasingSubarrays(List(1,2,3,4,4,4,4,5,6,7),5), false)
+  }
+
+  test("test3") {
+    assertEquals(Main.hasIncreasingSubarrays(List(-669, 939, -671, -764, -122, 65, 433, -158, 532, -539, 634, -912, -271, 596, 397, 732, -474, 665, 518, 851, 3, 290, -172, -303, -856, 594, -99, 265, -948, -66, 381, -217, 765, 992, -799, -962, -359, -116, -737, -271, 441, 552, -845, -663, -415, 23, 987),20), false)
+  }
+
+  test("test4") {
+    assertEquals(Main.hasIncreasingSubarrays(List(846, -627, 915, -300, -391, -505, 507),2), false)
+  }
+
+  test("test5") {
+    assertEquals(Main.hasIncreasingSubarrays(List(871, -896, -232, 537, 464, 728, -10, -927, -539, -113, 928, 555, 775, -900, -289, 795, -849, 450, 253, 450, -308, -589, -563, 848, 119, -780, -381),5), false)
+  }
+
+  test("test6") {
+    assertEquals(Main.hasIncreasingSubarrays(List(0, -807, 367, 485, 105, 174, -444, -479, -440, -626, -645, 422, 608, 881, -2, 147, -796, -752, 799, -782, -281, -955, -700, -946, -175, 134, 738, -983, 441, 284, 545, -597, -168, -53, 702, -845, -34, 126, -351, 842, 257, 59, 821, -974, 546, -628, -55, -452, 203, -793, -251, -515, 284),16), false)
+  }
+
+  test("test7") {
+    assertEquals(Main.hasIncreasingSubarrays(List(-256, -176, 324, -573, -964, -489, -141, 884, -44, 137, 492, 813, -442, 608, -455, 971, -200, 940, 772, 359, -886, -454, -148, -473, -344, 18, 292, 137, -893, 238, -706, 974, -980, -639, -51, 267),6), false)
+  }
+
+  test("test8") {
+    assertEquals(Main.hasIncreasingSubarrays(List(-744, 380, 344, 139, 841, 750, 102, -653, -428, -138, 104, 987, 604, -83, -428, -414, 664, -601, 663, -907, 190, 180, 926, -533, -872),3), false)
+  }
+
+  test("test9") {
+    assertEquals(Main.hasIncreasingSubarrays(List(945, -656, 548, -31, 150, 186, 646, -910, 998, 336, 297, -267, 255, 748, -171, 488, -426, 826, -497, -228, 558, -875, 606, -372, -83, -63, -639, 195, 747, -795, -198, 102, 187, -546, -325, 414, 839, 890, 959, -581, -662, 365, 369, 12, -955, -657, -199, 56, -141, 382, -892, -461, 259, -574, -677, -211, -170, 889, -221, 462, 901, 291, 588, 863, 193, 376, -358, -677, 620, -717, 782, 813, -329, -424, -901),18), false)
+  }
+
+  test("test10") {
+    assertEquals(Main.hasIncreasingSubarrays(List(-344, 743, 491, 216, 42, -955, -472, -736, 582, -552, 814, 538, 35, -988, 971, 362, 227, -42, 709, -704, -529, -537, 172, 609, 217, -73, -444, 67, -820, -687, -158, 738, 605, 804, -779, 463, -677, 491, -459, -479, -856, 680, -499, -349, -864, -462, 359, 119, -916, 43, 699, -488, 325, 559, 487, 151, 595, 425, -785, 706, 390, 215, -883, -693, 446),3), true)
+  }
+
+}

alice_and_bob_playing_flower_game/haskell_tests/Main.hs

@@ -0,0 +1,45 @@
+
+module Main where
+import Test.HUnit
+
+--Program start
+
+--Program end
+
+-- Test cases
+
+test1 :: Test
+test1 = TestCase (assertEqual "for (flowerGame 3 2)," 3 (flowerGame 3 2))
+
+test2 :: Test
+test2 = TestCase (assertEqual "for (flowerGame 1 1)," 0 (flowerGame 1 1))
+
+test3 :: Test
+test3 = TestCase (assertEqual "for (flowerGame 76449 82807)," 3165256171 (flowerGame 76449 82807))
+
+test4 :: Test
+test4 = TestCase (assertEqual "for (flowerGame 37149 7947)," 147611551 (flowerGame 37149 7947))
+
+test5 :: Test
+test5 = TestCase (assertEqual "for (flowerGame 65876 54651)," 1800094638 (flowerGame 65876 54651))
+
+test6 :: Test
+test6 = TestCase (assertEqual "for (flowerGame 83462 43930)," 1833242830 (flowerGame 83462 43930))
+
+test7 :: Test
+test7 = TestCase (assertEqual "for (flowerGame 85778 70262)," 3013466918 (flowerGame 85778 70262))
+
+test8 :: Test
+test8 = TestCase (assertEqual "for (flowerGame 85146 43396)," 1847497908 (flowerGame 85146 43396))
+
+test9 :: Test
+test9 = TestCase (assertEqual "for (flowerGame 31445 22823)," 358834617 (flowerGame 31445 22823))
+
+
+-- Grouping test cases
+tests :: Test
+tests = TestList [TestLabel "Test1" test1, TestLabel "Test2" test2, TestLabel "Test3" test3, TestLabel "Test4" test4, TestLabel "Test5" test5, TestLabel "Test6" test6, TestLabel "Test7" test7, TestLabel "Test8" test8, TestLabel "Test9" test9]
+
+-- Running the tests
+main :: IO Counts
+main = runTestTT tests

alice_and_bob_playing_flower_game/java_tests/Main.java

@@ -0,0 +1,21 @@
+
+import static org.junit.jupiter.api.Assertions.*;
+import org.junit.jupiter.api.Test;
+import java.util.List;
+import java.util.Arrays;
+import java.util.ArrayList;
+public class Main {
+    //Program start
+    
+    //Program end
+
+    @Test
+public void test1() {
+    assertEquals(3, flowerGame(3, 2));
+}
+@Test
+public void test2() {
+    assertEquals(0, flowerGame(1, 1));
+}
+
+}

alice_and_bob_playing_flower_game/meta.json

@@ -0,0 +1,97 @@
+{
+    "id": 3279,
+    "name": "alice_and_bob_playing_flower_game",
+    "difficulty": "Medium",
+    "link": "https://leetcode.com/problems/alice-and-bob-playing-flower-game/",
+    "date": "2024-01-21 00:00:00",
+    "task_description": "Alice and Bob are playing a turn-based game on a circular field surrounded by flowers. The circle represents the field, and there are `x` flowers in the clockwise direction between Alice and Bob, and `y` flowers in the anti-clockwise direction between them. The game proceeds as follows: Alice takes the first turn. In each turn, a player must choose either the clockwise or anti-clockwise direction and pick one flower from that side. At the end of the turn, if there are no flowers left at all, the **current** player captures their opponent and wins the game. Given two integers, `n` and `m`, the task is to compute the number of possible pairs `(x, y)` that satisfy the conditions: Alice must win the game according to the described rules. The number of flowers `x` in the clockwise direction must be in the range `[1,n]`. The number of flowers `y` in the anti-clockwise direction must be in the range `[1,m]`. Return _the number of possible pairs_ `(x, y)` _that satisfy the conditions mentioned in the statement_. **Example 1:** ``` **Input:** n = 3, m = 2 **Output:** 3 **Explanation:** The following pairs satisfy conditions described in the statement: (1,2), (3,2), (2,1). ``` **Example 2:** ``` **Input:** n = 1, m = 1 **Output:** 0 **Explanation:** No pairs satisfy the conditions described in the statement. ``` **Constraints:** `1 <= n, m <= 105`",
+    "public_test_cases": [
+        {
+            "label": "Example 1",
+            "input": "n = 3, m = 2",
+            "output": "3 "
+        },
+        {
+            "label": "Example 2",
+            "input": "n = 1, m = 1",
+            "output": "0 "
+        }
+    ],
+    "private_test_cases": [
+        {
+            "input": [
+                76449,
+                82807
+            ],
+            "output": 3165256171
+        },
+        {
+            "input": [
+                37149,
+                7947
+            ],
+            "output": 147611551
+        },
+        {
+            "input": [
+                65876,
+                54651
+            ],
+            "output": 1800094638
+        },
+        {
+            "input": [
+                83462,
+                43930
+            ],
+            "output": 1833242830
+        },
+        {
+            "input": [
+                85778,
+                70262
+            ],
+            "output": 3013466918
+        },
+        {
+            "input": [
+                85146,
+                43396
+            ],
+            "output": 1847497908
+        },
+        {
+            "input": [
+                31445,
+                22823
+            ],
+            "output": 358834617
+        },
+        {
+            "input": [
+                15704,
+                32979
+            ],
+            "output": 258951108
+        },
+        {
+            "input": [
+                74462,
+                73807
+            ],
+            "output": 2747908417
+        },
+        {
+            "input": [
+                53354,
+                74360
+            ],
+            "output": 1983701720
+        }
+    ],
+    "haskell_template": "flowerGame :: Int -> Int -> Int\nflowerGame n m ",
+    "ocaml_template": "let flowerGame (n: int) (m: int) : int =  ",
+    "scala_template": "def flowerGame(n: Int,m: Int): Int = { \n    \n}",
+    "java_template": "class Solution {\n    public long flowerGame(int n, int m) {\n        \n    }\n}",
+    "python_template": "class Solution(object):\n    def flowerGame(self, n, m):\n        \"\"\"\n        :type n: int\n        :type m: int\n        :rtype: int\n        \"\"\"\n        "
+}

alice_and_bob_playing_flower_game/ocaml_tests/main.ml

@@ -0,0 +1,50 @@
+
+module Main = struct
+    open OUnit2
+
+    (* Program start *)
+
+    (* Program end *)
+
+    (* Test cases *)
+    
+let test1 _ = assert_equal 3 (flowerGame 3 2)
+
+let test2 _ = assert_equal 0 (flowerGame 1 1)
+
+let test3 _ = assert_equal 3165256171 (flowerGame 76449 82807)
+
+let test4 _ = assert_equal 147611551 (flowerGame 37149 7947)
+
+let test5 _ = assert_equal 1800094638 (flowerGame 65876 54651)
+
+let test6 _ = assert_equal 1833242830 (flowerGame 83462 43930)
+
+let test7 _ = assert_equal 3013466918 (flowerGame 85778 70262)
+
+let test8 _ = assert_equal 1847497908 (flowerGame 85146 43396)
+
+let test9 _ = assert_equal 358834617 (flowerGame 31445 22823)
+
+let test10 _ = assert_equal 258951108 (flowerGame 15704 32979)
+
+
+    (* Grouping test cases *)
+    let suite = "Test Suite for flowerGame" >::: [
+        
+  "test1" >:: test1;
+  "test2" >:: test2;
+  "test3" >:: test3;
+  "test4" >:: test4;
+  "test5" >:: test5;
+  "test6" >:: test6;
+  "test7" >:: test7;
+  "test8" >:: test8;
+  "test9" >:: test9;
+  "test10" >:: test10;
+    ]
+
+
+    (* Running the tests *)
+    let () = run_test_tt_main suite
+end

alice_and_bob_playing_flower_game/scala_tests/MySuite.scala

@@ -0,0 +1,44 @@
+
+class MySuite extends munit.FunSuite {
+  
+  test("test1") {
+    assertEquals(Main.flowerGame(3,2), 3)
+  }
+
+  test("test2") {
+    assertEquals(Main.flowerGame(1,1), 0)
+  }
+
+  test("test3") {
+    assertEquals(Main.flowerGame(76449,82807), BigInt("3165256171"))
+  }
+
+  test("test4") {
+    assertEquals(Main.flowerGame(37149,7947), 147611551)
+  }
+
+  test("test5") {
+    assertEquals(Main.flowerGame(65876,54651), 1800094638)
+  }
+
+  test("test6") {
+    assertEquals(Main.flowerGame(83462,43930), 1833242830)
+  }
+
+  test("test7") {
+    assertEquals(Main.flowerGame(85778,70262), BigInt("3013466918"))
+  }
+
+  test("test8") {
+    assertEquals(Main.flowerGame(85146,43396), 1847497908)
+  }
+
+  test("test9") {
+    assertEquals(Main.flowerGame(31445,22823), 358834617)
+  }
+
+  test("test10") {
+    assertEquals(Main.flowerGame(15704,32979), 258951108)
+  }
+
+}

all_divisions_with_the_highest_score_of_a_binary_array/haskell_tests/Main.hs

@@ -0,0 +1,27 @@
+
+module Main where
+import Test.HUnit
+
+--Program start
+
+--Program end
+
+-- Test cases
+
+test1 :: Test
+test1 = TestCase (assertEqual "for (maxScoreIndices [0,0,1,0])," [2,4] (maxScoreIndices [0,0,1,0]))
+
+test2 :: Test
+test2 = TestCase (assertEqual "for (maxScoreIndices [0,0,0])," [3] (maxScoreIndices [0,0,0]))
+
+test3 :: Test
+test3 = TestCase (assertEqual "for (maxScoreIndices [1,1])," [0] (maxScoreIndices [1,1]))
+
+
+-- Grouping test cases
+tests :: Test
+tests = TestList [TestLabel "Test1" test1, TestLabel "Test2" test2]
+
+-- Running the tests
+main :: IO Counts
+main = runTestTT tests

all_divisions_with_the_highest_score_of_a_binary_array/java_tests/Main.java

@@ -0,0 +1,25 @@
+
+import static org.junit.jupiter.api.Assertions.*;
+import org.junit.jupiter.api.Test;
+import java.util.List;
+import java.util.Arrays;
+import java.util.ArrayList;
+public class Main {
+    //Program start
+    
+    //Program end
+
+    @Test
+public void test1() {
+    assertEquals(new ArrayList<>(Arrays.asList(2,4)), maxScoreIndices(new ArrayList<>(Arrays.asList(0,0,1,0))));
+}
+@Test
+public void test2() {
+    assertEquals(new ArrayList<>(Arrays.asList(3)), maxScoreIndices(new ArrayList<>(Arrays.asList(0,0,0))));
+}
+@Test
+public void test3() {
+    assertEquals(new ArrayList<>(Arrays.asList(0)), maxScoreIndices(new ArrayList<>(Arrays.asList(1,1))));
+}
+
+}

all_divisions_with_the_highest_score_of_a_binary_array/meta.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:caa21b2b9270e6fba599ae2a4f0386444b2dd465a5a98e9c14689194513427cb
+size 11483445

all_divisions_with_the_highest_score_of_a_binary_array/ocaml_tests/main.ml

@@ -0,0 +1,29 @@
+
+module Main = struct
+    open OUnit2
+
+    (* Program start *)
+
+    (* Program end *)
+
+    (* Test cases *)
+    
+let test1 _ = assert_equal [2;4] (maxScoreIndices [0;0;1;0])
+
+let test2 _ = assert_equal [3] (maxScoreIndices [0;0;0])
+
+let test3 _ = assert_equal [0] (maxScoreIndices [1;1])
+
+
+    (* Grouping test cases *)
+    let suite = "Test Suite for maxScoreIndices" >::: [
+        
+  "test1" >:: test1;
+  "test2" >:: test2;
+  "test3" >:: test3;
+    ]
+
+
+    (* Running the tests *)
+    let () = run_test_tt_main suite
+end

all_divisions_with_the_highest_score_of_a_binary_array/scala_tests/MySuite.scala

@@ -0,0 +1,16 @@
+
+class MySuite extends munit.FunSuite {
+  
+  test("test1") {
+    assertEquals(Main.maxScoreIndices(List(0,0,1,0)), List(2,4))
+  }
+
+  test("test2") {
+    assertEquals(Main.maxScoreIndices(List(0,0,0)), List(3))
+  }
+
+  test("test3") {
+    assertEquals(Main.maxScoreIndices(List(1,1)), List(0))
+  }
+
+}

alternating_groups_i/haskell_tests/Main.hs

@@ -0,0 +1,41 @@
+
+module Main where
+import Test.HUnit
+
+--Program start
+numberOfAlternatingGroups :: [Int] -> Int
+numberOfAlternatingGroups colors = undefined
+
+--Program end
+
+-- Test cases
+
+test1 :: Test
+test1 = TestCase (assertEqual "for (numberOfAlternatingGroups [1,1,1])," 0 (numberOfAlternatingGroups [1,1,1]))
+
+test2 :: Test
+test2 = TestCase (assertEqual "for (numberOfAlternatingGroups [0,1,0,0,1])," 3 (numberOfAlternatingGroups [0,1,0,0,1]))
+
+test3 :: Test
+test3 = TestCase (assertEqual "for (numberOfAlternatingGroups [1, 0, 1, 1, 0, 0, 0, 1, 1, 0, 0, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 0])," 11 (numberOfAlternatingGroups [1, 0, 1, 1, 0, 0, 0, 1, 1, 0, 0, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 0]))
+
+test4 :: Test
+test4 = TestCase (assertEqual "for (numberOfAlternatingGroups [0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 0, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 1, 0, 0, 1, 1, 1, 1, 0, 1, 0, 1, 0, 0, 0, 1, 0, 0, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 1])," 30 (numberOfAlternatingGroups [0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 0, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 1, 0, 0, 1, 1, 1, 1, 0, 1, 0, 1, 0, 0, 0, 1, 0, 0, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 1]))
+
+test5 :: Test
+test5 = TestCase (assertEqual "for (numberOfAlternatingGroups [1, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 0, 0, 0, 0, 1, 1, 1, 0, 0, 1, 0, 0, 1, 1, 0, 0, 1, 1])," 5 (numberOfAlternatingGroups [1, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 0, 0, 0, 0, 1, 1, 1, 0, 0, 1, 0, 0, 1, 1, 0, 0, 1, 1]))
+
+test6 :: Test
+test6 = TestCase (assertEqual "for (numberOfAlternatingGroups [1, 1, 0, 0, 1, 0, 1, 0, 0, 1, 0, 0, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1, 0, 1, 1, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 1, 0, 0, 1, 1, 1, 0])," 19 (numberOfAlternatingGroups [1, 1, 0, 0, 1, 0, 1, 0, 0, 1, 0, 0, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1, 0, 1, 1, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 1, 0, 0, 1, 1, 1, 0]))
+
+test7 :: Test
+test7 = TestCase (assertEqual "for (numberOfAlternatingGroups [0, 1, 0, 0, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 0, 1, 0, 0, 0, 1, 1, 0, 1, 0, 0, 1, 1, 1, 1, 1, 1, 0, 1, 1, 0, 0, 0, 1, 1, 0, 1, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 1, 0])," 11 (numberOfAlternatingGroups [0, 1, 0, 0, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 0, 1, 0, 0, 0, 1, 1, 0, 1, 0, 0, 1, 1, 1, 1, 1, 1, 0, 1, 1, 0, 0, 0, 1, 1, 0, 1, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 1, 0]))
+
+
+-- Grouping test cases
+tests :: Test
+tests = TestList [TestLabel "Test1" test1, TestLabel "Test2" test2, TestLabel "Test3" test3, TestLabel "Test4" test4, TestLabel "Test5" test5, TestLabel "Test6" test6]
+
+-- Running the tests
+main :: IO Counts
+main = runTestTT tests

alternating_groups_i/java_tests/Main.java

@@ -0,0 +1,20 @@
+
+import static org.junit.jupiter.api.Assertions.*;
+import org.junit.jupiter.api.Test;
+import java.util.List;
+import java.util.Arrays;
+public class Main {
+    //Program start
+
+    //Program end
+
+    @Test
+public void test1() {
+    assertEquals(0, numberOfAlternatingGroups(Arrays.asList(1,1,1)));
+}
+@Test
+public void test2() {
+    assertEquals(3, numberOfAlternatingGroups(Arrays.asList(0,1,0,0,1)));
+}
+
+}

alternating_groups_i/meta.json

@@ -0,0 +1,333 @@
+{
+    "id": 3463,
+    "name": "alternating_groups_i",
+    "difficulty": "Easy",
+    "link": "https://leetcode.com/problems/alternating-groups-i/",
+    "date": "2024-06-22 00:00:00",
+    "task_description": "There is a circle of red and blue tiles. You are given an array of integers `colors`. The color of tile `i` is represented by `colors[i]`: `colors[i] == 0` means that tile `i` is **red**. `colors[i] == 1` means that tile `i` is **blue**. Every 3 contiguous tiles in the circle with **alternating** colors (the middle tile has a different color from its **left** and **right** tiles) is called an **alternating** group. Return the number of **alternating** groups. **Note** that since `colors` represents a **circle**, the **first** and the **last** tiles are considered to be next to each other. **Example 1:** **Input:** colors = [1,1,1] **Output:** 0 **Explanation:** **Example 2:** **Input:** colors = [0,1,0,0,1] **Output:** 3 **Explanation:** Alternating groups: ******** **Constraints:** `3 <= colors.length <= 100` `0 <= colors[i] <= 1`",
+    "public_test_cases": [
+        {
+            "label": "Example 1",
+            "input": "colors = [1,1,1]",
+            "output": "0 "
+        },
+        {
+            "label": "Example 2",
+            "input": "colors = [0,1,0,0,1]",
+            "output": "3 "
+        }
+    ],
+    "private_test_cases": [
+        {
+            "input": [
+                1,
+                0,
+                1,
+                1,
+                0,
+                0,
+                0,
+                1,
+                1,
+                0,
+                0,
+                1,
+                0,
+                1,
+                0,
+                0,
+                1,
+                1,
+                0,
+                0,
+                1,
+                0,
+                0,
+                0,
+                0,
+                0,
+                1,
+                0,
+                1,
+                0,
+                1,
+                0,
+                0
+            ],
+            "output": 11
+        },
+        {
+            "input": [
+                0,
+                1,
+                0,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                0,
+                0,
+                0,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                0,
+                1,
+                0,
+                0,
+                1,
+                0,
+                1,
+                0,
+                0,
+                1,
+                1,
+                0,
+                1,
+                0,
+                0,
+                0,
+                0,
+                0,
+                1,
+                0,
+                1,
+                0,
+                0,
+                1,
+                0,
+                0,
+                1,
+                1,
+                1,
+                1,
+                0,
+                1,
+                0,
+                1,
+                0,
+                0,
+                0,
+                1,
+                0,
+                0,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                0,
+                1,
+                1,
+                1,
+                0,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                0,
+                1,
+                0,
+                1,
+                0,
+                1,
+                1,
+                1,
+                0,
+                1,
+                0,
+                1,
+                1,
+                1,
+                1,
+                0,
+                1,
+                1
+            ],
+            "output": 30
+        },
+        {
+            "input": [
+                1,
+                0,
+                0,
+                0,
+                0,
+                0,
+                1,
+                0,
+                1,
+                0,
+                1,
+                1,
+                0,
+                0,
+                0,
+                0,
+                1,
+                1,
+                1,
+                0,
+                0,
+                1,
+                0,
+                0,
+                1,
+                1,
+                0,
+                0,
+                1,
+                1
+            ],
+            "output": 5
+        },
+        {
+            "input": [
+                1,
+                1,
+                0,
+                0,
+                1,
+                0,
+                1,
+                0,
+                0,
+                1,
+                0,
+                0,
+                1,
+                1,
+                1,
+                1,
+                0,
+                1,
+                1,
+                0,
+                1,
+                1,
+                0,
+                1,
+                1,
+                1,
+                0,
+                1,
+                0,
+                0,
+                1,
+                0,
+                1,
+                1,
+                0,
+                0,
+                1,
+                0,
+                1,
+                0,
+                1,
+                1,
+                1,
+                1,
+                1,
+                0,
+                0,
+                1,
+                0,
+                1,
+                1,
+                0,
+                0,
+                0,
+                0,
+                0,
+                1,
+                1,
+                1,
+                0,
+                0,
+                1,
+                0,
+                0,
+                1,
+                1,
+                1,
+                0
+            ],
+            "output": 19
+        },
+        {
+            "input": [
+                0,
+                1,
+                0,
+                0,
+                1,
+                1,
+                1,
+                1,
+                0,
+                1,
+                0,
+                1,
+                1,
+                1,
+                0,
+                0,
+                1,
+                0,
+                0,
+                0,
+                1,
+                1,
+                0,
+                1,
+                0,
+                0,
+                1,
+                1,
+                1,
+                1,
+                1,
+                1,
+                0,
+                1,
+                1,
+                0,
+                0,
+                0,
+                1,
+                1,
+                0,
+                1,
+                0,
+                0,
+                0,
+                0,
+                1,
+                1,
+                0,
+                0,
+                0,
+                0,
+                1,
+                0
+            ],
+            "output": 11
+        }
+    ],
+    "haskell_template": "numberOfAlternatingGroups :: [Int] -> Int\nnumberOfAlternatingGroups colors ",
+    "ocaml_template": "let numberOfAlternatingGroups (colors: int list) : int =  ",
+    "scala_template": "def numberOfAlternatingGroups(colors: List[Int]): Int = { \n    \n}",
+    "java_template": "class Solution {\n    public int numberOfAlternatingGroups(int[] colors) {\n        \n    }\n}",
+    "python_template": "class Solution(object):\n    def numberOfAlternatingGroups(self, colors):\n        \"\"\"\n        :type colors: List[int]\n        :rtype: int\n        \"\"\"\n        "
+}

alternating_groups_i/ocaml_tests/main.ml

@@ -0,0 +1,42 @@
+
+module Main = struct
+    open OUnit2
+
+    (* Program start *)
+    let numberOfAlternatingGroups (colors: int list) : int =   failwith "Not implemented"
+
+    (* Program end *)
+
+    (* Test cases *)
+    
+let test1 _ = assert_equal 0 (numberOfAlternatingGroups [1;1;1])
+
+let test2 _ = assert_equal 3 (numberOfAlternatingGroups [0;1;0;0;1])
+
+let test3 _ = assert_equal 3 (numberOfAlternatingGroups [1; 0; 1; 1; 0; 0; 0; 1; 1; 0; 0; 1; 0; 1; 0; 0; 1; 1; 0; 0; 1; 0; 0; 0; 0; 0; 1; 0; 1; 0; 1; 0; 0])
+
+let test4 _ = assert_equal 3 (numberOfAlternatingGroups [0; 1; 0; 1; 1; 1; 1; 1; 1; 1; 0; 0; 0; 1; 1; 1; 1; 1; 1; 1; 0; 1; 0; 0; 1; 0; 1; 0; 0; 1; 1; 0; 1; 0; 0; 0; 0; 0; 1; 0; 1; 0; 0; 1; 0; 0; 1; 1; 1; 1; 0; 1; 0; 1; 0; 0; 0; 1; 0; 0; 1; 1; 1; 1; 1; 1; 0; 1; 1; 1; 0; 1; 1; 1; 1; 1; 1; 1; 0; 1; 0; 1; 0; 1; 1; 1; 0; 1; 0; 1; 1; 1; 1; 0; 1; 1])
+
+let test5 _ = assert_equal 3 (numberOfAlternatingGroups [1; 0; 0; 0; 0; 0; 1; 0; 1; 0; 1; 1; 0; 0; 0; 0; 1; 1; 1; 0; 0; 1; 0; 0; 1; 1; 0; 0; 1; 1])
+
+let test6 _ = assert_equal 3 (numberOfAlternatingGroups [1; 1; 0; 0; 1; 0; 1; 0; 0; 1; 0; 0; 1; 1; 1; 1; 0; 1; 1; 0; 1; 1; 0; 1; 1; 1; 0; 1; 0; 0; 1; 0; 1; 1; 0; 0; 1; 0; 1; 0; 1; 1; 1; 1; 1; 0; 0; 1; 0; 1; 1; 0; 0; 0; 0; 0; 1; 1; 1; 0; 0; 1; 0; 0; 1; 1; 1; 0])
+
+let test7 _ = assert_equal 3 (numberOfAlternatingGroups [0; 1; 0; 0; 1; 1; 1; 1; 0; 1; 0; 1; 1; 1; 0; 0; 1; 0; 0; 0; 1; 1; 0; 1; 0; 0; 1; 1; 1; 1; 1; 1; 0; 1; 1; 0; 0; 0; 1; 1; 0; 1; 0; 0; 0; 0; 1; 1; 0; 0; 0; 0; 1; 0])
+
+
+    (* Grouping test cases *)
+    let suite = "Test Suite for numberOfAlternatingGroups" >::: [
+        
+  "test1" >:: test1;
+  "test2" >:: test2;
+  "test3" >:: test3;
+  "test4" >:: test4;
+  "test5" >:: test5;
+  "test6" >:: test6;
+  "test7" >:: test7;
+    ]
+
+
+    (* Running the tests *)
+    let () = run_test_tt_main suite
+end

alternating_groups_i/scala_tests/MySuite.scala

@@ -0,0 +1,32 @@
+
+class MySuite extends munit.FunSuite {
+  
+  test("test1") {
+    assertEquals(Main.numberOfAlternatingGroups(List(1,1,1)), 0)
+  }
+
+  test("test2") {
+    assertEquals(Main.numberOfAlternatingGroups(List(0,1,0,0,1)), 3)
+  }
+
+  test("test3") {
+    assertEquals(Main.numberOfAlternatingGroups(1,0,1,1,0,0,0,1,1,0,0,1,0,1,0,0,1,1,0,0,1,0,0,0,0,0,1,0,1,0,1,0,0), 11)
+  }
+
+  test("test4") {
+    assertEquals(Main.numberOfAlternatingGroups(0,1,0,1,1,1,1,1,1,1,0,0,0,1,1,1,1,1,1,1,0,1,0,0,1,0,1,0,0,1,1,0,1,0,0,0,0,0,1,0,1,0,0,1,0,0,1,1,1,1,0,1,0,1,0,0,0,1,0,0,1,1,1,1,1,1,0,1,1,1,0,1,1,1,1,1,1,1,0,1,0,1,0,1,1,1,0,1,0,1,1,1,1,0,1,1), 30)
+  }
+
+  test("test5") {
+    assertEquals(Main.numberOfAlternatingGroups(1,0,0,0,0,0,1,0,1,0,1,1,0,0,0,0,1,1,1,0,0,1,0,0,1,1,0,0,1,1), 5)
+  }
+
+  test("test6") {
+    assertEquals(Main.numberOfAlternatingGroups(1,1,0,0,1,0,1,0,0,1,0,0,1,1,1,1,0,1,1,0,1,1,0,1,1,1,0,1,0,0,1,0,1,1,0,0,1,0,1,0,1,1,1,1,1,0,0,1,0,1,1,0,0,0,0,0,1,1,1,0,0,1,0,0,1,1,1,0), 19)
+  }
+
+  test("test7") {
+    assertEquals(Main.numberOfAlternatingGroups(0,1,0,0,1,1,1,1,0,1,0,1,1,1,0,0,1,0,0,0,1,1,0,1,0,0,1,1,1,1,1,1,0,1,1,0,0,0,1,1,0,1,0,0,0,0,1,1,0,0,0,0,1,0), 11)
+  }
+
+}

alternating_groups_ii/java_tests/Main.java

@@ -0,0 +1,25 @@
+
+import static org.junit.jupiter.api.Assertions.*;
+import org.junit.jupiter.api.Test;
+import java.util.List;
+import java.util.Arrays;
+import java.util.ArrayList;
+public class Main {
+    //Program start
+    
+    //Program end
+
+    @Test
+public void test1() {
+    assertEquals(3, numberOfAlternatingGroups(new ArrayList<>(Arrays.asList(0,1,0,1,0)), 3));
+}
+@Test
+public void test2() {
+    assertEquals(2, numberOfAlternatingGroups(new ArrayList<>(Arrays.asList(0,1,0,0,1,0,1)), 6));
+}
+@Test
+public void test3() {
+    assertEquals(0, numberOfAlternatingGroups(new ArrayList<>(Arrays.asList(1,1,0,1)), 4));
+}
+
+}

alternating_groups_iii/java_tests/Main.java

@@ -0,0 +1,21 @@
+
+import static org.junit.jupiter.api.Assertions.*;
+import org.junit.jupiter.api.Test;
+import java.util.List;
+import java.util.Arrays;
+import java.util.ArrayList;
+public class Main {
+    //Program start
+    
+    //Program end
+
+    @Test
+public void test1() {
+    assertEquals(new ArrayList<>(Arrays.asList(2)), numberOfAlternatingGroups(new ArrayList<>(Arrays.asList(0,1,1,0,1)), new ArrayList<>(Arrays.asList(new ArrayList<>(Arrays.asList(2,1,0)),new ArrayList<>(Arrays.asList(1,4))))));
+}
+@Test
+public void test2() {
+    assertEquals(new ArrayList<>(Arrays.asList(2,0)), numberOfAlternatingGroups(new ArrayList<>(Arrays.asList(0,0,1,0,1,1)), new ArrayList<>(Arrays.asList(new ArrayList<>(Arrays.asList(1,3)),new ArrayList<>(Arrays.asList(2,3,0)),new ArrayList<>(Arrays.asList(1,5))))));
+}
+
+}

alternating_groups_iii/meta.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c2dfb4ad6017e4522029cc12f97ed5a3d68568525e67cbcf6dcd9bb2e2cb3818
+size 17190671

ant_on_the_boundary/haskell_tests/Main.hs

@@ -0,0 +1,41 @@
+
+module Main where
+import Test.HUnit
+
+--Program start
+returnToBoundaryCount :: [Int] -> Int
+returnToBoundaryCount nums = undefined
+
+--Program end
+
+-- Test cases
+
+test1 :: Test
+test1 = TestCase (assertEqual "for (returnToBoundaryCount [2,3,-5])," 1 (returnToBoundaryCount [2,3,-5]))
+
+test2 :: Test
+test2 = TestCase (assertEqual "for (returnToBoundaryCount [3,2,-3,-4])," 0 (returnToBoundaryCount [3,2,-3,-4]))
+
+test3 :: Test
+test3 = TestCase (assertEqual "for (returnToBoundaryCount [-10, 9, ( -10), 10, 1, ( -8), 5, 9, ( -7), ( -9), 2, ( -8), ( -1), ( -5), ( -7), 7, ( -5), ( -2), ( -3), 9, ( -9), ( -9), 9, ( -3), ( -7), ( -6), ( -9), ( -7), 0, 4, ( -1), ( -10), 0, 8, 8, ( -7), ( -1), 3, 8, ( -3), ( -1), ( -6)])," 1 (returnToBoundaryCount [-10, 9, -10, 10, 1, -8, 5, 9, -7, -9, 2, -8, -1, -5, -7, 7, -5, -2, -3, 9, -9, -9, 9, -3, -7, -6, -9, -7, 0, 4, -1, -10, 0, 8, 8, -7, -1, 3, 8, -3, -1, -6]))
+
+test4 :: Test
+test4 = TestCase (assertEqual "for (returnToBoundaryCount [-6, 0, 7, ( -4), ( -2), 5, 3, 4, 3, ( -7), 4, ( -6), 7, 8, ( -1), 5, 1, 10, ( -7), ( -6), 1, ( -5), 3, 8, ( -6), 5, ( -8), 10, ( -4), 3, ( -10), ( -3), ( -1), 10, 9, 10, ( -9), 10, ( -3), ( -3), ( -6), 0, 7, 4, 2, 0, 7, 2, ( -6)])," 1 (returnToBoundaryCount [-6, 0, 7, -4, -2, 5, 3, 4, 3, -7, 4, -6, 7, 8, -1, 5, 1, 10, -7, -6, 1, -5, 3, 8, -6, 5, -8, 10, -4, 3, -10, -3, -1, 10, 9, 10, -9, 10, -3, -3, -6, 0, 7, 4, 2, 0, 7, 2, -6]))
+
+test5 :: Test
+test5 = TestCase (assertEqual "for (returnToBoundaryCount [-2, 5, 1, ( -2), 7, ( -6), 6, 2, ( -2), ( -10), 10, 8, ( -3), 6])," 0 (returnToBoundaryCount [-2, 5, 1, -2, 7, -6, 6, 2, -2, -10, 10, 8, -3, 6]))
+
+test6 :: Test
+test6 = TestCase (assertEqual "for (returnToBoundaryCount [-2, ( -7), ( -7), ( -10), ( -10)])," 0 (returnToBoundaryCount [-2, -7, -7, -10, -10]))
+
+test7 :: Test
+test7 = TestCase (assertEqual "for (returnToBoundaryCount [-10, ( -9), 0])," 0 (returnToBoundaryCount [-10, -9, 0]))
+
+
+-- Grouping test cases
+tests :: Test
+tests = TestList [TestLabel "Test1" test1, TestLabel "Test2" test2, TestLabel "Test3" test3, TestLabel "Test4" test4, TestLabel "Test5" test5, TestLabel "Test6" test6]
+
+-- Running the tests
+main :: IO Counts
+main = runTestTT tests

ant_on_the_boundary/java_tests/Main.java

@@ -0,0 +1,20 @@
+
+import static org.junit.jupiter.api.Assertions.*;
+import org.junit.jupiter.api.Test;
+import java.util.List;
+import java.util.Arrays;
+public class Main {
+    //Program start
+
+    //Program end
+
+    @Test
+public void test1() {
+    assertEquals(1, returnToBoundaryCount(Arrays.asList(2,3,-5)));
+}
+@Test
+public void test2() {
+    assertEquals(0, returnToBoundaryCount(Arrays.asList(3,2,-3,-4)));
+}
+
+}

ant_on_the_boundary/meta.json

@@ -0,0 +1,165 @@
+{
+    "id": 3311,
+    "name": "ant_on_the_boundary",
+    "difficulty": "Easy",
+    "link": "https://leetcode.com/problems/ant-on-the-boundary/",
+    "date": "2024-01-28 00:00:00",
+    "task_description": "An ant is on a boundary. It sometimes goes **left** and sometimes **right**. You are given an array of **non-zero** integers `nums`. The ant starts reading `nums` from the first element of it to its end. At each step, it moves according to the value of the current element: If `nums[i] < 0`, it moves **left** by `-nums[i]` units. If `nums[i] > 0`, it moves **right** by `nums[i]` units. Return _the number of times the ant **returns** to the boundary._ **Notes:** There is an infinite space on both sides of the boundary. We check whether the ant is on the boundary only after it has moved `|nums[i]|` units. In other words, if the ant crosses the boundary during its movement, it does not count. **Example 1:** ``` **Input:** nums = [2,3,-5] **Output:** 1 **Explanation:** After the first step, the ant is 2 steps to the right of the boundary. After the second step, the ant is 5 steps to the right of the boundary. After the third step, the ant is on the boundary. So the answer is 1. ``` **Example 2:** ``` **Input:** nums = [3,2,-3,-4] **Output:** 0 **Explanation:** After the first step, the ant is 3 steps to the right of the boundary. After the second step, the ant is 5 steps to the right of the boundary. After the third step, the ant is 2 steps to the right of the boundary. After the fourth step, the ant is 2 steps to the left of the boundary. The ant never returned to the boundary, so the answer is 0. ``` **Constraints:** `1 <= nums.length <= 100` `-10 <= nums[i] <= 10` `nums[i] != 0`",
+    "public_test_cases": [
+        {
+            "label": "Example 1",
+            "input": "nums = [2,3,-5]",
+            "output": "1 "
+        },
+        {
+            "label": "Example 2",
+            "input": "nums = [3,2,-3,-4]",
+            "output": "0 "
+        }
+    ],
+    "private_test_cases": [
+        {
+            "input": [
+                -10,
+                9,
+                -10,
+                10,
+                1,
+                -8,
+                5,
+                9,
+                -7,
+                -9,
+                2,
+                -8,
+                -1,
+                -5,
+                -7,
+                7,
+                -5,
+                -2,
+                -3,
+                9,
+                -9,
+                -9,
+                9,
+                -3,
+                -7,
+                -6,
+                -9,
+                -7,
+                0,
+                4,
+                -1,
+                -10,
+                0,
+                8,
+                8,
+                -7,
+                -1,
+                3,
+                8,
+                -3,
+                -1,
+                -6
+            ],
+            "output": 1
+        },
+        {
+            "input": [
+                -6,
+                0,
+                7,
+                -4,
+                -2,
+                5,
+                3,
+                4,
+                3,
+                -7,
+                4,
+                -6,
+                7,
+                8,
+                -1,
+                5,
+                1,
+                10,
+                -7,
+                -6,
+                1,
+                -5,
+                3,
+                8,
+                -6,
+                5,
+                -8,
+                10,
+                -4,
+                3,
+                -10,
+                -3,
+                -1,
+                10,
+                9,
+                10,
+                -9,
+                10,
+                -3,
+                -3,
+                -6,
+                0,
+                7,
+                4,
+                2,
+                0,
+                7,
+                2,
+                -6
+            ],
+            "output": 1
+        },
+        {
+            "input": [
+                -2,
+                5,
+                1,
+                -2,
+                7,
+                -6,
+                6,
+                2,
+                -2,
+                -10,
+                10,
+                8,
+                -3,
+                6
+            ],
+            "output": 0
+        },
+        {
+            "input": [
+                -2,
+                -7,
+                -7,
+                -10,
+                -10
+            ],
+            "output": 0
+        },
+        {
+            "input": [
+                -10,
+                -9,
+                0
+            ],
+            "output": 0
+        }
+    ],
+    "haskell_template": "returnToBoundaryCount :: [Int] -> Int\nreturnToBoundaryCount nums ",
+    "ocaml_template": "let returnToBoundaryCount (nums: int list) : int =  ",
+    "scala_template": "def returnToBoundaryCount(nums: List[Int]): Int = { \n    \n}",
+    "java_template": "class Solution {\n    public int returnToBoundaryCount(int[] nums) {\n        \n    }\n}",
+    "python_template": "class Solution(object):\n    def returnToBoundaryCount(self, nums):\n        \"\"\"\n        :type nums: List[int]\n        :rtype: int\n        \"\"\"\n        "
+}

ant_on_the_boundary/ocaml_tests/main.ml

@@ -0,0 +1,42 @@
+
+module Main = struct
+    open OUnit2
+
+    (* Program start *)
+    let returnToBoundaryCount (nums: int list) : int =   failwith "Not implemented"
+
+    (* Program end *)
+
+    (* Test cases *)
+    
+let test1 _ = assert_equal 1 (returnToBoundaryCount [2;3;-5])
+
+let test2 _ = assert_equal 0 (returnToBoundaryCount [3;2;-3;-4])
+
+let test3 _ = assert_equal 0 (returnToBoundaryCount [-10; 9; -10; 10; 1; -8; 5; 9; -7; -9; 2; -8; -1; -5; -7; 7; -5; -2; -3; 9; -9; -9; 9; -3; -7; -6; -9; -7; 0; 4; -1; -10; 0; 8; 8; -7; -1; 3; 8; -3; -1; -6])
+
+let test4 _ = assert_equal 0 (returnToBoundaryCount [-6; 0; 7; -4; -2; 5; 3; 4; 3; -7; 4; -6; 7; 8; -1; 5; 1; 10; -7; -6; 1; -5; 3; 8; -6; 5; -8; 10; -4; 3; -10; -3; -1; 10; 9; 10; -9; 10; -3; -3; -6; 0; 7; 4; 2; 0; 7; 2; -6])
+
+let test5 _ = assert_equal 0 (returnToBoundaryCount [-2; 5; 1; -2; 7; -6; 6; 2; -2; -10; 10; 8; -3; 6])
+
+let test6 _ = assert_equal 0 (returnToBoundaryCount [-2; -7; -7; -10; -10])
+
+let test7 _ = assert_equal 0 (returnToBoundaryCount [-10; -9; 0])
+
+
+    (* Grouping test cases *)
+    let suite = "Test Suite for returnToBoundaryCount" >::: [
+        
+  "test1" >:: test1;
+  "test2" >:: test2;
+  "test3" >:: test3;
+  "test4" >:: test4;
+  "test5" >:: test5;
+  "test6" >:: test6;
+  "test7" >:: test7;
+    ]
+
+
+    (* Running the tests *)
+    let () = run_test_tt_main suite
+end

ant_on_the_boundary/scala_tests/MySuite.scala

@@ -0,0 +1,32 @@
+
+class MySuite extends munit.FunSuite {
+  
+  test("test1") {
+    assertEquals(Main.returnToBoundaryCount(List(2,3,-5)), 1)
+  }
+
+  test("test2") {
+    assertEquals(Main.returnToBoundaryCount(List(3,2,-3,-4)), 0)
+  }
+
+  test("test3") {
+    assertEquals(Main.returnToBoundaryCount(-10,9,-10,10,1,-8,5,9,-7,-9,2,-8,-1,-5,-7,7,-5,-2,-3,9,-9,-9,9,-3,-7,-6,-9,-7,0,4,-1,-10,0,8,8,-7,-1,3,8,-3,-1,-6), 1)
+  }
+
+  test("test4") {
+    assertEquals(Main.returnToBoundaryCount(-6,0,7,-4,-2,5,3,4,3,-7,4,-6,7,8,-1,5,1,10,-7,-6,1,-5,3,8,-6,5,-8,10,-4,3,-10,-3,-1,10,9,10,-9,10,-3,-3,-6,0,7,4,2,0,7,2,-6), 1)
+  }
+
+  test("test5") {
+    assertEquals(Main.returnToBoundaryCount(-2,5,1,-2,7,-6,6,2,-2,-10,10,8,-3,6), 0)
+  }
+
+  test("test6") {
+    assertEquals(Main.returnToBoundaryCount(-2,-7,-7,-10,-10), 0)
+  }
+
+  test("test7") {
+    assertEquals(Main.returnToBoundaryCount(-10,-9,0), 0)
+  }
+
+}

append_characters_to_string_to_make_subsequence/haskell_tests/Main.hs

@@ -0,0 +1,27 @@
+
+module Main where
+import Test.HUnit
+
+--Program start
+
+--Program end
+
+-- Test cases
+
+test1 :: Test
+test1 = TestCase (assertEqual "for (appendCharacters \"coaching \"  \"coding \")," 4 (appendCharacters "coaching" "coding"))
+
+test2 :: Test
+test2 = TestCase (assertEqual "for (appendCharacters \"abcde \"  \"a \")," 0 (appendCharacters "abcde" "a"))
+
+test3 :: Test
+test3 = TestCase (assertEqual "for (appendCharacters \"z \"  \"abcde \")," 5 (appendCharacters "z" "abcde"))
+
+
+-- Grouping test cases
+tests :: Test
+tests = TestList [TestLabel "Test1" test1, TestLabel "Test2" test2]
+
+-- Running the tests
+main :: IO Counts
+main = runTestTT tests

append_characters_to_string_to_make_subsequence/java_tests/Main.java

@@ -0,0 +1,25 @@
+
+import static org.junit.jupiter.api.Assertions.*;
+import org.junit.jupiter.api.Test;
+import java.util.List;
+import java.util.Arrays;
+import java.util.ArrayList;
+public class Main {
+    //Program start
+    
+    //Program end
+
+    @Test
+public void test1() {
+    assertEquals(4, appendCharacters("coaching", "coding"));
+}
+@Test
+public void test2() {
+    assertEquals(0, appendCharacters("abcde", "a"));
+}
+@Test
+public void test3() {
+    assertEquals(5, appendCharacters("z", "abcde"));
+}
+
+}

append_characters_to_string_to_make_subsequence/ocaml_tests/main.ml

@@ -0,0 +1,29 @@
+
+module Main = struct
+    open OUnit2
+
+    (* Program start *)
+
+    (* Program end *)
+
+    (* Test cases *)
+    
+let test1 _ = assert_equal 4 (appendCharacters "coaching" "coding")
+
+let test2 _ = assert_equal 0 (appendCharacters "abcde" "a")
+
+let test3 _ = assert_equal 5 (appendCharacters "z" "abcde")
+
+
+    (* Grouping test cases *)
+    let suite = "Test Suite for appendCharacters" >::: [
+        
+  "test1" >:: test1;
+  "test2" >:: test2;
+  "test3" >:: test3;
+    ]
+
+
+    (* Running the tests *)
+    let () = run_test_tt_main suite
+end

append_characters_to_string_to_make_subsequence/scala_tests/MySuite.scala

@@ -0,0 +1,16 @@
+
+class MySuite extends munit.FunSuite {
+  
+  test("test1") {
+    assertEquals(Main.appendCharacters("coaching","coding"), 4)
+  }
+
+  test("test2") {
+    assertEquals(Main.appendCharacters("abcde","a"), 0)
+  }
+
+  test("test3") {
+    assertEquals(Main.appendCharacters("z","abcde"), 5)
+  }
+
+}