Merge branch 'main' into add-approach-change

Author: jagdish-15

exercises/practice/bob/.meta/config.json

@@ -7,6 +7,7 @@
     "austinlyons",
     "c-thornton",
     "FridaTveit",
+    "jagdish-15",
     "jmrunkle",
     "jtigger",
     "kytrinyx",

exercises/practice/bob/.meta/tests.toml

@@ -1,6 +1,13 @@
-# This is an auto-generated file. Regular comments will be removed when this
-# file is regenerated. Regenerating will not touch any manually added keys,
-# so comments can be added in a "comment" key.
+# This is an auto-generated file.
+#
+# Regenerating this file via `configlet sync` will:
+# - Recreate every `description` key/value pair
+# - Recreate every `reimplements` key/value pair, where they exist in problem-specifications
+# - Remove any `include = true` key/value pair (an omitted `include` key implies inclusion)
+# - Preserve any other key/value pair
+#
+# As user-added comments (using the # character) will be removed when this file
+# is regenerated, comments can be added via a `comment` key.
 
 [e162fead-606f-437a-a166-d051915cea8e]
 description = "stating something"
@@ -64,6 +71,7 @@ description = "alternate silence"
 
 [66953780-165b-4e7e-8ce3-4bcb80b6385a]
 description = "multiple line question"
+include = false
 
 [5371ef75-d9ea-4103-bcfa-2da973ddec1b]
 description = "starting with whitespace"
@@ -76,3 +84,7 @@ description = "other whitespace"
 
 [12983553-8601-46a8-92fa-fcaa3bc4a2a0]
 description = "non-question ending with whitespace"
+
+[2c7278ac-f955-4eb4-bf8f-e33eb4116a15]
+description = "multiple line question"
+reimplements = "66953780-165b-4e7e-8ce3-4bcb80b6385a"

exercises/practice/bob/src/test/java/BobTest.java

@@ -152,13 +152,6 @@ public void alternateSilence() {
                 .isEqualTo("Fine. Be that way!");
     }
 
-    @Disabled("Remove to run test")
-    @Test
-    public void multipleLineQuestion() {
-        assertThat(bob.hey("\nDoes this cryogenic chamber make me look fat?\nNo."))
-                .isEqualTo("Whatever.");
-    }
-
     @Disabled("Remove to run test")
     @Test
     public void startingWithWhitespace() {
@@ -187,4 +180,11 @@ public void nonQuestionEndingWithWhiteSpace() {
                 .isEqualTo("Whatever.");
     }
 
+    @Disabled("Remove to run test")
+    @Test
+    public void multipleLineQuestion() {
+        assertThat(bob.hey("\nDoes this cryogenic chamber make\n me look fat?"))
+                .isEqualTo("Sure.");
+    }
+
 }

exercises/practice/complex-numbers/.docs/instructions.md

@@ -1,29 +1,100 @@
 # Instructions
 
-A complex number is a number in the form `a + b * i` where `a` and `b` are real and `i` satisfies `i^2 = -1`.
+A **complex number** is expressed in the form `z = a + b * i`, where:
 
-`a` is called the real part and `b` is called the imaginary part of `z`.
-The conjugate of the number `a + b * i` is the number `a - b * i`.
-The absolute value of a complex number `z = a + b * i` is a real number `|z| = sqrt(a^2 + b^2)`. The square of the absolute value `|z|^2` is the result of multiplication of `z` by its complex conjugate.
+- `a` is the **real part** (a real number),
 
-The sum/difference of two complex numbers involves adding/subtracting their real and imaginary parts separately:
-`(a + i * b) + (c + i * d) = (a + c) + (b + d) * i`,
-`(a + i * b) - (c + i * d) = (a - c) + (b - d) * i`.
+- `b` is the **imaginary part** (also a real number), and
 
-Multiplication result is by definition
-`(a + i * b) * (c + i * d) = (a * c - b * d) + (b * c + a * d) * i`.
+- `i` is the **imaginary unit** satisfying `i^2 = -1`.
 
