a54d0744d3adeb64425139b993c3f0457b61ebc81d16aa5c021673f8c7973711

.gitattributes

@@ -80,3 +80,4 @@ count_good_triplets_in_an_array/meta.json filter=lfs diff=lfs merge=lfs -text
 count_non_decreasing_subarrays_after_k_operations/meta.json filter=lfs diff=lfs merge=lfs -text
 count_number_of_bad_pairs/meta.json filter=lfs diff=lfs merge=lfs -text
 count_of_interesting_subarrays/meta.json filter=lfs diff=lfs merge=lfs -text
+count_pairs_of_points_with_distance_k/meta.json filter=lfs diff=lfs merge=lfs -text

count_pairs_of_points_with_distance_k/meta.json

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

count_pairs_of_points_with_distance_k/ocaml_tests/main.ml

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

count_pairs_of_points_with_distance_k/scala_tests/MySuite.scala

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

count_pairs_of_similar_strings/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 (similarPairs [ \"aba \", \"aabb \", \"abcd \", \"bac \", \"aabc \"])," 2 (similarPairs ["aba","aabb","abcd","bac","aabc"]))
+
+test2 :: Test
+test2 = TestCase (assertEqual "for (similarPairs [ \"aabb \", \"ab \", \"ba \"])," 3 (similarPairs ["aabb","ab","ba"]))
+
+test3 :: Test
+test3 = TestCase (assertEqual "for (similarPairs [ \"nba \", \"cba \", \"dba \"])," 0 (similarPairs ["nba","cba","dba"]))
+
+
+-- Grouping test cases
+tests :: Test
+tests = TestList [TestLabel "Test1" test1, TestLabel "Test2" test2]
+
+-- Running the tests
+main :: IO Counts
+main = runTestTT tests

count_pairs_of_similar_strings/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, similarPairs(new ArrayList<>(Arrays.asList("aba","aabb","abcd","bac","aabc"))));
+}
+@Test
+public void test2() {
+    assertEquals(3, similarPairs(new ArrayList<>(Arrays.asList("aabb","ab","ba"))));
+}
+@Test
+public void test3() {
+    assertEquals(0, similarPairs(new ArrayList<>(Arrays.asList("nba","cba","dba"))));
+}
+
+}

count_pairs_of_similar_strings/meta.json

@@ -0,0 +1,31 @@
+{
+    "id": 2594,
+    "name": "count_pairs_of_similar_strings",
+    "difficulty": "Easy",
+    "link": "https://leetcode.com/problems/count-pairs-of-similar-strings/",
+    "date": "1670716800000",
+    "task_description": "You are given a **0-indexed** string array `words`. Two strings are **similar** if they consist of the same characters. For example, `\"abca\"` and `\"cba\"` are similar since both consist of characters `'a'`, `'b'`, and `'c'`. However, `\"abacba\"` and `\"bcfd\"` are not similar since they do not consist of the same characters. Return _the number of pairs _`(i, j)`_ such that _`0 <= i < j <= word.length - 1`_ and the two strings _`words[i]`_ and _`words[j]`_ are similar_. **Example 1:** ``` **Input:** words = [\"aba\",\"aabb\",\"abcd\",\"bac\",\"aabc\"] **Output:** 2 **Explanation:** There are 2 pairs that satisfy the conditions: - i = 0 and j = 1 : both words[0] and words[1] only consist of characters 'a' and 'b'. - i = 3 and j = 4 : both words[3] and words[4] only consist of characters 'a', 'b', and 'c'. ``` **Example 2:** ``` **Input:** words = [\"aabb\",\"ab\",\"ba\"] **Output:** 3 **Explanation:** There are 3 pairs that satisfy the conditions: - i = 0 and j = 1 : both words[0] and words[1] only consist of characters 'a' and 'b'. - i = 0 and j = 2 : both words[0] and words[2] only consist of characters 'a' and 'b'. - i = 1 and j = 2 : both words[1] and words[2] only consist of characters 'a' and 'b'. ``` **Example 3:** ``` **Input:** words = [\"nba\",\"cba\",\"dba\"] **Output:** 0 **Explanation:** Since there does not exist any pair that satisfies the conditions, we return 0. ``` **Constraints:** `1 <= words.length <= 100` `1 <= words[i].length <= 100` `words[i]` consist of only lowercase English letters.",
+    "public_test_cases": [
+        {
+            "label": "Example 1",
+            "input": "words = [\"aba\",\"aabb\",\"abcd\",\"bac\",\"aabc\"]",
+            "output": "2 "
+        },
+        {
+            "label": "Example 2",
+            "input": "words = [\"aabb\",\"ab\",\"ba\"]",
+            "output": "3 "
+        },
+        {
+            "label": "Example 3",
+            "input": "words = [\"nba\",\"cba\",\"dba\"]",
+            "output": "0 "
+        }
+    ],
+    "private_test_cases": [],
+    "haskell_template": "similarPairs :: [String] -> Int\nsimilarPairs words ",
+    "ocaml_template": "let similarPairs (words: string list) : int =  ",
+    "scala_template": "def similarPairs(words: List[String]): Int = { \n    \n}",
+    "java_template": "public static int similarPairs(List<String> words) {\n\n}",
+    "python_template": "class Solution(object):\n    def similarPairs(self, words):\n        \"\"\"\n        :type words: List[str]\n        :rtype: int\n        \"\"\"\n        "
+}

count_pairs_of_similar_strings/ocaml_tests/main.ml

@@ -0,0 +1,29 @@
+
+module Main = struct
+    open OUnit2
+
+    (* Program start *)
+
+    (* Program end *)
+
+    (* Test cases *)
+    
+let test1 _ = assert_equal 2 (similarPairs ["aba";"aabb";"abcd";"bac";"aabc"])
+
+let test2 _ = assert_equal 3 (similarPairs ["aabb";"ab";"ba"])
+
+let test3 _ = assert_equal 0 (similarPairs ["nba";"cba";"dba"])
+
+
+    (* Grouping test cases *)
+    let suite = "Test Suite for similarPairs" >::: [
+        
+  "test1" >:: test1;
+  "test2" >:: test2;
+  "test3" >:: test3;
+    ]
+
+
+    (* Running the tests *)
+    let () = run_test_tt_main suite
+end

count_pairs_of_similar_strings/scala_tests/MySuite.scala

@@ -0,0 +1,16 @@
+
+class MySuite extends munit.FunSuite {
+  
+  test("test1") {
+    assertEquals(Main.similarPairs(List("aba","aabb","abcd","bac","aabc")), 2)
+  }
+
+  test("test2") {
+    assertEquals(Main.similarPairs(List("aabb","ab","ba")), 3)
+  }
+
+  test("test3") {
+    assertEquals(Main.similarPairs(List("nba","cba","dba")), 0)
+  }
+
+}

count_pairs_that_form_a_complete_day_i/haskell_tests/Main.hs

@@ -0,0 +1,41 @@
+
+module Main where
+import Test.HUnit
+
+--Program start
+countCompleteDayPairs :: [Int] -> Int
+countCompleteDayPairs hours = undefined
+
+--Program end
+
+-- Test cases
+
+test1 :: Test
+test1 = TestCase (assertEqual "for (countCompleteDayPairs [12,12,30,24,24])," 2 (countCompleteDayPairs [12,12,30,24,24]))
+
+test2 :: Test
+test2 = TestCase (assertEqual "for (countCompleteDayPairs [72,48,24,3])," 3 (countCompleteDayPairs [72,48,24,3]))
+
+test3 :: Test
+test3 = TestCase (assertEqual "for (countCompleteDayPairs [484249851, 20131823, 423249632, 306507858, 267480235, 644385379, 214221130, 863070660, 913399484, 33535693, 823052413, 119998291, 791789190, 747763329, 349740924, 870030038, 889221130, 582613194, 63031737, 217611714, 413754792, 45752817, 231824638, 97115412, 300411069, 750313959, 636662712])," 13 (countCompleteDayPairs [484249851, 20131823, 423249632, 306507858, 267480235, 644385379, 214221130, 863070660, 913399484, 33535693, 823052413, 119998291, 791789190, 747763329, 349740924, 870030038, 889221130, 582613194, 63031737, 217611714, 413754792, 45752817, 231824638, 97115412, 300411069, 750313959, 636662712]))
+
+test4 :: Test
+test4 = TestCase (assertEqual "for (countCompleteDayPairs [265192379, 251492627, 362613040, 576331209, 378573986, 1155128, 614150205, 637266169, 222720672])," 1 (countCompleteDayPairs [265192379, 251492627, 362613040, 576331209, 378573986, 1155128, 614150205, 637266169, 222720672]))
+
+test5 :: Test
+test5 = TestCase (assertEqual "for (countCompleteDayPairs [959299844, 761641332, 226576332, 6248306, 37544232, 814604392, 790190230, 634308442, 911324956, 451569407, 29169901, 397736530, 928782919, 546317527, 678979322, 512326702, 31339121, 436313688, 797629546, 954100757, 884971463, 1191042, 955577260, 457864963, 87740485, 885378995, 542064265, 867248085, 901391749, 297300874, 633857683, 176721844, 882394721, 313124199, 118927867, 394067016, 301108225, 84437874, 801474168, 330150184, 398444875, 878677133, 517602170, 506916391, 331983268, 180385407, 317174381, 532247244, 556657910, 791501365, 334916047, 641583456, 845444603, 801837711, 50404693, 734059136, 41364658, 326358511, 643541472, 872906855, 994866722, 817834129, 321631634, 71433786, 294754562, 665179719, 881449335, 73010774, 595933678, 732890714, 106684665, 714232800, 893332836, 580321311, 16073763, 986360070, 691933437, 8363963, 352951983, 936625985, 962588148, 878415236])," 135 (countCompleteDayPairs [959299844, 761641332, 226576332, 6248306, 37544232, 814604392, 790190230, 634308442, 911324956, 451569407, 29169901, 397736530, 928782919, 546317527, 678979322, 512326702, 31339121, 436313688, 797629546, 954100757, 884971463, 1191042, 955577260, 457864963, 87740485, 885378995, 542064265, 867248085, 901391749, 297300874, 633857683, 176721844, 882394721, 313124199, 118927867, 394067016, 301108225, 84437874, 801474168, 330150184, 398444875, 878677133, 517602170, 506916391, 331983268, 180385407, 317174381, 532247244, 556657910, 791501365, 334916047, 641583456, 845444603, 801837711, 50404693, 734059136, 41364658, 326358511, 643541472, 872906855, 994866722, 817834129, 321631634, 71433786, 294754562, 665179719, 881449335, 73010774, 595933678, 732890714, 106684665, 714232800, 893332836, 580321311, 16073763, 986360070, 691933437, 8363963, 352951983, 936625985, 962588148, 878415236]))
+
+test6 :: Test
+test6 = TestCase (assertEqual "for (countCompleteDayPairs [635297370, 842262050, 47951226, 553842598, 564226180, 132079688, 860183578, 597789984, 896408173, 546302081, 402136978, 120419676, 120626418, 745085032, 159309803, 354721973, 815512, 845926215, 456421865, 868676105, 611546687, 96749933, 673776359, 258276503, 316098261, 835801483, 379925373, 249076431, 763266688, 589941296, 722982600, 846555155, 269562800, 405201270, 927656154, 4734100, 842550771, 982478207, 546750710, 94852298, 382041278, 289672557, 90740594, 749839889, 677403199, 941307259, 222886603, 449089249, 88803540, 907045400, 819868345, 497317447, 749180510, 541620736, 7250842, 269689215, 900722308, 400666603, 826938836, 826358718, 384606428, 614408623, 102329937, 960338321, 233015652, 243266812])," 87 (countCompleteDayPairs [635297370, 842262050, 47951226, 553842598, 564226180, 132079688, 860183578, 597789984, 896408173, 546302081, 402136978, 120419676, 120626418, 745085032, 159309803, 354721973, 815512, 845926215, 456421865, 868676105, 611546687, 96749933, 673776359, 258276503, 316098261, 835801483, 379925373, 249076431, 763266688, 589941296, 722982600, 846555155, 269562800, 405201270, 927656154, 4734100, 842550771, 982478207, 546750710, 94852298, 382041278, 289672557, 90740594, 749839889, 677403199, 941307259, 222886603, 449089249, 88803540, 907045400, 819868345, 497317447, 749180510, 541620736, 7250842, 269689215, 900722308, 400666603, 826938836, 826358718, 384606428, 614408623, 102329937, 960338321, 233015652, 243266812]))
+
+test7 :: Test
+test7 = TestCase (assertEqual "for (countCompleteDayPairs [972255106, 715135991, 657342452, 418702895, 463108707, 443025123, 466716711, 392904233, 686106138, 826213895, 93600359, 472218527, 472528555, 889710596, 530569415, 634423426, 677691419, 813261936, 773309727, 247912299, 16770414, 691517040, 471974834, 345109292, 64836279, 650461299, 679249842, 557133447, 783166173, 189419588, 845198689, 96859531, 286993384, 711659721, 934039608, 409146963, 881625966, 436867286, 597545914, 404413821, 805048355, 361974413, 395468588, 69593810, 460483016, 465016063, 183973479, 831109894, 814316619, 916030264, 901368139, 133469276, 592061153, 821462735, 830015333, 883360042, 643512811, 747545234, 907354639, 786007693, 922923586, 842947056, 632319533, 501142589, 230543679, 732967892, 992767473, 620178248, 743090941, 586983000, 79529573, 421134157])," 87 (countCompleteDayPairs [972255106, 715135991, 657342452, 418702895, 463108707, 443025123, 466716711, 392904233, 686106138, 826213895, 93600359, 472218527, 472528555, 889710596, 530569415, 634423426, 677691419, 813261936, 773309727, 247912299, 16770414, 691517040, 471974834, 345109292, 64836279, 650461299, 679249842, 557133447, 783166173, 189419588, 845198689, 96859531, 286993384, 711659721, 934039608, 409146963, 881625966, 436867286, 597545914, 404413821, 805048355, 361974413, 395468588, 69593810, 460483016, 465016063, 183973479, 831109894, 814316619, 916030264, 901368139, 133469276, 592061153, 821462735, 830015333, 883360042, 643512811, 747545234, 907354639, 786007693, 922923586, 842947056, 632319533, 501142589, 230543679, 732967892, 992767473, 620178248, 743090941, 586983000, 79529573, 421134157]))
+
+
+-- 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

