Data update

Task/Weird-numbers/EasyLang/weird-numbers.easy

@@ -0,0 +1,68 @@
+func[] divisors n .
+   divs[] &= 1
+   for i = 2 to sqrt n
+      if n mod i = 0
+         j = n / i
+         divs[] &= i
+         if i <> j
+            divs2[] &= j
+         .
+      .
+   .
+   for i = len divs2[] downto 1
+      divs[] &= divs2[i]
+   .
+   return divs[]
+.
+func sum divs[] .
+   for e in divs[]
+      s += e
+   .
+   return s
+.
+func semiperf n divs[] .
+   if len divs[] = 0
+      return 0
+   .
+   h = divs[$]
+   len divs[] -1
+   if n = h
+      return 1
+   .
+   if n > h
+      if semiperf (n - h) divs[] = 1
+         return 1
+      .
+   .
+   return semiperf n divs[]
+.
+proc sieve limit . wierd[] .
+   len wierd[] limit
+   for j = 1 to limit
+      if j mod 6 <> 0
+         wierd[j] = 1
+      .
+   .
+   for i = 2 step 2 to limit
+      if wierd[i] = 1
+         divs[] = divisors i
+         if i > sum divs[]
+            wierd[i] = 0
+         elif semiperf i divs[] = 1
+            for j = i step i to limit
+               wierd[j] = 0
+            .
+         .
+      .
+   .
+.
+sieve 20000 wierd[]
+i = 2
+repeat
+   if wierd[i] = 1
+      cnt += 1
+      write i & " "
+   .
+   until cnt = 25
+   i += 2
+.

Task/Weird-numbers/YAMLScript/weird-numbers.ys

@@ -0,0 +1,48 @@
+!yamlscript/v0
+
+defn main(max=16500):
+  weird =: sieve(max)
+  numbers =:
+    filter \(nth weird _): range(2 max 2)
+  say: |
+    The first $(numbers.#) weird numbers:
+    $(numbers:joins)
+
+defn sieve(limit):
+  weirds =: into([] repeat(limit true))
+  loop i 2, weirds weirds:
+    if i < limit:
+      recur (i + 2):
+        or _ weirds:
+          when weirds.$i:
+            divs =: divisors(i)
+            if abundant(i divs):
+              when semiperfect(i divs):
+                loop j i, weirds weirds:
+                  if j < limit:
+                    recur (j + i):
+                      weirds.assoc(j false)
+                    else: weirds
+              weirds: .assoc(i false)
+      else: weirds
+
+defn divisors(number):
+  divisors =:
+    mapcat _ range(1 sqrt(number)):
+      fn(n):
+        when 0 == (number % n):
+          V: n (number / n)
+  divisors: .distinct().sort(gt _):rest
+
+defn abundant(n divs):
+  sum(divs) > n
+
+defn semiperfect(n divs):
+  when divs.# > 0:
+    div *divs =: divs
+    if n < div:
+      semiperfect: n divs
+      or:
+        n ==: div
+        semiperfect: (n - div) divs
+        semiperfect: n divs