b55df0184d27544bfbb29ce9da3fe89617b7aaecab49b5ae05ffcd8cfbc4f6a9

.gitattributes

@@ -170,3 +170,8 @@ maximum_beauty_of_an_array_after_applying_operation/meta.json filter=lfs diff=lf
 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_count_of_positive_integer_and_negative_integer/ocaml_tests/main.ml

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

maximum_count_of_positive_integer_and_negative_integer/scala_tests/MySuite.scala

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

maximum_deletions_on_a_string/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 (deleteString \"abcabcdabc \")," 2 (deleteString "abcabcdabc"))
+
+test2 :: Test
+test2 = TestCase (assertEqual "for (deleteString \"aaabaab \")," 4 (deleteString "aaabaab"))
+
+test3 :: Test
+test3 = TestCase (assertEqual "for (deleteString \"aaaaa \")," 5 (deleteString "aaaaa"))
+
+
+-- Grouping test cases
+tests :: Test
+tests = TestList [TestLabel "Test1" test1, TestLabel "Test2" test2]
+
+-- Running the tests
+main :: IO Counts
+main = runTestTT tests

maximum_deletions_on_a_string/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(2, deleteString("abcabcdabc"));
+}
+@Test
+public void test2() {
+    assertEquals(4, deleteString("aaabaab"));
+}
+@Test
+public void test3() {
+    assertEquals(5, deleteString("aaaaa"));
+}
+
+}

maximum_deletions_on_a_string/meta.json

