first commit

Author: rw

.envrc

@@ -0,0 +1 @@
+use nix

.github/workflows/test.yml

@@ -0,0 +1,13 @@
+name: "Test"
+on:
+  pull_request:
+  push:
+jobs:
+  tests:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v3
+    - uses: cachix/install-nix-action@v22
+      with:
+        nix_path: nixpkgs=channel:nixos-unstable
+    - run: nix develop -c 'nix-instantiate --eval leetcode.nix | jq -r "fromjson | ."'   

leetcode.nix

@@ -0,0 +1,60 @@
+#  nix-instantiate --eval leetcode.nix | jq -r 'fromjson | .'          
+
+let 
+  fac = self: acc: n: if n == 0 then acc else self (n * acc) (n - 1);
+  pow2 = n: builtins.bitAnd n (n - 1) == 0;
+  remainder = a: b:
+    if a < b then a
+    else remainder (a - b) b;
+  sumDivisors = n: builtins.foldl'
+    (runningsum: current: 
+      if remainder n current == 0
+      then current + runningsum 
+      else runningsum)
+    0 
+    (if n == 1 then [] else 
+      builtins.genList (x: x+1) (n - 2));   
+  # https://leetcode.com/problems/perfect-number/
+  perfectNumber = n: 
+    if n < 6 then false
+    else sumDivisors n == n;
+  fib = n:
+    if n == 0 then n else
+    if n == 1 then n else
+    fib(n - 1)+fib(n - 2);
+  fibTCO = self: acc: n:
+    if n == 0 then acc else
+    if n == 1 then acc else
+    self (acc + n) (n - 1);
+  tco = import ./tco.nix;
+  facTCO = n: tco fac 1 n;
+  ftco = n: tco fibTCO 1 n;
+  # https://leetcode.com/problems/take-gifts-from-the-richest-pile/
+  sqrt = number: iterations: 
+    let 
+      nextGuess = guess: (guess + number / guess) / 2;
+      improve = guess: 
+        if iterations == 0 then guess
+        else improve (nextGuess guess) (iterations - 1);
+    in improve 1 iterations;
+
+  # pickGifts = gifts: k:
+in
+  # using builtins.toJSON to eagerly evaluate the tests
+  # jq then pretty prints the result
+  builtins.toJSON {
+    tests =[
+      (assert remainder 10 3 == 1; "remainder works")
+      (assert  perfectNumber 6; "six is perfect")
+      (assert ! perfectNumber 7; "seven is not perfect")
+      (assert pow2 33554432; "2^25 is a power of 2")
+      (assert fib 1 == 1; "fib 1 is 1")
+      (assert fib 2 == 1; "fib 2 is 1")
+      (assert fib 3 == 2; "fib 3 is 2")
+      (assert fib 4 == 3; "fib 4 is 3")
+      (assert fib 5 == 5; "fib 5 is 5")
+      (assert fib 6 == 8; "fib 6 is 8")
+      (assert facTCO 15 == 1307674368000; "tail call optimized factorial works")
+      (assert ftco 100 == 5050; "tail call optimized fibonacci works")
+    ];
+  }

shell.nix

@@ -0,0 +1,8 @@
+{ pkgs ? import <nixpkgs> {} }:
+pkgs.mkShell {
+  packages = [
+    pkgs.git
+    pkgs.nixfmt
+    pkgs.jq
+  ];
+}

tco.nix

@@ -0,0 +1,97 @@
+# https://discourse.nixos.org/t/tail-call-optimization-in-nix-today/17763
+f:
+let
+  lib = import <nixpkgs/lib>;
+  # we'll use a fixed point and tail recursion
+  fac = self: acc: n: if n == 0 then acc else self (n * acc) (n - 1);
+  apply = f: args: builtins.foldl' (f: x: f x) f args;
+
+  unapply =
+    let
+      unapply' = acc: n: f: x:
+        if n == 1
+        then f (acc ++ [ x ])
+        else unapply' (acc ++ [ x ]) (n - 1) f;
+    in
+    unapply' [ ];
+  argCount = f:
+    let
+      # N.B. since we are only interested if the result of calling is a function
+      # as opposed to a normal value or evaluation failure, we never need to
+      # check success, as value will be false (i.e. not a function) in the
+      # failure case.
+      called = builtins.tryEval (
+        f (builtins.throw "You should never see this error message")
+      );
+    in
+    if !(builtins.isFunction f || builtins.isFunction (f.__functor or null))
+    then 0
+    else 1 + argCount called.value;
+  tailCallOpt = f:
+    let
+      argc = argCount (lib.fix f);
+
+      # This function simulates being f for f's self reference. Instead of
+      # recursing, it will just return the arguments received as a specially
+      # tagged set, so the recursion step can be performed later.
+      fakef = unapply argc (args: {
+        __tailCall = true;
+        inherit args;
+      });
+      # Pass fakef to f so that it'll be called instead of recursing, ensuring
+      # only one recursion step is performed at a time.
+      encodedf = f fakef;
+
+      # This is the main function, implementing the “optimized” recursion
+      opt = args:
+        let
+          steps = builtins.genericClosure {
+            # This is how we encode a (tail) call: A set with final == false
+            # and the list of arguments to pass to be found in args.
+            startSet = [
+              {
+                key = "0";
+                id = 0;
+                final = false;
+                inherit args;
+              }
+            ];
+
+            operator =
+              { id, final, ... }@state:
+              let
+                # Generate a new, unique key to make genericClosure happy
+                newIds = {
+                  key = toString (id + 1);
+                  id = id + 1;
+                };
+
+                # Perform recursion step
+                call = apply encodedf state.args;
+
+                # If call encodes a new call, return the new encoded call,
+                # otherwise signal that we're done.
+                newState =
+                  if builtins.isAttrs call && call.__tailCall or false
+                  then newIds // {
+                    final = false;
+                    inherit (call) args;
+                  } else newIds // {
+                    final = true;
+                    value = call;
+                  };
+              in
+
+              if final
+              then [ ] # end condition for genericClosure
+              else [ newState ];
+          };
+        in
+        # The returned list contains intermediate steps we need to ignore
+        (builtins.head (builtins.filter (x: x.final) steps)).value;
+    in
+    # make it look like a normal function again
+    unapply argc opt;
+in
+tailCallOpt f
+# => 1307674368000