-The reciprocal of a non-zero complex number is
-`1 / (a + i * b) = a/(a^2 + b^2) - b/(a^2 + b^2) * i`.
+## Operations on Complex Numbers
 
-Dividing a complex number `a + i * b` by another `c + i * d` gives:
-`(a + i * b) / (c + i * d) = (a * c + b * d)/(c^2 + d^2) + (b * c - a * d)/(c^2 + d^2) * i`.
+### Conjugate
 
-Raising e to a complex exponent can be expressed as `e^(a + i * b) = e^a * e^(i * b)`, the last term of which is given by Euler's formula `e^(i * b) = cos(b) + i * sin(b)`.
+The conjugate of the complex number `z = a + b * i` is given by:
 
-Implement the following operations:
+```text
+zc = a - b * i
+```
 
-- addition, subtraction, multiplication and division of two complex numbers,
-- conjugate, absolute value, exponent of a given complex number.
+### Absolute Value
 
-Assume the programming language you are using does not have an implementation of complex numbers.
+The absolute value (or modulus) of `z` is defined as:
+
+```text
+|z| = sqrt(a^2 + b^2)
+```
+
+The square of the absolute value is computed as the product of `z` and its conjugate `zc`:
+
+```text
+|z|^2 = z * zc = a^2 + b^2
+```
+
+### Addition
+
+The sum of two complex numbers `z1 = a + b * i` and `z2 = c + d * i` is computed by adding their real and imaginary parts separately:
+
+```text
+z1 + z2 = (a + b * i) + (c + d * i)
+        = (a + c) + (b + d) * i
+```
+
+### Subtraction
+
+The difference of two complex numbers is obtained by subtracting their respective parts:
+
+```text
+z1 - z2 = (a + b * i) - (c + d * i)
+        = (a - c) + (b - d) * i
+```
+
+### Multiplication
+
+The product of two complex numbers is defined as:
+
+```text
+z1 * z2 = (a + b * i) * (c + d * i)
+        = (a * c - b * d) + (b * c + a * d) * i
+```
+
+### Reciprocal
+
+The reciprocal of a non-zero complex number is given by:
+
+```text
+1 / z = 1 / (a + b * i)
+      = a / (a^2 + b^2) - b / (a^2 + b^2) * i
+```
+
+### Division
+
+The division of one complex number by another is given by:
+
+```text
+z1 / z2 = z1 * (1 / z2)
+        = (a + b * i) / (c + d * i)
+        = (a * c + b * d) / (c^2 + d^2) + (b * c - a * d) / (c^2 + d^2) * i
+```
+
+### Exponentiation
+
+Raising _e_ (the base of the natural logarithm) to a complex exponent can be expressed using Euler's formula:
+
+```text
+e^(a + b * i) = e^a * e^(b * i)
+              = e^a * (cos(b) + i * sin(b))
+```
+
+## Implementation Requirements
+
+Given that you should not use built-in support for complex numbers, implement the following operations:
+
+- **addition** of two complex numbers
+- **subtraction** of two complex numbers
+- **multiplication** of two complex numbers
+- **division** of two complex numbers
+- **conjugate** of a complex number
+- **absolute value** of a complex number
+- **exponentiation** of _e_ (the base of the natural logarithm) to a complex number

exercises/practice/dot-dsl/.meta/config.json

@@ -16,6 +16,9 @@
     "editor": [
       "src/main/java/Node.java",
       "src/main/java/Edge.java"
+    ],
+    "invalidator": [
+      "build.gradle"
     ]
   },
   "blurb": "Write a Domain Specific Language similar to the Graphviz dot language.",

exercises/practice/forth/.meta/config.json

@@ -6,6 +6,7 @@
     "aadityakulkarni",
     "FridaTveit",
     "hgvanpariya",
