diff options
Diffstat (limited to 'rosetta')
| -rw-r--r-- | rosetta/factors-of-int.neb | 29 | ||||
| -rw-r--r-- | rosetta/lev.neb | 20 | ||||
| -rw-r--r-- | rosetta/lines.neb | 16 | ||||
| -rw-r--r-- | rosetta/luhn.neb | 73 | ||||
| -rw-r--r-- | rosetta/palindrome.neb | 6 | ||||
| -rw-r--r-- | rosetta/sum-of-squares.neb | 2 |
6 files changed, 146 insertions, 0 deletions
diff --git a/rosetta/factors-of-int.neb b/rosetta/factors-of-int.neb new file mode 100644 index 0000000..ea3ca15 --- /dev/null +++ b/rosetta/factors-of-int.neb @@ -0,0 +1,29 @@ +(func .list-of-num (num) + (def nums (list)) + (for-count num + (redef nums (append nums _idx_))) + nums) + +(func .rough-sqrt (num) (.rough-sqrt num 1)) + +(func .rough-sqrt (num val) + (branch + ((eq? (* val val) num) val) + ((> (* val val) num) (- val 1)) + (#true + (.rough-sqrt num (+ 1 val))))) + +(func factor-naive (num) + (filter (lambda (x) (int? (/ num x))) (.list-of-num num))) + +(func factor-better (num) + (append + (filter (lambda (x) (int? (/ num x))) (.list-of-num (floor (/ num 2)))) + num)) + +(func factor-even-better (num) + (def ret (list)) + (for-each (.list-of-num (.rough-sqrt num)) + (if (int? (/ num _item_)) + (redef ret (append ret (list _item_ (/ num _item_)))))) + ret) diff --git a/rosetta/lev.neb b/rosetta/lev.neb new file mode 100644 index 0000000..6797c41 --- /dev/null +++ b/rosetta/lev.neb @@ -0,0 +1,20 @@ +(func min (lst :{:int}) + (def val (first lst)) + (for-each (rest lst) + (if (< _item_ val) + (redef val _item_))) + val) + +(func lev (s t) + (branch + ((eq? 0 (length s)) (length t)) + ((eq? 0 (length t)) (length s)) + ((eq? (first s) (first t)) + (lev (rest s) (rest t))) + (#true + (+ 1 + (min + (list + (lev s (rest t)) + (lev (rest s) t) + (lev (rest s) (rest t)))))))) diff --git a/rosetta/lines.neb b/rosetta/lines.neb new file mode 100644 index 0000000..45a6a6f --- /dev/null +++ b/rosetta/lines.neb @@ -0,0 +1,16 @@ + +(func adjust (text width) + (def lines (list)) + (def word "") + (for-each (split text " ") + (branch + ((eq? 0 (length word)) (redef word _item_)) + ((<= (+ (length word) 1 (length _item_)) width) + (redef word (concat word " " _item_))) + (#true + (block + (redef lines (append lines word)) + (redef word _item_))))) + (if (not (eq? 0 (length word))) + (append lines word) + lines)) diff --git a/rosetta/luhn.neb b/rosetta/luhn.neb new file mode 100644 index 0000000..ac06e17 --- /dev/null +++ b/rosetta/luhn.neb @@ -0,0 +1,73 @@ +(func odd-elems (lst) + (odd-elems lst (list))) + +(func odd-elems (lst acc) + (if (eq? 0 (length lst)) + acc + (odd-elems (rest (rest lst)) (append acc (first lst))))) + +(func even-elems (lst) + (even-elems lst (list))) + +(func even-elems (lst acc) + (if (>= 1 (length lst)) + acc + (even-elems (rest (rest lst)) (append acc (first (rest lst)))))) + +(func luhn? (num) + ;; algo: + ;; with digits reversed, sum odd digits + ;; for all even digits: + ;; - double them + ;; - sum the digits (i.e. 16 -> 1 + 6 -> 7) + ;; - sum everything + ;; sum both values, and if the result ends in 0, it's valid + (def reverse-digits (reverse (->string num))) + ; sum the odd digits + (def s1 + (reduce + (lambda (x y) (+ x (string->int y))) + (odd-elems reverse-digits) 0)) + (def s2 + ; sum everything + (reduce (lambda (x y) (+ x y)) + ; sum each of the digits + (map (lambda (x) (apply + x)) + ; split the resulting numbers into digits + (map (lambda (x) (map string->int (split (->string x)))) + ; double the even digits + (map (lambda (x) (* 2 (string->int x))) + (even-elems reverse-digits)))) 0)) + (int? (/ (+ s1 s2) 10))) + +(func base36-to-base10 (value :string) + (base36-to-base10 (ord value))) + +(func base36-to-base10 (value :int) + (if (< value 32) + (+ 9 value) + (base36-to-base10 (- value 32)))) + +(func isin? (value) + ;; algo: + ;; - must be 12 digits + ;; - first 2 must be letters + ;; - last must be a number + ;; - interpret all values as base 32 + ;; - replace them as if replacing characters in a string + ;; - run luhn + (def digits (split "0123456789")) + (and + (eq? 12 (length value)) + (not (in? (first value) digits)) + (not (in? (first (rest value)) digits)) + (in? (last value) digits) + (luhn? (string->int + (apply concat + (reduce + (lambda (acc val) + (append acc + (->string (try + (string->int val) + (base36-to-base10 val))))) + (split value) (list))))))) diff --git a/rosetta/palindrome.neb b/rosetta/palindrome.neb new file mode 100644 index 0000000..198456d --- /dev/null +++ b/rosetta/palindrome.neb @@ -0,0 +1,6 @@ +(func palindrome? (str) + (branch + ((<= (length str) 1) #true) + ((eq? (first str) (last str)) + (palindrome? (reverse (rest (reverse (rest str)))))) + (#true #false))) diff --git a/rosetta/sum-of-squares.neb b/rosetta/sum-of-squares.neb new file mode 100644 index 0000000..be76194 --- /dev/null +++ b/rosetta/sum-of-squares.neb @@ -0,0 +1,2 @@ +(func sum-of-squares (lst :[:int]) + (reduce + (map (lambda (x) (* x x)) lst) 0)) |