@@ -0,0 +1,72 @@
+{
+    "id": 2510,
+    "name": "maximum_deletions_on_a_string",
+    "difficulty": "Hard",
+    "link": "https://leetcode.com/problems/maximum-deletions-on-a-string/",
+    "date": "1664064000000",
+    "task_description": "You are given a string `s` consisting of only lowercase English letters. In one operation, you can: Delete **the entire string** `s`, or Delete the **first** `i` letters of `s` if the first `i` letters of `s` are **equal** to the following `i` letters in `s`, for any `i` in the range `1 <= i <= s.length / 2`. For example, if `s = \"ababc\"`, then in one operation, you could delete the first two letters of `s` to get `\"abc\"`, since the first two letters of `s` and the following two letters of `s` are both equal to `\"ab\"`. Return _the **maximum** number of operations needed to delete all of _`s`. **Example 1:** ``` **Input:** s = \"abcabcdabc\" **Output:** 2 **Explanation:** - Delete the first 3 letters (\"abc\") since the next 3 letters are equal. Now, s = \"abcdabc\". - Delete all the letters. We used 2 operations so return 2. It can be proven that 2 is the maximum number of operations needed. Note that in the second operation we cannot delete \"abc\" again because the next occurrence of \"abc\" does not happen in the next 3 letters. ``` **Example 2:** ``` **Input:** s = \"aaabaab\" **Output:** 4 **Explanation:** - Delete the first letter (\"a\") since the next letter is equal. Now, s = \"aabaab\". - Delete the first 3 letters (\"aab\") since the next 3 letters are equal. Now, s = \"aab\". - Delete the first letter (\"a\") since the next letter is equal. Now, s = \"ab\". - Delete all the letters. We used 4 operations so return 4. It can be proven that 4 is the maximum number of operations needed. ``` **Example 3:** ``` **Input:** s = \"aaaaa\" **Output:** 5 **Explanation:** In each operation, we can delete the first letter of s. ``` **Constraints:** `1 <= s.length <= 4000` `s` consists only of lowercase English letters.",
+    "public_test_cases": [
+        {
+            "label": "Example 1",
+            "input": "s = \"abcabcdabc\"",
+            "output": "2 "
+        },
+        {
+            "label": "Example 2",
+            "input": "s = \"aaabaab\"",
+            "output": "4 "
+        },
+        {
+            "label": "Example 3",
+            "input": "s = \"aaaaa\"",
+            "output": "5 "
+        }
+    ],
+    "private_test_cases": [
+        {
+            "input": "bqqjbbogzidmfheguwtcvefhmqnjdukhyakrcvgfgypknlegykrbfqkcstojdgryefmkjvanzppcyersojxidzojismjiflxsckvcnppbnajhhbcabrwhzpurjaqlupbtwkxslvjhwcrpyrtrsgukpvkmnohaleijuwgfkdlrnzanhvvbgirivfrbgoywdjlrzwkuvuvxqrnyimrjcdyoqtdctvucevvhmwtztiqukexyxdxdgrueemurddtdgwjirpbqhrbgysurghxaeycllpphiusqeifhyblorwqibcgmwbpxdmxjwdrntvxphodwqiajgwjwmfizhtpfanoecunjctwslrnwgwgecmukrumlvmsybarnfzmuwjjeaflmxljycpobawwnnssglxjaxnuqklkqinkschtzlywiahnxodnmyxnowwapucwfyvbrtjjmtiylhjzxlhrfjpxhrfumyunkjsxjfmxhybvoyxfbjuwuqssmfjypnlqntttxninjwszayqaclaudqmnnbtosxeudztzkogewnsanwmutffmrtektnldqdmkvliycfgcdagwdiuhfcadcvfealyoklrdoycwuopozkoavcruelefjsmgkvdmjagmrbwgmsptapskiymcbwquwleucoiinwqchollgnsvwysnieivkatocgfjbdmllhphbeyhgxudqzlbphazyieysqkeekpsvkypagpklkxaarwsgxrxylhdgumpdjxlbvakmtsxpywzktxyrduetqtjnygvptepkwtokvxhjfeeqbpijgcetiiandnssiagfcceozowomnwxccwayedosqaxtiujejbqhmlizawiqcbjggzhnldvzecormelimrgsijdoatyfekpqqgfvbukmimhqgyoxkqdplpdcwnaetipzlmpyhlqfnsvkenngdjtlxbufnndrvxebwieffgayflwshubcftxeqdyinkevjleejzilkcjeumdbyrnysjmnjlkqaruqbcguqssgwzbfkjdjhhdligxeouzmjmhrwuuxymvmppjbhpuywerkhwkxeluxjwytncczpmdkuioqmohmsvuuqywybsovpgvezbhbglycxypuntbpzvlcwwiwnkrddxujlzehiksvqrtwirobmyyefwiwttipicoasyvbjiiihmtadacrxsmxczzzdlhctzedwtoqecwczpboqotraomrwanrmczujcyhrlfslpolouljqdjvvzmslxttrqnnroprmycyzbnsiuswjjvapvnqiolfiksknzditxeeqdbkjdglwktqlnsugbkzlsioiqgrzudixhpqbtelzsoremhqncaqhxuoxqhbqjzznsneshmlfcfcmriwmuqkfpyhwkfzvepydrycxibpmssskiiuresxvdnnmqnfeinhcfwpumzmjxmgzdwzzayuktttqvayfxnopmswjxljsecrlygjhmiskantpnvtatpnqvbqbtjmbnwgxxefzfwajqvbfivlbbvgsedtvjpodagiknbravxfogcflfdgilwgctanfbwmmyjnwyiudxncghgrqgsxlwueehvkvncmiegprgbcshtmtecnlmohguvcmtcvctlxaljmpmrsvmvkotuovhisvziaypeetphpcjsxipsswpbbieiecreynqaygdpeddihkcedqgyhokkutfpedobkbexbxuiotsixqumsmlrtifkbduqtfxtgwkzzlxgyaijedfxzgzoxuunjxukdrmyclvtfcubnhwokefonoqmueotiqbzspcwgnrstdtthtuuqtoclyurzrveqaeifuomjwvnlziduggqdfsmsobjfvajonsverllyoszwrycqbbqritikortsvobcirzyoxntzmexibfsynqimowwbgwijomehnhmbwrrfxtlphvadlsgfbdhxjntsmohbznonkjczwethghdnzdvarqqbkjswwoiiqffznmgbhxhffzoxzdhmiazzfywmvzwodkmeiujhvwywidmtfwlaierwulirfrhaklvmiclqvxsezthgbecttiyjihbhreeesikhabgxpmbvjwjoeshpmufvlrvcmxqfwbzceyjyxggcrmdqquvoescustmnlknpvplwpezsnhdsvlhgoebtwolgqtwxeomszkibccvrqcomkslatdodseqdsjpenbqojesfntwthpkxiqaegpuxerianekwdxhhhlejhovfiyruxmcekjvgquzthmgecynytyvqgamywvwphwovzanksxgoyvlfjszlybckznkaessabxtbolgtfxfldusddefofrynaaslczuztcesgilyojfivxptsevbmosscconfesmutypzscicgexpayptazfugubzuoezqoanqkponygyfzmkltzntstpejnhkqxdaqdtdrwocijasudhbbolujvnbtobomofqnehrhrbpmcueacuesudayyqxrexshagutmwrotibqshyitcjcmhcovfrbyzgklyqhuawovpbpopbuqtigoickfeoayxtvjhadpiowltiknpuppipvvfwvifmwcefrbvstdetutqtcuawkwcrnthrofcekjzlphqdagltikuzwxmokmefwbthjtimwnbtvyouxookegyijlyswdcwbkibxvvgyxknmqxffnunhuubmtuhpdeutumbnzwjjfunxcsymbdkzfxyhkotavnbjmiqcypvvmojlfxawdbizmudybzsvyqtvoabcowuzngnyrxqkydnhjsfmjfzfnjpggbodkkpspteskujdznmqsnuyirolkxsyghruathjsmppaaommehecjriomuwrsaiwpkcgtvzjkuysbgugipyompkobtyhtcjqtmptwmmynahnztvrxqcskzpcrwabiefabvaxrnacqbejswoywbsvlnrwdatmflqizsfzskbuunuelwqnjnwktopzpfrbcectlplewbbupaclzgzyqucwgenzpyioivgthxxwdmyhaopmforhujnhjqlqefbryqfhjibjwpcqnbbuqwkqgamskdvbqctzkaijspcswunepkmhvyhydyamwplxllcvondndetetxszfcjizdqnlkcvrombdkpyiyfiptyrfmebosalcmayrteuklrbkvqedevhtazfvyujrwqrpcnlpilhtgbphmkymqrjfqtjwfcmqhnxxghhbhupjrgrhnjcscifvokktknqwazfvgrojajenxpktfmgjejohfaetrntabmoyclltxivgecnswbrzxfkkwmhttjazavngphoflqhzylptqtbyxlvmjzxabucofxpptvnvurrlsbxoqslchoxdrhdbvouvvbpllaebqeyyllusevmjzholpdyxtkctafcwqjgukimpgznnnwwasuuvluxwdliklwguuojidmfalacpxgttdnydkvcegstpgdvsboscnnohrcovgeshywmja",
+            "output": 1
+        },
+        {
+            "input": "rtwphklhjdnzhnpgoqoedqxewynhgecjbvdciewczavkumsrdgwrdqlkvqxpvtxqncgcgvuemjskjednzcgjapsvhwiqqzemnwynvumugjcmzcggkwvejbpehwwmmqoaiamhoybdczavzyuyfmpxbawrygudosbtteinxobbuaiiosdrbgcvaztxzokeftpsgujqayflthtyyxzuhoumlxlvtkhdquyjzegiobslmjowvlaycrqtnitxqfegitsfppywberdsrexuukowckpxuldgtahcdvdunqcghlurkgdpmdcgbotymtvcchvuzludunwbnzjnxoclrqofybgwvogxblnwvzbmdffvkwrshgewlyhsrhjpkyrvafftvenmekrtftvsnedjvmlivktxkqxwuzglxbjlviffjyktpjrpiidklouapbaqbbwuicdsttluabfykhphanmgdgogcqkkkmildnoadgjcnhphvpeygvicgrabetnokrzfrlpdtpitjswgiihzjppstlvaareohshtuogyhxeauwhymxrenucrbeqekylcilzvguulllrmncuvvirygawigjrhcnofrrvsmscfqxadhedwcmuwmojchypbsjfdxaqndcaymlmnrlfzbczfpstnmfauteicfljutyjwinbmfadjksylnlbsfcbaactjboumxkgmwhykltwicyvakjgjodynmrflpdtvfmvtweuciqsmmoobpeyesubgcpbjjscrifrdgoipvubqmqaiszvjcicisqctcdoamtcqpdetrrmzwsdkmhytnlqefdnstuourytfgfuaqiurrrudfckabkyiozkegfagwgueedtcvrprqeizmdsyyokeyfdanwduifzieoahfvnpqvwusvmwhlnxiefwzqphcqkfdyotcwpmetpkavxtquhsrgeboxqzchgdnyczwbcxqtdmrvmdltdqproppvqmkpgpewjlfcdfgsaxjfpnqcpbkqcdmkezeqflyrxowuunyywxwxipkvcqjyhtwvqqazrmzqodtblcznhtxzdofztkeymsdvxogleqzfxwnexqyeouyqpltpnktxqiwcouomlufkrkehkpwywqtwkakstpivaokxujzgajrlxumlbnmnmckyzjrpnmwdjowhzndrzxieuikhbmlorqemyiodcuunsosfwlxounqkcbjaofjpzkzttvvisbwskyjnuhiaeiwjmvczogvxsjguxplpuyjphcdztuvofwxykspcxaxdczukudqhwjyrecsyxbckulbbmlekydfyejqeqdxehwmvhpazgsgybvkdhosjsotpfofxlwqxixrigecdcmxhegxddkutwjimznceybyzaqeigywgkvmqdqiktoytvljlytqsjniuheofbtacnrwsmopecgnouezkceoinniujlvdtqqmmhvbtunkcnsvuestdigtwqvxbcpqqrvljvmqnfpghjbfcmexdzcnawonykxqfoetjaztpwjgfweofoxmzbnwrtjdgfmllbvhrqfhruavynetydblbeutdoziqnkgkxyxunmodbxtjrbegobckfnglulyyglmqwuegnmvcinucnhmaehlhzlsklaklwntpyiaubbcqbibptayuasjhpqfhqpjrskbroyfbwdjbyjbainnxubbifzexbhhqeukeqsqjtejhyjqgpjveelohwuzmenfhchckcodgqsfbvilmlkvusviblouiigfgjqqdefedhuqjipgskafuqpmabirpmdhsscuhqvnejhmmpwlmmwkhqgkbpwvzguxhukajfuzfnwssmutypvkcywklgfjnbanactnmyaswhlychxyapsevolgmsazlkbbimjqwaltkfwbvdmxjsfogflisvebjuooglaedowzhgnxovuirqrkzuzzukqrzfwksqfijcyhkfjvzcormxrnsujjpdsiawvxofndueeatsbrikxedjolfhobtlvckopnbntsgwxrnfzknsuuvfdwbhausknzqewsmqzcaipzpukqokifcointkezhcbgkqyszbfvxfywrywluyhhxucbiewyecymycwgopzlpiavrgqradzauowgcfsbeybcwcgscatvjahrjoqzipxbvaqwmjxac",
+            "output": 1
+        },
+        {
+            "input": "qkvqtqeqfwqreoiotirftnghgzxnevhtwwipgqciyqxalsazqzumskdxtyxttfvtpzqfybmnxpintspxmnidvoislzizgxdasdrcrdydgrutkprqzcbityurzdaceoziorgzijxdljncrurylszlijhutijjwczrwynqrrgqbegpzmoyqabkdvnmcfinmihhcapchelevdzslspvvulshuxmdalwyqulzslqfrycgpffhysobjdovjjuamrmnyulhrektxefhpmgpxglcxbdulxoczujeyqiizyslfhatjhxetjzcooaymvtfnkuuaurgdncdymrirrmenmngikystvtfjraapxlwtqauxzfyzeqkrkfsgjyieysdadnlotdejqymwckwinkuzxvruxbqneaoprrigzbygmxfnfgjlnbwfwqxiosysfwtxqnsltseepqnxtkzkvqhjdmmihaqykrdmyqsxrkmyawrrhzufhbuekvavnnilzffddhtpvglewjftnpizcnrjwpieeisokoruvqgrzhgjdbpcdepheiamitnwopuyuftlqhlfrkbjyapgltjzeflcdkbvrlgepzmkyivwyjpxxlsacbtdmzvwnuusgeeyqabaualszvhxirrfojiviielhpnidyziqpxosaxuqsywjolqnpbmgttnghukpjhyfyxnrcnsftxxrspyhlmvuxpkuoxrdtqfnkycvpljlvleeoyblzgkjjjxzgnztizqdxwlvudstgatioqbbjxqtwyyrpexyzikhsibwvzonkcnibdgaaklwtjsaofeyguvslzbmszlmqqjjvniwnofrbewakiqjnbwwprfvwxi",
+            "output": 1
+        },
+        {
+            "input": "ocbgvglfpxcbeoguirucxmotkhzrsfnbpghtyzfthnlmvwpubtbjgarmcnutpbzbclutrelxmlyuomyicdhxeqlapttezkyvpakmwjyokcupdynphirlriccgblosotqswfbiapyqzcvkzxatzaacketvvipeavaatbbtbeatydmcztvktqwouwpappkqrwohikoiusvuycfotxpwklygbsgbzefgelupxvsjkansdnstonafayyiuzdhuvawjtrbyrwfokpaflvjxdoxxsrrvwsyklpbnhtlbsrqkyeolhngziojebkeofjrxdzqfzsodppoiikdfndrfvqgcynoblwxuakqpknggpzlotnrhxfvffrcawmjxrwwbthqmbqsqvltbxgitfvxilidpjfrxxxizmraqexucvmfugjqdmcugwljbiwyrczbgcqgcczmvtmomomclptalamtvolqejrdynjmzblsdkcsqxzijoskimarqbpbfvkajkxeduxjrdgsmptsnegpcugsurppiyfglmodvprxmxgzxubwqbvhlnhplhjgolqjdsszjjzqztecteqwpidklsqppqpezrecaapakcwllijeqexsivqgofzhbgnharfxpuugdhbugndpfhktgdbhvytnaunppkaoprjxuztavmsxmdhhpjbfqsqyxwywcdltthwdqnqoucpwyhugxyvkezlywvcmtinacbntwotzoxjvmwnchcvrmlqtkzmuoyliovgovjlybpweeetzpwcjbtbzfropytuuwsgpkobfgukwvluqyqnhtwinutgtrrtxbazanhdhxyoozgkivmldelfmpyxeqnxbcbtchfzbrivarwrdxwoodlsmlcauhjtsuoysdyjaztyunroafzhnheraygggvvezgzoanycdrtdtibqjsfvahnjgomvrosextqohkyvyvtlrrdszeydtjyaoziperfnllvmcvjviyyhdwnxaoqwfqlgazhxobxwzoqaqcxioevjvzdmtcxlfiqprhshtxbpbvctzqrcgyiksdnzryrjkcjdsazojhpejxqnglrukxglipvecohkdthpunzvzculznbqyglgtlgkfijbseaaexmzmyisercljowuupnhxpjciixtxdsgnfjmvrtzmsffxxmsyoyknwbhpeolnkcpcwaztdnsocfdezuwzgeulowunapaeedmqqjlrtavhwdejrzdgiorbidiqwbsiwqhnlmttmfzwuqxfchvmicvrmjdnslvyztdgwseuwawfclnnyfwthsjesuymocnerfjtoktxdvnbmjsawzzweoudxoxjocjittwkeyuhmxgygzbugioorxirhfdvmnfcdguehjirrjirbnankvjzjiqyliyuxiwqclxuzmtcysmzvmzsxlkhtlqntaskpgfegwskqhocupryrkcbreccfmdgdscvzqbupwffluhbdxdxocvlsgjbjrbllfepylrhyjbzwgfspigujdyoesloikwbtsttsdxtqorqhtqirtwtmftrsyjveylngjxwtdzxkkntzrplakgqatwdhfkwdsmcdlxtzjclpivuqyhttddfnhvzsymgykezezifsuqibtlbeaifxiofujygghwiovzfhmhtjrtnrpphijptqvslzmgaetunfcwieideddsaruigiiyoxvqwtkotuyzmwkatxcgvlxsymhjpodxccguhcveprohegqazpfvgjzwkfdwbdwbbrirqmcydomdpbyhogquoutxtljqygfuatojytecvfupyriukwtwzmtdzhjjjvbtvipdydfpuhppwlgqkjejzdungzanikwxjfvueexixiijndqebukopzloijnfeaaxszdmucsnoekvtyeuumciaiejszfpbjycmhrkwyggmepdwiozrtuwhvavwqbuvvilynkmwnxgzdkrdxfmzncodwynpnalkcdszrurdomwrlxkhimksxfgonzyqddkwloyzlzjbqmtwheqxnstrgiievyhncxldfamknzlxiljzbdlxqxpr",
+            "output": 1
+        },
+        {
+            "input": "yqhivnzqcocvfqhgvqxkcfhocjnznoolxrnwxzbsineaixufjiamlgmldrxloafwzolpuhhgjzrvrojeidhbwbwcteutzyywhrmjlakerewmiziitqznaltmzomrgpvgpwbpkywvmyqkwippfhkhvlfbcrdsbubddappnsnycsdnlngrbhgnlgssluoksblbihyklvdyyhhjqupuoqalnmnlhfaunchhdjzdhwqnwljoxpxlhfhlvyrszakxqlfevvkaczerteacdinyzjmhwjxasjduxvbretqugggbofxmylasweueiukrbssqaldazlaiqpsejuyruthckerfykmgrrinmxjhfieqnmrljasrkjgqwshlsjovapgwpnfdsfmhdblecofmbaacfejsukcevljtcwyvzzewkvenrvxdilnjjmnpprhooeuholgywqzbomkquqdzwuuxsfvpcralkxwgdxyalhcgqijlgfehbuxcclfibvdptmujvqhfbnddztuoevfrpjkeumktvbqtgfnicgsclslzldsqthutfbtqnaeuosaaxhhibhqrjihamstzwbbrzcghirxhcvbrypxutqscazmeyzjhxzojdngmddvzwosoamcxrjxkmmulhyblfpkaynjgwourolfoyrjzayaaxediyderdqmqwadcfpaojbwsnnvaqxsoseejvmmhghbbtnptpembvogsrfydsjrgrwxatozngpydtohlkghqgmqdsuvclpoxpsvqvfpaogdxzwwksdbppxsmdmoydpyodpweduqoslamnbcbffqrrqfhodzseelcqggfwwrrkqfyvgyrekztftudqzpznfyogmkvzfvbkcosklmgwqosfrmrmftkulppakfpbzocscdkfgkcwkogdfwxevksbliqqchmgssqvfgoriipdmnxbhtfoqmgsfjybjqtrbgbyzaczmhdlmkrilceozgsellqmjagzlsvtffmxypqprqndgstnvgpablhtzsvnpeeijtyqzbkkfhldzslagychnxkddfqppmysjaajjhoysabdwzzilgybwkieeqbyevqrzgfecbyoqnryaxewreiwhlnslqjsuywkqyvsbzpibbuxgocgldtijjoakjkvwxmsxmzpvawtbmexkmqrtdkfbkhyvzcalylixapqzndijurpmseorqqumgpphtryjwbbrmohemfbdsdmgwaxarxkfgpkcfijymafvukwnfxzpwaznvodaxjbwetnaviuvemhkjcooldkpjmkvbkgsybvhfkciwtleqjyszpnstkdbovbvsappylonldkulxrdwxwriplcnykhxwkxzuqlfekjbxhqcsutwbzykkuekedsnyxhkskbqtddngilnfhvmvvqcxeaqboquqznevvlnyfyzpphqxxyhekcwihpnezpkxohkvwvvqntgrtfotwbhhwlrtdutvmlfsimwfushiykknqqmcqymjnahecyjqwxohqscapsfljcktxsbmkohdlpmymrezgesnsfvmctzosucxmkkmikmryiuqjgqcpoidukfnovecypggfilcreegovvejgtwfxhoiqsujjpdyqkasiuuguzlyjkrfaklwsapzipgsrzbifwqabtipnswepvpyhahmiyjfcpxwgrlmdgvdgsxpudqybadmqwhligpinjejlhsiqdxeikmznpipzbbuwvbcxvlwcrileibwbjgaewkfrjfomtxraokhmpgrkcyhzhtanashgwpgovobfwdzffoplqxuqbswdnjegulwbexbhexobkohhwblikqzkcnvhtthmagqnxcayddczzosyxmnmtnkatpgeijsxgsdhxbgggjspbcbpyxpjisvopbioglglruagjmypxwwzlhiuomlfjabfkylwydhbjajcevfcwsvbrrxlylathfeqhcqxfmhfwpwhbygegcsclceetwzmbnyrhqrxqysesrbfjkqskfbtuffthkxjxyyvaoriefgzjyfumemwnkmkjnecgfrttbwllcraceknvowbxsxgcstvscnqbketnkeauaakgjmntxmrbccdhsntlvjhoklbalztozuwpcofevveemkvufvyanbkucinmsgwnhyqzwmndnckdgpxcgamjxqakmfvxgerklazphocdtqajzafvhmeookftbrxljhazdtiuxidecgffopkxrvestcsmtqtqiwkdncaetqwpnibxeqvvylbmcpvougxcnwqpknwwwryjhcxrbjyrkutfkirnvvuemhafbosxvsdrxtzdvihbvnhicuqqwuwdrrhfpqmjweetcoevvksitggaajxuoblzuprwliazyldariezdmadoolirbpxfvunygfgwkgxhkzyvfwxoeuoiuhmioaxaudkoraeesuvtwzcjswnxthbilrbespkethoqynrpvojreoolaeqpvpoeyrnyzjfodyzjbnexoiyzgnhghlpduaamxeznnadwgeraopjfxoczmopvwsfvfeaupjzxdzxvoovjtrscrofiqtjeuhyakfrmrngcikqwnrfiglfbwoicbnigxyoqiqkaviuzbanpkyvlcqzmtrghxdeqmlnpbrutcjfmgxevcquckqglxaodkwlbhzkwipzmmsxeiurbzxbkvwxqlgqcbodmurdgkhyurzwptptcdwcdwgvannmyneayxzzfyoecyaerolknnyaekkmtewrbbditbksqpgyarnkjkkcyludwquqtyzhjayvltcuuleeabjrptbvkxowrvwwhmzbwpjqthxxadnklhxsoiwodaacqxptxogcqydqeymvzlqfpaelgkxsariiauqleejrjfxcbcjozjzceqqrrdselviapclqrrnamuosadyuknzhjfwfbygzddfkzwbvexvpzhrqyhkypvfhpaekbaqovugugratkzocclmlmmjfvdcwupgdbgjtnyjzkcyytwkiqnfbwmfwksynsnshmifmrpukemqzbyktzvrjcqgowmxaccceuyqutmglqqtxsjpgduxyzyhbgkffbsqfcsekmlzzbgmfkerjoswqhawpjasprunoemhqeawbkxnqoghaoxfdwlsowjtdjpqlzczbshaliemdhrbckxmgsyvblhdwbpzuizvjfxdjtwzkuykvczchkopshoipgcamcbfygvzviuzmhnmucswmaure",
+            "output": 1
+        },
+        {
+            "input": "dzksearhykbtmifwqnbbkaaavdrenshbafjoxnywxjnemuhtkqfysisxiegpmiyqivghzmygudbjsbbttxyprrydfuwpeikyqzndtmflwxlbnngnynwcofpbfvkxcyiivojyqldcqppebymgdxbvgnszoephrnphlmxwxkxllqlqtrjblmanyttvqhviftqewqbedcveuchsdvyebgrfsgduwxyvnrerjwqfmzkgoxtwdajcgrtcfyfxrwwqnafsrfkrdabgoxcfdnjovzqmfliyxrqvfsbndzanfwnrqpnpanngxkpturxezfiixlnewfxlriyesarliloqvkrbturdbejvbgfujxfcvpogogmydeylbsblbpecflmoolddtfpivxkzwtvhpmcbtatksrdamfkpjimuwkrgjvsmiddnfnncdgianozehgxjdemodbhofbfayurtilmsngrmgblhnaptackggspelfarqbnvyfrqvghogbxzqxoxlgylzxqhtqsiqfqqzptoifrinvdlbpibppmfykvttyvrxwgcrdvmdsmatykljknhjuhhregfnideztrzpinpjipfpditfgqzhhrijwfaxvbyzmmogvpiqwwrzwbvnvxfdvfsplhcklvrrpylvohoyejdylgciiberyxtlkjzvsghwzfdhgbazdiuhgkmnttvmdsmasmzrlqtmsueneaqkcjkkxjyqratjzivhmkinaumrpzwnvmdgqjpmqbzklnkhwmnxgnvbauaikfegsuhaxigjqndxatdvyibomcaeujrrlbwvsgfvbfmoeilyerygiuwexpfpownvogafeecxbsplghcorfddunevrcaxdvirhuuesfrbauzlzqayauayycuinzcpwvgjzrxxhzdtavlmivjffdwrnrdltflqwrxpfkbqulqixbguxlymvlfjuqizobpgrizdbahmvlwvvhbdupsctzjnihnweznzoyjcjkvcgrxfppohzrrrhxjclzrpxkouwshnrudeijuwnybvjregvkagdivgxnodbkdqpmcpubtmiqbvgwbjobyjddyvwetyljiyyjvwaopfcnzvuaobswygvwfblrlargrczwafizpqbjnsfmhtkerwkbqctcyvstfgkrkkouhlbhymbqqzbelbpwknxiiegucihtifxvhsmybojprfsgvkajiploiqjhbupazgdynoovxeyxxvhbhxsryzwylbunyjjbuvypntyeoqmmtfmxwmfrgrxycstebeuexeqftfswyfnjyiodkqdbravssdydvbznkuwszevyyquiazfhllhxpragzhnahgkvvcxhxjqxeynsupwwclwblcytqmsgtmltwsgczrjoypjazifzhpmiiopkumozffkjuwdklkczsnqbgbhrtpbrbpchxzocroasjgjxotefhdvoqjwrtmqetlerxmlqplxhbehitzkhbrajnywhctvvxdvifdzocvkvjihrrtfzwyvpzrmwgerzcrpnddgsohcrqdlfmrarczbvewwhnyrxianlwkjgrskalzbmmlvooxxuwcdgxiwffklesawfkronojnqmkkgaovbrfeomqgwvgqfpvdafipktvfxtylwiusldkprwxyxvyvcezaptdlprnxzzwtuntgumznumvazkdupqifzlsoejbyvkiouplxztawgjovksulgddlumboamqtseyzzdnegxjswyxywexcljhjdnlblyzokuzndvmrbkidxqinnsuxivubucbreoolkpkavnbgegnjriefzigaxyzqflvqncxvpuzuuiwmttrycoqpwltgzkgkjrjnipudatvczknbparvuvwueqgafspsgicgcigozidjipdjkwsowywbgubjsjsfuttgxhjutdwuynpkxrbfngriroconvznighewuhnkoxcofgsbwjviunpmqjhmgjoiooqnzpxkmyytehdxzywcsgiizljfulbewyhmlkqbscuibjooombzzuggqmwlzpehqsmocgpqutlvuwfyuexharyfrrfxppwinuqzyvjbnycfdkaxpjwlfxuxbgibykzkahldzpfzvrpcraaefdyjnulzdsknrtjgmopzwtkenegcosmzlumderlqbioxrgjpnuuuesvzeiafpimeasomsfzwmoeykeqpwphuiefquzpfmbuahamcmyjmewyuhhqihmeuhldtzdhrclzgrdxikstdjheyqlodkpjjtuaegzenvqvbdwmlnyyopfvuyxsuxgjssvoeewjgqvzetavdckoejqevsxhdbdjfvehaulizraqumiqcfvccvjonwqgqmoitbczuuonnwpmksbtenpaefzmimpetudluipbcfhqttuyyamdqvadbxxqzoaftvjtcrktvupzlrowcxubvclfxmnkrglchwhspsjxomjzlcsfzaftzwwnstfncebiciiykzwrsgpqlpofsdrifyewnuddnaryuckivsgbzqpukhqpkdzwlfegsoexzjycvnfggxgwdipypsnzsltpbzjgpzeaatojkwvzqglzdseepoxymtmtvjaniesbmiaclufdtrzxwubkgltqiskfxuveparzdvawapwdtovofsuozqxcwklkmxhvvbfctzpsyxtjbtpbohxhiklbguvlpaliclkzghovzjatiuicdmmlsvlrqexcieguqxqrvxzppdxgrszcrchhnlpninbjpdyvwbuadecaxzonulzliuqcapxcqqkrhrwdkxrjfcsilcyxhcexdddvolgjeiuxfofjzhjcldzoxlayzbzmenwmafrkuobcnykckbsezskorubppjdqxlollocvpezamzthvbntznpniatjsikgdeubfxdbinmgubeqthjoetqmeenfivpciszkexobhginyyuxqllevkqfehqaobuzrzsndngkrzelejtzeozrdmhrsrljtsllelmgaukhupujkwklawnmoulydifmsrsqltkqyupsrdjrnzypolfrczlxncbqvrkzfpmrdtjhzohzcybjlpnzkxrvdgxplfqqfxwodbevxzalrhjzaqgcaertawnmdcmyoihqnvtlcvczogjnnhgskgsdadczycsfglfnefubfclqdonezqjlectlxrvwickmvdpjrunveahntivyraojpvyjpfwesfndlqpxmogdvngegcsihnpoaqpqkhijqilxzjopznhxekxxolptrmkwcvhgaxdrjaxnssqrwqvyhmspwihqsbfsidxipyirncpqldaulfchchxwwurdqltkhsibidgijtnwkursrrxfphnlhmsueflenoufijjbvdenbiphdxqbodjgtosydltyazkldavmgugotkjzxmvjjuwgithgqpmrbeaneahoqdroipsnyuetnbgkwxmqeecemcguukrylfyldhtdeeqgdhbixdnzzmzqmhcbpzrzahulkcckiqmwuvdornifpvqpc",
+            "output": 1
+        },
+        {
+            "input": "hpwniciubkrmdgcbnqeriqgssmmdawpsbfszfvczmbilvoyolorliojkivipopxckiqiczrvjyuaxnahiasgyigsbfjrtuagehixgnjuiavwjqpffozbvqkexkwgngwtidwufqpxhyplsclyfjcdclyxaxbijkrinlzqxxaawrdqwafmvemzbwgnnsctzmnoaaaewtfmghfzapvmjlkwfmdbfzclfbjbcfaayzrmogogkjtodzljthvmxgvifdinqkplxusimasyqnwxqlljjijjkzvtmtylwtwmpwroxkpzlpswrrdqjptasalltcmaaukoetwfisfriscwatogakfglkllrdzbflocpdoghrlvnkpqtthmiutafvbyyzrikpfqzlfxhawdjrxgncfirkzshtfkfrenenursdipwhdsqldueavlqloqckioromwdelrydqijcijpabzbjoxweppzhdbqwrevnufvotscfmltmaugeltzsdphcndzvkjkucszerthnabnjiuugbppyvayuxmnjhwzdtymhizfsapqkamwtmuedubvrhknfcaeshbgwneaajmsrnwrdwrjwlxosghfqrkebrblvrelfgkkdhafdbmncponnrcsesxrengjrekdbpvkoyjqtoiqxmialmzclcrxfgkarxrsgpweblwmlgbkdsrsxgcyqpsenkhhvbzsigstkxcxjmvvpoagtxexizojjibequycqapywurkrmelazlnwyqazgtsgtpgqkisleqgedpthiliuntrtyuxtcppyrlxeswrcjhkfwcwmewjeqbvjyytlzxypptcexryaiqkrpjuibeaghxrfxisnawbnosckzxkzknieyectrulwxzwqdpsfjwiznogyxqrjgwqubcultmcaxikxazbnvrgpovfsgkqozvxngmcahuisvkinenteyhtjucsytlspuoinbpqtymcrkkjyglmfxtehgvqqllbndtfptkquenjwjyolvlofqlouztsebmymtcgbzuxozlgcfxparlbkvrofxvgoqhylgkndrleadlfmjcojlzthvztfsatxxprmpsyyjgohxcqowklrvnrdhollpqsfloaqadwnfcrddzuapzmytrbwgpbepsjvyodyfmbhqxwnvxllrnuiitscczymcdlwfyvqnxsdyvnxkmlajavrxfnohqcxlacrqoxuqcodufddnbvfsaeqsmdspabjfsmmfyosuvcdxgnidafsfvlqmknkyzpzrhvsdzecbcfqswdldunyqtkxgmfpeqzitbfnvlqeorinmqwrahjdrdjkpplaytdumbwmiqmwqpmlfusjfbfxbckflklecryjxocgcstxtesduvnkfkjucscerlkkkmmzlcsrfcfcareqdzwfltsynlsrkgfqwyeoetlazvnsqnoudcsmlrytuixfmgtjeyvjqitklgeoxczvszvztmaqmztknlzpakranusxikseeykecovtmaflcsyinnbfrwxekfzglenzkxuitaitemnennxgmitmdfbrwzlxdbwsnfvrwxebvypowycwknouynfaeroxkhsbkemzephaqjqfwqyginufhfguwsbrmccwatqpmnijabesbqrqrydagiiaqajqhfbqwfwaywkymjxxfzyrwbvsosysfgtmhpgcswbhdrhnykqzllhqbufxiqbwocvvodtrbdvyjrzkvmcrhctznneixgdvkmsnulfhubrrcyufticwopwniepokllunhozfaolxyevtybfluofgiokkczmvhyzhmhixykhhnqbjdkzcokvqljeusfvremjqpxrikbhihukgcindzwbowkprbprpjaffzyilgwriojfsyevemfzvmtrakquvppbejfjfldxrkavmmcbwdpwitbpjbqnmnwnbcuvudlasqpcijceugucbiufvbofwhiuubnlonipcnawmvzspygrhohnpdcfivsottoirdossaoybdmixgenytzechmrrkwiegusxzvazoeiunmtdtngkixlxthsitzvvrgdcgyrsxkbeksdyfdnoccfcfubsflhuvfgotdfpcgnutqtilaryoanqljfyxmvilyegveapyhvgxcvgohpzpesqybazjthcjohyomzpnsyclefvjlougqfcdszvkzanzzdrmfwqgjxmmtzholwxrnjqxirflhonyljstbehbkhsthvunqxfyyotclmebijjkxaptumpnyyqvevmdhuklnrodookfcklqsleuejcewchovfzzayyffqpravndwczmystdrqgorgtbpkclldadfwdleovjgtljummmdyytktidxqmfxeandqlwolbraptzqkrtmtvpysjqjwxibpqkayirqtpvwxyyaohfkztxcktnntxcqwatthwmvizahsciwhjapkwwqaulswvwsupwfgbqscesufjhhrxvsvhfvarviydieysrielsiolqtvcronytshenlbgclxyrvhukbzuyaqilioyvutsnijlwyghcceyvgkcqdqvkjbxucrfpnbjwrxflrhlynpcaylcphiyiuymgrdxpnxbwbcojjmncooywfdwstaaibuyxllrgvxnsbqbmpsjhlrmjcoylnmuhlwdxysvkknidmzjlzzvebubtsdcerjhyyjxtvmffrplyusemhvrwmczqirgwwbuhcumqkiuwwuktujsikgphuydyhxwmhbugcvbqcqejwfpybppliicxwyqatzgzbcfagqyoaycnvyfrwonkwjbnlhuvnwrumtqbdkv",
+            "output": 1
+        },
+        {
+            "input": "zkgepeixyskrggfbkwiafeycaaodrnkpkundhqbpbybxsgxexuuxylciaddfpmahmqaybpfyhivaqavswoxfhxkcdvgkuetwxlafzfgjykleyufgvkxbfdcoxrpjjbcookvmqlfugjrihjiewrojfbpcajpokfxmojekrqasnxbkpgwkttbovprcokdtxwyyjjrnuipuccdbngrkzxddqleixyvpcbxgtdxdwtjoykkbnghqmpujddrspfsagbdgbryjzoshorjrrodtjfqgaotuxniakkwcihweacppsllgleqbcsqmzflnhoneikvmlraawpubvhogbshcmzbojkdgjqshhvdiwrsaossuspejhuvatuowzzxxmlvddnjiumkbvxreeoqywucruczpgksiufwxwpconodokeurcpqmacmblgxuxmhytgtqnrrviqkdwfoonwnlsouxfkbdhnwjgizbgyerhrwuptaoscubhabodnhpzhuqlrtjzxqsgecbsxtymtfpibnsfstqevnygrdeunvfdqygklzewnjhwbdmeyvbebdgfqijjmhfkjylgvweoahjtqyljuctxcpmckrmcpxexehdjazndwdfoywfbbmjblzviklaehrtcpgtyvcbafphvhtbwdypdhppbfrcfiarcdigwawsfihupsadmsinafkbxlcudgijogzwrcbifnbhhgvfadiyvmkfcfgrtrjpgyoqmwvozvmvhylitkqjqamxcftrzabwxgnbsvrtofwpqodhpehhiienohzaghujqjjiwinpoycuukmluhdhmrinizqhwapuratinezgtiokydqkqtmuofwfswuwzelfplcwdgqmbdpkdgmuxuyaetfbiogkskkckndqtgcqwtxrauceebhkqedwrengzpludhrywxabmvnzsqlcmnktzdsjvsbwdgyrumvuyujqjcvuemhipzdpacdsgtgcodignofiwqzcxvkucbnsjcpuxtbrrnvqjlerzbkavvzecexfexmjvkgsyepgmqgltvjzcxhcsnsbzvayqeifeiptnjihnfqlagtwqakechbiyyzgfmlopuwgquwnqjgyxpyhhfovdwqpwpminrcjpnarawuolquixgnymywadxbyfoswkibsvxxcthachqaedukamcshmydqqishcmpuikgsedsnhxduaxeozwihobiauxpxqnclqcfozhlhdvsxvvkwysphhpmsgoqgzvsyeiartotrvulkecknzlygdsjmezogiaslcozpatruhsygpyukyouhbstelzxlaoukmuxabdpgryvftblavipapcavyhgjrinlxbbzzlqmyznrgxnqchrixxtgifvhxgbgnvdjtvqufduuonzaczxlpgclcdrbmwtjebyibohfenhbappsisglxdpskjzxecwvmbzkhvjhfjmklygidmzsggfwrflewocxyiwgkrfhdptiwejxlgdjdykdywdcyasyjbjmnyptasifziogkeybyducgwlkqyuteajgpbhqeuormkiweabybswnuerrervhulvzcdlxhdcsqhhyqcohibxgpbhegkdkpyxaxwljbuylwcmafrvlzmdrdulhqrpolprggezulyfyxbasnczjwlrfrcozlzddiblvcknzegwighlykrqigrnjuddrsohttgfjxuaxjgqlywqmmwsalajjgnltwdjvqttiefbpyqafmrbtenabscwayylwzldbpdgeddqwclyjhzhuhxutzpbitptpovbxazfabitmedshevodoeciwel",
+            "output": 1
+        },
+        {
+            "input": "jnyibgjjuziqbdrpdhshfchiebbrkleqkduulxshhyuekiiyberrfjxawwdushprszomonbgxpyfsdaxarbbgnxagplcxbofttbvzpvahacpjklvylbsvfitkmsgmqaehukukccihijfiyjstfswhfajwijebolkxnuprinlmearnhuhlbbmumhhzgxazhlozrlfrumacrmdzkzcdmbfkadsbvgkcszwttciwsoslelunkjharoutrclipvplaqwcdqrxcdnldsasjbcgcjcgokvocthqwmhrsmfiybivxqcbhufaawwoxjdskvshoohemdhvtsljngcwttssciqbghuusygayymyvkpqxnsoawemxaxouhdcibwhrwxsxnaesbcjrfexmsvqgexiowufltbszosvmuktutfaiyrdpugajxcjwxyknhjbybyyzpbsqurfkpnltaistpphawxmtqdmsdbjhrohnottwuqcyxhusgrhmfymmpciaxogfjawijyrbwovhjslecnqvkydzqssbcxbifvyqwgrbiugzpkexplquokhuqezkcncrbwrjiwjemfaybjcztgpicjisjzfpspbnwfusilthbxkwqibhtvmfuaobqsoqnoricejszyvzcuqxgyrrumnkpdkspbawtkplepewvzcurgptarchdwqkzfygtyvttaaftscczwjkarfzveotkpmlbmwmoohwjkrpazvkthaaibjexmpdpecrwhybraxcljrnffcrjnriziihvwvbdkkogapfolljzqqdmpcuwvdlersrityvapouhwmdaqpaywdomsliobizugevvsmuqlcehdujbwcdplkdoveztxqwzhyrqxmwglpoavyjqnaryjkpowwsceozcpintxazhjwgtblczpomtwcaraxhhkomkwsqvyxsdqvpnvopjxiwqnhtfaylaermadebwzowjerkzjngsdsvuxfsemodhljwmbmmvsugtxkzxdcdulrgdnupjohnqadvkbtoeutpsffjvdhqfarcpewbtepljlmyvryiwfgxsfluhnvplugtaohezvsgpxepwgtkuocjqlykznbywlynvjhcdldlbpkapnkopnjfnwhrjnkrfsgqngmapcvfihcdudpanjvqthvndoarocpqznfjqjteotjtokhxmolmmlaibzlfvmtyltuinfbcodoyxbtmkmcgcbbfjltxzfbwgxwtkgisbjbazafnnzntmgcbazwdacauezxkecbivieexvyehlbxthoxsjyhwmhvhbtxpkshwxsprorqbgvjnhrqqvvootuzvnejyfgokgaznopasxxjovbpwyrlveybxbujtwwpvxkexgzvmcpljjmkqolqhteqwukjomzempzwahpilwstwzlbqzgfarhxxskgqkyyhcyankopckwajgaiqyhgjvomeumedbnqqewggfalhxvovsdklqwdphlgrulrmqeekvymadizkmpcioqapxwkmxjxsybbknmqmxeeoccbmvwrbkwrwwyuvbbmrvhgblkhgwralecxwmssmjgunjssimoigoatceiubbkynukrczqlqautejpnanvtuuyxiwlgsonlhsjuuxxdrsooxoffhexexqgnuvtgyfultuwpjaiapebrjztflywcxhsggdqsaeujhgdkgmdkosxfzmyrlgdarvcsswhvuyoezcdhvfvrezmvkxvoaexmjmwrxsheejzyrdtvkqhqhxkdsylrpcxvvxekmwbahwktccxpavtrchdcdrldnowkphqboemaurctchwpopdbnqqaylxmlwwelmjitthkvohzqgxiblvsxssingxdfqmmxqzvktrzkkphswmmaewrarelpltmgbuekmtctrufukzckqjgnfwgqxqcegqwkojnnemoulpczdhzsjkcnxxnrcghiqlhewexmtncnyccbvfxbstljxvargyjlofeasycvqyisfkxwdhpkfeavkvwdwmppbxoqmcdeqjmimfaagreoxhrbdkhrwfivqlyimugwdlvcdnxgyblcyeipfcryqfksmykdhiiudpfzyshdcdlfwuzusbenerykujmkvptsfbivnzawhxdoqkpjftyjsvgiuxzhmnljrxgfwuyarazdlprgqttcoesfmsxvmscdqcytliqmlmbmkneblcpvispilzupxybewxosoapvtjnfrasccegdckebtsztjzkthhioflvynyhmawcwwjqsacdpbfowonhgwbgynavogabbpuotoytbwafhouxleyssrhruqwhcgrxkegkogodtxxpwandrmysrqwukgnsecixvpajkgdxctcbsoxjjspxcmxgvxjimjbkrzzxubkbwfiobdyrdtgpwrbphvpkzbzqtjxwonzmobreupoqrfvjerhjhgjibzwijmhblvtzpqukjyzlqtvanvxoplvquyibbmuctbvggxqdvzruaqaiaztoeprbasbrifsgdpcskpweslamvvqwietnxjayduysevfquudgqftnnaibytlppfajqgkpmfmfivjoimbfxqrgxbvsygqbdkqwhcjlrqzyrdkxfdgjcnwjfvlnhmwfivhmltylovyixeawrqwakdltwcuhohuosnskkebydgqvxkwznfqdplnaerizmnyzvsaagyvomvmiixvoyatstkcyrbnqsecgavcxeqaqjiiskknpitcubqphvtcatljedlekjfrnhahnccifzosthkbedivibvwmrbpptzhxrkigunoypyvukpjlsytgowpxymhyzwlwncggeeotnbcxsouajmjjnliigmvwhlctoqvvrlmjatslkiwghwalzicmkfkuvaxiwtktvgkebqmfvdkeoyfmgexmenkbzuqxaeyyooksfjuutyxumzvrjkxpwixbmnggqgnprpbgvhbqxicnazhwdjfmlpucfanivgckoxvxsanhkonoubkzyctftifvmvkigxsnowcbpebpiwkhtajkgmdhapwdxatwhlyomboovwbyyyrhzxrklczxocrdrcsiscqxctqabltbextrzfdzslpsmzeeebzgaxsbqxzjgniwsexlbccavbsqwktzaojrfzibssjtfdslajuicvumbaifkcoknoczcwfknjhqfzxszsfxofrcdbujdeojnevmweyhorilvhquooozilwhbggfyiawhejyukuwibpggvptlvgsfnbzmlhbsyhbrlrkmjwhsuemfqfskkhdumofsuhuzrzeytoqmhcvinhjsoihhjfnidzbazxvvmubjcydyfqlibntxnlkzjiiyrszyvcdniywbtsohjkwwixopwmhphaoefmcdnplpdwzoqjeesjvywpczjeetdgmfmwkpmptzxfztghkftswncwhcstgjsbljqiqcmxgnzhrhcbqyqcdcjwmvejezlefvjmhnmdlxvysqrlyvcjvneondgpbxpmymiifwiucaozciqbgmrquuyfcyhlxeagovyybdaasqvuzvhrqumllpefhwasooyhiwhrjpiuocmtqubwepjqmxqwtbjnogsnyytqygkaxnwuqrqdlafnuzruwstphiwwkxzpmuboygbqjxowxcbxamdefvjomgvwhmzxidbdgskmlmislblftbngppkbpknkbvcwihsoenhktymrmjxdsmuwguqjqjgwifnmvovumkhxnwvyqfaxleiyiqegmobsagxlgkfvnyslufkzqtrduaggqdysgnyhytatusqauevmioqpzrduomifuckokqkafbeowmzyinrsumuvanribdspsvqpyjrzpdifeebeehckpihrrrgrkzzojkhuzvfxjzkhtvnanlqecfdrksdccpknivtzhrmlrloftbyuhgtmovcgkjymdtejdewyuvezbnjlz",
+            "output": 1
+        },
+        {
+            "input": "wacfxjzmywbrxvylieialefwcywjhnjdsnnzmjrjxwaydpgyqntcaypafyzvqvjxtyfthydbgdgumcgoscagutwkktcxdbxvszpjrigewtsapyaowojxnkoxhzrkzkvmhepggenddvvttmruteuazltvknfsyxgwmysbudzcznizzdrlxmobydbbmeotqfyhuuzxoyjvjzkddzyifvpyiovcapdacmwczloxupflgxtbcbbjkjfcqwcoolgqqyqqmxwzzfhdndfkmerdukprgtjasoascefrqzyncchjbrqursdqupcquadlugynurobgxmdapxvniauhmqslzfkrlfqpdvvahlswtuzmjpraeyhwfuyxdpvhockrtjtqdhtxqkprcdrqpbhlramkwhkmwpijhebakdvljmwtklhymjayyzbiczpsmschkenmgpsydrrhvxczhjgqqbakxnpagpcxocpjcytokwzehuwghrwcznvzmwveaerdceeqryfydzcofquudyysnttlazwvnmmmddaclcrexcwqrmtbymwhdltisksjxufkxrbibwhleyucqzowizxlqdbrhqdctglkdwcctrxyfdmftdkxefaztlpodeebntdsyerzbrgznkzprzlksnhgatnaynixubknliojylcyigntnouomexsxynmoriuzlmudnsarebhvrdzthxuqtqtzfuxkwrnhlztfzcdeqphqnlvxsgofriosxossalstgvihqtmhlxiwnlzpagdtzpmgqhazqmveapjpmprmorvqlqcsbokdcgvjjgoukdaetsiuuvdpzukscpvavkrlaxrztzbxfwzstmfurhovgxrxispdyftuydpaverstakocsjwpleuweuqiadhdcwdfljmmdfgtortfskxbaxirlciupupmqgkoxatejxztewkttugytluyfkejqfanbgrkvlvoyefitsdztubqyaghbyfvqaxjxxrnlycsnogxfnkscoxqvqdzlqfwvydvjusszblwphksjysxuplytbjgezjfahckrxnvjikyaeierpaoarpgjawxtuhfnxdkgqtajmouwlkwusgvnqxeqmsqkwbkylcwbuwzseymxvidaxjoumkacrkepnkkxjhjgcytwximrghajmovqcuyhgmimmpkekexhmqvfnyzkhgdfhyuryfmftatstdxmmvaguiukezhulwndujpwjweypxcuzjvpckugbkpd",
+            "output": 1
+        }
+    ],
+    "haskell_template": "deleteString :: String -> Int\ndeleteString s ",
+    "ocaml_template": "let deleteString (s: string) : int =  ",
+    "scala_template": "def deleteString(s: String): Int = { \n    \n}",
+    "java_template": "public static int deleteString(String s) {\n\n}",
+    "python_template": "class Solution(object):\n    def deleteString(self, s):\n        \"\"\"\n        :type s: str\n        :rtype: int\n        \"\"\"\n        "
+}