+    "jagdish-15",
     "jmrunkle",
     "kytrinyx",
     "lemoncurry",

exercises/practice/forth/.meta/tests.toml

@@ -24,6 +24,9 @@ description = "addition -> errors if there is nothing on the stack"
 [06efb9a4-817a-435e-b509-06166993c1b8]
 description = "addition -> errors if there is only one value on the stack"
 
+[1e07a098-c5fa-4c66-97b2-3c81205dbc2f]
+description = "addition -> more than two values on the stack"
+
 [09687c99-7bbc-44af-8526-e402f997ccbf]
 description = "subtraction -> can subtract two numbers"
 
@@ -33,6 +36,9 @@ description = "subtraction -> errors if there is nothing on the stack"
 [b3cee1b2-9159-418a-b00d-a1bb3765c23b]
 description = "subtraction -> errors if there is only one value on the stack"
 
+[2c8cc5ed-da97-4cb1-8b98-fa7b526644f4]
+description = "subtraction -> more than two values on the stack"
+
 [5df0ceb5-922e-401f-974d-8287427dbf21]
 description = "multiplication -> can multiply two numbers"
 
@@ -42,6 +48,9 @@ description = "multiplication -> errors if there is nothing on the stack"
 [8ba4b432-9f94-41e0-8fae-3b3712bd51b3]
 description = "multiplication -> errors if there is only one value on the stack"
 
+[5cd085b5-deb1-43cc-9c17-6b1c38bc9970]
+description = "multiplication -> more than two values on the stack"
+
 [e74c2204-b057-4cff-9aa9-31c7c97a93f5]
 description = "division -> can divide two numbers"
 
@@ -57,12 +66,21 @@ description = "division -> errors if there is nothing on the stack"
 [d5547f43-c2ff-4d5c-9cb0-2a4f6684c20d]
 description = "division -> errors if there is only one value on the stack"
 
+[f224f3e0-b6b6-4864-81de-9769ecefa03f]
+description = "division -> more than two values on the stack"
+
 [ee28d729-6692-4a30-b9be-0d830c52a68c]
 description = "combined arithmetic -> addition and subtraction"
 
 [40b197da-fa4b-4aca-a50b-f000d19422c1]
 description = "combined arithmetic -> multiplication and division"
 
+[f749b540-53aa-458e-87ec-a70797eddbcb]
+description = "combined arithmetic -> multiplication and addition"
+
+[c8e5a4c2-f9bf-4805-9a35-3c3314e4989a]
+description = "combined arithmetic -> addition and multiplication"
+
 [c5758235-6eef-4bf6-ab62-c878e50b9957]
 description = "dup -> copies a value on the stack"
 

exercises/practice/forth/src/test/java/ForthEvaluatorTest.java

@@ -48,6 +48,13 @@ public void testErrorIfAdditionAttemptedWithOneNumberOnTheStack() {
                 .withMessage("Addition requires that the stack contain at least 2 values");
     }
 