count_pairs_that_form_a_complete_day_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(2, countCompleteDayPairs(Arrays.asList(12,12,30,24,24)));
+}
+@Test
+public void test2() {
+    assertEquals(3, countCompleteDayPairs(Arrays.asList(72,48,24,3)));
+}
+
+}

count_pairs_that_form_a_complete_day_i/meta.json

@@ -0,0 +1,308 @@
+{
+    "id": 3421,
+    "name": "count_pairs_that_form_a_complete_day_i",
+    "difficulty": "Easy",
+    "link": "https://leetcode.com/problems/count-pairs-that-form-a-complete-day-i/",
+    "date": "2024-06-09 00:00:00",
+    "task_description": "Given an integer array `hours` representing times in **hours**, return an integer denoting the number of pairs `i`, `j` where `i < j` and `hours[i] + hours[j]` forms a **complete day**. A **complete day** is defined as a time duration that is an **exact** **multiple** of 24 hours. For example, 1 day is 24 hours, 2 days is 48 hours, 3 days is 72 hours, and so on. **Example 1:** **Input:** hours = [12,12,30,24,24] **Output:** 2 **Explanation:** The pairs of indices that form a complete day are `(0, 1)` and `(3, 4)`. **Example 2:** **Input:** hours = [72,48,24,3] **Output:** 3 **Explanation:** The pairs of indices that form a complete day are `(0, 1)`, `(0, 2)`, and `(1, 2)`. **Constraints:** `1 <= hours.length <= 100` `1 <= hours[i] <= 109`",
+    "public_test_cases": [
+        {
+            "label": "Example 1",
+            "input": "hours = [12,12,30,24,24]",
+            "output": "2 "
+        },
+        {
+            "label": "Example 2",
+            "input": "hours = [72,48,24,3]",
+            "output": "3 "
+        }
+    ],
+    "private_test_cases": [
+        {
+            "input": [
+                484249851,
+                20131823,
+                423249632,
+                306507858,
+                267480235,
+                644385379,
+                214221130,
+                863070660,
+                913399484,
+                33535693,
+                823052413,
+                119998291,
+                791789190,
+                747763329,
+                349740924,
+                870030038,
+                889221130,
+                582613194,
+                63031737,
+                217611714,
+                413754792,
+                45752817,
+                231824638,
+                97115412,
+                300411069,
+                750313959,
+                636662712
+            ],
+            "output": 13
+        },
+        {
+            "input": [
+                265192379,
+                251492627,
+                362613040,
+                576331209,
+                378573986,
+                1155128,
+                614150205,
+                637266169,
+                222720672
+            ],
+            "output": 1
+        },
+        {
+            "input": [
+                959299844,
+                761641332,
+                226576332,
+                6248306,
+                37544232,
+                814604392,
+                790190230,
+                634308442,
+                911324956,
+                451569407,
+                29169901,
+                397736530,
+                928782919,
+                546317527,
+                678979322,
+                512326702,
+                31339121,
+                436313688,
+                797629546,
+                954100757,
+                884971463,
+                1191042,
+                955577260,
+                457864963,
+                87740485,
+                885378995,
+                542064265,
+                867248085,
+                901391749,
+                297300874,
+                633857683,
+                176721844,
+                882394721,
+                313124199,
+                118927867,
+                394067016,
+                301108225,
+                84437874,
+                801474168,
+                330150184,
+                398444875,
+                878677133,
+                517602170,
+                506916391,
+                331983268,
+                180385407,
+                317174381,
+                532247244,
+                556657910,
+                791501365,
+                334916047,
+                641583456,
+                845444603,
+                801837711,
+                50404693,
+                734059136,
+                41364658,
+                326358511,
+                643541472,
+                872906855,
+                994866722,
+                817834129,
+                321631634,
+                71433786,
+                294754562,
+                665179719,
+                881449335,
+                73010774,
+                595933678,
+                732890714,
+                106684665,
+                714232800,
+                893332836,
+                580321311,
+                16073763,
+                986360070,
+                691933437,
+                8363963,
+                352951983,
+                936625985,
+                962588148,
+                878415236
+            ],
+            "output": 135
+        },
+        {
+            "input": [
+                635297370,
+                842262050,
+                47951226,
+                553842598,
+                564226180,
+                132079688,
+                860183578,
+                597789984,
+                896408173,
+                546302081,
+                402136978,
+                120419676,
+                120626418,
+                745085032,
+                159309803,
+                354721973,
+                815512,
+                845926215,
+                456421865,
+                868676105,
+                611546687,
+                96749933,
+                673776359,
+                258276503,
+                316098261,
+                835801483,
+                379925373,
+                249076431,
+                763266688,
+                589941296,
+                722982600,
+                846555155,
+                269562800,
+                405201270,
+                927656154,
+                4734100,
+                842550771,
+                982478207,
+                546750710,
+                94852298,
+                382041278,
+                289672557,
+                90740594,
+                749839889,
+                677403199,
+                941307259,
+                222886603,
+                449089249,
+                88803540,
+                907045400,
+                819868345,
+                497317447,
+                749180510,
+                541620736,
+                7250842,
+                269689215,
+                900722308,
+                400666603,
+                826938836,
+                826358718,
+                384606428,
+                614408623,
+                102329937,
+                960338321,
+                233015652,
+                243266812
+            ],
+            "output": 87
+        },
+        {
+            "input": [
+                972255106,
+                715135991,
+                657342452,
+                418702895,
+                463108707,
+                443025123,
+                466716711,
+                392904233,
+                686106138,
+                826213895,
+                93600359,
+                472218527,
+                472528555,
+                889710596,
+                530569415,
+                634423426,
+                677691419,
+                813261936,
+                773309727,
+                247912299,
+                16770414,
+                691517040,
+                471974834,
+                345109292,
+                64836279,
+                650461299,
+                679249842,
+                557133447,
+                783166173,
+                189419588,
+                845198689,
+                96859531,
+                286993384,
+                711659721,
+                934039608,
+                409146963,
+                881625966,
+                436867286,
+                597545914,
+                404413821,
+                805048355,
+                361974413,
+                395468588,
+                69593810,
+                460483016,
+                465016063,
+                183973479,
+                831109894,
+                814316619,
+                916030264,
+                901368139,
+                133469276,
+                592061153,
+                821462735,
+                830015333,
+                883360042,
+                643512811,
+                747545234,
+                907354639,
+                786007693,
+                922923586,
+                842947056,
+                632319533,
+                501142589,
+                230543679,
+                732967892,
+                992767473,
+                620178248,
+                743090941,
+                586983000,
+                79529573,
+                421134157
+            ],
+            "output": 87
+        }
+    ],
+    "haskell_template": "countCompleteDayPairs :: [Int] -> Int\ncountCompleteDayPairs hours ",
+    "ocaml_template": "let countCompleteDayPairs (hours: int list) : int =  ",
+    "scala_template": "def countCompleteDayPairs(hours: List[Int]): Int = { \n    \n}",
+    "java_template": "class Solution {\n    public int countCompleteDayPairs(int[] hours) {\n        \n    }\n}",
+    "python_template": "class Solution(object):\n    def countCompleteDayPairs(self, hours):\n        \"\"\"\n        :type hours: List[int]\n        :rtype: int\n        \"\"\"\n        "
+}

count_pairs_that_form_a_complete_day_i/ocaml_tests/main.ml

@@ -0,0 +1,42 @@
+
+module Main = struct
+    open OUnit2
+
+    (* Program start *)
+    let countCompleteDayPairs (hours: int list) : int =   failwith "Not implemented"
+
+    (* Program end *)
+
+    (* Test cases *)
+    
+let test1 _ = assert_equal 2 (countCompleteDayPairs [12;12;30;24;24])
+
+let test2 _ = assert_equal 3 (countCompleteDayPairs [72;48;24;3])
+
+let test3 _ = assert_equal 3 (countCompleteDayPairs [484249851; 20131823; 423249632; 306507858; 267480235; 644385379; 214221130; 863070660; 913399484; 33535693; 823052413; 119998291; 791789190; 747763329; 349740924; 870030038; 889221130; 582613194; 63031737; 217611714; 413754792; 45752817; 231824638; 97115412; 300411069; 750313959; 636662712])
+
+let test4 _ = assert_equal 3 (countCompleteDayPairs [265192379; 251492627; 362613040; 576331209; 378573986; 1155128; 614150205; 637266169; 222720672])
+
+let test5 _ = assert_equal 3 (countCompleteDayPairs [959299844; 761641332; 226576332; 6248306; 37544232; 814604392; 790190230; 634308442; 911324956; 451569407; 29169901; 397736530; 928782919; 546317527; 678979322; 512326702; 31339121; 436313688; 797629546; 954100757; 884971463; 1191042; 955577260; 457864963; 87740485; 885378995; 542064265; 867248085; 901391749; 297300874; 633857683; 176721844; 882394721; 313124199; 118927867; 394067016; 301108225; 84437874; 801474168; 330150184; 398444875; 878677133; 517602170; 506916391; 331983268; 180385407; 317174381; 532247244; 556657910; 791501365; 334916047; 641583456; 845444603; 801837711; 50404693; 734059136; 41364658; 326358511; 643541472; 872906855; 994866722; 817834129; 321631634; 71433786; 294754562; 665179719; 881449335; 73010774; 595933678; 732890714; 106684665; 714232800; 893332836; 580321311; 16073763; 986360070; 691933437; 8363963; 352951983; 936625985; 962588148; 878415236])
+
+let test6 _ = assert_equal 3 (countCompleteDayPairs [635297370; 842262050; 47951226; 553842598; 564226180; 132079688; 860183578; 597789984; 896408173; 546302081; 402136978; 120419676; 120626418; 745085032; 159309803; 354721973; 815512; 845926215; 456421865; 868676105; 611546687; 96749933; 673776359; 258276503; 316098261; 835801483; 379925373; 249076431; 763266688; 589941296; 722982600; 846555155; 269562800; 405201270; 927656154; 4734100; 842550771; 982478207; 546750710; 94852298; 382041278; 289672557; 90740594; 749839889; 677403199; 941307259; 222886603; 449089249; 88803540; 907045400; 819868345; 497317447; 749180510; 541620736; 7250842; 269689215; 900722308; 400666603; 826938836; 826358718; 384606428; 614408623; 102329937; 960338321; 233015652; 243266812])
+
+let test7 _ = assert_equal 3 (countCompleteDayPairs [972255106; 715135991; 657342452; 418702895; 463108707; 443025123; 466716711; 392904233; 686106138; 826213895; 93600359; 472218527; 472528555; 889710596; 530569415; 634423426; 677691419; 813261936; 773309727; 247912299; 16770414; 691517040; 471974834; 345109292; 64836279; 650461299; 679249842; 557133447; 783166173; 189419588; 845198689; 96859531; 286993384; 711659721; 934039608; 409146963; 881625966; 436867286; 597545914; 404413821; 805048355; 361974413; 395468588; 69593810; 460483016; 465016063; 183973479; 831109894; 814316619; 916030264; 901368139; 133469276; 592061153; 821462735; 830015333; 883360042; 643512811; 747545234; 907354639; 786007693; 922923586; 842947056; 632319533; 501142589; 230543679; 732967892; 992767473; 620178248; 743090941; 586983000; 79529573; 421134157])
+
+
+    (* Grouping test cases *)
+    let suite = "Test Suite for countCompleteDayPairs" >::: [
+        
+  "test1" >:: test1;
+  "test2" >:: test2;
+  "test3" >:: test3;
+  "test4" >:: test4;
+  "test5" >:: test5;
+  "test6" >:: test6;
+  "test7" >:: test7;
+    ]
+
+
+    (* Running the tests *)
+    let () = run_test_tt_main suite
+end

count_pairs_that_form_a_complete_day_i/scala_tests/MySuite.scala