maximum_deletions_on_a_string/ocaml_tests/main.ml

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

maximum_deletions_on_a_string/scala_tests/MySuite.scala

@@ -0,0 +1,16 @@
+
+class MySuite extends munit.FunSuite {
+  
+  test("test1") {
+    assertEquals(Main.deleteString("abcabcdabc"), 2)
+  }
+
+  test("test2") {
+    assertEquals(Main.deleteString("aaabaab"), 4)
+  }
+
+  test("test3") {
+    assertEquals(Main.deleteString("aaaaa"), 5)
+  }
+
+}

maximum_difference_between_adjacent_elements_in_a_circular_array/haskell_tests/Main.hs

@@ -0,0 +1,41 @@
+
+module Main where
+import Test.HUnit
+
+--Program start
+maxAdjacentDistance :: [Int] -> Int
+maxAdjacentDistance nums = undefined
+
+--Program end
+
+-- Test cases
+
+test1 :: Test
+test1 = TestCase (assertEqual "for (maxAdjacentDistance [1,2,4])," 3 (maxAdjacentDistance [1,2,4]))
+
+test2 :: Test
+test2 = TestCase (assertEqual "for (maxAdjacentDistance [-5,-10,-5])," 5 (maxAdjacentDistance [-5,-10,-5]))
+
+test3 :: Test
+test3 = TestCase (assertEqual "for (maxAdjacentDistance [36, 97, ( -60), 77, ( -96), ( -74), ( -26), 59, ( -6), ( -58), 59, ( -30), ( -37), ( -29), 61, 1, ( -90), 76, ( -12), ( -75), 40, ( -9), ( -76), ( -45), ( -68), 32, ( -71), ( -47), 14, ( -75), 52, 15, ( -19), ( -16), 40, 32, 17, ( -23), ( -3), ( -83), ( -98), 13, ( -61), ( -48), ( -98)])," 173 (maxAdjacentDistance [36, 97, -60, 77, -96, -74, -26, 59, -6, -58, 59, -30, -37, -29, 61, 1, -90, 76, -12, -75, 40, -9, -76, -45, -68, 32, -71, -47, 14, -75, 52, 15, -19, -16, 40, 32, 17, -23, -3, -83, -98, 13, -61, -48, -98]))
+
+test4 :: Test
+test4 = TestCase (assertEqual "for (maxAdjacentDistance [88, ( -53), ( -67), ( -15), ( -69), ( -31), 89, 16, 99])," 141 (maxAdjacentDistance [88, -53, -67, -15, -69, -31, 89, 16, 99]))
+
+test5 :: Test
+test5 = TestCase (assertEqual "for (maxAdjacentDistance [-77, ( -9), 26, 62, ( -97), ( -71), ( -84), 39, ( -61), ( -97), ( -63), ( -48), ( -74), ( -49), ( -37), ( -11), 94, 17, ( -78), ( -1), ( -80), ( -30), ( -14), ( -100), ( -66), 54, 79, ( -4), 59, 41, ( -28), ( -40), ( -71), 84, ( -31), ( -56), 68, ( -58), 24, ( -45), ( -80), ( -94), 85, ( -36), ( -16), 49, ( -86), 70, 61, ( -65), 43])," 179 (maxAdjacentDistance [-77, -9, 26, 62, -97, -71, -84, 39, -61, -97, -63, -48, -74, -49, -37, -11, 94, 17, -78, -1, -80, -30, -14, -100, -66, 54, 79, -4, 59, 41, -28, -40, -71, 84, -31, -56, 68, -58, 24, -45, -80, -94, 85, -36, -16, 49, -86, 70, 61, -65, 43]))
+
+test6 :: Test
+test6 = TestCase (assertEqual "for (maxAdjacentDistance [-8, 20, 27, ( -48), ( -83), ( -15), ( -85), 11, 82, ( -33), ( -66), ( -46), 32, ( -52), ( -97), 1, 5, ( -19), 48, 16, ( -4), 82, 97, 92, ( -43), 5, 21, ( -60), 68, 98, ( -79), ( -62), ( -66), ( -61), ( -83), 50, ( -48), 35, 50, 8, ( -55), ( -75), ( -52), ( -24), ( -45), ( -36), 44, 58, ( -33), 94, ( -82), 98, ( -17), 43, 82, 58, ( -42), ( -44), ( -61), ( -47), ( -79), ( -100), ( -94), 58, 4, ( -56), ( -41), 89, 56, ( -21), 34, 24, 63, ( -90), ( -37), ( -58), 99, 49, 64, ( -100), ( -89), ( -48), ( -61), 67, 31, 73, 17])," 180 (maxAdjacentDistance [-8, 20, 27, -48, -83, -15, -85, 11, 82, -33, -66, -46, 32, -52, -97, 1, 5, -19, 48, 16, -4, 82, 97, 92, -43, 5, 21, -60, 68, 98, -79, -62, -66, -61, -83, 50, -48, 35, 50, 8, -55, -75, -52, -24, -45, -36, 44, 58, -33, 94, -82, 98, -17, 43, 82, 58, -42, -44, -61, -47, -79, -100, -94, 58, 4, -56, -41, 89, 56, -21, 34, 24, 63, -90, -37, -58, 99, 49, 64, -100, -89, -48, -61, 67, 31, 73, 17]))
+
+test7 :: Test
+test7 = TestCase (assertEqual "for (maxAdjacentDistance [-19, ( -69), ( -77), 19, ( -2), 65, ( -85), ( -47), ( -33), ( -72), ( -52), ( -71), 99, 29, ( -53), ( -53), ( -37), 84, 84, 62, 14, 69, 31, 12, ( -26), ( -39), ( -85), ( -74), 40, ( -58), 13, 17, ( -48), ( -73), 39, 65, 79, ( -92), 25, 52, 58, 94, ( -1), ( -50), ( -77), 61, 78, ( -12), ( -22), ( -81), 28, ( -99), 6, ( -70), 82, ( -3), 37, ( -54), 100, 52, 22, ( -24), ( -73), ( -48), 82, ( -23), ( -74), 13, 0, 54, ( -9), 41, ( -57), ( -63), ( -77), ( -14), 78, ( -72), 89, ( -83), ( -75), ( -27), ( -16), ( -35), ( -79), 33, 61, 45, ( -44), ( -23), ( -55), ( -18), 31, 21, 80, ( -44)])," 172 (maxAdjacentDistance [-19, -69, -77, 19, -2, 65, -85, -47, -33, -72, -52, -71, 99, 29, -53, -53, -37, 84, 84, 62, 14, 69, 31, 12, -26, -39, -85, -74, 40, -58, 13, 17, -48, -73, 39, 65, 79, -92, 25, 52, 58, 94, -1, -50, -77, 61, 78, -12, -22, -81, 28, -99, 6, -70, 82, -3, 37, -54, 100, 52, 22, -24, -73, -48, 82, -23, -74, 13, 0, 54, -9, 41, -57, -63, -77, -14, 78, -72, 89, -83, -75, -27, -16, -35, -79, 33, 61, 45, -44, -23, -55, -18, 31, 21, 80, -44]))
+
+
+-- 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