+    @Disabled("Remove to run test")
+    @Test
+    public void testAdditionForMoreThanTwoValuesOnTheStack() {
+        assertThat(forthEvaluator.evaluateProgram(Collections.singletonList("1 2 3 +")))
+                .containsExactly(1, 5);
+    }
+
     @Disabled("Remove to run test")
     @Test
     public void testTwoNumbersCanBeSubtracted() {
@@ -72,6 +79,13 @@ public void testErrorIfSubtractionAttemptedWithOneNumberOnTheStack() {
                 .withMessage("Subtraction requires that the stack contain at least 2 values");
     }
 
+    @Disabled("Remove to run test")
+    @Test
+    public void testSubtractionForMoreThanTwoValuesOnTheStack() {
+        assertThat(forthEvaluator.evaluateProgram(Collections.singletonList("1 12 3 -")))
+                .containsExactly(1, 9);
+    }
+
     @Disabled("Remove to run test")
     @Test
     public void testTwoNumbersCanBeMultiplied() {
@@ -94,6 +108,13 @@ public void testErrorIfMultiplicationAttemptedWithOneNumberOnTheStack() {
                 .withMessage("Multiplication requires that the stack contain at least 2 values");
     }
 
+    @Disabled("Remove to run test")
+    @Test
+    public void testMultiplicationForMoreThanTwoValuesOnTheStack() {
+        assertThat(forthEvaluator.evaluateProgram(Collections.singletonList("1 2 3 *")))
+                .containsExactly(1, 6);
+    }
+
     @Disabled("Remove to run test")
     @Test
     public void testTwoNumbersCanBeDivided() {
@@ -130,6 +151,13 @@ public void testErrorIfDivisionAttemptedWithOneNumberOnTheStack() {
                 .withMessage("Division requires that the stack contain at least 2 values");
     }
 
+    @Disabled("Remove to run test")
+    @Test
+    public void testDivisionForMoreThanTwoValuesOnTheStack() {
+        assertThat(forthEvaluator.evaluateProgram(Collections.singletonList("1 12 3 /")))
+                .containsExactly(1, 4);
+    }
+
     @Disabled("Remove to run test")
     @Test
     public void testCombinedAdditionAndSubtraction() {
@@ -142,6 +170,18 @@ public void testCombinedMultiplicationAndDivision() {
         assertThat(forthEvaluator.evaluateProgram(Collections.singletonList("2 4 * 3 /"))).containsExactly(2);
     }
 
+    @Disabled("Remove to run test")
+    @Test
+    public void testCombinedMultiplicationAndAddition() {
+        assertThat(forthEvaluator.evaluateProgram(Collections.singletonList("1 3 4 * +"))).containsExactly(13);
+    }
+
+    @Disabled("Remove to run test")
+    @Test
+    public void testCombinedAdditionAndMultiplication() {
+        assertThat(forthEvaluator.evaluateProgram(Collections.singletonList("1 3 4 + *"))).containsExactly(7);
+    }
+
     @Disabled("Remove to run test")
     @Test
     public void testDupCopiesAValueOnTheStack() {

exercises/practice/hamming/.docs/instructions.md

@@ -1,6 +1,6 @@
 # Instructions
 
-Calculate the Hamming Distance between two DNA strands.
+Calculate the Hamming distance between two DNA strands.
 
 Your body is made up of cells that contain DNA.
 Those cells regularly wear out and need replacing, which they achieve by dividing into daughter cells.
@@ -9,18 +9,18 @@ In fact, the average human body experiences about 10 quadrillion cell divisions
 When cells divide, their DNA replicates too.
 Sometimes during this process mistakes happen and single pieces of DNA get encoded with the incorrect information.
 If we compare two strands of DNA and count the differences between them we can see how many mistakes occurred.
-This is known as the "Hamming Distance".
+This is known as the "Hamming distance".
 
-We read DNA using the letters C,A,G and T.
+We read DNA using the letters C, A, G and T.
 Two strands might look like this:
 
     GAGCCTACTAACGGGAT
     CATCGTAATGACGGCCT
     ^ ^ ^  ^ ^    ^^
 
-They have 7 differences, and therefore the Hamming Distance is 7.
+They have 7 differences, and therefore the Hamming distance is 7.
 
-The Hamming Distance is useful for lots of things in science, not just biology, so it's a nice phrase to be familiar with :)
+The Hamming distance is useful for lots of things in science, not just biology, so it's a nice phrase to be familiar with :)
 
 ## Implementation notes
 

exercises/practice/hamming/.meta/config.json

@@ -43,7 +43,7 @@
       "build.gradle"
     ]
   },
-  "blurb": "Calculate the Hamming difference between two DNA strands.",
+  "blurb": "Calculate the Hamming distance between two DNA strands.",
   "source": "The Calculating Point Mutations problem at Rosalind",
   "source_url": "https://rosalind.info/problems/hamm/"
 }