@@ -0,0 +1,32 @@
+
+class MySuite extends munit.FunSuite {
+  
+  test("test1") {
+    assertEquals(Main.countCompleteDayPairs(List(12,12,30,24,24)), 2)
+  }
+
+  test("test2") {
+    assertEquals(Main.countCompleteDayPairs(List(72,48,24,3)), 3)
+  }
+
+  test("test3") {
+    assertEquals(Main.countCompleteDayPairs(484249851,20131823,423249632,306507858,267480235,644385379,214221130,863070660,913399484,33535693,823052413,119998291,791789190,747763329,349740924,870030038,889221130,582613194,63031737,217611714,413754792,45752817,231824638,97115412,300411069,750313959,636662712), 13)
+  }
+
+  test("test4") {
+    assertEquals(Main.countCompleteDayPairs(265192379,251492627,362613040,576331209,378573986,1155128,614150205,637266169,222720672), 1)
+  }
+
+  test("test5") {
+    assertEquals(Main.countCompleteDayPairs(959299844,761641332,226576332,6248306,37544232,814604392,790190230,634308442,911324956,451569407,29169901,397736530,928782919,546317527,678979322,512326702,31339121,436313688,797629546,954100757,884971463,1191042,955577260,457864963,87740485,885378995,542064265,867248085,901391749,297300874,633857683,176721844,882394721,313124199,118927867,394067016,301108225,84437874,801474168,330150184,398444875,878677133,517602170,506916391,331983268,180385407,317174381,532247244,556657910,791501365,334916047,641583456,845444603,801837711,50404693,734059136,41364658,326358511,643541472,872906855,994866722,817834129,321631634,71433786,294754562,665179719,881449335,73010774,595933678,732890714,106684665,714232800,893332836,580321311,16073763,986360070,691933437,8363963,352951983,936625985,962588148,878415236), 135)
+  }
+
+  test("test6") {
+    assertEquals(Main.countCompleteDayPairs(635297370,842262050,47951226,553842598,564226180,132079688,860183578,597789984,896408173,546302081,402136978,120419676,120626418,745085032,159309803,354721973,815512,845926215,456421865,868676105,611546687,96749933,673776359,258276503,316098261,835801483,379925373,249076431,763266688,589941296,722982600,846555155,269562800,405201270,927656154,4734100,842550771,982478207,546750710,94852298,382041278,289672557,90740594,749839889,677403199,941307259,222886603,449089249,88803540,907045400,819868345,497317447,749180510,541620736,7250842,269689215,900722308,400666603,826938836,826358718,384606428,614408623,102329937,960338321,233015652,243266812), 87)
+  }
+
+  test("test7") {
+    assertEquals(Main.countCompleteDayPairs(972255106,715135991,657342452,418702895,463108707,443025123,466716711,392904233,686106138,826213895,93600359,472218527,472528555,889710596,530569415,634423426,677691419,813261936,773309727,247912299,16770414,691517040,471974834,345109292,64836279,650461299,679249842,557133447,783166173,189419588,845198689,96859531,286993384,711659721,934039608,409146963,881625966,436867286,597545914,404413821,805048355,361974413,395468588,69593810,460483016,465016063,183973479,831109894,814316619,916030264,901368139,133469276,592061153,821462735,830015333,883360042,643512811,747545234,907354639,786007693,922923586,842947056,632319533,501142589,230543679,732967892,992767473,620178248,743090941,586983000,79529573,421134157), 87)
+  }
+
+}

count_pairs_that_form_a_complete_day_ii/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(2, countCompleteDayPairs(Arrays.asList(12,12,30,24,24)));
+}
+@Test
+public void test2() {
+    assertEquals(3, countCompleteDayPairs(Arrays.asList(72,48,24,3)));
+}
+
+}

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

count_pairs_whose_sum_is_less_than_target/java_tests/Main.java

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

count_pairs_whose_sum_is_less_than_target/meta.json

@@ -0,0 +1,266 @@
+{
+    "id": 2917,
+    "name": "count_pairs_whose_sum_is_less_than_target",
+    "difficulty": "Easy",
+    "link": "https://leetcode.com/problems/count-pairs-whose-sum-is-less-than-target/",
+    "date": "1691193600000",
+    "task_description": "Given a **0-indexed** integer array `nums` of length `n` and an integer `target`, return _the number of pairs_ `(i, j)` _where_ `0 <= i < j < n` _and_ `nums[i] + nums[j] < target`. **Example 1:** ``` **Input:** nums = [-1,1,2,3,1], target = 2 **Output:** 3 **Explanation:** There are 3 pairs of indices that satisfy the conditions in the statement: - (0, 1) since 0 < 1 and nums[0] + nums[1] = 0 < target - (0, 2) since 0 < 2 and nums[0] + nums[2] = 1 < target - (0, 4) since 0 < 4 and nums[0] + nums[4] = 0 < target Note that (0, 3) is not counted since nums[0] + nums[3] is not strictly less than the target. ``` **Example 2:** ``` **Input:** nums = [-6,2,5,-2,-7,-1,3], target = -2 **Output:** 10 **Explanation:** There are 10 pairs of indices that satisfy the conditions in the statement: - (0, 1) since 0 < 1 and nums[0] + nums[1] = -4 < target - (0, 3) since 0 < 3 and nums[0] + nums[3] = -8 < target - (0, 4) since 0 < 4 and nums[0] + nums[4] = -13 < target - (0, 5) since 0 < 5 and nums[0] + nums[5] = -7 < target - (0, 6) since 0 < 6 and nums[0] + nums[6] = -3 < target - (1, 4) since 1 < 4 and nums[1] + nums[4] = -5 < target - (3, 4) since 3 < 4 and nums[3] + nums[4] = -9 < target - (3, 5) since 3 < 5 and nums[3] + nums[5] = -3 < target - (4, 5) since 4 < 5 and nums[4] + nums[5] = -8 < target - (4, 6) since 4 < 6 and nums[4] + nums[6] = -4 < target ``` **Constraints:** `1 <= nums.length == n <= 50` `-50 <= nums[i], target <= 50`",
+    "public_test_cases": [
+        {
+            "label": "Example 1",
+            "input": "nums = [-1,1,2,3,1], target = 2",
+            "output": "3 "
+        },
+        {
+            "label": "Example 2",
+            "input": "nums = [-6,2,5,-2,-7,-1,3], target = -2",
+            "output": "10 "
+        }
+    ],
+    "private_test_cases": [
+        {
+            "input": [
+                [
+                    -47,
+                    -2,
+                    18,
+                    31
+                ],
+                46
+            ],
+            "output": 5
+        },
+        {
+            "input": [
+                [
+                    -18,
+                    -13,
+                    14,
+                    28,
+                    34,
+                    50
+                ],
+                -39
+            ],
+            "output": 0
+        },
+        {
+            "input": [
+                [
+                    -27,
+                    -6,
+                    19,
+                    42,
+                    43
+                ],
+                6
+            ],
+            "output": 2
+        },
+        {
+            "input": [
+                [
+                    -48,
+                    -29,
+                    -22,
+                    35,
+                    46
+                ],
+                -49
+            ],
+            "output": 3
+        },
+        {
+            "input": [
+                [
+                    -40,
+                    -35,
+                    -31,
+                    -30,
+                    -29,
+                    -27,
+                    -25,
+                    -24,
+                    -22,
+                    -21,
+                    -12,
+                    -9,
+                    -5,
+                    -2,
+                    8,
+                    9,
+                    10,
+                    17,
+                    27,
+                    31,
+                    35,
+                    38,
+                    43,
+                    49
+                ],
+                3
+            ],
+            "output": 152
+        },
+        {
+            "input": [
+                [
+                    -48,
+                    -44,
+                    -43,
+                    -40,
+                    -36,
+                    -30,
+                    -29,
+                    -29,
+                    -29,
+                    -26,
+                    -22,
+                    -22,
+                    -18,
+                    -18,
+                    -18,
+                    -17,
+                    -14,
+                    -6,
+                    -5,
+                    -5,
+                    -4,
+                    -2,
+                    -2,
+                    3,
+                    5,
+                    7,
+                    7,
+                    9,
+                    11,
+                    14,
+                    16,
+                    17,
+                    25,
+                    25,
+                    27,
+                    28,
+                    31,
+                    32,
+                    33,
+                    38,
+                    45,
+                    48
+                ],
+                -35
+            ],
+            "output": 175
+        },
+        {
+            "input": [
+                [
+                    -50,
+                    -47,
+                    -43,
+                    -43,
+                    -36,
+                    -32,
+                    -32,
+                    -28,
+                    -26,
+                    -23,
+                    -16,
+                    -3,
+                    8,
+                    12,
+                    17,
+                    28,
+                    28,
+                    36,
+                    37,
+                    37,
+                    48
+                ],
+                -18
+            ],
+            "output": 90
+        },
+        {
+            "input": [
+                [
+                    -50,
+                    -50,
+                    -38,
+                    -34,
+                    -32,
+                    -30,
+                    -21,
+                    -12,
+                    -7,
+                    2,
+                    6,
+                    27
+                ],
+                1
+            ],
+            "output": 60
+        },
+        {
+            "input": [
+                [
+                    -45,
+                    -36,
+                    -26,
+                    -21,
+                    -20,
+                    -8,
+                    -6,
+                    -6,
+                    -3,
+                    7,
+                    7,
+                    9,
+                    11,
+                    11,
+                    13,
+                    14,
+                    25,
+                    35,
+                    37,
+                    39,
+                    40,
+                    40,
+                    41,
+                    45,
+                    49,
+                    49
+                ],
+                -16
+            ],
+            "output": 48
+        },
+        {
+            "input": [
+                [
+                    -28,
+                    -27,
+                    -20,
+                    -18,
+                    -16,
+                    -10,
+                    11,
+                    13,
+                    16,
+                    17,
+                    19,
+                    21,
+                    21,
+                    33
+                ],
+                -6
+            ],
+            "output": 30
+        }
+    ],
+    "haskell_template": "countPairs :: [Int] -> Int -> Int\ncountPairs nums target ",
+    "ocaml_template": "let countPairs (nums: int list) (target: int) : int =  ",
+    "scala_template": "def countPairs(nums: List[Int],target: Int): Int = { \n    \n}",
+    "java_template": "public static int countPairs(List<Integer> nums, int target) {\n\n}",
+    "python_template": "class Solution(object):\n    def countPairs(self, nums, target):\n        \"\"\"\n        :type nums: List[int]\n        :type target: int\n        :rtype: int\n        \"\"\"\n        "
+}

count_pairs_whose_sum_is_less_than_target/ocaml_tests/main.ml

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

count_pairs_whose_sum_is_less_than_target/scala_tests/MySuite.scala

@@ -0,0 +1,12 @@
+
+class MySuite extends munit.FunSuite {
+  
+  test("test1") {
+    assertEquals(Main.countPairs(List(-1,1,2,3,1),2), 3)
+  }
+
+  test("test2") {
+    assertEquals(Main.countPairs(List(-6,2,5,-2,-7,-1,3),-2), 10)
+  }
+
+}

count_palindromic_subsequences/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 (countPalindromes \"103301 \")," 2 (countPalindromes "103301"))
+
+test2 :: Test
+test2 = TestCase (assertEqual "for (countPalindromes \"0000000 \")," 21 (countPalindromes "0000000"))
+
+test3 :: Test
+test3 = TestCase (assertEqual "for (countPalindromes \"9999900000 \")," 2 (countPalindromes "9999900000"))
+
+
+-- Grouping test cases
+tests :: Test
+tests = TestList [TestLabel "Test1" test1, TestLabel "Test2" test2]
+
+-- Running the tests
+main :: IO Counts
+main = runTestTT tests

count_palindromic_subsequences/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, countPalindromes("103301"));
+}
+@Test
+public void test2() {
+    assertEquals(21, countPalindromes("0000000"));
+}
+@Test
+public void test3() {
+    assertEquals(2, countPalindromes("9999900000"));
+}
+
+}

count_palindromic_subsequences/meta.json

