Data update

Task/100-doors/ABC/100-doors.abc

@@ -0,0 +1,26 @@
+HOW TO INITIALIZE:
+    SHARE doors
+    PUT {} IN doors
+    FOR door IN {1..100}:
+        PUT 0 IN doors[door]
+
+HOW TO TOGGLE door:
+    SHARE doors
+    PUT 1-doors[door] IN doors[door]
+
+HOW TO WALK step:
+    SHARE doors
+    PUT step IN door
+    WHILE door <= 100:
+        TOGGLE door
+        PUT door+step IN door
+
+HOW TO DISPLAY OPEN DOORS:
+    SHARE doors
+    FOR door IN {1..100}:
+        IF doors[door] = 1:
+            WRITE "Door", door, "is open"/
+
+INITIALIZE
+FOR pass IN {1..100}: WALK pass
+DISPLAY OPEN DOORS

Task/100-doors/Stringle/100-doors.stringle

@@ -0,0 +1,15 @@
+d "."
+#d
+i d
+#i
+p "door" #i
+*p *p "."
+i d f "oc"
+i d #@f #*p
+i d .\f "o" $ #i
+i i d
+#i +101 i ""
+#i
+d d "."
+#d +101 d ""
+#d

Task/100-prisoners/ABC/100-prisoners.abc

@@ -0,0 +1,40 @@
+HOW TO FILL drawers:
+    PUT {} IN drawers
+    FOR i IN {1..100}: PUT i IN drawers[i]
+    FOR i IN {1..100}:
+        PUT choice {i..100} IN j
+        PUT drawers[i], drawers[j] IN drawers[j], drawers[i]
+
+HOW TO REPORT prisoner random.strat drawers:
+    PUT {1..100} IN available
+    FOR turn IN {1..50}:
+        PUT choice available IN drawer
+        IF drawers[drawer] = prisoner: SUCCEED
+        REMOVE drawer FROM available
+    FAIL
+
+HOW TO REPORT prisoner optimal.strat drawers:
+    PUT prisoner IN drawer
+    FOR turn IN {1..50}:
+        IF drawers[drawer] = prisoner: SUCCEED
+        PUT drawers[drawer] IN drawer
+    FAIL
+
+HOW TO REPORT simulate strategy:
+    FILL drawers
+    FOR prisoner IN {1..100}:
+        SELECT:
+            strategy = "Random":
+                IF NOT prisoner random.strat drawers: FAIL
+            strategy = "Optimal":
+                IF NOT prisoner optimal.strat drawers: FAIL
+    SUCCEED
+
+HOW TO RETURN n.sim chance.of.success strategy:
+    PUT 0 IN success
+    FOR n IN {1..n.sim}:
+        IF simulate strategy: PUT success+1 IN success
+    RETURN success * 100 / n.sim
+
+FOR strategy IN {"Random"; "Optimal"}:
+    WRITE strategy, ": ", 10000 chance.of.success strategy, '%'/

Task/99-bottles-of-beer/ABC/99-bottles-of-beer.abc

@@ -0,0 +1,19 @@
+HOW TO RETURN bottles n:
+    SELECT:
+        n<0: RETURN "99 bottles"
+        n=0: RETURN "No more bottles"
+        n=1: RETURN "1 bottle"
+        n>1: RETURN "`n` bottles"
+
+HOW TO SING VERSE n:
+    WRITE "`bottles n` of beer on the wall,"/
+    WRITE "`bottles n` of beer,"/
+    SELECT:
+        n=0: WRITE "Go to the store and buy some more,"/
+        n=1: WRITE "Take it down and pass it around,"/
+        n>1: WRITE "Take one down and pass it around,"/
+    WRITE "`bottles (n-1)` of beer on the wall."/
+    WRITE /
+
+FOR n IN {0..99}:
+    SING VERSE 99-n

Task/ABC-problem/ABC/abc-problem.abc

@@ -0,0 +1,17 @@
+HOW TO REPORT word can.be.made.with blocks:
+    FOR letter IN upper word:
+        IF NO block IN blocks HAS letter in block: FAIL
+        REMOVE block FROM blocks
+    SUCCEED
+
+PUT {"BO";"XK";"DQ";"CP";"NA";"GT";"RE";"TG";"QD";"FS"} IN blocks
+PUT {"JW";"HU";"VI";"AN";"OB";"ER";"FS";"LY";"PC";"ZM"} IN blocks2
+FOR block IN blocks2: INSERT block IN blocks
+
+PUT {"A";"BARK";"BOOK";"treat";"common";"Squad";"CoNfUsE"} IN words
+
+FOR word IN words:
+    WRITE word, ": "
+    SELECT:
+        word can.be.made.with blocks: WRITE "yes"/
+        ELSE: WRITE "no"/

Task/Abundant-deficient-and-perfect-number-classifications/ABC/abundant-deficient-and-perfect-number-classifications.abc

@@ -0,0 +1,28 @@
+PUT 0 IN deficient
+PUT 0 IN perfect
+PUT 0 IN abundant
+
+HOW TO FIND PROPER DIVISOR SUMS UP TO limit:
+    SHARE p
+    PUT {} IN p
+    FOR i IN {0..limit}: PUT 0 IN p[i]
+    FOR i IN {1..floor (limit/2)}:
+        PUT i+i IN j
+        WHILE j <= limit:
+            PUT p[j]+i IN p[j]
+            PUT j+i IN j
+
+HOW TO CLASSIFY n:
+    SHARE deficient, perfect, abundant, p
+    SELECT:
+        p[n] < n: PUT deficient+1 IN deficient
+        p[n] = n: PUT perfect+1 IN perfect
+        p[n] > n: PUT abundant+1 IN abundant
+
+PUT 20000 IN limit
+FIND PROPER DIVISOR SUMS UP TO limit
+FOR n IN {1..limit}: CLASSIFY n
+
+WRITE deficient, "deficient"/
+WRITE perfect, "perfect"/
+WRITE abundant, "abundant"/