maximum_difference_between_adjacent_elements_in_a_circular_array/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(3, maxAdjacentDistance(Arrays.asList(1,2,4)));
+}
+@Test
+public void test2() {
+    assertEquals(5, maxAdjacentDistance(Arrays.asList(-5,-10,-5)));
+}
+
+}

maximum_difference_between_adjacent_elements_in_a_circular_array/meta.json

@@ -0,0 +1,340 @@
+{
+    "id": 3747,
+    "name": "maximum_difference_between_adjacent_elements_in_a_circular_array",
+    "difficulty": "Easy",
+    "link": "https://leetcode.com/problems/maximum-difference-between-adjacent-elements-in-a-circular-array/",
+    "date": "2025-01-04 00:00:00",
+    "task_description": "Given a **circular** array `nums`, find the maximum absolute difference between adjacent elements. **Note**: In a circular array, the first and last elements are adjacent. **Example 1:** **Input:** nums = [1,2,4] **Output:** 3 **Explanation:** Because `nums` is circular, `nums[0]` and `nums[2]` are adjacent. They have the maximum absolute difference of `|4 - 1| = 3`. **Example 2:** **Input:** nums = [-5,-10,-5] **Output:** 5 **Explanation:** The adjacent elements `nums[0]` and `nums[1]` have the maximum absolute difference of `|-5 - (-10)| = 5`. **Constraints:** `2 <= nums.length <= 100` `-100 <= nums[i] <= 100`",
+    "public_test_cases": [
+        {
+            "label": "Example 1",
+            "input": "nums = [1,2,4]",
+            "output": "3 "
+        },
+        {
+            "label": "Example 2",
+            "input": "nums = [-5,-10,-5]",
+            "output": "5 "
+        }
+    ],
+    "private_test_cases": [
+        {
+            "input": [
+                36,
+                97,
+                -60,
+                77,
+                -96,
+                -74,
+                -26,
+                59,
+                -6,
+                -58,
+                59,
+                -30,
+                -37,
+                -29,
+                61,
+                1,
+                -90,
+                76,
+                -12,
+                -75,
+                40,
+                -9,
+                -76,
+                -45,
+                -68,
+                32,
+                -71,
+                -47,
+                14,
+                -75,
+                52,
+                15,
+                -19,
+                -16,
+                40,
+                32,
+                17,
+                -23,
+                -3,
+                -83,
+                -98,
+                13,
+                -61,
+                -48,
+                -98
+            ],
+            "output": 173
+        },
+        {
+            "input": [
+                88,
+                -53,
+                -67,
+                -15,
+                -69,
+                -31,
+                89,
+                16,
+                99
+            ],
+            "output": 141
+        },
+        {
+            "input": [
+                -77,
+                -9,
+                26,
+                62,
+                -97,
+                -71,
+                -84,
+                39,
+                -61,
+                -97,
+                -63,
+                -48,
+                -74,
+                -49,
+                -37,
+                -11,
+                94,
+                17,
+                -78,
+                -1,
+                -80,
+                -30,
+                -14,
+                -100,
+                -66,
+                54,
+                79,
+                -4,
+                59,
+                41,
+                -28,
+                -40,
+                -71,
+                84,
+                -31,
+                -56,
+                68,
+                -58,
+                24,
+                -45,
+                -80,
+                -94,
+                85,
+                -36,
+                -16,
+                49,
+                -86,
+                70,
+                61,
+                -65,
+                43
+            ],
+            "output": 179
+        },
+        {
+            "input": [
+                -8,
+                20,
+                27,
+                -48,
+                -83,
+                -15,
+                -85,
+                11,
+                82,
+                -33,
+                -66,
+                -46,
+                32,
+                -52,
+                -97,
+                1,
+                5,
+                -19,
+                48,
+                16,
+                -4,
+                82,
+                97,
+                92,
+                -43,
+                5,
+                21,
+                -60,
+                68,
+                98,
+                -79,
+                -62,
+                -66,
+                -61,
+                -83,
+                50,
+                -48,
+                35,
+                50,
+                8,
+                -55,
+                -75,
+                -52,
+                -24,
+                -45,
+                -36,
+                44,
+                58,
+                -33,
+                94,
+                -82,
+                98,
+                -17,
+                43,
+                82,
+                58,
+                -42,
+                -44,
+                -61,
+                -47,
+                -79,
+                -100,
+                -94,
+                58,
+                4,
+                -56,
+                -41,
+                89,
+                56,
+                -21,
+                34,
+                24,
+                63,
+                -90,
+                -37,
+                -58,
+                99,
+                49,
+                64,
+                -100,
+                -89,
+                -48,
+                -61,
+                67,
+                31,
+                73,
+                17
+            ],
+            "output": 180
+        },
+        {
+            "input": [
+                -19,
+                -69,
+                -77,
+                19,
+                -2,
+                65,
+                -85,
+                -47,
+                -33,
+                -72,
+                -52,
+                -71,
+                99,
+                29,
+                -53,
+                -53,
+                -37,
+                84,
+                84,
+                62,
+                14,
+                69,
+                31,
+                12,
+                -26,
+                -39,
+                -85,
+                -74,
+                40,
+                -58,
+                13,
+                17,
+                -48,
+                -73,
+                39,
+                65,
+                79,
+                -92,
+                25,
+                52,
+                58,
+                94,
+                -1,
+                -50,
+                -77,
+                61,
+                78,
+                -12,
+                -22,
+                -81,
+                28,
+                -99,
+                6,
+                -70,
+                82,
+                -3,
+                37,
+                -54,
+                100,
+                52,
+                22,
+                -24,
+                -73,
+                -48,
+                82,
+                -23,
+                -74,
+                13,
+                0,
+                54,
+                -9,
+                41,
+                -57,
+                -63,
+                -77,
+                -14,
+                78,
+                -72,
+                89,
+                -83,
+                -75,
+                -27,
+                -16,
+                -35,
+                -79,
+                33,
+                61,
+                45,
+                -44,
+                -23,
+                -55,
+                -18,
+                31,
+                21,
+                80,
+                -44
+            ],
+            "output": 172
+        }
+    ],
+    "haskell_template": "maxAdjacentDistance :: [Int] -> Int\nmaxAdjacentDistance nums ",
+    "ocaml_template": "let maxAdjacentDistance (nums: int list) : int =  ",
+    "scala_template": "def maxAdjacentDistance(nums: List[Int]): Int = { \n    \n}",
+    "java_template": "class Solution {\n    public int maxAdjacentDistance(int[] nums) {\n        \n    }\n}",
+    "python_template": "class Solution(object):\n    def maxAdjacentDistance(self, nums):\n        \"\"\"\n        :type nums: List[int]\n        :rtype: int\n        \"\"\"\n        "
+}

maximum_difference_between_adjacent_elements_in_a_circular_array/ocaml_tests/main.ml

@@ -0,0 +1,42 @@
+
+module Main = struct
+    open OUnit2
+
+    (* Program start *)
+    let maxAdjacentDistance (nums: int list) : int =   failwith "Not implemented"
+
+    (* Program end *)
+
+    (* Test cases *)
+    
+let test1 _ = assert_equal 3 (maxAdjacentDistance [1;2;4])
+
+let test2 _ = assert_equal 5 (maxAdjacentDistance [-5;-10;-5])
+
+let test3 _ = assert_equal 5 (maxAdjacentDistance [36; 97; -60; 77; -96; -74; -26; 59; -6; -58; 59; -30; -37; -29; 61; 1; -90; 76; -12; -75; 40; -9; -76; -45; -68; 32; -71; -47; 14; -75; 52; 15; -19; -16; 40; 32; 17; -23; -3; -83; -98; 13; -61; -48; -98])
+
+let test4 _ = assert_equal 5 (maxAdjacentDistance [88; -53; -67; -15; -69; -31; 89; 16; 99])
+
+let test5 _ = assert_equal 5 (maxAdjacentDistance [-77; -9; 26; 62; -97; -71; -84; 39; -61; -97; -63; -48; -74; -49; -37; -11; 94; 17; -78; -1; -80; -30; -14; -100; -66; 54; 79; -4; 59; 41; -28; -40; -71; 84; -31; -56; 68; -58; 24; -45; -80; -94; 85; -36; -16; 49; -86; 70; 61; -65; 43])
+
+let test6 _ = assert_equal 5 (maxAdjacentDistance [-8; 20; 27; -48; -83; -15; -85; 11; 82; -33; -66; -46; 32; -52; -97; 1; 5; -19; 48; 16; -4; 82; 97; 92; -43; 5; 21; -60; 68; 98; -79; -62; -66; -61; -83; 50; -48; 35; 50; 8; -55; -75; -52; -24; -45; -36; 44; 58; -33; 94; -82; 98; -17; 43; 82; 58; -42; -44; -61; -47; -79; -100; -94; 58; 4; -56; -41; 89; 56; -21; 34; 24; 63; -90; -37; -58; 99; 49; 64; -100; -89; -48; -61; 67; 31; 73; 17])
+
+let test7 _ = assert_equal 5 (maxAdjacentDistance [-19; -69; -77; 19; -2; 65; -85; -47; -33; -72; -52; -71; 99; 29; -53; -53; -37; 84; 84; 62; 14; 69; 31; 12; -26; -39; -85; -74; 40; -58; 13; 17; -48; -73; 39; 65; 79; -92; 25; 52; 58; 94; -1; -50; -77; 61; 78; -12; -22; -81; 28; -99; 6; -70; 82; -3; 37; -54; 100; 52; 22; -24; -73; -48; 82; -23; -74; 13; 0; 54; -9; 41; -57; -63; -77; -14; 78; -72; 89; -83; -75; -27; -16; -35; -79; 33; 61; 45; -44; -23; -55; -18; 31; 21; 80; -44])
+
+
+    (* Grouping test cases *)
+    let suite = "Test Suite for maxAdjacentDistance" >::: [
+        
+  "test1" >:: test1;
+  "test2" >:: test2;
+  "test3" >:: test3;
+  "test4" >:: test4;
+  "test5" >:: test5;
+  "test6" >:: test6;
+  "test7" >:: test7;
+    ]
+
+
+    (* Running the tests *)
+    let () = run_test_tt_main suite
+end

maximum_difference_between_adjacent_elements_in_a_circular_array/scala_tests/MySuite.scala