@@ -0,0 +1,72 @@
+{
+    "id": 2577,
+    "name": "count_palindromic_subsequences",
+    "difficulty": "Hard",
+    "link": "https://leetcode.com/problems/count-palindromic-subsequences/",
+    "date": "1668211200000",
+    "task_description": "Given a string of digits `s`, return _the number of **palindromic subsequences** of_ `s`_ having length _`5`. Since the answer may be very large, return it **modulo** `109 + 7`. **Note:** A string is **palindromic** if it reads the same forward and backward. A **subsequence** is a string that can be derived from another string by deleting some or no characters without changing the order of the remaining characters. **Example 1:** ``` **Input:** s = \"103301\" **Output:** 2 **Explanation:** There are 6 possible subsequences of length 5: \"10330\",\"10331\",\"10301\",\"10301\",\"13301\",\"03301\". Two of them (both equal to \"10301\") are palindromic. ``` **Example 2:** ``` **Input:** s = \"0000000\" **Output:** 21 **Explanation:** All 21 subsequences are \"00000\", which is palindromic. ``` **Example 3:** ``` **Input:** s = \"9999900000\" **Output:** 2 **Explanation:** The only two palindromic subsequences are \"99999\" and \"00000\". ``` **Constraints:** `1 <= s.length <= 104` `s` consists of digits.",
+    "public_test_cases": [
+        {
+            "label": "Example 1",
+            "input": "s = \"103301\"",
+            "output": "2 "
+        },
+        {
+            "label": "Example 2",
+            "input": "s = \"0000000\"",
+            "output": "21 "
+        },
+        {
+            "label": "Example 3",
+            "input": "s = \"9999900000\"",
+            "output": "2 "
+        }
+    ],
+    "private_test_cases": [
+        {
+            "input": "43189039005465682401855284277114609803946426902927018008175173354658761312483443240419199364861114044074253075408792457538582018893770021892739784424394354335707669915767204154052306522188900841694172601433616069794267052691589996258984891528116747489492940120183822065834577831047161579083573870377672320040711790597240579902319436940388685423083857845496794813288381250309078898995608823537813044129810439503981494050814906348826897283199909777131630214671745755289640073192113577064800752977848450406896142092628092493296672100793542799410642549480762865319855754207011089945545683810225746231829769525648763181152017168008719535434624697948753057377027120212944835457735715554060483343314379090846677511183919672734643138286637821322853245232239971701449844140934365425234534715967537031540175374201556598936885838658665613270264676015381689142483377541576981825751667799560772604524945031857909738919556418909606621625477383901220832135775576224415976411904050224301630934343279198424767191442936864408623948081558332297562036482249941379947392807564625153824743885469268609158968595318723605256679685908752645694279409636367618075596786035803379176649823675553648331186774075991924788192577078047912744777818877118687890231981715083450966817013754577540618366236836778929025749575150757831246298245215860375150777703613820933429898989209340259775142280082240240611893149603861528666430793780841097248625954993489803378806463778436843516042036782741011877733057415576340955565687938051443482302002059170441135986761020323135214487142287823104181092712126144614091994119745571408220430701571781061241571126604277863388736843902322085554066487947026428003140625496161045788014427254178106818440278586443133768275235629242605973388655822594511753442864257218967212348238776703453189182179640889109839484920834895055563502268911310682739576918368923397740867302087948797066739990394793412717629774314025340722825359978687524353205028094327029543057509845047624795446615597713168713585710858222167437461044568583133413534176650369482969638268406383540894366227828952878682785727131781043459082678270537220477469327597306257701559759920692990407245133218258711891096817065322706739885499215632475174640956385397377845168476121150135510231156131987767537335084871159634695695126080477522026031773332131454355278883112499162032977534339591522651618938884547589544816545159981085330246697089917569366618504465895844620860331030264551413587678482742956860862946030547697665866572533482920414831383259214909956222995479703161084536940810983837152579182320381349332004504931987342202704488959169138692414041017738156458451629602699453506585021666544198429390823172797286878083438930302194792137849628081371195942185579368019455689596195742872749087132245303877527894930565602528748004339687189065412712160642608807667604862474284120895061232085269855987036796677340493898332657104673190114600276564907797444853913473643366878837698705840363396011220363574444145506108063952961108751887496323710019018148362600192413275235104612808136722135497913844150093363842500381471726734519576180403321240585891657656367728588172832258010798350037593093025086840881655789220404945754915201279859936220494701985894849469365723227360137321540839929215395707840668965039844528402550101230894816414595055404642263599067753059313990915997917651302029084474397051347386467611907773493596238550824644789412900475243761678346761385814092163351021607310207392910677916244785241961",
+            "output": 86192140
+        },
+        {
+            "input": "72862245308703552695442052725411769012490565604100426920531587543393876539635187055232101951547568504957899332220202793586923271843679067460247104215233838752395740708560755863138216874853488600680029508763054950958875255869336920758727208929851095979238704964758859028508292468921368031969461100117710379691933249774083984509771797639518316806595215324822075118468831970976410143264332854769543850370753550024502103286539736369971143187257643945176258004125247296904032465383058504842801651069887232748871000113233722510295243837535065552253694309907017833780246309126031368257667026786449730198030577731926541664759026169305479352709409779547258014884577790820131633758383865793845418664275213237424906146098296819524585550412875310439912270472892463905864416343170191498366138115271182294425602168774878645467580243562498375438162850391421680400784547347208096655633567531735838588376192968766863170376032970624896391603942999577817052965853515853282209637068720333155230052339949911684888347781990487792360433021914716026561375868586632503397738935169287480003932315580948351799900560056071621056549020489058883988760086138870474491347043292360898668929624758372608897177002692910745833265800675834582189868775575472750427273225949215765428524115377350552090216016010949124082644541506954573362368820417204485168688709228646616223984348288154505247100057603916080913120777023071671001211094168358262793527729249323981833520939016367195628372408061480937065207825754510776802618745947235154873246746709046418617909426186133829492459734948475489897827941108825886505521867613899574621453991984228135440568076276043252779520020605841080064699219324552633356627737506607293363774854357529289989363810958961704705664512006453380901793502916477056493911556579835917612449778654698856072510524589499712697164473286093239947380027773422561361875788427775753434844175141793244202217466808055777402567215849836682219338002101592423807925094221071892845591560752930905012549194290314059213458179009195203783504449456456086844358764335317667203158386180306701340107220955639990291143034805330336547673082278524719985970264787739975123824061807382814963839588255809775",
+            "output": 800887156
+        },
+        {
+            "input": "76840148663056598449721507909447351065536251366078066704302298300304183627877350031794682225913857377996559947998883674672205026870293941072027651103618539087549759428910607573370246452640336361582533662144326413724232890800860150282351039500972914833232830279953411128308513161823347048038370349404777370738232545193642181287583396955860534541619519200062484632820439521423356385215251515195372188174515059360492801570443302457055445992536168570357408517539454563128073316984643176128915134920780281641104717091655034171875390649967212324788258957653276838551000858241076444609068844075960315487066038764208965911783797962321410630131442678978548183527456646039343713944528923671549074682997863821597811555854046554381320119577166501394431512803548671038215773113808710407816046943039537444566679544337808976821491151931314393616426540313522130395134168072639444684849353442877480337726728504920314513050179887473086966236034494905882726577797778942889842818330580675585896052808621260698952706004547526861310828357886914050162929053958862725174078000862576870479464713387732983628119496126699737928144363474246684789042885962810997011036155146430655821068244148823423642849872861890527891131356227793675136357777090147846624915427367870973472288320820719718252428388485348107094048077641523901423732015618891348256021537877463062672225661769277485768964077156017997742116584687312993730415089707023712417711497087393115536255787651530392990268540753032311086306477622130692434518888453831630536869247333040178847951038038451485039049480454316901154968024223437699236539902256781992476308835498759400698822985176921766165499063118484138332883315795509085872492539218212158643556551426414201126270374367987421194860310334621005203019603263463965995875577277267860348592548577105115072816389335965732904336748420880058526329541440875079848352734793881600536919306655620071388151165008857950964861114935724644682106932346060104759226832655368248826173043050339325203286138739113715373914513868385361274161756547105960836586697414716543811873150389521078586617180478443655089915380924908523071812979692352831069206253671630957964504843916968469347371812387968753189903712645492569241457712684787985113276543141648133880728855623217468718749737527948665392100247842199735483014294817977816193067250127609504608133050319244283821938662359516017820731130178398022288820015301860691206756446953028264428131010746662934062932624307965148878848892298057317009531786574978091713649013263595559479509232027315780507907788395083356407890724021232930997504797132893497824116048913793164855590121",
+            "output": 227795771
+        },
+        {
+            "input": "8526721318409085603221532932063171614259649650840237763788732471234086930795896682773336435008729589941962444464503839582780737370298860719481908640963459484301051372100802207438527840354637509481741221463887379959572218219763425456589792630253113872443727393977520131122424505798951311184802866052129168800681136775123413134573199786643627256783146419931051278706439044663220231082561334140139807847441436741627419159696568892308865369531349937366569979654096377250895887179374865566860610596034198362606998524349599114844975252663588294272249387855898975678748410581171140985762075963131554424402623083338899913182262412675252638432744947602388118764567129577503549200117180830602187317242010230154853732975920572297793067594954184853369584698702946053145686357549663631445485633594604963671717860164544968625607365576283198571609724516905132336788837007623156158546683048004081462928971399644456351571650831852796028619614538542403777225059392453528744747583282126186137476619560286803362948260097686818850765724735198299518958396687855783974280245387443580811130552660809165652305338368873547471894399913265363157525487968223829585077640249639753090466263538355244667125834928264794921050865773377949453363967865158830156082722570270309127890163142568732328223222499510734597705386353647322089405004976520411879078334359099528314704493543155655373850161702135116392600133456210753468810315789831941271420285457081920082954545157770797575883177364642551756527935702502405710956570213046327094967520287470597087818653735779912307198561206807863156881496164184867600630552432394099560739048550564377793063557447360528193602700714066604881218196984375147402388354604618873880668699489555098541217713991778450162048472506632853611010039017803918189675173061853053997947444419445306756943065865374100000714294671732678085549220042294363726289766402300947474484511184938331758199031531115554273247274442831691822687853360393092691638307765619762162160932575008928880669147225110249337341769428297199906431008502105626240253106041746474516188709863291832792932953553516203144752836224134679962049867903707870962725935832430340505455785159554808605628486917806426256949487313293191999554137840042462164878000616772186940558678784336089312483188839388064806699644237474095322456646338721254566624661032847368266364977209450100115268577063512450013952433551710690928047091537407785041965059115794349358467425751129799532963766270424544285504097836151996977672810910112257324941869704633675898498609852384782134653825925047097800872335108143850880088494305543492661153367032124105097580500853489809206305694926730112691987763749122332629796479198654719942230705087151352575497225761908567689928678737477945190503226114410769484733879125668487227288868318957134014152827080565066919637570624264892779530521075944447405115820604817132454500472216403591256970008570731935080724318120940864026756478085033464954380208187797522413819934339167137609396061479507639534683129736469499741636569134734384939068479082178205456608791777849195606343987762855736761021063923997627741457583938896785897909842938781327411925847158760856069324371653985435694534946913191727801645433167774103586149369465238773851011187203528944932135655920886499577552486413442045363175352111635694221099320510309614212182678717281140857027582559419167737489915694459595360569203271822140025907593758982903424790807947754095498739741933858258473756061868414558259146466189719317026465392504799250410212327801900423764620558457205629930098636305365100167694469711060986022158007026109249866537476840494673931466651423874128013019147615226679550336127822248498126655683967498095536902380993727526861165098127621530160356990054062619433642193270948682941557254499912982565224927605710210262937514044006864559558116389855024437259362603542402304243028095179687333486239713588758903890335957506600083773796260940079167943055746090783056857703700145741455845490215666832917253680547510206630297891728977742237510501334221535745629359201011086455317929938014934338996039635038236558869835928777465609514222293595796412650285217788980538131008453408071735614315799502944353758932826422955128337942879096347880315999726637121877054680060132748081159229047260964496351899556515337322318580367095014752984534005591669405706272144943605474793121167049216349732647937988371968014549680964578439530944004301554751339389584909729759553857121058830551493030582448408955567276617423664387623835779776998302991021801603403904693445454778155767779703199916896872091803316507319555122653540894272810447191976448817744390845317383834843301128484094674416318598837519918940482740144471416620645791475314613240599288837301879188881207645238031998803645057996010544008220227248211186598275407933949572111618585437728191157062592933443358712080930147951147578521595592351940284184938368797037578139882758061771016285549940679691638142469760738967349412713999413290958009838919453713629912511602542724709093248426949034909591728347412144068388639316303079648962703112759298292034560779424891746584483700702135163308682954702089592626314365167300926022191734718788711726617598902871953862210792982671124046673412441046163094228076031053572808092730175940514540405476144171313788229929716970110701902813566251765287081014259678570702759761408452515929996866536028971391769758969901602326959144145732848838809560695471809303105664063400149428153241558711910432874078365098508074774258610286798303658448333768529304971399691280258395253900849429123087466849321227157851304809354072163957273276354729897512383665531650663143178408498424006662371605864517132461265732149566379962458627520938130517069497945607955901020965065005590188381971249585018167068203030040588735839085863665570614282579015856176145939147042211303955613428464515898620937732497793059256252157146705016634783523970807200868590404862123977753286182067722886310317181869640633424984485945265212996265514717170465731542688167887697720860055911127237767867555918752988495201989196986172839890148502380467210205061429986385809383196686133919767450709762700080021748092535717860690912703226446480924872712579583041049554560664473029083869023646399348879839582224100107682355258210291676147258079610464464157716741075084313748331422661681268372127279624425654783801310222724721773833565524074103632437191222128599879719917341557616876136460753223970026739782143949023630607756484846985657134131978036132794958721927489156119537278579356458226206195864474600902117380474758672466690383853451969691209604169978876591180111732993621701912882940236098020935037455789634221445328554090125402139517031863985804954557646794548529466150050921841246402154884393984371061756664260807660788444798862953026542710535238133209038750960906147079418996758279910511703436969749293492388960221314908312972648476152948540381664165062505936014604410537167256269613882533896179600148610305078648989328655758973402661929239348328514650768673680454327402466274181903123106002630584432933421856605382909621921185481142104757266837466589045002714134720488380447257455877232373233386657834467510296078342236741104272054749338055845086422067467986457776663760083720904597471955898250536435894562937225145571061996493828956718516156131959062266397617196376860708906931407794290196704153564383769756771882685636386862131225466864906456480954223560388332146835315797268249325422242497048873638069946619340852363705402681566452503743860308375600713765317103274510497738145671701116029376646444961686874827247969071604895318495017756957045449471365331411731671112747946531794055636735061789091795310637471497222751202780202840618806630050131974398672108147165612205949929085462999767341500565630042404562246073801660435739183548980545521788964049019155163482440573033048696910500633993080015611499597",
+            "output": 502766489
+        },
+        {
+            "input": "36255206141499377397130235639389625155668559158090125099366456946571533242700609082936236045828792151244574844280680171516755090306675149724350667504469430004787720830548961303152756305341218985308369798478433238960558118369437858995734393608559331861022555416707010466692326411468301515782059074991239400383632190278079611045559357991300874722673233911277491640238090338683650897316913094458717434120304049526740576406996219772722367727329970312836944450843469018355102538190288728416771879534789319442734725036288903144925523756010511154543258196981090423103445929119033680516518252654505298455348821095084058455676992678720395206882127214811606170308015367074569602346456430883127986323481370816145385686710492444105722946392962177574725606379077979852910101200933659413668235241780073020356082909632825496894946586172712969449066372174399971719932770188224738629772100071669385779081300321989506589380322872413643381534903468378919323628459072988130999587129933278291769225731296953610905650931208176482567886770309246998475927917303445645511467466272200970339831333860966424320484516383007011712639029744434604367056522335160154674603477524108958480014973303084353920412492534468534507792677061731945042190177304304386621329347832545287641704685829842871514752379428866404701409830912059903135575892058853201424996739333405593326295382484148272606194616034001173801023319606863130381121031420164746208894813686306296188768168862990885282771394731352945927678331962757993091321061634002884025386156044287906909007296918637887642205828084286936799368986341347330786491146434141282678027455194230520295158192353255403700088938013865788259616049999147556668130875605900625656058526670210330720165778249333716185351613704412786042731236362034837364978049658737970025005023411306102831765971450625202741986783913676583071149090858433727609175122878050202902632977217811337404588354458544455938923364644571877098185609420619332656443748079331162816914826773799638772386123032071441833400498151472189883142519680202837858934942885002591777034107108599224749310052500656587572135642373454975494277948446830577801850521676023600325701451540849977713160267754737641284372527872853456927021638605310532147220458597519502168953845470144810188726340634059881019662024454906668892404209092916200301259933417472856045789035515761697336053694888116084954945353466492070868876517151131971482359324205209755091136097996468133948826088786928594154056260518715554763037562655078734094340116464942262731205338631799758403286653199673160724982203728371071348900507941338486404788958670874058005622806326486522915173782131926275462645091848422409866563797033012551949847555246232936997886207067602764086561827119250241130592713148870297505817739080417651329301729732820486017063081406020852442766439664380165354792866826184825318446956704660275922331981677140025136511913971988234476467165513621090655752254264279255466967424276237222473789068091260954941862289200005069298186289425386458707474215296528833958932920075408935338092036135662186637029870321764524576936430914211777950718704933829780012585258549985427263936925519611287958814788218457937289357330934114955703771296875872179787808131369634610227569484842394758887668629015591755180814852262682451882421409349238804593100618349241629842510326820138412505745188066890054687406391770475030670456017732755986357937485840298672511043519083645189241052610206498832829351569216146859526730315987819768236626003047489429632377853463945561370403786509305254480147100902485675586239921614491260959228685850944246956523651806720468903444546107991256981029213624217676764208116867859457128946683712270148679606263238363909861003526808642466504358752508070499029423029579835568577049611101232842184652289393483490621681794137420543103482187286655638566210070730275114558171167743646129691884001480938536015134861642861117378827143841223561146249450714250679918727794136788524892451125247407339885973207015027974086351848872674476403046493038581573015037561733433768608497375472325857285994129836110046552643778563734392459250800311567083605599209051426327352605890849537344522510724374637892297008464246307444166483896892406690734430041582284238574256950049872134219388224834649386312434063064319713638453726608472810761124749009539954064941106478955258759864811957413986555279776390907039661899402462258548585356378596327499001172940707331261025448562091559164674487388159032921577823005452524055920342000807658960437998405806847859379072554567302012141481892676558043088377757720012490728095343115073919903999533165407582807694847045607672670362229228813385640051569756557070777640240286219677039162264611721326802348248841843535059302455541435436476206791574633278771933595147113426992642714125036452065273175692044522370444612939917500752197086004018676130975606981180430123313135574446254231478427042145612179694537282848752021958537654527056057210304087487235747444864958333423954194580560235286917488576614945395163093922886619384568285282125338339760332908770460019147106499455747756219301320733642499236091073340685275795954912639441971565606192494764091487782587128881031448503912687707000378047132571941448625328975931616825966599121863985612356813934015755305324276088154217936465379875308473661707690118030696073362879351427296856756333161756735172185875636884731621850333861135105801124952081770589154688281252268022504472151590497720025566306634350574864031793300085900262147770961427699617189066075924224616795970282633775190517162244773578885157601896914864998485537791743215858360486741584885533622947578819356075809268638955157977747444898299937098058937656802397487966288678151948325257800694328753197275307440628794236017757522494898892970421951172251469353455114258897699737294890884397248933914694527135576844805546642567195178748086658671408504538068587576362247941134795394358928737790105184380838037078662032104927832318170070897636569603362201197058022102697763842530648270212743858139635412759165521771359184855922688612447345714573139960599650239589896286428381625637882608332325533911888370921019871051360536913880557620203798460961533763091140551232270880373512472022456186172674855159346858941846206944411348933702164609807626033540145281382053722704958784333791087718761534782348996108512174392035700342062330995030308370131497826860171719548990736549562809382234563925732387162622599360044933100201252603846083377890503177243952241588138112280571123214916495036560666808076376758392413095708136277003521370279543274904173349559951418980272290255432426384444526549731469835983968315714483349256759339449595283060756884691707555146219730146408715306880692649971478105091184547854942533728963011640682736322093809915029471202678435279549540598776086860518587591769113486599266180336423854432857717641193338907589068142113733922264011674323807100682303636625476509633828332673067370183144805635766705419161919999512800688318775526693117054411888472992561573347449993183781401530259210150146459945442249106810542532370799603273021134624461902058101119466462184567263520529739588576616648900222104735581663228974216323240238684122894072174178706292623424574603769208130865988322565064628055674843343525240283935259661692674362718504590190931086142648388957136799967631672977285753470323764169320762634618859664611461497735794130254657117140915727657504431775486191746805290360224222848613790860426843554309503067312284014306794787583125059395526088572576716757340857424250553870952052897981589403323086366859178654165775016018212309796031319614143590286965657120070145465299992635536660505237426840413633756872149952472906224759949841614649498444443294937117014114114916453452402028663510581944281328373479133404728463911508236465283856676",
+            "output": 151313958
+        },
+        {
+            "input": "517540955283540546468253969248377080939914909677084743743939610432765947100317936572959813596050371516659076654888779643599263980395990884716534581556080015443758214677130602979257468060059557000253693886565679886295709963364068164600112635800390461599876739347680318048090238943643182829480100273505821916923135364205226360409324487327830337545467779594579276943823408393253964314765359846527868826067529274006979596715471768007657667657013453137368674262023448030518594413355421622159862997540419258208606225616380013201215030432852498852383581231245333606004406446229432859333802748911639014492668593669366180057821799145043459890252868807331791323794099802961475",
+            "output": 826306271
+        },
+        {
+            "input": "12618836709758901644891528429333454335245410497400841393566375629273490401746353015074368068917118218697751709379620940266882973792445170856482069538131872019562000304262397520546489699225829254192063265713205990937413806538599444908819107155983385508093781472198283531487118766339665289020215692614112809555743394697506148131773011747523617326252834684115806197173387145402008520440824270993841147511918146611556001678473969709069159304326800372950272925426525514287037799584020001909304541167340152285739480678535721239918185209766561321516455251686637429456740084258426741010275447365778493385610333160685257935042038131895044106156898441529602464323356097920309155840717380402043916690431306847667218738330849424512384001088492128440364001215251610040636252031484284342737870211722299954414006973092223443413098275678940382534606251604335382790641076503724385962740819669478141853205702139255160415791347245127110912301801642816420689235586578838959536996016756940282099839632116464416320704035892825081655951321994221418887490836944999332342579583140345280992256032004593239508465194589892516828150968878956975358477256290009664747282584279896896774942629067141784821803098473924196180859773836736164774845813008782857471502197848959644003071295473002959358135556030332257666204605479087695428822102693288976171208004983714814429025851516785524709259750445509195561679880730789207042551483091648320339356064574447949448180391493132163493802862242804774598110724609630104070063220269290814898111097991549157321292740589655259412506430493461597358709760537083772443171421347477881274772703247971766972097063333904347989942444538549056569863132351931701794566007799211215377086846573748419972114457428056198034808928403364842313675518463377705861317756091608275047282947702937077410896376914818368305203458187709938832702698409353165547902702987170254599082751579240224504535835194901451094912188447604997739788694561085855562348447924226656729131809868367643694027401039181047065449386702673216753578804797946889170133682565087739245598681189428588219555959866455311828609035946135055744144630839649432429115591663888439130058552189769349210797658225769044112981519927552677703009355436208405887668740187088355185338864346502763958071583604528104548316731963790935588663451150288861959968281960396372225174544016973730449311333353844384708956043883223904380698425073486592879722148782575309367585705128127231702018791835224003225554068442844474991651379937262904851575328297568950831592123085123381015608034402112740126958758381089557671599972521548245220116576699520829036681480426023007911986941529069220698002001848685524198028984169819918954493858439813305232519993417816712785393955354357706112284437816781190612926839448741099520173619734488307199990226892133204357713319560602917631504950576724086109335546191036268724551999797830521226883228113814851564008315359412021177008846720708672269832341771606326308124856431953820484392016981929106638488868779154703104009642337681776917797999555317868248614767322664476145691012903042879424269735242375239112892312740097929286624239233579769283882911584330136906490610807819631301313409282265878521168035319554014978650500936628260128149756292266219334155840937009695148218629200323230431346578238264199716871553167691322865743726029090711744741111008349279916798127062164320116682580048015018460207174903148704787629726584",
+            "output": 339979802
+        },
+        {
+            "input": "528202457565309769",
+            "output": 22
+        },
+        {
+            "input": "0121542175243078579580317086213930592054549735265758465024463595312803560183291021683424551919105682812492525145895403475988050045500828499193234413289256074606725378605421587162147637798097645073639769117224381741396663273112314194588157851923283793543004709926012381840914874933045331517821025293207553716620418219225010429576278593684356017272898677745675513219154338771797736761884477980169221725470878974443560749175457004615774024293529617605849747029636065371650001630628641068470176814142074355498371538617041207843484932130718939684593098873556836293017961923041704051616455593707200831295470569498159388373535605348460245531912725954929804876467565595937809161646099091095258589303233697056406352122739799141798128683030890684388523646092949137622463422330763842962696099247814642315228161654486230606201920328991334958879850243948148595489329368736853616066010463580708898993496380813090120231365611335479018127929506729541925085979790984405104386800544653914401327499841729628243629398895161102171053661379782907656737559622079695062837904381291020569371167471603212115523923427422753844411230141682293197598368746635302713562717912065581549995819694946183136162138286295977721326029803526872929663582622771396540879416241581631211963065872375847710311681570114372234937967742933488131741723703876886027413420167510655497078059920363952160365499928531614728115770523405879878738926760123058935146665820687805575175251426233817401019494855992396661297489478444652226539117300928687443765577723938824700527819165393464088236158306641395941586690943562519036074844622778775067727587772748379751795153018542163170015527267852775859032405350372499174111310035061724769756163790685041616326430409282236749911031712979036800459378930469597957873823346646171962310509097220008871457430048603899772540306304832209246364300475032779285803786546210554610268829386690108485043042003436142458875549629566255966552262064724745080447987395351527318387793454106939798655493253969923377184194258727882814283988366592320607666650935580598988081556462138632161717284533035231438377023951618611869397323100578368867261446804685162416128858977690532803240599204009335543941012970747977864339777696318146191935395492213069688188300039898671874906261266966508424757384502887833001183060897428884399997498117157500502565778504655772823542843925472854705087382507892274507634593730126080725353216760936639713070967210770933515537136465334802985885820943506399571704852686505328089283007331612892947704156948144575731286498287312917244098377956697946612529603261110598682641532677207218180298047963316050830023716493813503178054694051797799778594271244476935497508749908371738468552555239912224095718116474424953530533983266676667883213110751722837008561456006637152491757981280037290715713572977338094040135090575332414997981580447679731088627308119374455046036035809541288422443305450062372081504671207482761155999892286403469668216902028459990982293285426058631046278875506636962203166191421225185031391399291907600607094475014104834689538859977793468454196641269739496143182918768984370324102998412853685345945329288827019156930524095348476667249623805474055098058603078853717172750819316724347816902921124351526652215982310176319511148747383386566838390863101824284261789259207370284653221884492930538053014791480207595775770426583980609060806670873030885777407446579177851327006666584178868098615772831141995576481925143712829580901201236642537955315696342913722538081030519055886510666525100389074701038526500008863812712808978358968114558995015528690500268729369768912894386409902670885922253821127103764485143409993406578657993271573667851477048413128062107154234085057605823528261298423074975004252381984499461878120078837941243841615111364508506128108852624028150981444260642261259798840719548018127504488649172665110568527116056401845242133339286455214387478477611213817034948049846966676330093969199591827341810740617268458935556503166006573412407637240504057215200709390591938261228460224947769116116648097354574520818449307205998818617323517803963377583773765395951540386307320245912016628116115750567493257343006759963978891871554398487486748733153965455653544186484335423637099552960240670513874741866467499366800185340765021990458983365385733187525782889726837117381985597197654396891686210865082233817213714194597566477691156503211271979159615010152193090474164732539202487689064189138174247558568518445059591635000387915744430164783895141341408398634047461024113591831550942564003559383096359344227436680315176089668305004699590990878940481643178397080083419621139674053093393611581012877374943057917686241774944926062925225629859909897933786105505129206220729804760758474080159242132494639729075188116389267639251325731684451709941683127604655508071075901430023592961597957240126358593322192240275982534856027999489178553028973875086863475919283086692721281299469159853459385160354664970921095867714517610917845172656092828108575702421273795486668855497787165474363469235800050388579490340272955983498680992606684230221922944781347944865872858178227595402463974720515646772540902785482387607883264670904154031472187507825691469139840703032981537482686243765759156763470172952572297213049354720689126073830415977786397608050661777510017351369007567641316874862711968302150704869660960094076300391990198427901839513915247068945690440876433182226865804967948244355824536440194061901194936408757521696594761728917891650558745605300088173657468137012556665221047362275569717434711913882064069969541225648925550176794533757507773479704764682038728982139424204569819662667850563743127284683976644157669130665743308038268087252901546087644788596690944495990237941829038673916162133514265344352245400050566509781310704972455495028130393892347035291885098060467524720017181936398603814994382382650772574920951573251326841845596316117299555997520916921915693160390299946008037680731260289695663573328090295537184696109232961090256422746522240472779037947295553726890564541773183477341602385951250433066652436138907902513589141738984934035007118664457476702936175650532509974018859439897886938198705640224223531234161260494322835831910378739588878491486617772807256473907034615046017101979937448218760285712584115288239247068231185957731208040921969180687753816193332137470856155246184949408134208200781940331836165445332930527471325714699759663858697807486050516493915324687842049986638734797535077595009741573159086455865094526903507403634911304373642720947632743385606283416611803212276401655933319426477128718287531667778383534047329884055641156991461477580852875209605005145126748824382422847181771750227196469595493271083814929516966438279233349067301095431409428514479262217459082711535063579295954517279717019222487411853321959691007874959969382951749153769062624470174891136832493132751789744689002779946207134317564465466868986305955401344546226513276461770171598322199796692440179181149263369957672925710529737582477570506008201364256571321370582099438144554856585474638067857043555384561909623097403981896849326106625220840982935046845517776048403410501066898143708554149005399240996930382819006299171651966865527052594658559148162164850496698238956358965052198094985758695630319101476782538225392487875419849624494502743109905783246387795074137385993953050307885761184985209650716568685151159403316194109560691917965623867997472288170185221416185561997921101763718270130455973547946909667850091771922688048132643522108486530483599928660497610701288891298635225865489831006664914734730335115161838593766426180355837690007795667535486442163512499332635827265006022538662366857118923222980300313936536891113241485469164188684199653997706795776586276769930953065966487166850696007092826917265587038628308195665627167813312761372348899276132601392810647168421100568203290802884486785941798199652583036959236350315978749180415243235311007507023929580635402944864694590835553719502820113821297204073191863656436873858831721599499885250300760758484259992227301861236545662335949945517466343812052793386728604582059049449343375199803935786163907946776582594181507949291932626561926690681337554251000803620491072815168478108453190751005524662783384589693550237048310181652741373807092873209705738802574214720855114634403354253192584116444613872964351464889696804538927765143013290236177530879357079154295378964836800967387498009278823505418082233180006877353115724768897469405954950349676687678953031771064775190917103549673750061122539395946840907221362090537925968678051436241846562377239469706611359945730366914573367208324505498627301315873392341956694605327947337828073199230024745806178976815005235572717045279485106899342694233541752603518934163216412574201030261719425030676358173715925568214410817460762496238944168873854733415534318062060282196739349414494752656954535126420360317478133545659492793838167786318693603951211345748867871040880220521236987280365895875214617686119033584199197678121258801288108651169108459118044307573718850994680163665483464332243250384121519611150751542426324288473994555080400758915525472819602309183435029002301959162380153838709916673857914495250994642492169101393607995528992941633654323837752230754485070146124686015936891266363971709141915706319618799866404489122038347175600560148756284230439814037035479423833885071317442707889637670148396628747936885352344230110937443906976520885933709719988197796174220594997595235960607848107601135358641885671272374961802255117386521847735642710832170144020485390382120783904081464196555991762353088278514699741326336020255646379232399526671628567189445773205607837",
+            "output": 699903097
+        },
+        {
+            "input": "60024048105337522711773417464783263324832094585692964392472883697604993898414906626822307996148832646298751146332145488220054254768335562598507380541031596951106051525006787601683802231050144251757656510911040085260639305851358667929740757690711180385073042513942092438842121122396266152706103016099264301002910819572034544440314536590791523707430242769364948666975724636014062998446655597688919654431339321475294817157468940993294111484075421309961659491552768691673193424872747460816705135733933550893172072984360864501842709156441074587703487082882966978770929605450200936680303802513351265079224573650414192909521958718102163256006656648841744374065338264664043467372956063182083453362475551976353769881088646193766530405903985898604592661462725398350037123672500009003166936209487473954501343880695347087974713347417574874402434513682543323662322969149530269722772530702449461261860315454403864761806643605321020782686898781386596910471806638194509349174691552873642396026991100171354566961903129452288080588012927839221034318971318161759918116960069307342199421387050101240036399008283369556711389217884288619589590031573349742596033310937757047197688855207912668652044672867406622794208317622566248174995747803549291274352253023415823715387604064036300376135666334008452989797174372768371183286819034194782885678185924646520672132199038266784102965447056666031241976091977515604563990026438424381364656082581565546242731456127652039829909110360783242471145760273661843765957863999581342847138899513786654515468891851221894629459538836443586899892684591306838706395892573126832852419991957792849866744299670435725493388141288393188979329863404944025897954019091035046067875412730541376796756643537828273552585730107875032078597244609003309655110049327289034312700048011671521920004525681581628283760429557412037888964109235966661243796796271336122201020347592178557271172322593985217541954445116319007390856680174060324079595270892470350236737329301110997062575215274123651501416185878093334316219023943132570551511367737682644708217619118089785109650151004750433860011342018484275433125217846434670556766236440729849791999787680087979947405268291993374050595470626203599067026813791218331491188120532678193552150902288777747774128662056644297455302127414257594683059257234329250824684442532265498537181918559873109465152261283850326765266691746233225788322619778726907779252796988216418482232194180123017415339329441194590487150530386834065748515241603281137529385383137800788581704687980227838782358594981409728506685397449601184933679347435401926523260405324557636855816538589132823191593370763820132312399050622128452396474338357868391233092987256379015807438574026222346083108954499257081363703640751167319437262617026235744586999217658237025268750213516396328425293627873352447767351208780266886156715803704075490368179617869041950342066973024221419229066233725892337474759503227640182398975667771422761847680230366458983409107978983044256253914165375293361340839896737869787926639408660955550088225519240854346463797442749850971437793140401890816218944707975818117136491892652231440824313246513599996662215922923579651771393854749800816816100132425225937175988028722378677837128983205027456589067909250901126829321385628966272131571766773507666998893491976895862053556366241291868640922704580155186806839779901773580969658342711274649256853843556014374286317850314671887354414297565239621342067205288316679745246844953259534698027542736861958589473536254473520475735674801399087244954935419144336598717295781627421008883657554392241343956258154964167756716031499893243329509369376979989509296916967747586552012331642862331364320355688289425625493578370422585637348209891538309287680821427406666857700036450645555918113537550139869488395802376209685384520982369762945096198572131641343784882343952036342023199398654456993653024759810921374894530620338796992304539232062511297193304373203235510016875309218428693188510265677921892939015547226732880495372174467660791662494732803061776151088135113753324469673067720107189259478738726579610174219150837311466854126647974064460544416649803583303132684200862193122920424294620030086640525322134042750169653392005746573512071935440844054566437808613369536932389537149915515361533279507480995630321884353561954604562347929683502975863994306722895764127577732033623770828483164335236",
+            "output": 295826001
+        }
+    ],
+    "haskell_template": "countPalindromes :: String -> Int\ncountPalindromes s ",
+    "ocaml_template": "let countPalindromes (s: string) : int =  ",
+    "scala_template": "def countPalindromes(s: String): Int = { \n    \n}",
+    "java_template": "public static int countPalindromes(String s) {\n\n}",
+    "python_template": "class Solution(object):\n    def countPalindromes(self, s):\n        \"\"\"\n        :type s: str\n        :rtype: int\n        \"\"\"\n        "
+}

