daily bitwise hehe

Author: Zanger67

.github/workflows/main.yml

@@ -1,4 +1,4 @@
-name: '[Updating markdown files]'
+name: "[Updating markdown files]"
 
 on:
     # Allows for munual runs of workflow
@@ -9,18 +9,18 @@ on:
         branches:
             - main
         paths:
-            - 'my-submissions/**'
+            - "my-submissions/**"
 
 permissions:
     contents: write
 
 jobs:
     build:
         runs-on: ubuntu-latest
-        
+
         steps:
             - name: Call and run markdown generator
               uses: Zanger67/WikiLeet@main
               with:
-                # Insert your LeetCode username here!
-                username: Zanger
+                  # Insert your LeetCode username here!
+                  username: Zanger

my-submissions/m2683 v1.py

@@ -0,0 +1,17 @@
+class Solution:
+    def doesValidArrayExist(self, derived: List[int]) -> bool:
+        orig_prev = 0
+
+        for i, v in enumerate(derived) :
+            orig_prev = v ^ orig_prev
+        
+        if orig_prev == 0 :
+            return True
+        
+        orig_prev = 1
+
+        for i, v in enumerate(derived) :
+            orig_prev = v ^ orig_prev
+        
+
+        return orig_prev == 1

my-submissions/m2683 v2.py

@@ -0,0 +1,3 @@
+class Solution:
+    def doesValidArrayExist(self, derived: List[int]) -> bool:
+        return not reduce(xor, derived)

my-submissions/m2683 v3.c

@@ -0,0 +1,9 @@
+bool doesValidArrayExist(int* derived, int derivedSize) {
+    bool out = true;
+    while (derivedSize > 0) {
+        out ^= *derived;
+        derivedSize -= 1;
+        derived += 1;
+    }
+    return out;
+}

my-submissions/m2683 v3.py

@@ -0,0 +1,3 @@
+class Solution:
+    def doesValidArrayExist(self, derived: List[int]) -> bool:
+        return not(derived.count(1) % 2)

my-submissions/m2683.md

@@ -0,0 +1,51 @@
+0 = 0
+1 = 1
+2 = either 0 or 1
+
+```
+orig[0]     orig[1]     orig[2]     orig[3]     .......
+   | \\_____   | \\_____   | \\_____   | \\_____   |
+   |       \\  |       \\  |       \\  |       \\  |
+der[0]       der[1]      der[2]      der[3]     .......
+
+
+der[i] = orig[i - 1] ^ orig[i]
+der[i] ^ orig[i - 1] = orig[i]
+
+orig[i] = der[i] ^ orig[i - 1]
+```
+
+Idea 1:
+I can see the possibility of there being multiple solutions
+or paths in a sense. The main issue at hand is that we don't
+know what the first index 0 value is in the original, thus
+we can't predict how it'll cascade. I think, right now, that
+the best option is to test both orig[0]=0 and orig[0] = 1
+SCRAPPED
+
+Idea 2:
+The derived list can be interpreted as a mutation list that
+accumulates the changes. We can see if the end result for index
+0 is equal to the starting index we assigned maybe.
+
+    Basically, use the derived as an accumulating XOR then see if it
+    matches the original assumed value we assigned it (0 or 1) and
+    check for both cases of 0 and 1.
+
+Version 2/3 Idea:
+
+```
+orig_prev = v ^ orig_prev for v in derived
+    ==>
+    final_orig_prev = starter ^ v for v in derived
+                    = derived[-1] ^ v for v in derived
+```
+
+Use accumulate()
+
+In the end it simplifies to just whether the xor of all derived
+values equals 0 or not, aka they all cancel each other out.
+This could also be calculated in just seeing if the number of
+ONES is odd.
+
+**_It's bitwise math._**