@@ -0,0 +1,32 @@
+
+class MySuite extends munit.FunSuite {
+  
+  test("test1") {
+    assertEquals(Main.maxAdjacentDistance(List(1,2,4)), 3)
+  }
+
+  test("test2") {
+    assertEquals(Main.maxAdjacentDistance(List(-5,-10,-5)), 5)
+  }
+
+  test("test3") {
+    assertEquals(Main.maxAdjacentDistance(36,97,-60,77,-96,-74,-26,59,-6,-58,59,-30,-37,-29,61,1,-90,76,-12,-75,40,-9,-76,-45,-68,32,-71,-47,14,-75,52,15,-19,-16,40,32,17,-23,-3,-83,-98,13,-61,-48,-98), 173)
+  }
+
+  test("test4") {
+    assertEquals(Main.maxAdjacentDistance(88,-53,-67,-15,-69,-31,89,16,99), 141)
+  }
+
+  test("test5") {
+    assertEquals(Main.maxAdjacentDistance(-77,-9,26,62,-97,-71,-84,39,-61,-97,-63,-48,-74,-49,-37,-11,94,17,-78,-1,-80,-30,-14,-100,-66,54,79,-4,59,41,-28,-40,-71,84,-31,-56,68,-58,24,-45,-80,-94,85,-36,-16,49,-86,70,61,-65,43), 179)
+  }
+
+  test("test6") {
+    assertEquals(Main.maxAdjacentDistance(-8,20,27,-48,-83,-15,-85,11,82,-33,-66,-46,32,-52,-97,1,5,-19,48,16,-4,82,97,92,-43,5,21,-60,68,98,-79,-62,-66,-61,-83,50,-48,35,50,8,-55,-75,-52,-24,-45,-36,44,58,-33,94,-82,98,-17,43,82,58,-42,-44,-61,-47,-79,-100,-94,58,4,-56,-41,89,56,-21,34,24,63,-90,-37,-58,99,49,64,-100,-89,-48,-61,67,31,73,17), 180)
+  }
+
+  test("test7") {
+    assertEquals(Main.maxAdjacentDistance(-19,-69,-77,19,-2,65,-85,-47,-33,-72,-52,-71,99,29,-53,-53,-37,84,84,62,14,69,31,12,-26,-39,-85,-74,40,-58,13,17,-48,-73,39,65,79,-92,25,52,58,94,-1,-50,-77,61,78,-12,-22,-81,28,-99,6,-70,82,-3,37,-54,100,52,22,-24,-73,-48,82,-23,-74,13,0,54,-9,41,-57,-63,-77,-14,78,-72,89,-83,-75,-27,-16,-35,-79,33,61,45,-44,-23,-55,-18,31,21,80,-44), 172)
+  }
+
+}

maximum_difference_between_even_and_odd_frequency_i/haskell_tests/Main.hs

@@ -0,0 +1,41 @@
+
+module Main where
+import Test.HUnit
+
+--Program start
+maxDifference :: String -> Int
+maxDifference s = undefined
+
+--Program end
+
+-- Test cases
+
+test1 :: Test
+test1 = TestCase (assertEqual "for (maxDifference \"aaaaabbc \")," 3 (maxDifference "aaaaabbc"))
+
+test2 :: Test
+test2 = TestCase (assertEqual "for (maxDifference \"abcabcab \")," 1 (maxDifference "abcabcab"))
+
+test3 :: Test
+test3 = TestCase (assertEqual "for (maxDifference  \"bbzzrrrwwkkaaaafmmyvvnlllllljjtttggxxuoooqsciip \")," 1 (maxDifference "bbzzrrrwwkkaaaafmmyvvnlllllljjtttggxxuoooqsciip"))
+
+test4 :: Test
+test4 = TestCase (assertEqual "for (maxDifference  \"qqqqtoolzzsxkkjnhceu \")," (-1) (maxDifference "qqqqtoolzzsxkkjnhceu"))
+
+test5 :: Test
+test5 = TestCase (assertEqual "for (maxDifference  \"hyzzxnfueqqvr \")," (-1) (maxDifference "hyzzxnfueqqvr"))
+
+test6 :: Test
+test6 = TestCase (assertEqual "for (maxDifference  \"jjjexxllqqqrrrrrkkkfffihssaaauuuuppppvvnzgybcm \")," 3 (maxDifference "jjjexxllqqqrrrrrkkkfffihssaaauuuuppppvvnzgybcm"))
+
+test7 :: Test
+test7 = TestCase (assertEqual "for (maxDifference  \"nnnjssssspprrrruuuwwhhhvvviiqqdddooobmmaafffgcccyxx \")," 3 (maxDifference "nnnjssssspprrrruuuwwhhhvvviiqqdddooobmmaafffgcccyxx"))
+
+
+-- 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

maximum_difference_between_even_and_odd_frequency_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(3, maxDifference("aaaaabbc"));
+}
+@Test
+public void test2() {
+    assertEquals(1, maxDifference("abcabcab"));
+}
+
+}

maximum_difference_between_even_and_odd_frequency_i/meta.json

@@ -0,0 +1,47 @@
+{
+    "id": 3753,
+    "name": "maximum_difference_between_even_and_odd_frequency_i",
+    "difficulty": "Easy",
+    "link": "https://leetcode.com/problems/maximum-difference-between-even-and-odd-frequency-i/",
+    "date": "2025-01-26 00:00:00",
+    "task_description": "You are given a string `s` consisting of lowercase English letters. Your task is to find the **maximum** difference between the frequency of **two** characters in the string such that: One of the characters has an **even frequency** in the string. The other character has an **odd frequency** in the string. Return the **maximum** difference, calculated as the frequency of the character with an odd frequency **minus** the frequency of the character with an even frequency. **Example 1:** **Input:** s = \"aaaaabbc\" **Output:** 3 **Explanation:** The character `'a'` has an **odd frequency** of `5`, and `'b'` has an **even frequency** of `2`. The maximum difference is `5 - 2 = 3`. **Example 2:** **Input:** s = \"abcabcab\" **Output:** 1 **Explanation:** The character `'a'` has an **odd frequency** of `3`, and `'c'` has an **even frequency** of 2. The maximum difference is `3 - 2 = 1`. **Constraints:** `3 <= s.length <= 100` `s` consists only of lowercase English letters. `s` contains at least one character with an odd frequency and one with an even frequency.",
+    "public_test_cases": [
+        {
+            "label": "Example 1",
+            "input": "s = \"aaaaabbc\"",
+            "output": "3 "
+        },
+        {
+            "label": "Example 2",
+            "input": "s = \"abcabcab\"",
+            "output": "1 "
+        }
+    ],
+    "private_test_cases": [
+        {
+            "input": "bbzzrrrwwkkaaaafmmyvvnlllllljjtttggxxuoooqsciip",
+            "output": 1
+        },
+        {
+            "input": "qqqqtoolzzsxkkjnhceu",
+            "output": -1
+        },
+        {
+            "input": "hyzzxnfueqqvr",
+            "output": -1
+        },
+        {
+            "input": "jjjexxllqqqrrrrrkkkfffihssaaauuuuppppvvnzgybcm",
+            "output": 3
+        },
+        {
+            "input": "nnnjssssspprrrruuuwwhhhvvviiqqdddooobmmaafffgcccyxx",
+            "output": 3
+        }
+    ],
+    "haskell_template": "maxDifference :: String -> Int\nmaxDifference s ",
+    "ocaml_template": "let maxDifference (s: string) : int =  ",
+    "scala_template": "def maxDifference(s: String): Int = { \n    \n}",
+    "java_template": "class Solution {\n    public int maxDifference(String s) {\n        \n    }\n}",
+    "python_template": "class Solution(object):\n    def maxDifference(self, s):\n        \"\"\"\n        :type s: str\n        :rtype: int\n        \"\"\"\n        "
+}

maximum_difference_between_even_and_odd_frequency_i/ocaml_tests/main.ml

@@ -0,0 +1,42 @@
+
+module Main = struct
+    open OUnit2
+
+    (* Program start *)
+    let maxDifference (s: string) : int =   failwith "Not implemented"
+
+    (* Program end *)
+
+    (* Test cases *)
+    
+let test1 _ = assert_equal 3 (maxDifference "aaaaabbc")
+
+let test2 _ = assert_equal 1 (maxDifference "abcabcab")
+
+let test3 _ = assert_equal 1 (maxDifference "bbzzrrrwwkkaaaafmmyvvnlllllljjtttggxxuoooqsciip")
+
+let test4 _ = assert_equal 1 (maxDifference "qqqqtoolzzsxkkjnhceu")
+
+let test5 _ = assert_equal 1 (maxDifference "hyzzxnfueqqvr")
+
+let test6 _ = assert_equal 1 (maxDifference "jjjexxllqqqrrrrrkkkfffihssaaauuuuppppvvnzgybcm")
+
+let test7 _ = assert_equal 1 (maxDifference "nnnjssssspprrrruuuwwhhhvvviiqqdddooobmmaafffgcccyxx")
+
+
+    (* Grouping test cases *)
+    let suite = "Test Suite for maxDifference" >::: [
+        
+  "test1" >:: test1;
+  "test2" >:: test2;
+  "test3" >:: test3;
+  "test4" >:: test4;
+  "test5" >:: test5;
+  "test6" >:: test6;
+  "test7" >:: test7;
+    ]
+
+
+    (* Running the tests *)
+    let () = run_test_tt_main suite
+end

maximum_difference_between_even_and_odd_frequency_i/scala_tests/MySuite.scala

@@ -0,0 +1,32 @@
+
+class MySuite extends munit.FunSuite {
+  
+  test("test1") {
+    assertEquals(Main.maxDifference("aaaaabbc"), 3)
+  }
+
+  test("test2") {
+    assertEquals(Main.maxDifference("abcabcab"), 1)
+  }
+
+  test("test3") {
+    assertEquals(Main.maxDifference(",b,b,z,z,r,r,r,w,w,k,k,a,a,a,a,f,m,m,y,v,v,n,l,l,l,l,l,l,j,j,t,t,t,g,g,x,x,u,o,o,o,q,s,c,i,i,p,"), 1)
+  }
+
+  test("test4") {
+    assertEquals(Main.maxDifference(",q,q,q,q,t,o,o,l,z,z,s,x,k,k,j,n,h,c,e,u,"), -1)
+  }
+
+  test("test5") {
+    assertEquals(Main.maxDifference(",h,y,z,z,x,n,f,u,e,q,q,v,r,"), -1)
+  }
+
+  test("test6") {
+    assertEquals(Main.maxDifference(",j,j,j,e,x,x,l,l,q,q,q,r,r,r,r,r,k,k,k,f,f,f,i,h,s,s,a,a,a,u,u,u,u,p,p,p,p,v,v,n,z,g,y,b,c,m,"), 3)
+  }
+
+  test("test7") {
+    assertEquals(Main.maxDifference(",n,n,n,j,s,s,s,s,s,p,p,r,r,r,r,u,u,u,w,w,h,h,h,v,v,v,i,i,q,q,d,d,d,o,o,o,b,m,m,a,a,f,f,f,g,c,c,c,y,x,x,"), 3)
+  }
+
+}

maximum_difference_between_even_and_odd_frequency_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(-1, maxDifference("12233", 4));
+}
+@Test
+public void test2() {
+    assertEquals(1, maxDifference("1122211", 3));
+}
+@Test
+public void test3() {
+    assertEquals(-, maxDifference("110", 3));
+}
+
+}

maximum_difference_score_in_a_grid/haskell_tests/Main.hs

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

maximum_difference_score_in_a_grid/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(9, maxScore(Arrays.asList(Arrays.asList(9,5,7,3),Arrays.asList(8,9,6,1),Arrays.asList(6,7,14,3),Arrays.asList(2,5,3,1))));
+}
+@Test
+public void test2() {
+    assertEquals(-1, maxScore(Arrays.asList(Arrays.asList(4,3,2),Arrays.asList(3,2,1))));
+}
+
+}

maximum_difference_score_in_a_grid/meta.json

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

maximum_elegance_of_a_k_length_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 (findMaximumElegance [[3,2],[5,1],[10,1]] 2)," 17 (findMaximumElegance [[3,2],[5,1],[10,1]] 2))
+
+test2 :: Test
+test2 = TestCase (assertEqual "for (findMaximumElegance [[3,1],[3,1],[2,2],[5,3]] 3)," 19 (findMaximumElegance [[3,1],[3,1],[2,2],[5,3]] 3))
+
+test3 :: Test
+test3 = TestCase (assertEqual "for (findMaximumElegance [[1,1],[2,1],[3,1]] 3)," 7 (findMaximumElegance [[1,1],[2,1],[3,1]] 3))
+
+
+-- Grouping test cases
+tests :: Test
+tests = TestList [TestLabel "Test1" test1, TestLabel "Test2" test2]
+
+-- Running the tests
+main :: IO Counts
+main = runTestTT tests

maximum_elegance_of_a_k_length_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(17, findMaximumElegance(new ArrayList<>(Arrays.asList(new ArrayList<>(Arrays.asList(3,2)),new ArrayList<>(Arrays.asList(5,1)),new ArrayList<>(Arrays.asList(10,1)))), 2));
+}
+@Test
+public void test2() {
+    assertEquals(19, findMaximumElegance(new ArrayList<>(Arrays.asList(new ArrayList<>(Arrays.asList(3,1)),new ArrayList<>(Arrays.asList(3,1)),new ArrayList<>(Arrays.asList(2,2)),new ArrayList<>(Arrays.asList(5,3)))), 3));
+}
+@Test
+public void test3() {
+    assertEquals(7, findMaximumElegance(new ArrayList<>(Arrays.asList(new ArrayList<>(Arrays.asList(1,1)),new ArrayList<>(Arrays.asList(2,1)),new ArrayList<>(Arrays.asList(3,1)))), 3));
+}
+
+}

maximum_elegance_of_a_k_length_subsequence/meta.json

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

maximum_elegance_of_a_k_length_subsequence/ocaml_tests/main.ml

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

maximum_elegance_of_a_k_length_subsequence/scala_tests/MySuite.scala

@@ -0,0 +1,16 @@
+
+class MySuite extends munit.FunSuite {
+  
+  test("test1") {
+    assertEquals(Main.findMaximumElegance(List(List(3,2),List(5,1),List(10,1)),2), 17)
+  }
+
+  test("test2") {
+    assertEquals(Main.findMaximumElegance(List(List(3,1),List(3,1),List(2,2),List(5,3)),3), 19)
+  }
+
+  test("test3") {
+    assertEquals(Main.findMaximumElegance(List(List(1,1),List(2,1),List(3,1)),3), 7)
+  }
+
+}

maximum_enemy_forts_that_can_be_captured/haskell_tests/Main.hs

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

maximum_enemy_forts_that_can_be_captured/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(4, captureForts(new ArrayList<>(Arrays.asList(1,0,0,-1,0,0,0,0,1))));
+}
+@Test
+public void test2() {
+    assertEquals(0, captureForts(new ArrayList<>(Arrays.asList(0,0,1,-1))));
+}
+
+}

maximum_enemy_forts_that_can_be_captured/ocaml_tests/main.ml

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

maximum_enemy_forts_that_can_be_captured/scala_tests/MySuite.scala

@@ -0,0 +1,12 @@
+
+class MySuite extends munit.FunSuite {
+  
+  test("test1") {
+    assertEquals(Main.captureForts(List(1,0,0,-1,0,0,0,0,1)), 4)
+  }
+
+  test("test2") {
+    assertEquals(Main.captureForts(List(0,0,1,-1)), 0)
+  }
+
+}