count_palindromic_subsequences/ocaml_tests/main.ml

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

count_palindromic_subsequences/scala_tests/MySuite.scala

@@ -0,0 +1,16 @@
+
+class MySuite extends munit.FunSuite {
+  
+  test("test1") {
+    assertEquals(Main.countPalindromes("103301"), 2)
+  }
+
+  test("test2") {
+    assertEquals(Main.countPalindromes("0000000"), 21)
+  }
+
+  test("test3") {
+    assertEquals(Main.countPalindromes("9999900000"), 2)
+  }
+
+}

count_partitions_with_even_sum_difference/haskell_tests/Main.hs

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

count_partitions_with_even_sum_difference/java_tests/Main.java

@@ -0,0 +1,24 @@
+
+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(4, countPartitions(Arrays.asList(10,10,3,7,6)));
+}
+@Test
+public void test2() {
+    assertEquals(0, countPartitions(Arrays.asList(1,2,2)));
+}
+@Test
+public void test3() {
+    assertEquals(3, countPartitions(Arrays.asList(2,4,6,8)));
+}
+
+}

count_partitions_with_even_sum_difference/meta.json

@@ -0,0 +1,627 @@
+{
+    "id": 3704,
+    "name": "count_partitions_with_even_sum_difference",
+    "difficulty": "Easy",
+    "link": "https://leetcode.com/problems/count-partitions-with-even-sum-difference/",
+    "date": "2025-01-19 00:00:00",
+    "task_description": "You are given an integer array `nums` of length `n`. A **partition** is defined as an index `i` where `0 <= i < n - 1`, splitting the array into two **non-empty** subarrays such that: Left subarray contains indices `[0, i]`. Right subarray contains indices `[i + 1, n - 1]`. Return the number of **partitions** where the **difference** between the **sum** of the left and right subarrays is **even**. **Example 1:** **Input:** nums = [10,10,3,7,6] **Output:** 4 **Explanation:** The 4 partitions are: `[10]`, `[10, 3, 7, 6]` with a sum difference of `10 - 26 = -16`, which is even. `[10, 10]`, `[3, 7, 6]` with a sum difference of `20 - 16 = 4`, which is even. `[10, 10, 3]`, `[7, 6]` with a sum difference of `23 - 13 = 10`, which is even. `[10, 10, 3, 7]`, `[6]` with a sum difference of `30 - 6 = 24`, which is even. **Example 2:** **Input:** nums = [1,2,2] **Output:** 0 **Explanation:** No partition results in an even sum difference. **Example 3:** **Input:** nums = [2,4,6,8] **Output:** 3 **Explanation:** All partitions result in an even sum difference. **Constraints:** `2 <= n == nums.length <= 100` `1 <= nums[i] <= 100`",
+    "public_test_cases": [
+        {
+            "label": "Example 1",
+            "input": "nums = [10,10,3,7,6]",
+            "output": "4 "
+        },
+        {
+            "label": "Example 2",
+            "input": "nums = [1,2,2]",
+            "output": "0 "
+        },
+        {
+            "label": "Example 3",
+            "input": "nums = [2,4,6,8]",
+            "output": "3 "
+        }
+    ],
+    "private_test_cases": [
+        {
+            "input": [
+                52,
+                48,
+                75,
+                98,
+                57,
+                68,
+                78,
+                16,
+                15,
+                63,
+                22,
+                68,
+                84,
+                83,
+                7,
+                96,
+                28,
+                6,
+                39,
+                42,
+                5,
+                91,
+                27,
+                89,
+                51,
+                22,
+                61,
+                69,
+                14,
+                4,
+                46,
+                48,
+                72,
+                7,
+                33,
+                22,
+                16,
+                1,
+                6,
+                56,
+                2,
+                84,
+                68,
+                27,
+                84,
+                13,
+                100,
+                98,
+                88,
+                35,
+                60,
+                79,
+                2,
+                78,
+                76,
+                40,
+                17,
+                39,
+                32,
+                3,
+                8,
+                23,
+                79,
+                76,
+                73,
+                64,
+                32,
+                58,
+                5,
+                89,
+                71,
+                43,
+                45
+            ],
+            "output": 72
+        },
+        {
+            "input": [
+                87,
+                41,
+                31,
+                40,
+                93,
+                87,
+                72,
+                75,
+                22,
+                83,
+                59,
+                93,
+                51,
+                79,
+                57,
+                45,
+                69,
+                34,
+                28,
+                63,
+                70,
+                75,
+                43,
+                63,
+                11,
+                5,
+                88,
+                28,
+                74,
+                11
+            ],
+            "output": 0
+        },
+        {
+            "input": [
+                35,
+                13,
+                9,
+                30,
+                94,
+                30,
+                5,
+                33,
+                33,
+                93,
+                21,
+                61,
+                93,
+                57,
+                37,
+                15,
+                58,
+                6,
+                22,
+                20,
+                19,
+                67,
+                63
+            ],
+            "output": 22
+        },
+        {
+            "input": [
+                56,
+                19,
+                68,
+                86,
+                70,
+                24,
+                82,
+                91,
+                92,
+                80,
+                43,
+                48,
+                81,
+                3,
+                16,
+                57,
+                2,
+                56,
+                66,
+                58,
+                2,
+                31,
+                57,
+                61,
+                36,
+                100,
+                41,
+                13,
+                1,
+                84,
+                58,
+                91,
+                95,
+                23,
+                98,
+                5,
+                51,
+                48,
+                19,
+                29,
+                65,
+                27,
+                49,
+                89,
+                56,
+                9,
+                78,
+                43,
+                31,
+                60,
+                68,
+                73
+            ],
+            "output": 0
+        },
+        {
+            "input": [
+                15,
+                11,
+                3,
+                6,
+                81,
+                52,
+                74,
+                97,
+                100,
+                67,
+                68,
+                47,
+                83,
+                68,
+                75,
+                75,
+                70,
+                99,
+                62,
+                62,
+                51,
+                60,
+                40,
+                62,
+                97,
+                49,
+                60,
+                94,
+                41,
+                87,
+                99,
+                76,
+                73,
+                28,
+                78,
+                20,
+                69,
+                98,
+                2,
+                23,
+                64,
+                99,
+                72,
+                68,
+                84,
+                88,
+                29,
+                22,
+                50,
+                56,
+                56,
+                20,
+                52,
+                43,
+                100,
+                8,
+                17,
+                87,
+                10,
+                55,
+                57,
+                81,
+                79,
+                84,
+                57,
+                12,
+                44,
+                62,
+                92,
+                89,
+                56,
+                94,
+                13,
+                48,
+                35,
+                12,
+                43,
+                35,
+                72,
+                56
+            ],
+            "output": 0
+        },
+        {
+            "input": [
+                55,
+                1,
+                32,
+                65,
+                3,
+                46,
+                72,
+                75,
+                91,
+                42,
+                81,
+                30,
+                25,
+                96,
+                15,
+                30,
+                23,
+                28,
+                55,
+                23,
+                20,
+                36,
+                81,
+                38,
+                4,
+                91,
+                22,
+                68,
+                1,
+                63,
+                2
+            ],
+            "output": 30
+        },
+        {
+            "input": [
+                15,
+                3,
+                73,
+                9,
+                8,
+                90,
+                94,
+                77,
+                26,
+                3,
+                38,
+                16,
+                40,
+                17,
+                6,
+                40,
+                92,
+                56,
+                14,
+                13,
+                81,
+                60,
+                58,
+                21,
+                92,
+                49,
+                39,
+                71,
+                89,
+                87,
+                6,
+                88,
+                39,
+                84,
+                24,
+                54,
+                24,
+                71,
+                77,
+                53,
+                16,
+                2,
+                34,
+                28,
+                33,
+                69,
+                77,
+                89,
+                63,
+                49,
+                42,
+                85,
+                79,
+                31,
+                78,
+                41,
+                86,
+                33,
+                36,
+                91,
+                53,
+                58,
+                89,
+                83,
+                97,
+                59
+            ],
+            "output": 65
+        },
+        {
+            "input": [
+                96,
+                52,
+                76,
+                66,
+                45,
+                3,
+                15,
+                70,
+                2,
+                49,
+                16,
+                2,
+                74,
+                79,
+                54,
+                93,
+                25,
+                91,
+                85,
+                62,
+                7,
+                98,
+                66,
+                1,
+                31,
+                86,
+                9,
+                25,
+                78,
+                99,
+                64,
+                13,
+                4,
+                64,
+                14,
+                3,
+                70,
+                47,
+                78,
+                63,
+                76,
+                45,
+                67,
+                89,
+                69,
+                92,
+                11,
+                76,
+                34,
+                60,
+                92,
+                18,
+                44,
+                35,
+                72,
+                82,
+                71,
+                53,
+                2,
+                6,
+                36,
+                29,
+                9,
+                23,
+                84,
+                64,
+                53,
+                89,
+                60,
+                68,
+                11,
+                14,
+                21,
+                65,
+                41,
+                57,
+                50,
+                20,
+                92,
+                84,
+                91,
+                25,
+                52,
+                55,
+                51,
+                76,
+                80,
+                45,
+                53,
+                14,
+                40,
+                27,
+                51,
+                1,
+                51,
+                16,
+                52,
+                25,
+                83,
+                7
+            ],
+            "output": 99
+        },
+        {
+            "input": [
+                51,
+                42,
+                23,
+                66,
+                95,
+                47,
+                17,
+                21,
+                6,
+                60,
+                7,
+                45,
+                7,
+                61,
+                55,
+                21,
+                70,
+                79,
+                4,
+                46,
+                4,
+                62,
+                71,
+                90,
+                70,
+                47,
+                72,
+                6,
+                79,
+                76,
+                98,
+                70,
+                69,
+                62,
+                93,
+                77,
+                3,
+                58,
+                67,
+                40,
+                65,
+                87,
+                86,
+                70,
+                78,
+                61,
+                22,
+                20,
+                40,
+                44,
+                47,
+                27,
+                76,
+                25,
+                63,
+                70,
+                94,
+                14,
+                38,
+                54,
+                81,
+                76,
+                58,
+                40,
+                86,
+                15,
+                16,
+                93,
+                33,
+                56,
+                34,
+                14
+            ],
+            "output": 71
+        },
+        {
+            "input": [
+                40,
+                91,
+                86,
+                12,
+                31,
+                79,
+                93,
+                29,
+                27,
+                12,
+                8,
+                96,
+                13,
+                49,
+                5,
+                5,
+                63,
+                85
+            ],
+            "output": 17
+        }
+    ],
+    "haskell_template": "countPartitions :: [Int] -> Int\ncountPartitions nums ",
+    "ocaml_template": "let countPartitions (nums: int list) : int =  ",
+    "scala_template": "def countPartitions(nums: List[Int]): Int = { \n    \n}",
+    "java_template": "class Solution {\n    public int countPartitions(int[] nums) {\n        \n    }\n}",
+    "python_template": "class Solution(object):\n    def countPartitions(self, nums):\n        \"\"\"\n        :type nums: List[int]\n        :rtype: int\n        \"\"\"\n        "
+}

