add first approach

Author: Yrahcaz7

exercises/practice/eliuds-eggs/.approaches/config.json

@@ -0,0 +1,15 @@
+{
+  "introduction": {
+    "authors": ["yrahcaz7"],
+    "contributors": []
+  },
+  "approaches": [
+    {
+      "uuid": "27fb20ed-a4c2-4f73-a8fc-86ba384c7b35",
+      "slug": "parameter-modification",
+      "title": "Modify the Parameter in a Loop",
+      "blurb": "Modify the Parameter in a while-loop to Calculate the Number of Eggs.",
+      "authors": ["yrahcaz7"]
+    }
+  ]
+}

exercises/practice/eliuds-eggs/.approaches/introduction.md

@@ -0,0 +1,46 @@
+# Introduction
+
+There are many Pythonic approaches to solving the Eliud's Eggs exercise:
+
+- Using a `while-loop`, modifying the parameter on each iteration
+- Looping over every binary digit _without_ modifying the parameter
+- Converting the `int` to a binary string and counting the ones
+
+There are also some approaches that aren't recommended:
+
+- Using the bit-count functionality from the Python standard library, as the instructions forbid it
+- Breaking up the proccess into many functions, overcomplicating the solution
+
+
+## General guidance
+
+The goal of the Eliud's Eggs exercise is to count the number of ones in the binary representation of a number.
+In essence, this requires you to loop over each bit (binary digit) of the number in some way.
+
+The approaches below represent categories of the most common ways of accomplishing this.
+
+
+## Approach: Modifying the Parameter in a `while-loop`
+
+```python
+def egg_count(display_value):
+    eggs = 0
+    while display_value:
+        eggs += display_value % 2
+        display_value //= 2
+    return eggs
+```
+
+This approach uses a `while-loop` to count up all of the ones.
+In the loop, we increment `eggs` by `display_value % 2`.
+This adds the least significant bit (the rightmost digit in the binary representation) of `display_value` to `eggs`.
+
+Next, we divide `display_value` by `2`, discarding any remainder.
+This essentially removes the least significant bit of `display_value`, setting up `display_value` for processing the next bit.
+
+The loop repeats until `display_value` reaches `0` (which indicates that we have no more bits to check), and then we return `eggs`.
+
+To see more variants of this solution, see the [modify the parameter in a loop][parameter-modification] approach.
+
+
+[parameter-modification]: https://exercism.org/tracks/python/exercises/eliuds-eggs/approaches/parameter-modification

exercises/practice/eliuds-eggs/.approaches/parameter-modification/content.md

@@ -0,0 +1,80 @@
+# Modify the Parameter in a Loop
+
+```python
+def egg_count(display_value):
+    eggs = 0
+    while display_value:
+        eggs += display_value % 2
+        display_value //= 2
+    return eggs
+```
+
+This approach uses a `while-loop` to count up all of the ones.
+In the loop, we increment `eggs` by `display_value % 2`.
+This adds the least significant bit (the rightmost digit in the binary representation) of `display_value` to `eggs`.
+
+Next, we divide `display_value` by `2`, discarding any remainder.
+This essentially removes the least significant bit of `display_value`, setting up `display_value` for processing the next bit.
+
+The loop repeats until `display_value` reaches `0` (which indicates that we have no more bits to check), and then we return `eggs`.
+
+
+## Variation #1: Using Boolean Operators
+
+```python
+def egg_count(display_value):
+    eggs = 0
+    while display_value > 0:
+        if display_value % 2 == 1:
+            eggs += 1
+        display_value //= 2
+    return eggs
+```
+
+This is essentially just a more verbose formulation of the previous version.
+Instead of relying on Python converting `int`s to `bool`s, this solution manually compares `display_value` to `0`.
+It also uses an `if` statement to check if `eggs` should be incremented by `1`, instead of directly using the result of `display_value % 2`.
+
+Even though this variant is more verbose, some may consider it to be more readable.
+
+
+## Variation #2: Using Bitwise Operators
+
+```python
+def egg_count(display_value):
+    eggs = 0
+    while display_value > 0:
+        eggs += display_value & 1
+        display_value >>= 1
+    return eggs
+```
+
+This variant replaces the modulo (`%`) and floor division (`//`) with [bitwise operators][bitwise-operators].
+`&` is the bitwise AND operator, which results in a number whose binary representation only has ones where _both_ of its arguments has ones.
+(All other bits are zeros.)
+
+For example, if we used the numbers `3` (`11` in binary) and `1` (`1` in binary), we get `1`:
+
+```python
+0b011 & 0b001
+#=> 0b001
+```
+
+This is because the only bit in both numbers that is `1` is least significant bit.
+This property lets us extract the least significant bit of `display_value` by using `display_value & 1`.
+
+For the next step, we use `>>`, the [right-shift operator][right-shift-operator].
+The expression `a >> b` shifts all of `a`'s bits to the right by `b` places, and returns the resulting number.
+
+For example, if we used the numbers `5` (`101` in binary) and `1`, we get `2` (`10` in binary):
+
+```python
+0b101 >> 1
+#=> 0b010
+```
+
+You can see how `& 1` and `>>= 1` perform the same function as the `% 2` and `//= 2` used in earier variants.
+
+
+[bitwise-operators]: https://www.w3schools.com/programming/prog_operators_bitwise.php
+[right-shift-operator]: https://www.geeksforgeeks.org/software-engineering/right-shift-operator-in-programming/

exercises/practice/eliuds-eggs/.approaches/parameter-modification/snippet.txt

@@ -0,0 +1,6 @@
+def egg_count(display_value):
+    eggs = 0
+    while display_value:
+        eggs += display_value % 2
+        display_value //= 2
+    return eggs