maximum_energy_boost_from_two_drinks/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 (maxEnergyBoost [1,3,1] [3,1,1])," 5 (maxEnergyBoost [1,3,1] [3,1,1]))
+
+test2 :: Test
+test2 = TestCase (assertEqual "for (maxEnergyBoost [4,1,1] [1,1,3])," 7 (maxEnergyBoost [4,1,1] [1,1,3]))
+
+test3 :: Test
+test3 = TestCase (assertEqual "for (maxEnergyBoost [28, 82, 48, 32, 55, 10, 18, 100, 26, 13, 77, 59, 49, 30, 17, 94, 93, 72, 61, 41, 70, 28, 54, 15, 80, 49, 2, 16, 54, 4, 80, 86, 87, 39, 91, 50, 85, 17, 94, 51, 36, 14, 73, 97, 41, 24, 49, 60, 2, 85, 99, 8, 84, 39, 48, 16, 18, 51, 105, 23, 95, 92, 103, 101, 77, 42, 96, 85, 65, 81, 88, 3, 9, 25, 79, 19, 45, 64, 91, 34, 25, 41] [80, 69, 52, 3, 36, 65, 55, 59, 1, 49, 26, 8, 34, 62, 55, 72, 65, 79, 71, 17, 20, 3, 103, 26, 70, 101, 43, 48, 45, 38, 83, 29, 55, 98, 24, 104, 33, 17, 53, 11, 34, 58, 38, 87, 1, 102, 99, 71, 42, 53, 73, 89, 3, 19, 88, 102, 12, 34, 94, 44, 3, 6, 39, 57, 104, 20, 76, 31, 103, 24, 37, 53, 22, 39, 33, 104, 100, 85, 36, 32, 71, 7])," 4817 (maxEnergyBoost [28, 82, 48, 32, 55, 10, 18, 100, 26, 13, 77, 59, 49, 30, 17, 94, 93, 72, 61, 41, 70, 28, 54, 15, 80, 49, 2, 16, 54, 4, 80, 86, 87, 39, 91, 50, 85, 17, 94, 51, 36, 14, 73, 97, 41, 24, 49, 60, 2, 85, 99, 8, 84, 39, 48, 16, 18, 51, 105, 23, 95, 92, 103, 101, 77, 42, 96, 85, 65, 81, 88, 3, 9, 25, 79, 19, 45, 64, 91, 34, 25, 41] [80, 69, 52, 3, 36, 65, 55, 59, 1, 49, 26, 8, 34, 62, 55, 72, 65, 79, 71, 17, 20, 3, 103, 26, 70, 101, 43, 48, 45, 38, 83, 29, 55, 98, 24, 104, 33, 17, 53, 11, 34, 58, 38, 87, 1, 102, 99, 71, 42, 53, 73, 89, 3, 19, 88, 102, 12, 34, 94, 44, 3, 6, 39, 57, 104, 20, 76, 31, 103, 24, 37, 53, 22, 39, 33, 104, 100, 85, 36, 32, 71, 7]))
+
+test4 :: Test
+test4 = TestCase (assertEqual "for (maxEnergyBoost [33, 1, 69, 49, 86, 17, 61, 82, 80, 34, 76, 19, 86, 46, 91, 32, 34, 39, 15, 60, 64, 63, 39, 82, 92, 47, 67, 36, 91, 64, 96, 28, 13, 45, 43, 18, 79, 38, 67, 33, 77, 26, 84, 68, 15, 91, 86, 82, 30, 44, 65, 71, 56, 72, 75, 71, 97, 68, 34, 12, 7, 55, 62, 77, 51, 13, 79, 28, 66, 21, 29, 13, 76, 27, 64, 84, 42, 5, 104] [17, 81, 81, 51, 95, 9, 90, 35, 31, 40, 66, 35, 65, 76, 13, 83, 53, 58, 1, 81, 31, 28, 75, 70, 54, 17, 59, 32, 39, 51, 26, 39, 12, 53, 13, 46, 5, 85, 25, 87, 14, 84, 97, 47, 17, 21, 66, 14, 85, 100, 50, 53, 63, 4, 61, 16, 105, 79, 51, 62, 48, 87, 31, 4, 50, 97, 21, 84, 43, 60, 91, 17, 11, 36, 13, 77, 80, 47, 38])," 4443 (maxEnergyBoost [33, 1, 69, 49, 86, 17, 61, 82, 80, 34, 76, 19, 86, 46, 91, 32, 34, 39, 15, 60, 64, 63, 39, 82, 92, 47, 67, 36, 91, 64, 96, 28, 13, 45, 43, 18, 79, 38, 67, 33, 77, 26, 84, 68, 15, 91, 86, 82, 30, 44, 65, 71, 56, 72, 75, 71, 97, 68, 34, 12, 7, 55, 62, 77, 51, 13, 79, 28, 66, 21, 29, 13, 76, 27, 64, 84, 42, 5, 104] [17, 81, 81, 51, 95, 9, 90, 35, 31, 40, 66, 35, 65, 76, 13, 83, 53, 58, 1, 81, 31, 28, 75, 70, 54, 17, 59, 32, 39, 51, 26, 39, 12, 53, 13, 46, 5, 85, 25, 87, 14, 84, 97, 47, 17, 21, 66, 14, 85, 100, 50, 53, 63, 4, 61, 16, 105, 79, 51, 62, 48, 87, 31, 4, 50, 97, 21, 84, 43, 60, 91, 17, 11, 36, 13, 77, 80, 47, 38]))
+
+test5 :: Test
+test5 = TestCase (assertEqual "for (maxEnergyBoost [73, 77, 30, 65, 52, 81, 13, 99, 54, 10, 18, 82, 55, 99, 45, 11, 57, 63, 11, 63, 53, 73, 79, 43, 103, 99, 43, 70, 93, 104, 53, 63, 65, 88, 31, 3, 50, 99, 45, 91, 69, 81, 67, 11, 42, 47, 70, 11, 48, 22, 50, 67, 36, 70, 50, 8] [90, 103, 19, 76, 53, 17, 91, 40, 94, 3, 78, 19, 101, 85, 89, 10, 40, 38, 35, 80, 102, 25, 105, 54, 77, 62, 8, 34, 38, 50, 101, 62, 93, 77, 29, 74, 83, 43, 72, 50, 28, 64, 10, 65, 104, 104, 80, 92, 65, 87, 97, 25, 31, 83, 27, 28])," 3540 (maxEnergyBoost [73, 77, 30, 65, 52, 81, 13, 99, 54, 10, 18, 82, 55, 99, 45, 11, 57, 63, 11, 63, 53, 73, 79, 43, 103, 99, 43, 70, 93, 104, 53, 63, 65, 88, 31, 3, 50, 99, 45, 91, 69, 81, 67, 11, 42, 47, 70, 11, 48, 22, 50, 67, 36, 70, 50, 8] [90, 103, 19, 76, 53, 17, 91, 40, 94, 3, 78, 19, 101, 85, 89, 10, 40, 38, 35, 80, 102, 25, 105, 54, 77, 62, 8, 34, 38, 50, 101, 62, 93, 77, 29, 74, 83, 43, 72, 50, 28, 64, 10, 65, 104, 104, 80, 92, 65, 87, 97, 25, 31, 83, 27, 28]))
+
+test6 :: Test
+test6 = TestCase (assertEqual "for (maxEnergyBoost [59, 38, 105, 67, 79, 22, 6, 84, 75, 96, 92, 98, 2, 5, 105, 34, 35, 30, 94, 89, 3, 35, 44, 37, 35, 29, 104, 17, 25, 42, 32, 16, 25, 42, 31, 78, 72, 25, 80, 98, 90, 74, 77, 7, 21, 66, 56, 91, 57, 16, 78, 89, 69, 16, 86, 63, 86, 99, 100, 44] [87, 46, 10, 81, 14, 74, 42, 43, 93, 48, 91, 65, 54, 18, 29, 103, 61, 29, 19, 20, 56, 98, 38, 43, 42, 31, 45, 19, 103, 34, 27, 96, 97, 32, 19, 64, 101, 94, 55, 87, 58, 54, 35, 47, 72, 11, 56, 26, 6, 59, 23, 81, 53, 102, 77, 72, 33, 81, 16, 46])," 3590 (maxEnergyBoost [59, 38, 105, 67, 79, 22, 6, 84, 75, 96, 92, 98, 2, 5, 105, 34, 35, 30, 94, 89, 3, 35, 44, 37, 35, 29, 104, 17, 25, 42, 32, 16, 25, 42, 31, 78, 72, 25, 80, 98, 90, 74, 77, 7, 21, 66, 56, 91, 57, 16, 78, 89, 69, 16, 86, 63, 86, 99, 100, 44] [87, 46, 10, 81, 14, 74, 42, 43, 93, 48, 91, 65, 54, 18, 29, 103, 61, 29, 19, 20, 56, 98, 38, 43, 42, 31, 45, 19, 103, 34, 27, 96, 97, 32, 19, 64, 101, 94, 55, 87, 58, 54, 35, 47, 72, 11, 56, 26, 6, 59, 23, 81, 53, 102, 77, 72, 33, 81, 16, 46]))
+
+test7 :: Test
+test7 = TestCase (assertEqual "for (maxEnergyBoost [97, 102, 36, 100, 20, 16, 44, 74, 8, 94, 1, 18, 89, 38, 96, 77, 33, 26, 103, 81, 4, 63, 84, 70, 15, 96, 66, 79, 89, 64, 48] [33, 8, 75, 37, 7, 72, 56, 52, 76, 31, 88, 14, 37, 27, 81, 74, 87, 24, 95, 42, 39, 50, 87, 65, 81, 24, 30, 95, 82, 99, 63])," 1931 (maxEnergyBoost [97, 102, 36, 100, 20, 16, 44, 74, 8, 94, 1, 18, 89, 38, 96, 77, 33, 26, 103, 81, 4, 63, 84, 70, 15, 96, 66, 79, 89, 64, 48] [33, 8, 75, 37, 7, 72, 56, 52, 76, 31, 88, 14, 37, 27, 81, 74, 87, 24, 95, 42, 39, 50, 87, 65, 81, 24, 30, 95, 82, 99, 63]))
+
+test8 :: Test
+test8 = TestCase (assertEqual "for (maxEnergyBoost [46, 75, 78, 22, 15, 88, 65, 19, 94, 5, 90, 18, 43, 1, 75, 65, 3, 88, 48, 4, 4, 80, 92, 9, 44, 16, 52, 21, 23, 76, 42, 44, 50, 43, 55, 69, 45, 3, 16, 49, 36, 70, 44, 70, 49, 10, 7, 19, 20, 7, 5, 10, 39, 26, 19, 8, 74, 32, 99, 32, 33, 16, 28, 36, 47, 1, 33, 62, 74, 12, 57, 47, 3, 72, 85, 28, 49, 74, 45, 44, 91, 37, 24, 31, 6, 11, 11, 31, 51, 95, 15, 65, 34, 37, 87, 66, 59] [34, 50, 20, 33, 79, 14, 59, 29, 37, 5, 20, 3, 40, 25, 85, 8, 7, 42, 10, 50, 40, 5, 16, 27, 37, 5, 10, 68, 41, 48, 23, 102, 91, 83, 13, 68, 60, 48, 23, 2, 48, 51, 26, 45, 95, 43, 86, 83, 23, 22, 36, 12, 32, 19, 66, 28, 36, 84, 88, 79, 48, 14, 19, 73, 22, 33, 65, 87, 61, 42, 3, 88, 90, 85, 62, 8, 19, 34, 47, 49, 20, 91, 41, 60, 69, 28, 40, 73, 60, 17, 74, 58, 100, 71, 23, 13, 37])," 4791 (maxEnergyBoost [46, 75, 78, 22, 15, 88, 65, 19, 94, 5, 90, 18, 43, 1, 75, 65, 3, 88, 48, 4, 4, 80, 92, 9, 44, 16, 52, 21, 23, 76, 42, 44, 50, 43, 55, 69, 45, 3, 16, 49, 36, 70, 44, 70, 49, 10, 7, 19, 20, 7, 5, 10, 39, 26, 19, 8, 74, 32, 99, 32, 33, 16, 28, 36, 47, 1, 33, 62, 74, 12, 57, 47, 3, 72, 85, 28, 49, 74, 45, 44, 91, 37, 24, 31, 6, 11, 11, 31, 51, 95, 15, 65, 34, 37, 87, 66, 59] [34, 50, 20, 33, 79, 14, 59, 29, 37, 5, 20, 3, 40, 25, 85, 8, 7, 42, 10, 50, 40, 5, 16, 27, 37, 5, 10, 68, 41, 48, 23, 102, 91, 83, 13, 68, 60, 48, 23, 2, 48, 51, 26, 45, 95, 43, 86, 83, 23, 22, 36, 12, 32, 19, 66, 28, 36, 84, 88, 79, 48, 14, 19, 73, 22, 33, 65, 87, 61, 42, 3, 88, 90, 85, 62, 8, 19, 34, 47, 49, 20, 91, 41, 60, 69, 28, 40, 73, 60, 17, 74, 58, 100, 71, 23, 13, 37]))
+
+test9 :: Test
+test9 = TestCase (assertEqual "for (maxEnergyBoost [100, 88, 9, 105, 36, 87, 12, 48, 13, 69, 53, 14, 95, 35, 77, 34, 41, 23, 45, 73, 36, 13, 9, 68, 105, 79, 94, 36, 30, 5, 67, 46, 99, 8, 24, 61, 91, 27, 46, 66, 81, 53, 47, 23, 8, 92, 17, 57, 8] [15, 53, 85, 32, 22, 68, 43, 65, 97, 30, 18, 21, 13, 82, 85, 104, 69, 10, 37, 92, 42, 37, 26, 63, 28, 96, 61, 24, 62, 84, 91, 101, 43, 24, 23, 68, 85, 19, 18, 62, 12, 31, 2, 81, 14, 14, 18, 95, 88])," 2759 (maxEnergyBoost [100, 88, 9, 105, 36, 87, 12, 48, 13, 69, 53, 14, 95, 35, 77, 34, 41, 23, 45, 73, 36, 13, 9, 68, 105, 79, 94, 36, 30, 5, 67, 46, 99, 8, 24, 61, 91, 27, 46, 66, 81, 53, 47, 23, 8, 92, 17, 57, 8] [15, 53, 85, 32, 22, 68, 43, 65, 97, 30, 18, 21, 13, 82, 85, 104, 69, 10, 37, 92, 42, 37, 26, 63, 28, 96, 61, 24, 62, 84, 91, 101, 43, 24, 23, 68, 85, 19, 18, 62, 12, 31, 2, 81, 14, 14, 18, 95, 88]))
+
+
+-- 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

maximum_energy_boost_from_two_drinks/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(5, maxEnergyBoost(new ArrayList<>(Arrays.asList(1,3,1)), new ArrayList<>(Arrays.asList(3,1,1))));
+}
+@Test
+public void test2() {
+    assertEquals(7, maxEnergyBoost(new ArrayList<>(Arrays.asList(4,1,1)), new ArrayList<>(Arrays.asList(1,1,3))));
+}
+
+}

maximum_energy_boost_from_two_drinks/meta.json

