Refactorings based on Steffan153's work

Author: ingydotnet

exercises/practice/acronym/.meta/acronym.ys

@@ -1,6 +1,5 @@
 !yamlscript/v0
 
 defn abbreviate(phrase):
-  uc(phrase):
-    .re-seq(/[A-Z']+/)
+  uc(phrase).re-seq(/[A-Z']+/)
     .map(first):join

exercises/practice/all-your-base/.meta/all-your-base.ys

@@ -1,28 +1,12 @@
 !yamlscript/v0
 
-defn rebase(input-base digits output-base):
-  :: Converts a sequence of digits given in input-base
-     into a sequence of digits in the desired output-base.
-
-  cond:
-    input-base  < 2: die('input base must be >= 2')
-    output-base < 2: die('output base must be >= 2')
-    digits.some(neg?) || digits.some(ge(input-base)):
-      die: 'all digits must satisfy 0 <= d < input base'
-
-    digits.every?(zero?) || count(digits).eq(0) :: [0]
-
-    else: digits
-      .digits-to-decimal(input-base)
-      .decimal-to-digits(output-base)
-
-defn digits-to-decimal(digits input-base):
-  reduce \(%2 + (%1 * input-base)): digits
-
-defn decimal-to-digits(number output-base):
-  loop digits nil, num number:
-    if num > 0:
-      recur:
-        conj digits: num % output-base
-        quot: num output-base
-      else: digits
+defn rebase(input digits output):
+  when input < 2: die('input base must be >= 2')
+  when output < 2: die('output base must be >= 2')
+  when-not digits.every?(\(0 <= _ <= input.--)):
+    die('all digits must satisfy 0 <= d < input base')
+
+  loop n reduce(\((%1 * input) + %2) 0 digits), res []:
+    if n.?:
+      =>: recur(quot(n output) res.cons(n % output))
+      res |||: -[0]

exercises/practice/allergies/.meta/allergies.ys

@@ -1,20 +1,9 @@
 !yamlscript/v0
 
-allergen-map =:
-  zipmap _ range()::
-  - eggs
-  - peanuts
-  - shellfish
-  - strawberries
-  - tomatoes
-  - chocolate
-  - pollen
-  - cats
-
 defn allergic-to(item score):
-  bit-test score: allergen-map.$item
+  list-allergens(score).has?(item)
 
 defn list-allergens(score):
-  keep _ allergen-map:
-    fn([allergen num]):
-      bit-test(score num) &&& allergen
+  (0 .. 7).filter(P(bit-test score))
+    .map(qw(eggs peanuts shellfish strawberries
+            tomatoes chocolate pollen cats))

exercises/practice/anagram/.meta/anagram.ys

@@ -2,8 +2,5 @@
 
 defn find-anagrams(subject candidates):
   filter _ candidates:
-    partial _ subject:
-      fn(*words):
-        word1 word2 =: words.map(lc)
-        word1 != word2 &&:
-          sort(word1) == sort(word2)
+    \((_:lc != subject:lc) &&
+      (_:lc:sort == subject:lc:sort))

exercises/practice/atbash-cipher/.meta/atbash-cipher.ys

@@ -1,12 +1,10 @@
 !yamlscript/v0
 
-dict =:
-  zipmap (\\a .. \\z): \\z .. \\a
-
 defn encode(phrase):
-  lc(phrase):
-    .replace(/[^a-z0-9]/).escape(dict)
+  lc(phrase):decode:
+    .replace(/[^a-z0-9]/)
     .partition(5 5 '').map(join):joins
 
 defn decode(phrase):
-  phrase.replace(' ').escape(dict)
+  m =: (\\a .. \\z).zipmap(\\z .. \\a)
+  phrase: .replace(' ').escape(m)

exercises/practice/bank-account/.meta/bank-account.ys

@@ -1,50 +1,28 @@
 !yamlscript/v0
 
-account =: atom(nil)
+closed =: 'closed'
+closed? =: P(== closed)
 
 defn reset-test-state():
-  reset! account: nil
 
 defn bank-account(operations):
-  last:
-    for operation operations:
-      operation
-        .operation
-        .str('do-' _)
-        .call(operation)
-
-defn- do-open(op):
-  when deref(account):
-    die: 'account already open'
-  reset! account: 0
-
-defn- do-close(op):
-  when-not deref(account):
-    die: 'account not open'
-  reset! account: nil
-
-defn- do-balance(op):
-  balance =: deref(account)
-  if-not balance:
-    die: 'account not open'
-    else: balance
-
-defn- do-deposit(op):
-  when-not deref(account):
-    die: 'account not open'
-  swap! account +: op:get-amount
-
-defn- do-withdraw(op):
-  balance =: deref(account)
-  when-not balance:
-    die: 'account not open'
-  amount =: op:get-amount
-  when amount > balance:
-    die: 'amount must be less than balance'
-  swap! account -: amount
-
-defn- get-amount(op):
-  amount =: op.amount
-  if amount < 0:
-    die: 'amount must be greater than 0'
-    else: amount
+  reduce _ closed operations:
+    fn(bal op):
+      case op.operation:
+        -'open':
+          if closed?(bal): 0, die('account already open')
+        -'close':
+          if closed?(bal): die('account not open'), closed
+        -'balance':
+          if closed?(bal): die('account not open'), bal
+        -'deposit':
+          cond:
+            closed?(bal): die('account not open')
+            op.amount <= 0: die('amount must be greater than 0')
+            else: bal + op.amount
+        -'withdraw':
+          cond:
+            closed?(bal): die('account not open')
+            op.amount <= 0: die('amount must be greater than 0')
+            op.amount > bal: die('amount must be less than balance')
+            else: bal - op.amount

exercises/practice/binary-search/.meta/binary-search.ys

@@ -1,13 +1,9 @@
 !yamlscript/v0
 
 defn find(array value):
- loop low 0, high array.--:
-   when low > high:
-     die: 'value not in array'
-   mid =: (high + low).quot(2)
-   item =: array.$mid
-
-   cond:
-     value == item : mid
-     value <  item : recur(low mid.--)
-     else          : recur(mid.++ high)
+  when array.#.!: die('value not in array')
+  mid =: array.#.--.quot(2)
+  case compare(array.$mid value):
+    0: mid
+    1: find(take(mid array) value)
+    -1: find(drop(mid.++ array) value) + mid.++

exercises/practice/circular-buffer/.meta/circular-buffer.ys

@@ -1,7 +1,7 @@
 !yamlscript/v0
 
 defn run(capacity operations):
-  buffer =: M(:B V(capacity * [nil]), :P 0)
+  buffer =: -{:B V(capacity * [nil]), :P 0}
   reduce _ buffer operations:
     fn(buffer op):
       op item pass want =:
@@ -10,14 +10,14 @@ defn run(capacity operations):
       args =:
         condp eq op:
           -'clear'     : -[buffer]
-          -'read'      : L(buffer pass want)
-          -'write'     : L(buffer pass item)
-          -'overwrite' : L(buffer pass item)
+          -'read'      : -[buffer pass want]
+          -'write'     : -[buffer pass item]
+          -'overwrite' : -[buffer pass item]
       value("op-$op"): args*
   =>: -{}
 
 defn op-clear(buffer):
-  M: :B V(buffer.B.# * [nil]) :P 0
+  hash-map: :B V(buffer.B.# * [nil]) :P 0
 
 defn op-read(buffer pass want):
   cell =: buffer.B.nth(buffer.P)
@@ -26,8 +26,9 @@ defn op-read(buffer pass want):
       die: S("Can't read:\ " buffer)
     when cell != want:
       die: "Bad read:\ $cell != $want ($buffer)"
-  M: :B update-in(buffer.B [buffer.P] constantly(nil))
-     :P (buffer.P.++ % buffer.B.#)
+  hash-map:
+    :B update-in(buffer.B [buffer.P] constantly(nil))
+    :P (buffer.P.++ % buffer.B.#)
 
 defn op-write(buffer pass item):
   B P =: buffer.slice(q(B P))

exercises/practice/eliuds-eggs/.meta/eliuds-eggs.ys

@@ -1,7 +1,4 @@
 !yamlscript/v0
 
 defn egg-count(number):
-  loop num number, eggs 0:
-    if num > 0:
-      recur: quot(num 2), eggs.add(num % 2)
-      else: eggs
+  len: P(bit-test number).filter(0 .. 31)

exercises/practice/etl/.meta/etl.ys

@@ -3,4 +3,4 @@
 defn transform(legacy):
   into {}:
     for [score letters] legacy, letter letters:
-      V: lc(letter) score:N
+      -[lc(letter) score:N]

exercises/practice/grains/.meta/grains.ys

@@ -3,5 +3,4 @@
 defn square(square):
   (1 <= square <= 64) |||:
     die: 'square must be between 1 and 64'
-
-  pow 2: square - 1
+  2 **: square.--

exercises/practice/hamming/.meta/hamming.ys

@@ -3,5 +3,4 @@
 defn distance(strand1 strand2):
   strand1.# == strand2.# ||:
     die: 'strands must be of equal length'
-
-  len: map(ne strand1 strand2).filter(a)
+  sum: map(ne strand1 strand2).map(N)

exercises/practice/isogram/.meta/isogram.ys

@@ -1,7 +1,4 @@
 !yamlscript/v0
 
-defn isogram(string):
-  empty?(string) ||:
-    lc(string):split      \"Want to be case insensitive"
-      .filter(/^[a-z]$/)  \"Keep letters only"
-      .distinct?(*)       \"Check if distinct letters"
+defn isogram(phrase):
+  phrase !~ /(?i)(\w).*\1/

exercises/practice/list-ops/.meta/list-ops.ys

@@ -19,10 +19,4 @@ defn foldl(list initial function):
   list.reduce(function initial)
 
 defn foldr(list initial function):
-  if len(list) > 0:
-    function _ list:first:
-      foldr: rest(list) initial function
-    else: initial
-
-defn reverse(list):
-  core/reverse: list
+  list:reverse.reduce(function initial)

exercises/practice/luhn/.meta/luhn.ys

@@ -1,18 +1,6 @@
 !yamlscript/v0
 
 defn valid(value):
-  digits =: value.replace(' ')
-
-  and:
-    digits.# >=: 2
-    digits !~: /[^\d]/
-    digits:split:
-      .map(to-num):reverse:V
-      .conj(0).partition(2)
-      .map(munge):flat:sum
-      .mod(10).eq(0)
-
-defn munge([a b]):
-  b *=: 2
-  vector a:
-    if b > 9: (b - 9) b
+  digits =: value.replace(' ').map(\(_ - \\0)):reverse
+  digits.#.gt(1) &&: digits.every?(\(0 <= _ <= 9)) &&
+    map(int.comp(mul) digits [1 2.2]:cycle):sum.mod(10).!

exercises/practice/matching-brackets/.meta/matching-brackets.ys

@@ -1,17 +1,8 @@
 !yamlscript/v0
 
-pairs =: reverse('()[]{}'):M
-opening =: vals(pairs):set
-closing =: keys(pairs):set
-
 defn is-paired(value):
-  loop stack [], [char *chars] value:
-    cond:
-      char:nil?: stack:count:zero?
-      opening(char):
-        recur: conj(stack char) chars
-      closing(char):
-        if peek(stack) == pairs(char):
-          recur: pop(stack) chars
-          else: false
-      else: recur(stack chars)
+  x =: value.replace(/\[\]|\(\)|\{\}|[^(){}\[\]]/)
+  cond:
+    x == '': true
+    x == value: false
+    else: is-paired(x)

exercises/practice/nth-prime/.meta/nth-prime.ys

@@ -1,15 +1,9 @@
 !yamlscript/v0
 
 defn prime(number):
-  lazy-primes().nth(number.--)
-
-defn- lazy-primes(d=2 table={}):
-  if-let factors table.$d:
-    recur d.++:
-      reduce _ table.dissoc(d) factors:
-        \(update-in(%1 [(%2 + d)] conj %2))
-
-    lazy-seq:
-      cons d:
-        lazy-primes d.++:
-          assoc table: sqr(d) [d]
+  loop n 2, u 0:
+    cond:
+      u == number: n.--
+      range(2 sqrt(n):I.++).every?(\((n % _).?)):
+        recur(n.++ u.++)
+      else: recur(n.++ u)

exercises/practice/nucleotide-count/.meta/nucleotide-count.ys

@@ -1,10 +1,8 @@
 !yamlscript/v0
 
-nucleotides =: zipmap(qw(A C G T) repeat(0))
-
 defn nucleotide-counts(strand):
-  when strand !~ /^[ACGT]*$/:
+  when strand =~ /[^ACGT]/:
     die: 'Invalid nucleotide in strand'
 
-  reduce-kv _ nucleotides frequencies(strand):
-    fn(map key val): map.assoc(str(key) val)
+  into zipmap(qw(A C G T) repeat(0)):
+    frequencies(strand.map(str))

exercises/practice/pangram/.meta/pangram.ys

@@ -1,6 +1,4 @@
 !yamlscript/v0
 
 defn is-pangram(sentence):
-  26 ==: lc(sentence)
-           .replace(/[^a-z]/)
-           .distinct():len
+  B: sentence =~ /(?i)(?>.*?(\pL)(?!.*\1)){26}/

exercises/practice/pascals-triangle/.meta/pascals-triangle.ys

@@ -1,11 +1,5 @@
 !yamlscript/v0
 
 defn rows(count):
-  reduce _ [] range(1 count.++):
-    fn(tri row):
-      conj tri:
-        or _ [1]:
-          when row > 1:
-            mapv _ (-1 .. row.sub(2)):
-              \(last(tri).get(_):N.or(0) +
-                last(tri).get(_.++):N.or(0))
+  \(mapv + _.cons(0) _.conj(0))
+    .iterate([1]).take(count)