wave8c: 452/202 — envoy/cilium, graph-dbs, elixir/nim, k8s/maven + PDF

defects/nim/unit/NimSeqUtilsDeduplicateAlgorithm.java

@@ -0,0 +1,110 @@
+package unit;
+
+import java.util.*;
+
+/**
+ * NimSeqUtilsDeduplicateAlgorithm — CWE-407 test for nim-0001
+ *
+ * Models sequtils.deduplicate[T](s, isSorted=false):
+ *   slow: result.contains(itm) inside for-loop — O(N²)
+ *   fast: HashSet seen + result.add                — O(N)
+ *
+ * Test: slow does N*(N/2) avg contains checks; fast does N hash lookups.
+ */
+public class NimSeqUtilsDeduplicateAlgorithm {
+
+    // --- SLOW: O(N²) ---
+    // for itm in items(s):
+    //   if not result.contains(itm): result.add(itm)
+    static class SlowDeduplicate {
+        long containsChecks = 0;
+
+        List<Integer> deduplicate(List<Integer> s) {
+            List<Integer> result = new ArrayList<>();
+            for (int itm : s) {
+                // result.contains — linear scan
+                boolean found = false;
+                for (int r : result) {
+                    containsChecks++;
+                    if (r == itm) { found = true; break; }
+                }
+                if (!found) result.add(itm);
+            }
+            return result;
+        }
+    }
+
+    // --- FAST: O(N) ---
+    // var seen = initHashSet[T]()
+    // for itm in items(s):
+    //   if itm notin seen: seen.incl(itm); result.add(itm)
+    static class FastDeduplicate {
+        long hashOps = 0;
+
+        List<Integer> deduplicate(List<Integer> s) {
+            List<Integer> result = new ArrayList<>();
+            Set<Integer> seen = new HashSet<>();
+            for (int itm : s) {
+                hashOps++;
+                if (seen.add(itm)) result.add(itm);
+            }
+            return result;
+        }
+    }
+
+    // Build a sequence with ~50% duplicates, unsorted
+    static List<Integer> makeSeq(int n, long seed) {
+        Random rng = new Random(seed);
+        List<Integer> s = new ArrayList<>(n);
+        int range = n / 2; // 50% duplicates on average
+        for (int i = 0; i < n; i++) s.add(rng.nextInt(range));
+        return s;
+    }
+
+    public static void main(String[] args) {
+        int[] sizes = {100, 500, 1000, 2000};
+        System.out.println("NimSeqUtilsDeduplicateAlgorithm — nim-0001");
+        System.out.println("  Pattern: result.contains(itm) in for-loop — O(N²) vs HashSet — O(N)");
+        System.out.println();
+
+        int passed = 0;
+        int total = 0;
+
+        for (int n : sizes) {
+            List<Integer> s = makeSeq(n, 12345L + n);
+
+            SlowDeduplicate slow = new SlowDeduplicate();
+            FastDeduplicate fast = new FastDeduplicate();
+
+            List<Integer> slowResult = slow.deduplicate(new ArrayList<>(s));
+            List<Integer> fastResult = fast.deduplicate(new ArrayList<>(s));
+
+            // Both should produce the same unique elements in the same first-seen order
+            boolean same = slowResult.equals(fastResult);
+
+            // Slow: with 50% duplicates, result grows to ~N/2. Average scan of result = N/4 per element.
+            // Total ≈ N * N/4 = N²/4 checks.
+            long slowChecks = slow.containsChecks;
+            long fastOps = fast.hashOps;
+
+            boolean slowIsQuadratic = slowChecks >= (long) n * n / 8; // conservative threshold
+            boolean fastIsLinear = fastOps == n;
+
+            total += 3;
+            if (same) { System.out.println("PASS N=" + n + ": results match, unique=" + slowResult.size()); passed++; }
+            else { System.out.println("FAIL N=" + n + ": result mismatch, slow.size=" + slowResult.size() + " fast.size=" + fastResult.size()); }
+
+            if (slowIsQuadratic) { System.out.println("PASS N=" + n + ": slow O(N²) checks=" + slowChecks + " >= N²/8=" + (n * n / 8)); passed++; }
+            else { System.out.println("FAIL N=" + n + ": slow not quadratic, checks=" + slowChecks); }
+
+            if (fastIsLinear) { System.out.println("PASS N=" + n + ": fast O(N) ops=" + fastOps + " == N=" + n); passed++; }
+            else { System.out.println("FAIL N=" + n + ": fast not linear, ops=" + fastOps); }
+        }
+
+        System.out.println();
+        System.out.println(passed + "/" + total + " PASS");
+        if (passed != total) {
+            throw new AssertionError(passed + "/" + total + " tests passed");
+        }
+    }
+}