count_partitions_with_even_sum_difference/ocaml_tests/main.ml

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

count_partitions_with_even_sum_difference/scala_tests/MySuite.scala

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

count_paths_that_can_form_a_palindrome_in_a_tree/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 (countPalindromePaths [-1,0,0,1,1,2]  \"acaabc \")," 8 (countPalindromePaths [-1,0,0,1,1,2] "acaabc"))
+
+test2 :: Test
+test2 = TestCase (assertEqual "for (countPalindromePaths [-1,0,0,0,0]  \"aaaaa \")," 10 (countPalindromePaths [-1,0,0,0,0] "aaaaa"))
+
+
+-- Grouping test cases
+tests :: Test
+tests = TestList [TestLabel "Test1" test1]
+
+-- Running the tests
+main :: IO Counts
+main = runTestTT tests

count_paths_that_can_form_a_palindrome_in_a_tree/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(8, countPalindromePaths(new ArrayList<>(Arrays.asList(-1,0,0,1,1,2)), "acaabc"));
+}
+@Test
+public void test2() {
+    assertEquals(10, countPalindromePaths(new ArrayList<>(Arrays.asList(-1,0,0,0,0)), "aaaaa"));
+}
+
+}

count_paths_that_can_form_a_palindrome_in_a_tree/meta.json