@@ -0,0 +1,1429 @@
+{
+    "id": 3525,
+    "name": "maximum_energy_boost_from_two_drinks",
+    "difficulty": "Medium",
+    "link": "https://leetcode.com/problems/maximum-energy-boost-from-two-drinks/",
+    "date": "2024-08-11 00:00:00",
+    "task_description": "You are given two integer arrays `energyDrinkA` and `energyDrinkB` of the same length `n` by a futuristic sports scientist. These arrays represent the energy boosts per hour provided by two different energy drinks, A and B, respectively. You want to _maximize_ your total energy boost by drinking one energy drink _per hour_. However, if you want to switch from consuming one energy drink to the other, you need to wait for _one hour_ to cleanse your system (meaning you won't get any energy boost in that hour). Return the **maximum** total energy boost you can gain in the next `n` hours. **Note** that you can start consuming _either_ of the two energy drinks. **Example 1:** **Input:** energyDrinkA = [1,3,1], energyDrinkB = [3,1,1] **Output:** 5 **Explanation:** To gain an energy boost of 5, drink only the energy drink A (or only B). **Example 2:** **Input:** energyDrinkA = [4,1,1], energyDrinkB = [1,1,3] **Output:** 7 **Explanation:** To gain an energy boost of 7: Drink the energy drink A for the first hour. Switch to the energy drink B and we lose the energy boost of the second hour. Gain the energy boost of the drink B in the third hour. **Constraints:** `n == energyDrinkA.length == energyDrinkB.length` `3 <= n <= 105` `1 <= energyDrinkA[i], energyDrinkB[i] <= 105`",
+    "public_test_cases": [
+        {
+            "label": "Example 1",
+            "input": "energyDrinkA = [1,3,1], energyDrinkB = [3,1,1]",
+            "output": "5 "
+        },
+        {
+            "label": "Example 2",
+            "input": "energyDrinkA = [4,1,1], energyDrinkB = [1,1,3]",
+            "output": "7 "
+        }
+    ],
+    "private_test_cases": [
+        {
+            "input": [
+                [
+                    28,
+                    82,
+                    48,
+                    32,
+                    55,
+                    10,
+                    18,
+                    100,
+                    26,
+                    13,
+                    77,
+                    59,
+                    49,
+                    30,
+                    17,
+                    94,
+                    93,
+                    72,
+                    61,
+                    41,
+                    70,
+                    28,
+                    54,
+                    15,
+                    80,
+                    49,
+                    2,
+                    16,
+                    54,
+                    4,
+                    80,
+                    86,
+                    87,
+                    39,
+                    91,
+                    50,
+                    85,
+                    17,
+                    94,
+                    51,
+                    36,
+                    14,
+                    73,
+                    97,
+                    41,
+                    24,
+                    49,
+                    60,
+                    2,
+                    85,
+                    99,
+                    8,
+                    84,
+                    39,
+                    48,
+                    16,
+                    18,
+                    51,
+                    105,
+                    23,
+                    95,
+                    92,
+                    103,
+                    101,
+                    77,
+                    42,
+                    96,
+                    85,
+                    65,
+                    81,
+                    88,
+                    3,
+                    9,
+                    25,
+                    79,
+                    19,
+                    45,
+                    64,
+                    91,
+                    34,
+                    25,
+                    41
+                ],
+                [
+                    80,
+                    69,
+                    52,
+                    3,
+                    36,
+                    65,
+                    55,
+                    59,
+                    1,
+                    49,
+                    26,
+                    8,
+                    34,
+                    62,
+                    55,
+                    72,
+                    65,
+                    79,
+                    71,
+                    17,
+                    20,
+                    3,
+                    103,
+                    26,
+                    70,
+                    101,
+                    43,
+                    48,
+                    45,
+                    38,
+                    83,
+                    29,
+                    55,
+                    98,
+                    24,
+                    104,
+                    33,
+                    17,
+                    53,
+                    11,
+                    34,
+                    58,
+                    38,
+                    87,
+                    1,
+                    102,
+                    99,
+                    71,
+                    42,
+                    53,
+                    73,
+                    89,
+                    3,
+                    19,
+                    88,
+                    102,
+                    12,
+                    34,
+                    94,
+                    44,
+                    3,
+                    6,
+                    39,
+                    57,
+                    104,
+                    20,
+                    76,
+                    31,
+                    103,
+                    24,
+                    37,
+                    53,
+                    22,
+                    39,
+                    33,
+                    104,
+                    100,
+                    85,
+                    36,
+                    32,
+                    71,
+                    7
+                ]
+            ],
+            "output": 4817
+        },
+        {
+            "input": [
+                [
+                    33,
+                    1,
+                    69,
+                    49,
+                    86,
+                    17,
+                    61,
+                    82,
+                    80,
+                    34,
+                    76,
+                    19,
+                    86,
+                    46,
+                    91,
+                    32,
+                    34,
+                    39,
+                    15,
+                    60,
+                    64,
+                    63,
+                    39,
+                    82,
+                    92,
+                    47,
+                    67,
+                    36,
+                    91,
+                    64,
+                    96,
+                    28,
+                    13,
+                    45,
+                    43,
+                    18,
+                    79,
+                    38,
+                    67,
+                    33,
+                    77,
+                    26,
+                    84,
+                    68,
+                    15,
+                    91,
+                    86,
+                    82,
+                    30,
+                    44,
+                    65,
+                    71,
+                    56,
+                    72,
+                    75,
+                    71,
+                    97,
+                    68,
+                    34,
+                    12,
+                    7,
+                    55,
+                    62,
+                    77,
+                    51,
+                    13,
+                    79,
+                    28,
+                    66,
+                    21,
+                    29,
+                    13,
+                    76,
+                    27,
+                    64,
+                    84,
+                    42,
+                    5,
+                    104
+                ],
+                [
+                    17,
+                    81,
+                    81,
+                    51,
+                    95,
+                    9,
+                    90,
+                    35,
+                    31,
+                    40,
+                    66,
+                    35,
+                    65,
+                    76,
+                    13,
+                    83,
+                    53,
+                    58,
+                    1,
+                    81,
+                    31,
+                    28,
+                    75,
+                    70,
+                    54,
+                    17,
+                    59,
+                    32,
+                    39,
+                    51,
+                    26,
+                    39,
+                    12,
+                    53,
+                    13,
+                    46,
+                    5,
+                    85,
+                    25,
+                    87,
+                    14,
+                    84,
+                    97,
+                    47,
+                    17,
+                    21,
+                    66,
+                    14,
+                    85,
+                    100,
+                    50,
+                    53,
+                    63,
+                    4,
+                    61,
+                    16,
+                    105,
+                    79,
+                    51,
+                    62,
+                    48,
+                    87,
+                    31,
+                    4,
+                    50,
+                    97,
+                    21,
+                    84,
+                    43,
+                    60,
+                    91,
+                    17,
+                    11,
+                    36,
+                    13,
+                    77,
+                    80,
+                    47,
+                    38
+                ]
+            ],
+            "output": 4443
+        },
+        {
+            "input": [
+                [
+                    73,
+                    77,
+                    30,
+                    65,
+                    52,
+                    81,
+                    13,
+                    99,
+                    54,
+                    10,
+                    18,
+                    82,
+                    55,
+                    99,
+                    45,
+                    11,
+                    57,
+                    63,
+                    11,
+                    63,
+                    53,
+                    73,
+                    79,
+                    43,
+                    103,
+                    99,
+                    43,
+                    70,
+                    93,
+                    104,
+                    53,
+                    63,
+                    65,
+                    88,
+                    31,
+                    3,
+                    50,
+                    99,
+                    45,
+                    91,
+                    69,
+                    81,
+                    67,
+                    11,
+                    42,
+                    47,
+                    70,
+                    11,
+                    48,
+                    22,
+                    50,
+                    67,
+                    36,
+                    70,
+                    50,
+                    8
+                ],
+                [
+                    90,
+                    103,
+                    19,
+                    76,
+                    53,
+                    17,
+                    91,
+                    40,
+                    94,
+                    3,
+                    78,
+                    19,
+                    101,
+                    85,
+                    89,
+                    10,
+                    40,
+                    38,
+                    35,
+                    80,
+                    102,
+                    25,
+                    105,
+                    54,
+                    77,
+                    62,
+                    8,
+                    34,
+                    38,
+                    50,
+                    101,
+                    62,
+                    93,
+                    77,
+                    29,
+                    74,
+                    83,
+                    43,
+                    72,
+                    50,
+                    28,
+                    64,
+                    10,
+                    65,
+                    104,
+                    104,
+                    80,
+                    92,
+                    65,
+                    87,
+                    97,
+                    25,
+                    31,
+                    83,
+                    27,
+                    28
+                ]
+            ],
+            "output": 3540
+        },
+        {
+            "input": [
+                [
+                    59,
+                    38,
+                    105,
+                    67,
+                    79,
+                    22,
+                    6,
+                    84,
+                    75,
+                    96,
+                    92,
+                    98,
+                    2,
+                    5,
+                    105,
+                    34,
+                    35,
+                    30,
+                    94,
+                    89,
+                    3,
+                    35,
+                    44,
+                    37,
+                    35,
+                    29,
+                    104,
+                    17,
+                    25,
+                    42,
+                    32,
+                    16,
+                    25,
+                    42,
+                    31,
+                    78,
+                    72,
+                    25,
+                    80,
+                    98,
+                    90,
+                    74,
+                    77,
+                    7,
+                    21,
+                    66,
+                    56,
+                    91,
+                    57,
+                    16,
+                    78,
+                    89,
+                    69,
+                    16,
+                    86,
+                    63,
+                    86,
+                    99,
+                    100,
+                    44
+                ],
+                [
+                    87,
+                    46,
+                    10,
+                    81,
+                    14,
+                    74,
+                    42,
+                    43,
+                    93,
+                    48,
+                    91,
+                    65,
+                    54,
+                    18,
+                    29,
+                    103,
+                    61,
+                    29,
+                    19,
+                    20,
+                    56,
+                    98,
+                    38,
+                    43,
+                    42,
+                    31,
+                    45,
+                    19,
+                    103,
+                    34,
+                    27,
+                    96,
+                    97,
+                    32,
+                    19,
+                    64,
+                    101,
+                    94,
+                    55,
+                    87,
+                    58,
+                    54,
+                    35,
+                    47,
+                    72,
+                    11,
+                    56,
+                    26,
+                    6,
+                    59,
+                    23,
+                    81,
+                    53,
+                    102,
+                    77,
+                    72,
+                    33,
+                    81,
+                    16,
+                    46
+                ]
+            ],
+            "output": 3590
+        },
+        {
+            "input": [
+                [
+                    97,
+                    102,
+                    36,
+                    100,
+                    20,
+                    16,
+                    44,
+                    74,
+                    8,
+                    94,
+                    1,
+                    18,
+                    89,
+                    38,
+                    96,
+                    77,
+                    33,
+                    26,
+                    103,
+                    81,
+                    4,
+                    63,
+                    84,
+                    70,
+                    15,
+                    96,
+                    66,
+                    79,
+                    89,
+                    64,
+                    48
+                ],
+                [
+                    33,
+                    8,
+                    75,
+                    37,
+                    7,
+                    72,
+                    56,
+                    52,
+                    76,
+                    31,
+                    88,
+                    14,
+                    37,
+                    27,
+                    81,
+                    74,
+                    87,
+                    24,
+                    95,
+                    42,
+                    39,
+                    50,
+                    87,
+                    65,
+                    81,
+                    24,
+                    30,
+                    95,
+                    82,
+                    99,
+                    63
+                ]
+            ],
+            "output": 1931
+        },
+        {
+            "input": [
+                [
+                    46,
+                    75,
+                    78,
+                    22,
+                    15,
+                    88,
+                    65,
+                    19,
+                    94,
+                    5,
+                    90,
+                    18,
+                    43,
+                    1,
+                    75,
+                    65,
+                    3,
+                    88,
+                    48,
+                    4,
+                    4,
+                    80,
+                    92,
+                    9,
+                    44,
+                    16,
+                    52,
+                    21,
+                    23,
+                    76,
+                    42,
+                    44,
+                    50,
+                    43,
+                    55,
+                    69,
+                    45,
+                    3,
+                    16,
+                    49,
+                    36,
+                    70,
+                    44,
+                    70,
+                    49,
+                    10,
+                    7,
+                    19,
+                    20,
+                    7,
+                    5,
+                    10,
+                    39,
+                    26,
+                    19,
+                    8,
+                    74,
+                    32,
+                    99,
+                    32,
+                    33,
+                    16,
+                    28,
+                    36,
+                    47,
+                    1,
+                    33,
+                    62,
+                    74,
+                    12,
+                    57,
+                    47,
+                    3,
+                    72,
+                    85,
+                    28,
+                    49,
+                    74,
+                    45,
+                    44,
+                    91,
+                    37,
+                    24,
+                    31,
+                    6,
+                    11,
+                    11,
+                    31,
+                    51,
+                    95,
+                    15,
+                    65,
+                    34,
+                    37,
+                    87,
+                    66,
+                    59
+                ],
+                [
+                    34,
+                    50,
+                    20,
+                    33,
+                    79,
+                    14,
+                    59,
+                    29,
+                    37,
+                    5,
+                    20,
+                    3,
+                    40,
+                    25,
+                    85,
+                    8,
+                    7,
+                    42,
+                    10,
+                    50,
+                    40,
+                    5,
+                    16,
+                    27,
+                    37,
+                    5,
+                    10,
+                    68,
+                    41,
+                    48,
+                    23,
+                    102,
+                    91,
+                    83,
+                    13,
+                    68,
+                    60,
+                    48,
+                    23,
+                    2,
+                    48,
+                    51,
+                    26,
+                    45,
+                    95,
+                    43,
+                    86,
+                    83,
+                    23,
+                    22,
+                    36,
+                    12,
+                    32,
+                    19,
+                    66,
+                    28,
+                    36,
+                    84,
+                    88,
+                    79,
+                    48,
+                    14,
+                    19,
+                    73,
+                    22,
+                    33,
+                    65,
+                    87,
+                    61,
+                    42,
+                    3,
+                    88,
+                    90,
+                    85,
+                    62,
+                    8,
+                    19,
+                    34,
+                    47,
+                    49,
+                    20,
+                    91,
+                    41,
+                    60,
+                    69,
+                    28,
+                    40,
+                    73,
+                    60,
+                    17,
+                    74,
+                    58,
+                    100,
+                    71,
+                    23,
+                    13,
+                    37
+                ]
+            ],
+            "output": 4791
+        },
+        {
+            "input": [
+                [
+                    100,
+                    88,
+                    9,
+                    105,
+                    36,
+                    87,
+                    12,
+                    48,
+                    13,
+                    69,
+                    53,
+                    14,
+                    95,
+                    35,
+                    77,
+                    34,
+                    41,
+                    23,
+                    45,
+                    73,
+                    36,
+                    13,
+                    9,
+                    68,
+                    105,
+                    79,
+                    94,
+                    36,
+                    30,
+                    5,
+                    67,
+                    46,
+                    99,
+                    8,
+                    24,
+                    61,
+                    91,
+                    27,
+                    46,
+                    66,
+                    81,
+                    53,
+                    47,
+                    23,
+                    8,
+                    92,
+                    17,
+                    57,
+                    8
+                ],
+                [
+                    15,
+                    53,
+                    85,
+                    32,
+                    22,
+                    68,
+                    43,
+                    65,
+                    97,
+                    30,
+                    18,
+                    21,
+                    13,
+                    82,
+                    85,
+                    104,
+                    69,
+                    10,
+                    37,
+                    92,
+                    42,
+                    37,
+                    26,
+                    63,
+                    28,
+                    96,
+                    61,
+                    24,
+                    62,
+                    84,
+                    91,
+                    101,
+                    43,
+                    24,
+                    23,
+                    68,
+                    85,
+                    19,
+                    18,
+                    62,
+                    12,
+                    31,
+                    2,
+                    81,
+                    14,
+                    14,
+                    18,
+                    95,
+                    88
+                ]
+            ],
+            "output": 2759
+        },
+        {
+            "input": [
+                [
+                    28,
+                    20,
+                    57,
+                    73,
+                    56,
+                    9,
+                    35,
+                    8,
+                    57,
+                    55,
+                    7,
+                    83,
+                    43,
+                    60,
+                    30,
+                    87,
+                    32,
+                    92,
+                    94,
+                    57,
+                    60,
+                    85,
+                    70,
+                    69,
+                    31,
+                    101,
+                    33,
+                    103,
+                    103,
+                    53,
+                    15,
+                    57,
+                    78,
+                    5,
+                    3,
+                    21,
+                    6,
+                    96,
+                    76,
+                    68,
+                    16,
+                    5,
+                    50,
+                    84,
+                    9,
+                    48,
+                    105,
+                    19,
+                    77,
+                    28,
+                    18,
+                    87,
+                    89,
+                    2,
+                    8,
+                    35,
+                    19,
+                    3,
+                    22,
+                    42,
+                    95,
+                    55,
+                    96,
+                    7,
+                    30,
+                    32,
+                    60,
+                    94,
+                    62,
+                    64,
+                    93,
+                    9,
+                    15,
+                    33
+                ],
+                [
+                    92,
+                    62,
+                    55,
+                    100,
+                    51,
+                    23,
+                    17,
+                    18,
+                    94,
+                    57,
+                    58,
+                    68,
+                    70,
+                    82,
+                    88,
+                    58,
+                    19,
+                    5,
+                    80,
+                    103,
+                    27,
+                    37,
+                    55,
+                    67,
+                    15,
+                    32,
+                    34,
+                    12,
+                    43,
+                    92,
+                    14,
+                    18,
+                    28,
+                    90,
+                    54,
+                    83,
+                    33,
+                    26,
+                    35,
+                    18,
+                    66,
+                    83,
+                    53,
+                    54,
+                    99,
+                    103,
+                    47,
+                    9,
+                    62,
+                    95,
+                    97,
+                    20,
+                    67,
+                    5,
+                    20,
+                    104,
+                    22,
+                    61,
+                    105,
+                    98,
+                    10,
+                    7,
+                    57,
+                    72,
+                    36,
+                    98,
+                    67,
+                    95,
+                    75,
+                    64,
+                    22,
+                    88,
+                    16,
+                    75
+                ]
+            ],
+            "output": 4474
+        },
+        {
+            "input": [
+                [
+                    21,
+                    11,
+                    12,
+                    17,
+                    31,
+                    17,
+                    87,
+                    45,
+                    9,
+                    90,
+                    22,
+                    5,
+                    36,
+                    49,
+                    44,
+                    13,
+                    80,
+                    23,
+                    98,
+                    35,
+                    32,
+                    25,
+                    29,
+                    97,
+                    71,
+                    82,
+                    24,
+                    25,
+                    89,
+                    1,
+                    80,
+                    39,
+                    83,
+                    34,
+                    65,
+                    20,
+                    5,
+                    20,
+                    40,
+                    7,
+                    87,
+                    43,
+                    35,
+                    1,
+                    75,
+                    67,
+                    89,
+                    57,
+                    45,
+                    80,
+                    68,
+                    68,
+                    85,
+                    91,
+                    70,
+                    61,
+                    1,
+                    92,
+                    65,
+                    85,
+                    65,
+                    14,
+                    55,
+                    89,
+                    20,
+                    25,
+                    5,
+                    4,
+                    23,
+                    30,
+                    72,
+                    69,
+                    77
+                ],
+                [
+                    45,
+                    46,
+                    8,
+                    97,
+                    62,
+                    12,
+                    36,
+                    66,
+                    74,
+                    72,
+                    80,
+                    78,
+                    48,
+                    76,
+                    93,
+                    95,
+                    55,
+                    60,
+                    58,
+                    3,
+                    7,
+                    37,
+                    65,
+                    62,
+                    6,
+                    91,
+                    78,
+                    69,
+                    86,
+                    102,
+                    26,
+                    35,
+                    103,
+                    34,
+                    50,
+                    47,
+                    37,
+                    47,
+                    33,
+                    80,
+                    81,
+                    66,
+                    29,
+                    27,
+                    103,
+                    54,
+                    21,
+                    7,
+                    93,
+                    21,
+                    16,
+                    22,
+                    26,
+                    83,
+                    43,
+                    97,
+                    44,
+                    38,
+                    69,
+                    64,
+                    37,
+                    98,
+                    79,
+                    64,
+                    30,
+                    21,
+                    78,
+                    28,
+                    32,
+                    65,
+                    4,
+                    43,
+                    96
+                ]
+            ],
+            "output": 4200
+        },
+        {
+            "input": [
+                [
+                    47,
+                    7,
+                    90,
+                    75,
+                    36,
+                    12,
+                    55,
+                    100,
+                    20,
+                    97,
+                    56,
+                    85,
+                    37,
+                    72,
+                    31,
+                    60,
+                    17,
+                    88,
+                    99,
+                    101,
+                    50,
+                    58,
+                    96,
+                    105,
+                    82,
+                    68,
+                    92,
+                    97,
+                    22,
+                    24,
+                    27,
+                    49,
+                    33,
+                    5,
+                    27,
+                    86,
+                    75,
+                    44,
+                    82,
+                    51,
+                    39,
+                    39,
+                    39,
+                    96,
+                    43,
+                    46,
+                    52,
+                    71,
+                    37,
+                    57,
+                    84,
+                    55,
+                    33,
+                    13,
+                    28
+                ],
+                [
+                    65,
+                    17,
+                    28,
+                    86,
+                    46,
+                    77,
+                    51,
+                    84,
+                    83,
+                    68,
+                    48,
+                    77,
+                    73,
+                    78,
+                    100,
+                    86,
+                    43,
+                    55,
+                    14,
+                    60,
+                    98,
+                    16,
+                    89,
+                    60,
+                    79,
+                    31,
+                    53,
+                    69,
+                    63,
+                    85,
+                    80,
+                    62,
+                    37,
+                    33,
+                    32,
+                    21,
+                    4,
+                    63,
+                    77,
+                    79,
+                    74,
+                    75,
+                    42,
+                    88,
+                    8,
+                    15,
+                    66,
+                    98,
+                    81,
+                    35,
+                    79,
+                    61,
+                    33,
+                    41,
+                    25
+                ]
+            ],
+            "output": 3438
+        }
+    ],
+    "haskell_template": "maxEnergyBoost :: [Int] -> [Int] -> Int\nmaxEnergyBoost energyDrinkA energyDrinkB ",
+    "ocaml_template": "let maxEnergyBoost (energyDrinkA: int list) (energyDrinkB: int list) : int =  ",
+    "scala_template": "def maxEnergyBoost(energyDrinkA: List[Int],energyDrinkB: List[Int]): Int = { \n    \n}",
+    "java_template": "class Solution {\n    public long maxEnergyBoost(int[] energyDrinkA, int[] energyDrinkB) {\n        \n    }\n}",
+    "python_template": "class Solution(object):\n    def maxEnergyBoost(self, energyDrinkA, energyDrinkB):\n        \"\"\"\n        :type energyDrinkA: List[int]\n        :type energyDrinkB: List[int]\n        :rtype: int\n        \"\"\"\n        "
+}

maximum_energy_boost_from_two_drinks/ocaml_tests/main.ml