Task/Ackermann-function/ABC/ackermann-function.abc

@@ -0,0 +1,10 @@
+HOW TO RETURN m ack n:
+    SELECT:
+        m=0: RETURN n+1
+        m>0 AND n=0: RETURN (m-1) ack 1
+        m>0 AND n>0: RETURN (m-1) ack (m ack (n-1))
+
+FOR m IN {0..3}:
+    FOR n IN {0..8}:
+        WRITE (m ack n)>>6
+    WRITE /

Task/Additive-primes/ABC/additive-primes.abc

@@ -0,0 +1,20 @@
+HOW TO REPORT prime n:
+    REPORT n>=2 AND NO d IN {2..floor root n} HAS n mod d = 0
+
+HOW TO RETURN digit.sum n:
+    SELECT:
+        n<10: RETURN n
+        ELSE: RETURN (n mod 10) + digit.sum floor (n/10)
+
+HOW TO REPORT additive.prime n:
+    REPORT prime n AND prime digit.sum n
+
+PUT 0 IN n
+FOR i IN {1..499}:
+    IF additive.prime i:
+        WRITE i>>4
+        PUT n+1 IN n
+        IF n mod 10 = 0: WRITE /
+
+WRITE /
+WRITE "There are `n` additive primes less than 500."/

Task/Almost-prime/Onyx-(wasm)/almost-prime-1.onyx

@@ -0,0 +1,29 @@
+package main
+use core {printf}
+main :: () -> void {
+    printf("\n");
+    for k in 1..6 {
+        printf("k = {}:", k);
+        i := 2;
+        c: i32;
+        while c < 10 {
+            if kprime(i, k) {
+                printf(" {}", i);
+                c += 1;
+            }
+            i += 1;
+        }
+        printf("\n");
+    }
+}
+kprime :: (n: i32, k: i32) -> bool {
+    f: i32;
+    while p := 2; f < k && p * p <= n {
+        while n % p == 0 {
+            n /= p;
+            f += 1;
+        }
+        p += 1;
+    }
+    return f + (1 if n > 1 else 0) == k;
+}

Task/Almost-prime/Onyx-(wasm)/almost-prime-2.onyx

@@ -0,0 +1,37 @@
+//+optional-semicolons
+use core {printf}
+use core.iter
+
+main :: () {
+    generator :=
+        iter.counter(1)
+        |> iter.map(k => .{
+            k = k, kprimes = kprime_iter(k)->take(10)
+        })
+        |> iter.take(5)
+
+    for val in generator {
+        printf("k = {}:", val.k)
+        for p in val.kprimes do printf(" {}", p)
+        printf("\n")
+    }
+}
+
+kprime_iter :: k =>
+       iter.counter(2)
+    |> iter.filter((i, [k]) => kprime(i, k))
+
+kprime :: (n, k) => {
+    f := 0
+    for p in iter.counter(2) {
+        if f >= k    do break
+        if p * p > n do break
+
+        while n % p == 0 {
+            n /= p
+            f += 1
+        }
+    }
+
+    return f + (1 if n > 1 else 0) == k
+}

Task/Amicable-pairs/ABC/amicable-pairs.abc

@@ -0,0 +1,17 @@
+HOW TO RETURN proper.divisor.sum.table n:
+    PUT {} IN propdivs
+    FOR i IN {1..n}: PUT 1 IN propdivs[i]
+    FOR i IN {2..floor (n/2)}:
+        PUT i+i IN j
+        WHILE j<=n:
+            PUT propdivs[j] + i IN propdivs[j]
+            PUT i + j IN j
+    RETURN propdivs
+
+PUT 20000 IN maximum
+PUT proper.divisor.sum.table maximum IN propdivs
+
+FOR cand IN {1..maximum}:
+    PUT propdivs[cand] IN other
+    IF cand<other<maximum AND propdivs[other]=cand:
+        WRITE cand, other/

Task/Array-length/FurryScript/array-length.furryscript