@@ -0,0 +1,579 @@
+{
+    "id": 2905,
+    "name": "count_paths_that_can_form_a_palindrome_in_a_tree",
+    "difficulty": "Hard",
+    "link": "https://leetcode.com/problems/count-paths-that-can-form-a-palindrome-in-a-tree/",
+    "date": "1689465600000",
+    "task_description": "You are given a **tree** (i.e. a connected, undirected graph that has no cycles) **rooted** at node `0` consisting of `n` nodes numbered from `0` to `n - 1`. The tree is represented by a **0-indexed** array `parent` of size `n`, where `parent[i]` is the parent of node `i`. Since node `0` is the root, `parent[0] == -1`. You are also given a string `s` of length `n`, where `s[i]` is the character assigned to the edge between `i` and `parent[i]`. `s[0]` can be ignored. Return _the number of pairs of nodes _`(u, v)`_ such that _`u < v`_ and the characters assigned to edges on the path from _`u`_ to _`v`_ can be **rearranged** to form a **palindrome**_. A string is a **palindrome** when it reads the same backwards as forwards. **Example 1:** ``` **Input:** parent = [-1,0,0,1,1,2], s = \"acaabc\" **Output:** 8 **Explanation:** The valid pairs are: - All the pairs (0,1), (0,2), (1,3), (1,4) and (2,5) result in one character which is always a palindrome. - The pair (2,3) result in the string \"aca\" which is a palindrome. - The pair (1,5) result in the string \"cac\" which is a palindrome. - The pair (3,5) result in the string \"acac\" which can be rearranged into the palindrome \"acca\". ``` **Example 2:** ``` **Input:** parent = [-1,0,0,0,0], s = \"aaaaa\" **Output:** 10 **Explanation:** Any pair of nodes (u,v) where u < v is valid. ``` **Constraints:** `n == parent.length == s.length` `1 <= n <= 105` `0 <= parent[i] <= n - 1` for all `i >= 1` `parent[0] == -1` `parent` represents a valid tree. `s` consists of only lowercase English letters.",
+    "public_test_cases": [
+        {
+            "label": "Example 1",
+            "input": "parent = [-1,0,0,1,1,2], s = \"acaabc\"",
+            "output": "8 "
+        },
+        {
+            "label": "Example 2",
+            "input": "parent = [-1,0,0,0,0], s = \"aaaaa\"",
+            "output": "10 "
+        }
+    ],
+    "private_test_cases": [
+        {
+            "input": [
+                [
+                    -1,
+                    0,
+                    1,
+                    2,
+                    1,
+                    1,
+                    2,
+                    4,
+                    0,
+                    2,
+                    0,
+                    4,
+                    0,
+                    7,
+                    13,
+                    11,
+                    7,
+                    9,
+                    7,
+                    15,
+                    2,
+                    19,
+                    13,
+                    0,
+                    1,
+                    5,
+                    23,
+                    5,
+                    2,
+                    13,
+                    24,
+                    13,
+                    31,
+                    17,
+                    27,
+                    1,
+                    30,
+                    6,
+                    25,
+                    9,
+                    15,
+                    30,
+                    23,
+                    33,
+                    24,
+                    16,
+                    22,
+                    42,
+                    34,
+                    9,
+                    4,
+                    49,
+                    38,
+                    2,
+                    51,
+                    42,
+                    11,
+                    6,
+                    39,
+                    9,
+                    37,
+                    26,
+                    55,
+                    1,
+                    30,
+                    39,
+                    9,
+                    32,
+                    52,
+                    40,
+                    24,
+                    0,
+                    4,
+                    15,
+                    67,
+                    23,
+                    12,
+                    6,
+                    37,
+                    62,
+                    6,
+                    77,
+                    78,
+                    10,
+                    46,
+                    82,
+                    19,
+                    6,
+                    86,
+                    64,
+                    87,
+                    31,
+                    73,
+                    0,
+                    93,
+                    45
+                ],
+                "\"brhgekbocwhjkgzlylgqzfyuytfqmrzzyuoemarevgytqabypcexkgncoxjodafegcqlwqsvssaagvptolbojlxrvsiwgujv\""
+            ],
+            "output": 145
+        },
+        {
+            "input": [
+                [
+                    -1,
+                    0,
+                    0,
+                    1,
+                    2,
+                    1,
+                    4,
+                    3,
+                    0,
+                    8,
+                    1,
+                    5,
+                    2,
+                    9,
+                    0,
+                    10,
+                    8,
+                    15,
+                    0,
+                    3,
+                    7,
+                    8,
+                    12,
+                    21,
+                    3,
+                    3,
+                    8,
+                    10,
+                    4,
+                    1,
+                    11,
+                    27,
+                    15,
+                    8,
+                    26,
+                    1,
+                    17,
+                    34,
+                    8,
+                    2,
+                    33,
+                    28,
+                    39,
+                    39,
+                    9,
+                    44,
+                    44,
+                    6,
+                    28,
+                    34,
+                    6,
+                    13,
+                    46,
+                    13,
+                    9,
+                    50
+                ],
+                "\"eqvzwwxcamwddvngplrleasubmjsrmriwcenzylymwnynqkrcaxznbus\""
+            ],
+            "output": 84
+        },
+        {
+            "input": [
+                [
+                    -1,
+                    0,
+                    0,
+                    0,
+                    3,
+                    2,
+                    5,
+                    1,
+                    4,
+                    3,
+                    7,
+                    6,
+                    8,
+                    11,
+                    6,
+                    3,
+                    10,
+                    6,
+                    7,
+                    6,
+                    13,
+                    18
+                ],
+                "\"ghpdzzxedatcllldocdnby\""
+            ],
+            "output": 30
+        },
+        {
+            "input": [
+                [
+                    -1,
+                    0,
+                    1,
+                    0,
+                    2,
+                    1,
+                    5,
+                    1,
+                    7,
+                    1,
+                    8,
+                    2,
+                    5,
+                    8,
+                    4,
+                    5,
+                    11,
+                    9,
+                    11,
+                    6,
+                    16,
+                    19,
+                    4,
+                    18,
+                    21,
+                    5,
+                    23,
+                    16,
+                    13,
+                    28,
+                    22,
+                    6,
+                    28,
+                    18,
+                    0,
+                    5,
+                    20,
+                    23,
+                    16,
+                    28,
+                    2,
+                    25,
+                    23,
+                    22,
+                    9,
+                    14,
+                    10,
+                    31,
+                    0,
+                    21,
+                    12,
+                    5,
+                    6,
+                    43,
+                    22,
+                    19,
+                    53,
+                    7,
+                    41,
+                    0,
+                    3,
+                    7,
+                    8,
+                    23,
+                    31,
+                    46,
+                    31,
+                    4,
+                    61,
+                    37,
+                    8,
+                    39,
+                    24,
+                    28,
+                    32,
+                    60,
+                    42,
+                    45,
+                    14,
+                    47,
+                    2,
+                    21,
+                    70,
+                    12,
+                    62,
+                    64
+                ],
+                "\"cnsjxmrjmpbxlruodastllsthvgvtijfgvfzcnynltviadvsxwkdfqqzmrdoiayrczvcaqjzwcqpxageyrnqbz\""
+            ],
+            "output": 136
+        },
+        {
+            "input": [
+                [
+                    -1,
+                    0,
+                    0,
+                    2,
+                    1,
+                    4,
+                    3,
+                    1,
+                    3,
+                    5,
+                    6,
+                    5,
+                    2,
+                    3,
+                    12,
+                    3,
+                    1,
+                    7,
+                    3,
+                    11,
+                    8,
+                    15,
+                    16,
+                    13,
+                    22,
+                    12,
+                    1,
+                    9,
+                    6,
+                    17,
+                    8,
+                    24,
+                    6,
+                    1,
+                    7,
+                    2,
+                    34,
+                    13,
+                    26,
+                    22,
+                    26,
+                    12,
+                    1,
+                    33,
+                    24,
+                    34,
+                    45,
+                    30,
+                    23,
+                    45,
+                    15,
+                    34,
+                    36,
+                    49,
+                    26,
+                    32,
+                    47,
+                    48,
+                    14,
+                    15,
+                    45,
+                    20,
+                    15,
+                    51,
+                    42,
+                    55
+                ],
+                "\"lldslfpjifwjbojmpumthwpanuzsufdzmdwlpoaascbuaxeamdtgilitwmrvttppjy\""
+            ],
+            "output": 116
+        },
+        {
+            "input": [
+                [
+                    -1,
+                    0,
+                    1,
+                    1,
+                    0,
+                    3,
+                    0,
+                    1,
+                    2,
+                    2,
+                    0,
+                    9,
+                    2,
+                    2,
+                    0,
+                    12,
+                    4,
+                    9,
+                    3,
+                    2,
+                    17,
+                    9,
+                    16,
+                    7,
+                    21,
+                    15,
+                    24,
+                    20,
+                    18,
+                    0,
+                    10,
+                    17,
+                    12,
+                    19,
+                    16,
+                    4,
+                    4,
+                    32,
+                    32,
+                    32,
+                    36,
+                    21,
+                    6,
+                    38,
+                    30,
+                    18,
+                    21,
+                    17,
+                    35,
+                    36,
+                    6,
+                    24
+                ],
+                "\"ngdxhlyawjsimebbaznaruptuucwuttincjctydcwblniilscigr\""
+            ],
+            "output": 69
+        },
+        {
+            "input": [
+                [
+                    -1,
+                    0,
+                    1,
+                    0,
+                    0,
+                    1,
+                    0,
+                    4,
+                    1,
+                    4,
+                    0,
+                    2,
+                    5,
+                    8,
+                    10,
+                    6,
+                    11,
+                    6,
+                    6,
+                    15,
+                    5,
+                    1,
+                    7,
+                    1,
+                    15,
+                    22,
+                    20,
+                    25,
+                    19,
+                    2,
+                    0,
+                    18,
+                    29,
+                    30,
+                    22,
+                    4,
+                    30,
+                    30,
+                    20,
+                    29,
+                    10,
+                    6,
+                    22,
+                    11,
+                    13,
+                    38,
+                    41,
+                    29,
+                    5,
+                    28,
+                    25,
+                    44,
+                    12,
+                    28,
+                    22,
+                    43,
+                    37,
+                    13,
+                    39,
+                    40,
+                    41,
+                    41,
+                    17,
+                    22,
+                    19,
+                    55
+                ],
+                "\"gyflaflwodsjtsegttmknzkmcektkbdqdixieztdnxgqhcnwxbbwwkrdbmnfmlwjgf\""
+            ],
+            "output": 93
+        },
+        {
+            "input": [
+                [
+                    -1
+                ],
+                "k"
+            ],
+            "output": 0
+        },
+        {
+            "input": [
+                [
+                    -1,
+                    0,
+                    0,
+                    2,
+                    0,
+                    0,
+                    4,
+                    4,
+                    1,
+                    1,
+                    4,
+                    6,
+                    2,
+                    6,
+                    11,
+                    11,
+                    4,
+                    8,
+                    9,
+                    11,
+                    7
+                ],
+                "yfdigwrhbguolivqcpsbz"
+            ],
+            "output": 21
+        },
+        {
+            "input": [
+                [
+                    -1,
+                    0,
+                    1,
+                    1,
+                    3,
+                    0
+                ],
+                "ojcpyi"
+            ],
+            "output": 5
+        }
+    ],
+    "haskell_template": "countPalindromePaths :: [Int] -> String -> Int\ncountPalindromePaths parent s ",
+    "ocaml_template": "let countPalindromePaths (parent: int list) (s: string) : int =  ",
+    "scala_template": "def countPalindromePaths(parent: List[Int],s: String): Int = { \n    \n}",
+    "java_template": "public static int countPalindromePaths(List<Integer> parent, String s) {\n\n}",
+    "python_template": "class Solution(object):\n    def countPalindromePaths(self, parent, s):\n        \"\"\"\n        :type parent: List[int]\n        :type s: str\n        :rtype: int\n        \"\"\"\n        "
+}