@@ -0,0 +1,50 @@
+
+module Main = struct
+    open OUnit2
+
+    (* Program start *)
+
+    (* Program end *)
+
+    (* Test cases *)
+    
+let test1 _ = assert_equal 5 (maxEnergyBoost [1;3;1] [3;1;1])
+
+let test2 _ = assert_equal 7 (maxEnergyBoost [4;1;1] [1;1;3])
+
+let test3 _ = assert_equal 4817 (maxEnergyBoost [28; 82; 48; 32; 55; 10; 18; 100; 26; 13; 77; 59; 49; 30; 17; 94; 93; 72; 61; 41; 70; 28; 54; 15; 80; 49; 2; 16; 54; 4; 80; 86; 87; 39; 91; 50; 85; 17; 94; 51; 36; 14; 73; 97; 41; 24; 49; 60; 2; 85; 99; 8; 84; 39; 48; 16; 18; 51; 105; 23; 95; 92; 103; 101; 77; 42; 96; 85; 65; 81; 88; 3; 9; 25; 79; 19; 45; 64; 91; 34; 25; 41] [80; 69; 52; 3; 36; 65; 55; 59; 1; 49; 26; 8; 34; 62; 55; 72; 65; 79; 71; 17; 20; 3; 103; 26; 70; 101; 43; 48; 45; 38; 83; 29; 55; 98; 24; 104; 33; 17; 53; 11; 34; 58; 38; 87; 1; 102; 99; 71; 42; 53; 73; 89; 3; 19; 88; 102; 12; 34; 94; 44; 3; 6; 39; 57; 104; 20; 76; 31; 103; 24; 37; 53; 22; 39; 33; 104; 100; 85; 36; 32; 71; 7])
+
+let test4 _ = assert_equal 4443 (maxEnergyBoost [33; 1; 69; 49; 86; 17; 61; 82; 80; 34; 76; 19; 86; 46; 91; 32; 34; 39; 15; 60; 64; 63; 39; 82; 92; 47; 67; 36; 91; 64; 96; 28; 13; 45; 43; 18; 79; 38; 67; 33; 77; 26; 84; 68; 15; 91; 86; 82; 30; 44; 65; 71; 56; 72; 75; 71; 97; 68; 34; 12; 7; 55; 62; 77; 51; 13; 79; 28; 66; 21; 29; 13; 76; 27; 64; 84; 42; 5; 104] [17; 81; 81; 51; 95; 9; 90; 35; 31; 40; 66; 35; 65; 76; 13; 83; 53; 58; 1; 81; 31; 28; 75; 70; 54; 17; 59; 32; 39; 51; 26; 39; 12; 53; 13; 46; 5; 85; 25; 87; 14; 84; 97; 47; 17; 21; 66; 14; 85; 100; 50; 53; 63; 4; 61; 16; 105; 79; 51; 62; 48; 87; 31; 4; 50; 97; 21; 84; 43; 60; 91; 17; 11; 36; 13; 77; 80; 47; 38])
+
+let test5 _ = assert_equal 3540 (maxEnergyBoost [73; 77; 30; 65; 52; 81; 13; 99; 54; 10; 18; 82; 55; 99; 45; 11; 57; 63; 11; 63; 53; 73; 79; 43; 103; 99; 43; 70; 93; 104; 53; 63; 65; 88; 31; 3; 50; 99; 45; 91; 69; 81; 67; 11; 42; 47; 70; 11; 48; 22; 50; 67; 36; 70; 50; 8] [90; 103; 19; 76; 53; 17; 91; 40; 94; 3; 78; 19; 101; 85; 89; 10; 40; 38; 35; 80; 102; 25; 105; 54; 77; 62; 8; 34; 38; 50; 101; 62; 93; 77; 29; 74; 83; 43; 72; 50; 28; 64; 10; 65; 104; 104; 80; 92; 65; 87; 97; 25; 31; 83; 27; 28])
+
+let test6 _ = assert_equal 3590 (maxEnergyBoost [59; 38; 105; 67; 79; 22; 6; 84; 75; 96; 92; 98; 2; 5; 105; 34; 35; 30; 94; 89; 3; 35; 44; 37; 35; 29; 104; 17; 25; 42; 32; 16; 25; 42; 31; 78; 72; 25; 80; 98; 90; 74; 77; 7; 21; 66; 56; 91; 57; 16; 78; 89; 69; 16; 86; 63; 86; 99; 100; 44] [87; 46; 10; 81; 14; 74; 42; 43; 93; 48; 91; 65; 54; 18; 29; 103; 61; 29; 19; 20; 56; 98; 38; 43; 42; 31; 45; 19; 103; 34; 27; 96; 97; 32; 19; 64; 101; 94; 55; 87; 58; 54; 35; 47; 72; 11; 56; 26; 6; 59; 23; 81; 53; 102; 77; 72; 33; 81; 16; 46])
+
+let test7 _ = assert_equal 1931 (maxEnergyBoost [97; 102; 36; 100; 20; 16; 44; 74; 8; 94; 1; 18; 89; 38; 96; 77; 33; 26; 103; 81; 4; 63; 84; 70; 15; 96; 66; 79; 89; 64; 48] [33; 8; 75; 37; 7; 72; 56; 52; 76; 31; 88; 14; 37; 27; 81; 74; 87; 24; 95; 42; 39; 50; 87; 65; 81; 24; 30; 95; 82; 99; 63])
+
+let test8 _ = assert_equal 4791 (maxEnergyBoost [46; 75; 78; 22; 15; 88; 65; 19; 94; 5; 90; 18; 43; 1; 75; 65; 3; 88; 48; 4; 4; 80; 92; 9; 44; 16; 52; 21; 23; 76; 42; 44; 50; 43; 55; 69; 45; 3; 16; 49; 36; 70; 44; 70; 49; 10; 7; 19; 20; 7; 5; 10; 39; 26; 19; 8; 74; 32; 99; 32; 33; 16; 28; 36; 47; 1; 33; 62; 74; 12; 57; 47; 3; 72; 85; 28; 49; 74; 45; 44; 91; 37; 24; 31; 6; 11; 11; 31; 51; 95; 15; 65; 34; 37; 87; 66; 59] [34; 50; 20; 33; 79; 14; 59; 29; 37; 5; 20; 3; 40; 25; 85; 8; 7; 42; 10; 50; 40; 5; 16; 27; 37; 5; 10; 68; 41; 48; 23; 102; 91; 83; 13; 68; 60; 48; 23; 2; 48; 51; 26; 45; 95; 43; 86; 83; 23; 22; 36; 12; 32; 19; 66; 28; 36; 84; 88; 79; 48; 14; 19; 73; 22; 33; 65; 87; 61; 42; 3; 88; 90; 85; 62; 8; 19; 34; 47; 49; 20; 91; 41; 60; 69; 28; 40; 73; 60; 17; 74; 58; 100; 71; 23; 13; 37])
+
+let test9 _ = assert_equal 2759 (maxEnergyBoost [100; 88; 9; 105; 36; 87; 12; 48; 13; 69; 53; 14; 95; 35; 77; 34; 41; 23; 45; 73; 36; 13; 9; 68; 105; 79; 94; 36; 30; 5; 67; 46; 99; 8; 24; 61; 91; 27; 46; 66; 81; 53; 47; 23; 8; 92; 17; 57; 8] [15; 53; 85; 32; 22; 68; 43; 65; 97; 30; 18; 21; 13; 82; 85; 104; 69; 10; 37; 92; 42; 37; 26; 63; 28; 96; 61; 24; 62; 84; 91; 101; 43; 24; 23; 68; 85; 19; 18; 62; 12; 31; 2; 81; 14; 14; 18; 95; 88])
+
+let test10 _ = assert_equal 4474 (maxEnergyBoost [28; 20; 57; 73; 56; 9; 35; 8; 57; 55; 7; 83; 43; 60; 30; 87; 32; 92; 94; 57; 60; 85; 70; 69; 31; 101; 33; 103; 103; 53; 15; 57; 78; 5; 3; 21; 6; 96; 76; 68; 16; 5; 50; 84; 9; 48; 105; 19; 77; 28; 18; 87; 89; 2; 8; 35; 19; 3; 22; 42; 95; 55; 96; 7; 30; 32; 60; 94; 62; 64; 93; 9; 15; 33] [92; 62; 55; 100; 51; 23; 17; 18; 94; 57; 58; 68; 70; 82; 88; 58; 19; 5; 80; 103; 27; 37; 55; 67; 15; 32; 34; 12; 43; 92; 14; 18; 28; 90; 54; 83; 33; 26; 35; 18; 66; 83; 53; 54; 99; 103; 47; 9; 62; 95; 97; 20; 67; 5; 20; 104; 22; 61; 105; 98; 10; 7; 57; 72; 36; 98; 67; 95; 75; 64; 22; 88; 16; 75])
+
+
+    (* Grouping test cases *)
+    let suite = "Test Suite for maxEnergyBoost" >::: [
+        
+  "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

maximum_energy_boost_from_two_drinks/scala_tests/MySuite.scala

@@ -0,0 +1,44 @@
+
+class MySuite extends munit.FunSuite {
+  
+  test("test1") {
+    assertEquals(Main.maxEnergyBoost(List(1,3,1),List(3,1,1)), 5)
+  }
+
+  test("test2") {
+    assertEquals(Main.maxEnergyBoost(List(4,1,1),List(1,1,3)), 7)
+  }
+
+  test("test3") {
+    assertEquals(Main.maxEnergyBoost(List(28, 82, 48, 32, 55, 10, 18, 100, 26, 13, 77, 59, 49, 30, 17, 94, 93, 72, 61, 41, 70, 28, 54, 15, 80, 49, 2, 16, 54, 4, 80, 86, 87, 39, 91, 50, 85, 17, 94, 51, 36, 14, 73, 97, 41, 24, 49, 60, 2, 85, 99, 8, 84, 39, 48, 16, 18, 51, 105, 23, 95, 92, 103, 101, 77, 42, 96, 85, 65, 81, 88, 3, 9, 25, 79, 19, 45, 64, 91, 34, 25, 41),List(80, 69, 52, 3, 36, 65, 55, 59, 1, 49, 26, 8, 34, 62, 55, 72, 65, 79, 71, 17, 20, 3, 103, 26, 70, 101, 43, 48, 45, 38, 83, 29, 55, 98, 24, 104, 33, 17, 53, 11, 34, 58, 38, 87, 1, 102, 99, 71, 42, 53, 73, 89, 3, 19, 88, 102, 12, 34, 94, 44, 3, 6, 39, 57, 104, 20, 76, 31, 103, 24, 37, 53, 22, 39, 33, 104, 100, 85, 36, 32, 71, 7)), 4817)
+  }
+
+  test("test4") {
+    assertEquals(Main.maxEnergyBoost(List(33, 1, 69, 49, 86, 17, 61, 82, 80, 34, 76, 19, 86, 46, 91, 32, 34, 39, 15, 60, 64, 63, 39, 82, 92, 47, 67, 36, 91, 64, 96, 28, 13, 45, 43, 18, 79, 38, 67, 33, 77, 26, 84, 68, 15, 91, 86, 82, 30, 44, 65, 71, 56, 72, 75, 71, 97, 68, 34, 12, 7, 55, 62, 77, 51, 13, 79, 28, 66, 21, 29, 13, 76, 27, 64, 84, 42, 5, 104),List(17, 81, 81, 51, 95, 9, 90, 35, 31, 40, 66, 35, 65, 76, 13, 83, 53, 58, 1, 81, 31, 28, 75, 70, 54, 17, 59, 32, 39, 51, 26, 39, 12, 53, 13, 46, 5, 85, 25, 87, 14, 84, 97, 47, 17, 21, 66, 14, 85, 100, 50, 53, 63, 4, 61, 16, 105, 79, 51, 62, 48, 87, 31, 4, 50, 97, 21, 84, 43, 60, 91, 17, 11, 36, 13, 77, 80, 47, 38)), 4443)
+  }
+
+  test("test5") {
+    assertEquals(Main.maxEnergyBoost(List(73, 77, 30, 65, 52, 81, 13, 99, 54, 10, 18, 82, 55, 99, 45, 11, 57, 63, 11, 63, 53, 73, 79, 43, 103, 99, 43, 70, 93, 104, 53, 63, 65, 88, 31, 3, 50, 99, 45, 91, 69, 81, 67, 11, 42, 47, 70, 11, 48, 22, 50, 67, 36, 70, 50, 8),List(90, 103, 19, 76, 53, 17, 91, 40, 94, 3, 78, 19, 101, 85, 89, 10, 40, 38, 35, 80, 102, 25, 105, 54, 77, 62, 8, 34, 38, 50, 101, 62, 93, 77, 29, 74, 83, 43, 72, 50, 28, 64, 10, 65, 104, 104, 80, 92, 65, 87, 97, 25, 31, 83, 27, 28)), 3540)
+  }
+
+  test("test6") {
+    assertEquals(Main.maxEnergyBoost(List(59, 38, 105, 67, 79, 22, 6, 84, 75, 96, 92, 98, 2, 5, 105, 34, 35, 30, 94, 89, 3, 35, 44, 37, 35, 29, 104, 17, 25, 42, 32, 16, 25, 42, 31, 78, 72, 25, 80, 98, 90, 74, 77, 7, 21, 66, 56, 91, 57, 16, 78, 89, 69, 16, 86, 63, 86, 99, 100, 44),List(87, 46, 10, 81, 14, 74, 42, 43, 93, 48, 91, 65, 54, 18, 29, 103, 61, 29, 19, 20, 56, 98, 38, 43, 42, 31, 45, 19, 103, 34, 27, 96, 97, 32, 19, 64, 101, 94, 55, 87, 58, 54, 35, 47, 72, 11, 56, 26, 6, 59, 23, 81, 53, 102, 77, 72, 33, 81, 16, 46)), 3590)
+  }
+
+  test("test7") {
+    assertEquals(Main.maxEnergyBoost(List(97, 102, 36, 100, 20, 16, 44, 74, 8, 94, 1, 18, 89, 38, 96, 77, 33, 26, 103, 81, 4, 63, 84, 70, 15, 96, 66, 79, 89, 64, 48),List(33, 8, 75, 37, 7, 72, 56, 52, 76, 31, 88, 14, 37, 27, 81, 74, 87, 24, 95, 42, 39, 50, 87, 65, 81, 24, 30, 95, 82, 99, 63)), 1931)
+  }
+
+  test("test8") {
+    assertEquals(Main.maxEnergyBoost(List(46, 75, 78, 22, 15, 88, 65, 19, 94, 5, 90, 18, 43, 1, 75, 65, 3, 88, 48, 4, 4, 80, 92, 9, 44, 16, 52, 21, 23, 76, 42, 44, 50, 43, 55, 69, 45, 3, 16, 49, 36, 70, 44, 70, 49, 10, 7, 19, 20, 7, 5, 10, 39, 26, 19, 8, 74, 32, 99, 32, 33, 16, 28, 36, 47, 1, 33, 62, 74, 12, 57, 47, 3, 72, 85, 28, 49, 74, 45, 44, 91, 37, 24, 31, 6, 11, 11, 31, 51, 95, 15, 65, 34, 37, 87, 66, 59),List(34, 50, 20, 33, 79, 14, 59, 29, 37, 5, 20, 3, 40, 25, 85, 8, 7, 42, 10, 50, 40, 5, 16, 27, 37, 5, 10, 68, 41, 48, 23, 102, 91, 83, 13, 68, 60, 48, 23, 2, 48, 51, 26, 45, 95, 43, 86, 83, 23, 22, 36, 12, 32, 19, 66, 28, 36, 84, 88, 79, 48, 14, 19, 73, 22, 33, 65, 87, 61, 42, 3, 88, 90, 85, 62, 8, 19, 34, 47, 49, 20, 91, 41, 60, 69, 28, 40, 73, 60, 17, 74, 58, 100, 71, 23, 13, 37)), 4791)
+  }
+
+  test("test9") {
+    assertEquals(Main.maxEnergyBoost(List(100, 88, 9, 105, 36, 87, 12, 48, 13, 69, 53, 14, 95, 35, 77, 34, 41, 23, 45, 73, 36, 13, 9, 68, 105, 79, 94, 36, 30, 5, 67, 46, 99, 8, 24, 61, 91, 27, 46, 66, 81, 53, 47, 23, 8, 92, 17, 57, 8),List(15, 53, 85, 32, 22, 68, 43, 65, 97, 30, 18, 21, 13, 82, 85, 104, 69, 10, 37, 92, 42, 37, 26, 63, 28, 96, 61, 24, 62, 84, 91, 101, 43, 24, 23, 68, 85, 19, 18, 62, 12, 31, 2, 81, 14, 14, 18, 95, 88)), 2759)
+  }
+
+  test("test10") {
+    assertEquals(Main.maxEnergyBoost(List(28, 20, 57, 73, 56, 9, 35, 8, 57, 55, 7, 83, 43, 60, 30, 87, 32, 92, 94, 57, 60, 85, 70, 69, 31, 101, 33, 103, 103, 53, 15, 57, 78, 5, 3, 21, 6, 96, 76, 68, 16, 5, 50, 84, 9, 48, 105, 19, 77, 28, 18, 87, 89, 2, 8, 35, 19, 3, 22, 42, 95, 55, 96, 7, 30, 32, 60, 94, 62, 64, 93, 9, 15, 33),List(92, 62, 55, 100, 51, 23, 17, 18, 94, 57, 58, 68, 70, 82, 88, 58, 19, 5, 80, 103, 27, 37, 55, 67, 15, 32, 34, 12, 43, 92, 14, 18, 28, 90, 54, 83, 33, 26, 35, 18, 66, 83, 53, 54, 99, 103, 47, 9, 62, 95, 97, 20, 67, 5, 20, 104, 22, 61, 105, 98, 10, 7, 57, 72, 36, 98, 67, 95, 75, 64, 22, 88, 16, 75)), 4474)
+  }
+
+}

maximum_frequency_after_subarray_operation/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(2, maxFrequency(new ArrayList<>(Arrays.asList(1,2,3,4,5,6)), 1));
+}
+@Test
+public void test2() {
+    assertEquals(4, maxFrequency(new ArrayList<>(Arrays.asList(10,2,3,4,5,5,4,3,2,2)), 10));
+}
+
+}

maximum_frequency_after_subarray_operation/meta.json

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

maximum_frequency_of_an_element_after_performing_operations_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(2, maxFrequency(new ArrayList<>(Arrays.asList(1,4,5)), 1, 2));
+}
+@Test
+public void test2() {
+    assertEquals(2, maxFrequency(new ArrayList<>(Arrays.asList(5,11,20,20)), 5, 1));
+}
+
+}