@@ -0,0 +1,5 @@
+THE_LIST( <apple> <orange> )
+COUNT[ 0 SW ~| COUNT_STEP# 0 SW SU ]
+COUNT_STEP[ DR 1 SU ]
+
+`THE_LIST COUNT# +<>

Task/Attractive-numbers/ABC/attractive-numbers.abc

@@ -0,0 +1,21 @@
+HOW TO RETURN factors n:
+    PUT {} IN factors
+    PUT 2 IN factor
+    WHILE n >= factor:
+        SELECT:
+            n mod factor = 0:
+                INSERT factor IN factors
+                PUT n/factor IN n
+            ELSE:
+                PUT factor+1 IN factor
+    RETURN factors
+
+HOW TO REPORT attractive n:
+    REPORT 1 = #factors #factors n
+
+PUT 0 IN col
+FOR i IN {1..120}:
+    IF attractive i:
+        WRITE i>>5
+        PUT col+1 IN col
+        IF col mod 10=0: WRITE /

Task/Benfords-law/ABC/benfords-law.abc

@@ -0,0 +1,25 @@
+HOW TO RETURN fibonacci.numbers n:
+    PUT 1, 1 IN a, b
+    PUT {} IN fibo
+    FOR i IN {1..n}:
+        INSERT a IN fibo
+        PUT b, a+b IN a, b
+    RETURN fibo
+
+HOW TO RETURN digit.distribution nums:
+    PUT {} IN digits
+    FOR i IN {1..9}: PUT i IN digits["`i`"]
+    PUT {} IN dist
+    FOR i IN {1..9}: PUT 0 IN dist[i]
+    FOR n IN nums:
+        PUT digits["`n`"|1] IN digit
+        PUT dist[digit] + 1 IN dist[digit]
+    FOR i IN {1..9}:
+        PUT dist[i] / #nums IN dist[i]
+    RETURN dist
+
+PUT digit.distribution fibonacci.numbers 1000 IN observations
+
+WRITE "Digit"<<6, "Expected">>10, "Observed">>10/
+FOR d IN {1..9}:
+    WRITE d<<6, ((10 log (1 + 1/d))>>10)|10, observations[d]>>10/

Task/Bulls-and-cows/ABC/bulls-and-cows.abc

@@ -0,0 +1,62 @@
+HOW TO RETURN random.digit:
+    RETURN choice "123456789"
+
+HOW TO MAKE SECRET secret:
+    PUT "" IN secret
+    FOR i IN {1..4}:
+        PUT random.digit IN digit
+        WHILE SOME j IN {1..i-1} HAS secret item j = digit:
+            PUT random.digit IN digit
+        PUT secret^digit IN secret
+
+HOW TO RETURN guess count.bulls secret:
+    PUT 0 IN bulls
+    FOR i IN {1..4}:
+        IF secret item i = guess item i: PUT bulls+1 IN bulls
+    RETURN bulls
+
+HOW TO RETURN guess count.cows secret:
+    PUT -(guess count.bulls secret) IN cows
+    FOR c IN guess:
+        IF c in secret: PUT cows+1 IN cows
+    RETURN cows
+
+HOW TO REPORT has.duplicates guess:
+    FOR i IN {1..3}:
+        FOR j IN {i+1..4}:
+            IF guess item i = guess item j: SUCCEED
+    FAIL
+
+HOW TO REPORT is.valid guess:
+    IF SOME digit IN guess HAS digit not.in "123456789":
+        WRITE "Invalid digit: ", digit/
+        FAIL
+    IF #guess <> 4:
+        WRITE "Guess must contain 4 digits."/
+        FAIL
+    IF has.duplicates guess:
+        WRITE "No duplicates allowed"/
+        FAIL
+    SUCCEED
+
+HOW TO READ GUESS guess:
+    WHILE 1=1:
+        WRITE "Guess? "
+        READ guess RAW
+        IF is.valid guess: QUIT
+
+HOW TO PLAY BULLS AND COWS:
+    PUT 0, 0, 0 IN tries, bulls, cows
+    MAKE SECRET secret
+    WRITE "Bulls and cows"/
+    WRITE "--------------"/
+    WRITE /
+    WHILE bulls<>4:
+        READ GUESS guess
+        PUT guess count.bulls secret IN bulls
+        PUT guess count.cows secret IN cows
+        WRITE "Bulls:",bulls,"- Cows:",cows/
+        PUT tries+1 IN tries
+    WRITE "You win! Tries:", tries
+
+PLAY BULLS AND COWS

Task/Casting-out-nines/ABC/casting-out-nines.abc

@@ -0,0 +1,12 @@
+\ casting out nines - based on the Action! sample
+
+HOW TO ADD v TO n: PUT n + v IN n
+
+PUT 10, 2, 0, 0 IN base, n, count, total
+FOR i IN { 1 .. base ** n }:
+    ADD 1 TO total
+    IF i mod ( base - 1 ) = ( i * i ) mod ( base - 1 ):
+        ADD 1 TO count
+        WRITE i
+WRITE // "Trying", count, "numbers instead of", total, "numbers saves"
+WRITE 100 - ( ( 100 * count ) / total ), "%" /

Task/Colour-bars-Display/TI-BASIC/colour-bars-display.basic

@@ -0,0 +1,43 @@
+100 REM  SMPTE Format Color Bars
+110 REM  with 400 Hz reference tone
+120 CALL CLEAR
+130 CALL SCREEN(2)
+140 CALL COLOR(8,15,1)
+150 CALL COLOR(9,11,1)
+160 CALL COLOR(10,8,1)
+170 CALL COLOR(11,13,1)
+180 CALL COLOR(12,14,1)
+190 CALL COLOR(13,10,1)
+200 CALL COLOR(14,5,1)
+210 CALL COLOR(15,2,1)
+220 CALL COLOR(16,16,1)
+230 GOSUB 510
+240 REM  color bars
+250 CALL VCHAR(1,3,88,96)
+260 CALL VCHAR(1,7,96,96)
+270 CALL VCHAR(1,11,104,96)
+280 CALL VCHAR(1,15,112,96)
+290 CALL VCHAR(1,19,120,96)
+300 CALL VCHAR(1,23,128,96)
+310 CALL VCHAR(1,27,136,96)
+320 REM  BLACK BAR
+330 CALL HCHAR(19,1,144,224)
+340 REM  WHITE BOX
+350 FOR I=19 TO 24
+360 CALL HCHAR(I,8,152,6)
+370 NEXT I
+410 REM  SMPTE Complementary boxes
+420 CALL HCHAR(18,3,136,4)
+430 CALL HCHAR(18,7,144,4)
+440 CALL HCHAR(18,11,120,4)
+450 CALL HCHAR(18,15,144,4)
+460 CALL HCHAR(18,19,104,4)
+470 CALL HCHAR(18,23,144,4)
+480 CALL HCHAR(18,27,88,4)
+490 CALL SOUND(3000,400,12)
+500 GOTO 490
+510 SQUARE$="FFFFFFFFFFFFFFFF"
+520 FOR I = 88 TO 152 STEP 8
+530 CALL CHAR(I,SQUARE$)
+540 NEXT I
+590 RETURN

Task/Comma-quibbling/ABC/comma-quibbling.abc

@@ -0,0 +1,17 @@
+HOW TO RETURN quibble words:
+    PUT "" IN result
+    PUT #words IN remaining
+    FOR word IN words:
+        PUT result^word IN result
+        PUT remaining-1 IN remaining
+        IF remaining = 1: PUT result^" and " IN result
+        IF remaining > 1: PUT result^", " IN result
+    RETURN "{" ^ result ^ "}"
+
+PUT {} IN tests
+INSERT {} IN tests
+INSERT {[1]: "ABC"} IN tests
+INSERT {[1]: "ABC"; [2]: "DEF"} IN tests
+INSERT {[1]: "ABC"; [2]: "DEF"; [3]: "G"; [4]: "H"} IN tests
+FOR test IN tests:
+    WRITE quibble test/

Task/Department-numbers/ABC/department-numbers.abc

@@ -0,0 +1,11 @@
+PUT  7 IN max.department.number
+PUT 12 IN department.sum
+WRITE "police sanitation fire" /
+PUT 2 IN police
+WHILE police <= max.department.number:
+    FOR sanitation IN { 1 .. max.department.number }:
+        IF sanitation <> police:
+            PUT ( department.sum - police ) - sanitation IN fire
+            IF fire > 0 AND fire <= max.department.number AND fire <> sanitation AND fire <> police:
+                WRITE police>>6, sanitation>>11, fire>>5 /
+    PUT police + 2 IN police

Task/Evolutionary-algorithm/ABC/evolutionary-algorithm.abc

@@ -0,0 +1,39 @@
+PUT "ABCDEFGHIJKLMNOPQRSTUVWXYZ " IN alphabet
+
+HOW TO RETURN initial.state target:
+    SHARE alphabet
+    PUT "" IN state
+    FOR c IN target: PUT state^choice alphabet IN state
+    RETURN state
+
+HOW TO RETURN state fitness target:
+    PUT #target IN score
+    FOR i IN {1..#target}:
+        IF state item i = target item i: PUT score-1 IN score
+    RETURN score
+
+HOW TO RETURN chance mutate state:
+    SHARE alphabet
+    PUT "" IN mutated
+    FOR i IN {1..#state}:
+        SELECT:
+            random < chance: PUT choice alphabet IN next
+            ELSE: PUT state item i IN next
+        PUT mutated^next IN mutated
+    RETURN mutated
+
+HOW TO EVOLVE TOWARD target:
+    PUT 0.1 IN mutation.rate
+    PUT 100 IN generation.size
+    PUT initial.state target IN state
+    WHILE state fitness target > 0:
+        WRITE (state fitness target)>>2, ": ", state/
+        PUT {} IN next.generation
+        FOR i IN {1..generation.size}:
+            PUT mutation.rate mutate state IN child
+            PUT child fitness target IN score
+            PUT child IN next.generation[score]
+        PUT next.generation[min keys next.generation] IN state
+    WRITE (state fitness target)>>2, ": ", state/
+
+EVOLVE TOWARD "METHINKS IT IS LIKE A WEASEL"

Task/Fibonacci-sequence/Onyx-(wasm)/fibonacci-sequence.onyx

@@ -0,0 +1,64 @@
+use core.iter
+use core { printf }
+
+// Procedural Simple For-Loop Style
+fib_for_loop :: (n: i32) -> i32 {
+    a: i32 = 0;
+    b: i32 = 1;
+    for 0 .. n {
+        tmp := a;
+        a = b;
+        b = tmp + b;
+    }
+    return a;
+}
+
+FibState :: struct { a, b: u64 }
+
+// Functional Folding Style
+fib_by_fold :: (n: i32) => {
+    end_state :=
+        iter.counter()
+        |> iter.take(n)
+        |> iter.fold(
+            FibState.{ a = 0, b = 1 },
+            (_, state) => FibState.{
+                a = state.b,
+                b = state.a + state.b
+            }
+        );
+    return end_state.a;
+}
+
+// Custom Iterator Style
+fib_iterator :: (n: i32) =>
+    iter.generator(
+        &.{ a = cast(u64) 0, b = cast(u64) 1, counter = n },
+        (state: & $Ctx) -> (u64, bool) {
+            if state.counter <= 0 {
+                return 0, false;
+            }
+            tmp := state.a;
+            state.a = state.b;
+            state.b = state.b + tmp;
+            state.counter -= 1;
+            return tmp, true;
+        }
+    );
+
+main :: () {
+    printf("\nBy For Loop:\n");
+    for i in 0 .. 21 {
+        printf("{} ", fib_for_loop(i));
+    }
+
+    printf("\n\nBy Iterator:\n");
+    for i in 0 .. 21 {
+        printf("{} ", fib_by_fold(i));
+    }
+
+    printf("\n\nBy Fold:\n");
+    for value, index in fib_iterator(21) {
+        printf("{} ", value);
+    }
+}

Task/FizzBuzz/ABC/fizzbuzz.abc

@@ -0,0 +1,12 @@
+HOW TO RETURN fizzbuzz num:
+    PUT "" IN result
+    PUT {[3]: "Fizz"; [5]: "Buzz"} IN divwords
+    FOR div IN keys divwords:
+        IF num mod div=0:
+            PUT result^divwords[div] IN result
+    IF result="":
+        PUT num>>0 IN result
+    RETURN result
+
+FOR i IN {1..100}:
+    WRITE fizzbuzz i/

Task/FizzBuzz/Gleam/fizzbuzz.gleam

@@ -0,0 +1,19 @@
+import gleam/int
+import gleam/io
+import gleam/iterator
+
+pub fn main() {
+  iterator.range(1, 101)
+  |> iterator.map(to_fizzbuzz)
+  |> iterator.map(io.println)
+  |> iterator.run
+}
+
+fn to_fizzbuzz(n: Int) -> String {
+  case n % 3, n % 5 {
+    0, 0 -> "FizzBuzz"
+    0, _ -> "Fizz"
+    _, 0 -> "Buzz"
+    _, _ -> int.to_string(n)
+  }
+}

Task/FizzBuzz/Onyx-(wasm)/fizzbuzz.onyx

@@ -0,0 +1,16 @@
+use core { * }
+
+fizzbuzz :: (len: u32) -> void {
+    for i in 1..len+1 {
+        msg : str;
+        if (i%3 == 0 && i%5 == 0) { msg = "FizzBuzz !!!"; }
+        elseif (i%3 == 0) { msg = "Fizz"; }
+        elseif (i%5 == 0) { msg = "Buzz"; }
+        else { msg = tprintf("{}", i); }
+        printf("{}\n", msg);
+    }
+}
+
+main :: () {
+    fizzbuzz(100);
+}

Task/Floyds-triangle/ABC/floyds-triangle.abc

@@ -0,0 +1,18 @@
+HOW TO RETURN width n:
+    SELECT:
+        n<10: RETURN 1
+        ELSE: RETURN 1 + width floor (n/10)
+
+HOW TO DISPLAY A FLOYD TRIANGLE WITH lines LINES:
+    PUT lines * (lines+1)/2 IN maxno
+    PUT 1 IN n
+    FOR line IN {1..lines}:
+        FOR col IN {1..line}:
+            WRITE n >> (1 + width (maxno - lines + col))
+            PUT n+1 IN n
+        WRITE /
+
+DISPLAY A FLOYD TRIANGLE WITH 5 LINES
+WRITE /
+DISPLAY A FLOYD TRIANGLE WITH 14 LINES
+WRITE /

Task/Giuga-numbers/ABC/giuga-numbers.abc

@@ -0,0 +1,21 @@
+HOW TO REPORT is.giuga n:
+    \ each prime factor must appear only once, e.g.: for 2:
+    \ [ ( n / 2 ) - 1 ] mod 2 = 0  => n / 2 is odd => n isn't divisible by 4
+    \ similarly for other primes
+    PUT  1, 3, 1, floor( n / 2 ) IN f.count, f, giuga, v
+    WHILE f <= v AND giuga = 1:
+        IF v mod f = 0:
+            PUT f.count + 1 IN f.count
+            IF ( ( floor( n / f ) ) - 1 ) mod f <> 0: PUT 0 IN giuga
+            PUT floor( v / f ) IN v
+        PUT f + 2 IN f
+    IF giuga = 1:             \ n is still a candidate, check it is not prime
+        IF f.count = 1: FAIL       \ only 1 factor - it is prime so not giuga
+    REPORT giuga = 1
+
+PUT 0, -2 IN g.count, n
+WHILE g.count < 4:
+    PUT n + 4 IN n                          \ assume the numbers are all even
+    IF is.giuga n:
+        PUT g.count + 1 IN g.count
+        WRITE n

Task/Golden-ratio-Convergence/Onyx-(wasm)/golden-ratio-convergence.onyx

@@ -0,0 +1,26 @@
+package main
+use core {*}
+use core.math{abs}
+use core.intrinsics.wasm{sqrt_f64}
+main :: () {
+	iterate();
+}
+iterate :: () {
+	count := 0;
+	phi0: f64 = 1.0;
+	difference: f64 = 1.0;
+	phi1: f64;
+	println("\nGolden ratio/Convergence");
+	println("-----------------------------------------");
+	while 0.00001 < difference {
+		phi1 = 1.0 + (1.0 / phi0);
+		difference = abs(phi1 - phi0);
+		phi0 = phi1;
+		count += 1;
+		printf("Iteration {} : Estimate : {.8}\n", count, phi1);
+	}
+	println("-----------------------------------------");
+	printf("Result: {} after {} iterations", phi1, count);
+	printf("\nThe error is approximately {.8}\n", (phi1 - (0.5 * (1.0 + sqrt_f64(5.0)))));
+    println("\n");
+}

Task/Hailstone-sequence/ABC/hailstone-sequence.abc

@@ -0,0 +1,22 @@
+HOW TO RETURN hailstone n:
+    PUT {} IN seq
+    WHILE 1=1:
+        PUT n IN seq[#seq]
+        SELECT:
+            n=1: RETURN seq
+            n mod 2=0: PUT floor(n/2) IN n
+            n mod 2=1: PUT 3*n+1 IN n
+    RETURN seq
+
+PUT hailstone 27 IN h27
+WRITE "Length of Hailstone sequence for 27:", #h27/
+WRITE "First 4 elements:", h27[0], h27[1], h27[2], h27[3]/
+WRITE "Last 4 elements:", h27[#h27-4], h27[#h27-3], h27[#h27-2], h27[#h27-1]/
+
+PUT 0, 0 IN longest, length
+FOR n IN {1..100000}:
+    PUT hailstone n IN hn
+    IF #hn > length:
+        PUT n, #hn IN longest, length
+
+WRITE longest, "has the longest hailstone sequence < 100,000, of length:", length/

Task/Hailstone-sequence/Onyx-(wasm)/hailstone-sequence.onyx

@@ -0,0 +1,61 @@
+use core { * }
+
+hailstone :: (n: u32) -> [..]u32 {
+    seq: [..]u32;
+    array.push(&seq, n);
+    while n > 1 {
+        n = n/2 if n%2 == 0 else (n*3)+1;
+        array.push(&seq, n);
+    }
+    return seq;
+}
+
+Longest :: struct { num, len : u32; }
+
+main :: () {
+
+    // -------
+    // task 1:
+    // -------
+    // "Create a routine to generate the hailstone
+    // sequence for a number."
+
+    i := 27;
+    seq := hailstone(i);
+    printf("Task 1:\n{}: {}\n\n",
+        i,
+        seq
+    );
+
+    // -------
+    // task 2:
+    // -------
+    // "Use the routine to show that the hailstone
+    // sequence for the number 27 has
+    // 112 elements starting with
+    // 27, 82, 41, 124 and ending with 8, 4, 2, 1"
+
+    slice_size := 4;
+    len := seq.length;
+    slice_first := seq[0..slice_size];
+    slice_last := seq[seq.length-slice_size..seq.length];
+    printf("Task 2:\nlength: {}, first: {}, last: {}\n\n",
+        len,
+        slice_first,
+        slice_last
+    );
+
+    // -------
+    // task 3:
+    // -------
+    // "Show the number less than 100,000
+    // which has the longest hailstone sequence
+    // together with that sequences length."
+
+    l : Longest;
+    for i in 1..100000 {
+        seq := hailstone(i);
+        if l.len < seq.length { l = .{num = i, len = seq.length}; }
+    }
+    printf("Task 3:\nLongest Num: {}, Sequence Length: {}\n", l.num, l.len);
+}

Task/Happy-numbers/ABC/happy-numbers.abc

@@ -0,0 +1,24 @@
+HOW TO RETURN square.digit.sum n:
+    PUT 0 IN sum
+    WHILE n>0:
+        PUT n mod 10 IN digit
+        PUT sum + digit ** 2 IN sum
+        PUT floor (n/10) IN n
+    RETURN sum
+
+HOW TO REPORT happy n:
+    PUT {} IN seen
+    WHILE n not.in seen:
+        INSERT n IN seen
+        PUT square.digit.sum n IN n
+    REPORT n=1
+
+HOW TO RETURN next.happy n:
+    PUT n+1 IN n
+    WHILE NOT happy n: PUT n+1 IN n
+    RETURN n
+
+PUT 0 IN n
+FOR i IN {1..8}:
+    PUT next.happy n IN n
+    WRITE n/

Task/Harshad-or-Niven-series/ABC/harshad-or-niven-series.abc

@@ -0,0 +1,22 @@
+HOW TO RETURN digit.sum n:
+    PUT 0 IN sum
+    WHILE n>0:
+        PUT sum + (n mod 10) IN sum
+        PUT floor (n/10) IN n
+    RETURN sum
+
+HOW TO REPORT harshad n:
+    REPORT n mod digit.sum n = 0
+
+HOW TO RETURN next.harshad n:
+    PUT n+1 IN n
+    WHILE NOT harshad n: PUT n+1 IN n
+    RETURN n
+
+PUT 0 IN n
+WRITE "First 20 Harshad numbers:"
+FOR i IN {1..20}:
+    PUT next.harshad n IN n
+    WRITE n
+WRITE /
+WRITE "First Harshad number > 1000:", next.harshad 1000/

Task/Hello-world-Graphical/AutoHotKey-V2/hello-world-graphical.ahk

@@ -0,0 +1 @@
+MsgBox("Goodbye, World!")

Task/Hello-world-Text/DreamBerd/hello-world-text.dreamberd

@@ -0,0 +1 @@
+print "Hello world!"!

Task/Hello-world-Text/Gleam/hello-world-text.gleam

@@ -0,0 +1,5 @@
+import gleam/io
+
+pub fn main() {
+    io.println("Hello world!")
+}

Task/Hello-world-Text/Onyx-(wasm)/hello-world-text.onyx

@@ -0,0 +1,4 @@
+use core {printf}
+main :: () {
+    printf("Hello world!");
+}

Task/Hofstadter-Figure-Figure-sequences/ABC/hofstadter-figure-figure-sequences.abc

@@ -0,0 +1,35 @@
+PUT {[1]: 1} IN r.list
+PUT {[1]: 2} IN s.list
+
+HOW TO EXTEND R TO n:
+    SHARE r.list, s.list
+    WHILE n > #r.list:
+        PUT r.list[#r.list] + s.list[#r.list] IN next.r
+        FOR i IN {s.list[#s.list]+1 .. next.r-1}:
+            PUT i IN s.list[#s.list+1]
+        PUT next.r IN r.list[#r.list+1]
+        PUT next.r + 1 IN s.list[#s.list+1]
+
+HOW TO EXTEND S TO n:
+    SHARE r.list, s.list
+    WHILE n > #s.list: EXTEND R TO #r.list + 1
+
+HOW TO RETURN ffr n:
+    SHARE r.list
+    IF n > #r.list: EXTEND R TO n
+    RETURN r.list[n]
+
+HOW TO RETURN ffs n:
+    SHARE s.list
+    IF n > #s.list: EXTEND S TO n
+    RETURN s.list[n]
+
+WRITE "R[1..10]:"
+FOR i IN {1..10}: WRITE ffr i
+WRITE /
+
+PUT {} IN thousand
+FOR i IN {1..40}: INSERT ffr i IN thousand
+FOR i IN {1..960}: INSERT ffs i IN thousand
+IF thousand = {1..1000}:
+    WRITE "R[1..40] + S[1..960] = [1..1000]"/

Task/ISBN13-check-digit/ABC/isbn13-check-digit.abc

@@ -0,0 +1,21 @@
+HOW TO REPORT valid.isbn13 str:
+    PUT {} IN digits
+    FOR d IN {0..9}: PUT d IN digits["`d`"]
+    IF #str <> 14 OR str item 4 <> '-': FAIL
+    PUT 1, 0 IN mul, sum
+    FOR c IN str|3 ^ str@5:
+        IF c not.in keys digits: FAIL
+        PUT sum + digits[c] * mul IN sum
+        PUT 4 - mul IN mul
+    REPORT sum mod 10 = 0
+
+PUT {} IN tests
+PUT "978-0596528126" IN tests[1]
+PUT "978-0596528120" IN tests[2]
+PUT "978-1788399081" IN tests[3]
+PUT "978-1788399083" IN tests[4]
+
+FOR test IN tests:
+    SELECT:
+        valid.isbn13 test: WRITE test^": good"/
+        ELSE: WRITE test^": bad"/

Task/Jewels-and-stones/ABC/jewels-and-stones.abc

@@ -0,0 +1,8 @@
+HOW TO RETURN stones count.in jewels:
+    PUT 0 IN count
+    FOR stone IN stones:
+        IF stone in jewels: PUT count+1 IN count
+    RETURN count
+
+WRITE "aAAbbbb" count.in "aA"/
+WRITE "ZZ" count.in "z"/

Task/Lah-numbers/ABC/lah-numbers.abc

@@ -0,0 +1,30 @@
+HOW TO RETURN fac n:
+    PUT 1 IN result
+    FOR i IN {1..n}: PUT result*i IN result
+    RETURN result
+
+HOW TO RETURN n lah k:
+    SELECT:
+        n=k: RETURN 1
+        n=0 OR k=0: RETURN 0
+        k=1: RETURN fac n
+        ELSE: RETURN (((fac n)*fac(n-1)) / ((fac k)*fac(k-1)) )/ fac(n-k)
+
+HOW TO SHOW LAH TABLE UP TO N nmax:
+    FOR n IN {0..nmax}:
+        FOR k IN {0..n}:
+            WRITE (n lah k)>>11
+        WRITE /
+
+HOW TO RETURN max.lah.number n:
+    PUT 0 IN max
+    FOR k IN {0..n}:
+        PUT n lah k IN cur
+        IF cur>max: PUT cur IN max
+    RETURN max
+
+
+SHOW LAH TABLE UP TO N 12
+WRITE /
+WRITE "Maximum value where n=100:"/
+WRITE max.lah.number 100/

Task/McNuggets-problem/ABC/mcnuggets-problem.abc

@@ -0,0 +1,15 @@
+PUT {1..100} IN non.nuggets
+
+PUT 0 IN a
+WHILE a <= 100:
+    PUT a IN b
+    WHILE b <= 100:
+        PUT b IN c
+        WHILE c <= 100:
+            IF c in non.nuggets:
+                REMOVE c FROM non.nuggets
+            PUT c+20 IN c
+        PUT b+9 IN b
+    PUT a+6 IN a
+
+WRITE "Maximum non-McNuggets number:", max non.nuggets/

Task/Minimum-multiple-of-m-where-digital-sum-equals-m/ABC/minimum-multiple-of-m-where-digital-sum-equals-m.abc

@@ -0,0 +1,15 @@
+HOW TO RETURN digit.sum n:
+    PUT 0 IN sum
+    WHILE n>0:
+        PUT sum + (n mod 10) IN sum
+        PUT floor (n/10) IN n
+    RETURN sum
+
+HOW TO RETURN a131382 n:
+    PUT 1 IN m
+    WHILE n <> digit.sum (m*n): PUT m+1 IN m
+    RETURN m
+
+FOR n IN {1..70}:
+    WRITE (a131382 n)>>9
+    IF n mod 10=0: WRITE /

Task/Munchausen-numbers/ABC/munchausen-numbers.abc

@@ -0,0 +1,11 @@
+HOW TO REPORT munchausen n:
+    PUT 0 IN sum
+    PUT n IN m
+    WHILE m > 0:
+        PUT m mod 10 IN digit
+        PUT sum + digit**digit IN sum
+        PUT floor(m/10) IN m
+    REPORT sum = n
+
+FOR n IN {1..5000}:
+    IF munchausen n: WRITE n/

Task/Mutual-recursion/ABC/mutual-recursion.abc

@@ -0,0 +1,15 @@
+HOW TO RETURN f n:
+    IF n=0: RETURN 1
+    RETURN n - m f (n-1)
+
+HOW TO RETURN m n:
+    IF n=0: RETURN 0
+    RETURN n - f m (n-1)
+
+WRITE "F:"
+FOR n IN {0..15}: WRITE f n
+WRITE /
+
+WRITE "M:"
+FOR n IN {0..15}: WRITE m n
+WRITE /

Task/Nth/Stringle/nth.stringle

@@ -0,0 +1,11 @@
+#i
+s "th"
+.\#i "1" .:\#i !"1" s "st"
+.\#i "2" .:\#i !"1" s "nd"
+.\#i "3" .:\#i !"1" s "rd"
+$ #i s
+i i "."
+#i +26 26 +#i #@i 250
+#i +266 266 +#i #@i 1000
+#i +1026 i ""
+#i

Task/Primality-by-trial-division/ABC/primality-by-trial-division.abc

@@ -0,0 +1,5 @@
+HOW TO REPORT prime n:
+    REPORT n>=2 AND NO d IN {2..floor root n} HAS n mod d = 0
+
+FOR n IN {1..100}:
+    IF prime n: WRITE n

Task/Rep-string/ABC/rep-string.abc

@@ -0,0 +1,24 @@
+HOW TO RETURN repstrings str:
+    PUT {} IN reps
+    FOR len IN {0..floor(#str/2-1)}:
+        PUT str|floor(#str/2-len) IN rep
+        PUT rep IN rpt
+        WHILE #rpt < #str: PUT rpt^rep IN rpt
+        IF rpt|#str = str: INSERT rep IN reps
+    RETURN reps
+
+PUT {} IN tests
+PUT "1001110011" IN tests[1]
+PUT "1110111011" IN tests[2]
+PUT "0010010010" IN tests[3]
+PUT "1010101010" IN tests[4]
+PUT "1111111111" IN tests[5]
+PUT "0100101101" IN tests[6]
+PUT "0100100" IN tests[7]
+PUT "101" IN tests[8]
+PUT "11" IN tests[9]
+PUT "00" IN tests[10]
+PUT "1" IN tests[11]
+
+FOR t IN tests:
+    WRITE t, repstrings t /

Task/Reverse-a-string/Stringle/reverse-a-string.stringle

@@ -0,0 +1 @@
+$ \$

Task/Rot-13/Stringle/rot-13.stringle

@@ -0,0 +1,15 @@
+a "The quick brown fox jumps over the lazy dog."
+b "AaBbCcDdEeFfGgHhIiJjKkLlMmNnOoPpQqRrSsTtUuVvWwXxYyZz"
+c b
+#@c 78
+#\c 52
+#a
+b %.a d " " b
+b %.a #d .a
+b %.a e c
+b %.a #e #d
+b %.a a .\e :a
+f f .a
+a :a
+#a
+$ f

Task/Sequence-of-non-squares/ABC/sequence-of-non-squares.abc

@@ -0,0 +1,11 @@
+HOW TO RETURN non.square n:
+    RETURN n + floor (1/2 + root n)
+
+HOW TO REPORT square n:
+    REPORT n = (floor root n)**2
+
+FOR n IN {1..22}: WRITE non.square n
+WRITE /
+
+IF NO n IN {1..1000000} HAS square non.square n:
+    WRITE "No squares occur for n < 1.000.000"

Task/Sieve-of-Eratosthenes/ABC/sieve-of-eratosthenes.abc

@@ -0,0 +1,19 @@
+HOW TO SIEVE UP TO n:
+    SHARE sieve
+    PUT {} IN sieve
+    FOR cand IN {2..n}: PUT 1 IN sieve[cand]
+    FOR cand IN {2..floor root n}:
+        IF sieve[cand] = 1:
+            PUT cand*cand IN comp
+            WHILE comp <= n:
+                PUT 0 IN sieve[comp]
+                PUT comp+cand IN comp
+
+HOW TO REPORT prime n:
+    SHARE sieve
+    IF n<2: FAIL
+    REPORT sieve[n] = 1
+
+SIEVE UP TO 100
+FOR n IN {1..100}:
+    IF prime n: WRITE n

Task/Smith-numbers/ABC/smith-numbers.abc

@@ -0,0 +1,36 @@
+HOW TO RETURN factors n:
+    PUT {} IN factors
+    PUT 2 IN factor
+    WHILE n >= factor:
+        SELECT:
+            n mod factor = 0:
+                INSERT factor IN factors
+                PUT n/factor IN n
+            ELSE:
+                PUT factor+1 IN factor
+    RETURN factors
+
+HOW TO RETURN digit.sum n:
+    PUT 0 IN sum
+    WHILE n > 0:
+        PUT sum + (n mod 10) IN sum
+        PUT floor (n/10) IN n
+    RETURN sum
+
+HOW TO REPORT smith.number n:
+    PUT factors n IN facs
+    IF #facs = 1: FAIL
+    PUT 0 IN fac.dsum
+    FOR fac IN facs:
+        PUT fac.dsum + digit.sum fac IN fac.dsum
+    REPORT fac.dsum = digit.sum n
+
+PUT 0 IN col
+FOR i IN {1..9999}:
+    IF smith.number i:
+        WRITE (i>>5)
+        PUT col+1 IN col
+        IF col=16:
+            WRITE /
+            PUT 0 IN col
+WRITE /

Task/String-length/Stringle/string-length.stringle

@@ -0,0 +1 @@
+$ #$

Task/Strip-a-set-of-characters-from-a-string/ABC/strip-a-set-of-characters-from-a-string.abc

@@ -0,0 +1,7 @@
+HOW TO RETURN s stripchars chs:
+    PUT "" IN result
+    FOR c IN s:
+        IF c not.in chs: PUT result^c IN result
+    RETURN result
+
+WRITE "She was a soul stripper. She took my heart!" stripchars "aei"/

Task/Strip-a-set-of-characters-from-a-string/Stringle/strip-a-set-of-characters-from-a-string.stringle

@@ -0,0 +1,8 @@
+a "She was a soul stripper. She took my heart!"
+b "aei"
+#a
+c c .a
+b %.\c #c #:c
+a :a
+#a
+$ c

Task/Towers-of-Hanoi/ABC/towers-of-hanoi.abc

@@ -0,0 +1,7 @@
+HOW TO MOVE n DISKS FROM src VIA via TO dest:
+    IF n>0:
+        MOVE n-1 DISKS FROM src VIA dest TO via
+        WRITE "Move disk from pole", src, "to pole", dest/
+        MOVE n-1 DISKS FROM via VIA dest TO src
+
+MOVE 4 DISKS FROM 1 VIA 2 TO 3

Task/Van-Eck-sequence/ABC/van-eck-sequence.abc

@@ -0,0 +1,15 @@
+HOW TO RETURN vaneck.sequence length:
+    PUT {[1]: 0} IN seq
+    WHILE #seq < length:
+        PUT #seq-1 IN i
+        WHILE i>0 AND seq[i]<>seq[#seq]: PUT i-1 IN i
+        SELECT:
+            i=0: PUT 0 IN seq[#seq+1]
+            ELSE: PUT #seq-i IN seq[#seq+1]
+    RETURN seq
+
+PUT vaneck.sequence 1000 IN eck
+FOR i IN {1..10}: WRITE eck[i]>>4
+WRITE /
+FOR i IN {991..1000}: WRITE eck[i]>>4
+WRITE /