count_paths_that_can_form_a_palindrome_in_a_tree/ocaml_tests/main.ml

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

count_paths_that_can_form_a_palindrome_in_a_tree/scala_tests/MySuite.scala

@@ -0,0 +1,12 @@
+
+class MySuite extends munit.FunSuite {
+  
+  test("test1") {
+    assertEquals(Main.countPalindromePaths(List(-1,0,0,1,1,2),"acaabc"), 8)
+  }
+
+  test("test2") {
+    assertEquals(Main.countPalindromePaths(List(-1,0,0,0,0),"aaaaa"), 10)
+  }
+
+}

count_paths_with_the_given_xor_value/java_tests/Main.java

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

count_prefix_and_suffix_pairs_i/haskell_tests/Main.hs

@@ -0,0 +1,44 @@
+
+module Main where
+import Test.HUnit
+
+--Program start
+countPrefixSuffixPairs :: [String] -> Int
+countPrefixSuffixPairs words = undefined
+
+--Program end
+
+-- Test cases
+
+test1 :: Test
+test1 = TestCase (assertEqual "for (countPrefixSuffixPairs [ \"a \", \"aba \", \"ababa \", \"aa \"])," 4 (countPrefixSuffixPairs ["a","aba","ababa","aa"]))
+
+test2 :: Test
+test2 = TestCase (assertEqual "for (countPrefixSuffixPairs [ \"pa \", \"papa \", \"ma \", \"mama \"])," 2 (countPrefixSuffixPairs ["pa","papa","ma","mama"]))
+
+test3 :: Test
+test3 = TestCase (assertEqual "for (countPrefixSuffixPairs [ \"abab \", \"ab \"])," 0 (countPrefixSuffixPairs ["abab","ab"]))
+
+test4 :: Test
+test4 = TestCase (assertEqual "for (countPrefixSuffixPairs [ \"zyfn \",  \"ujuvsucqd \",  \"fin \",  \"vkzcgb \",  \"odgfyz \",  \"focupzrq \",  \"jocaylejk \",  \"bgm \",  \"fpmavzz \",  \"pmeuqcapjg \",  \"w \",  \"lbt \",  \"tqcbdaopp \",  \"jx \",  \"jrn \",  \"uyoqpbxl \",  \"csn \",  \"deorcs \",  \"tkwvtvfpls \",  \"zxwifl \",  \"jqfc \",  \"nyrrfiwojv \",  \"whwl \",  \"x \",  \"ydsrxiplz \",  \"arzz \",  \"ymngfqx \"])," 0 (countPrefixSuffixPairs ["zyfn", "ujuvsucqd", "fin", "vkzcgb", "odgfyz", "focupzrq", "jocaylejk", "bgm", "fpmavzz", "pmeuqcapjg", "w", "lbt", "tqcbdaopp", "jx", "jrn", "uyoqpbxl", "csn", "deorcs", "tkwvtvfpls", "zxwifl", "jqfc", "nyrrfiwojv", "whwl", "x", "ydsrxiplz", "arzz", "ymngfqx"]))
+
+test5 :: Test
+test5 = TestCase (assertEqual "for (countPrefixSuffixPairs [ \"agtqjfw \",  \"i \",  \"ffnfx \",  \"fxdud \",  \"oq \",  \"nyoadavbp \",  \"fvvcbr \",  \"mcfox \",  \"nlmrkr \",  \"sgmwin \",  \"anthihed \",  \"kaajld \",  \"ak \",  \"wnp \",  \"ijklwgrb \",  \"puqktr \",  \"by \",  \"xwq \",  \"rkbphyelux \",  \"hjom \",  \"ptp \",  \"xahpd \",  \"ztmealb \",  \"cmnmeiyl \",  \"xckksy \",  \"gzojok \",  \"canomipks \",  \"udpgrrnhz \"])," 0 (countPrefixSuffixPairs ["agtqjfw", "i", "ffnfx", "fxdud", "oq", "nyoadavbp", "fvvcbr", "mcfox", "nlmrkr", "sgmwin", "anthihed", "kaajld", "ak", "wnp", "ijklwgrb", "puqktr", "by", "xwq", "rkbphyelux", "hjom", "ptp", "xahpd", "ztmealb", "cmnmeiyl", "xckksy", "gzojok", "canomipks", "udpgrrnhz"]))
+
+test6 :: Test
+test6 = TestCase (assertEqual "for (countPrefixSuffixPairs [ \"cql \",  \"lfeaau \",  \"hghzxkea \",  \"arw \",  \"esfgwzhiy \",  \"joomofen \",  \"s \",  \"mb \",  \"gfums \",  \"cslailpgz \",  \"alrrcpzm \",  \"zwbsi \",  \"szdswocnji \",  \"w \",  \"we \",  \"m \",  \"zfniocou \",  \"e \",  \"mwzjl \",  \"gpbs \",  \"cxzkhltg \",  \"bvktqilzl \",  \"dwdqhi \",  \"hajxu \",  \"fnprdxxgdv \",  \"hhj \",  \"nrwjnkv \",  \"jietmjj \",  \"vxauqqmht \",  \"opmplgs \",  \"swdzgbmu \",  \"ek \",  \"sojcvovdny \",  \"szs \",  \"g \",  \"jxoattqel \",  \"mtrjn \",  \"wl \"])," 1 (countPrefixSuffixPairs ["cql", "lfeaau", "hghzxkea", "arw", "esfgwzhiy", "joomofen", "s", "mb", "gfums", "cslailpgz", "alrrcpzm", "zwbsi", "szdswocnji", "w", "we", "m", "zfniocou", "e", "mwzjl", "gpbs", "cxzkhltg", "bvktqilzl", "dwdqhi", "hajxu", "fnprdxxgdv", "hhj", "nrwjnkv", "jietmjj", "vxauqqmht", "opmplgs", "swdzgbmu", "ek", "sojcvovdny", "szs", "g", "jxoattqel", "mtrjn", "wl"]))
+
+test7 :: Test
+test7 = TestCase (assertEqual "for (countPrefixSuffixPairs [ \"jzspzok \",  \"lvcmouwhdr \",  \"rnhwwiikw \",  \"ykzhqidutg \",  \"jizyv \",  \"lv \",  \"sksgsmp \",  \"otevict \",  \"xshdigu \",  \"xji \",  \"ggymskwnpv \",  \"hre \",  \"jsk \",  \"chhol \",  \"glnyoo \",  \"zk \",  \"kwp \",  \"vk \",  \"kjqgjaftr \",  \"rrt \",  \"tjhrk \",  \"epj \",  \"i \",  \"uxlvexs \",  \"zkrtksdgvs \",  \"jeuhmsnad \",  \"opqunjyc \",  \"szut \",  \"ljtz \",  \"hmq \",  \"deie \",  \"ahak \"])," 0 (countPrefixSuffixPairs ["jzspzok", "lvcmouwhdr", "rnhwwiikw", "ykzhqidutg", "jizyv", "lv", "sksgsmp", "otevict", "xshdigu", "xji", "ggymskwnpv", "hre", "jsk", "chhol", "glnyoo", "zk", "kwp", "vk", "kjqgjaftr", "rrt", "tjhrk", "epj", "i", "uxlvexs", "zkrtksdgvs", "jeuhmsnad", "opqunjyc", "szut", "ljtz", "hmq", "deie", "ahak"]))
+
+test8 :: Test
+test8 = TestCase (assertEqual "for (countPrefixSuffixPairs [ \"tioefbiyzd \",  \"x \",  \"tx \",  \"zgvaelmla \",  \"lezuiqxwcu \",  \"mraf \",  \"fi \",  \"fxkq \",  \"qcejhxlgfr \",  \"wgyacuewhz \",  \"ooij \",  \"uo \",  \"qx \",  \"dhr \",  \"tbmx \",  \"xgbtnouan \",  \"xbetthbx \",  \"bpoq \",  \"jgropqunp \",  \"qqzwd \",  \"srgwdcqorb \",  \"yqcqrpvasi \",  \"f \",  \"gepw \",  \"hokn \",  \"edkqckl \",  \"qdzrfs \",  \"mznhanzqf \",  \"bshbc \",  \"xotl \",  \"wkeiwlidg \",  \"icet \",  \"qmtwngj \",  \"poodfvmes \"])," 1 (countPrefixSuffixPairs ["tioefbiyzd", "x", "tx", "zgvaelmla", "lezuiqxwcu", "mraf", "fi", "fxkq", "qcejhxlgfr", "wgyacuewhz", "ooij", "uo", "qx", "dhr", "tbmx", "xgbtnouan", "xbetthbx", "bpoq", "jgropqunp", "qqzwd", "srgwdcqorb", "yqcqrpvasi", "f", "gepw", "hokn", "edkqckl", "qdzrfs", "mznhanzqf", "bshbc", "xotl", "wkeiwlidg", "icet", "qmtwngj", "poodfvmes"]))
+
+
+-- 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]
+
+-- Running the tests
+main :: IO Counts
+main = runTestTT tests

count_prefix_and_suffix_pairs_i/java_tests/Main.java

@@ -0,0 +1,24 @@
+
+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(4, countPrefixSuffixPairs(Arrays.asList("a","aba","ababa","aa")));
+}
+@Test
+public void test2() {
+    assertEquals(2, countPrefixSuffixPairs(Arrays.asList("pa","papa","ma","mama")));
+}
+@Test
+public void test3() {
+    assertEquals(0, countPrefixSuffixPairs(Arrays.asList("abab","ab")));
+}
+
+}