[Sync Track] yamlscript

solutions/yamlscript/acronym/1/acronym.ys

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

solutions/yamlscript/all-your-base/1/all-your-base.ys

@@ -0,0 +1,16 @@
+!yamlscript/v0
+
+defn rebase(input-base digits output-base):
+  when input-base < 2: 
+    die('input base must be >= 2')
+
+  when output-base < 2: 
+    die('output base must be >= 2')
+
+  when-not digits.every?(\(-1 < _ < input-base)): 
+    die('all digits must satisfy 0 <= d < input base')
+
+  loop decimal reduce(\((_ * input-base) + %2) 0 digits), result []:
+    if decimal.?:
+      =>: recur(quot(decimal output-base) result.cons(decimal % output-base))
+      result |||: -[0]

solutions/yamlscript/allergies/1/allergies.ys

@@ -0,0 +1,20 @@
+!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
+
+defn list-allergens(score):
+  keep _ allergen-map:
+    fn([allergen num]):
+      bit-test(score num) &&& allergen

solutions/yamlscript/anagram/1/anagram.ys

@@ -0,0 +1,9 @@
+!yamlscript/v0
+
+defn find-anagrams(subject candidates):
+  filter _ candidates:
+    partial _ subject:
+      fn(*words):
+        word1 word2 =: words.map(lc)
+        word1 != word2 &&:
+          sort(word1) == sort(word2)

solutions/yamlscript/armstrong-numbers/1/armstrong-numbers.ys

@@ -0,0 +1,5 @@
+!yamlscript/v0
+
+defn is-armstrong-number(number):
+  ds =: digits(number)
+  number ==: ds.map(\(_ ** ds.#)):sum

solutions/yamlscript/atbash-cipher/1/atbash-cipher.ys

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

solutions/yamlscript/bank-account/1/bank-account.ys

@@ -0,0 +1,61 @@
+!yamlscript/v0
+
+# Constants for error messages
+ERROR-MESSAGES =::
+  account-closed: 'account not open'
+  account-open: 'account already open'
+  invalid-amount: 'amount must be greater than 0'
+  insufficient-funds: 'amount must be less than balance'
+
+# Global account state
+account =: atom(nil)
+
+# Reset function for tests
+defn reset-test-state():
+  reset! account: nil
+
+# Main account operation handler
+defn bank-account(operations):
+  last:
+    for operation operations:
+      operation
+        .operation
+        .str('do-' _)
+        .call(operation)
+
+# Account operation implementations
+defn- do-open(op):
+  when deref(account):
+    die: ERROR-MESSAGES.account-open
+  reset! account: 0
+
+defn- do-close(op):
+  when-not deref(account):
+    die: ERROR-MESSAGES.account-closed
+  reset! account: nil
+
+defn- do-balance(op):
+  balance =: deref(account)
+  if-not balance:
+    die: ERROR-MESSAGES.account-closed
+    else: balance
+
+defn- do-deposit(op):
+  when-not deref(account):
+    die: ERROR-MESSAGES.account-closed
+  when op.amount <= 0:
+    die: ERROR-MESSAGES.invalid-amount
+  swap! account +: op.amount
+
+defn- do-withdraw(op):
+  balance =: deref(account)
+  when-not balance:
+    die: ERROR-MESSAGES.account-closed
+
+  cond:
+    op.amount <= 0: 
+      die: ERROR-MESSAGES.invalid-amount
+    op.amount > balance: 
+      die: ERROR-MESSAGES.insufficient-funds
+    else: 
+      swap! account -: op.amount

solutions/yamlscript/binary-search/1/binary-search.ys

@@ -0,0 +1,13 @@
+!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)

solutions/yamlscript/bob/1/bob.ys

@@ -0,0 +1,11 @@
+!yamlscript/v0
+
+defn response(hey-bob):
+  condp re-matches hey-bob:trim:
+    /\s*/          : 'Fine. Be that way!'
+    /[^a-zA-Z]+\?/ : 'Sure.'
+    /[^a-z]+\?/    : "Calm down, I know what I'm doing!"
+    /.*\?/         : 'Sure.'
+    /[^a-zA-Z]*/   : 'Whatever.'
+    /[^a-z]*/      : 'Whoa, chill out!'
+    else           : 'Whatever.'

solutions/yamlscript/bottle-song/1/bottle-song.ys

@@ -0,0 +1,22 @@
+!yamlscript/v0
+
+defn recite(start-bottles take-down):
+  nums =: start-bottles ..
+          (start-bottles - take-down).++
+  nums: .map(verse).join("\n"):lines
+
+defn- verse(num): |
+  $uc1(bottles(num)) hanging on the wall,
+  $uc1(bottles(num)) hanging on the wall,
+  And if one green bottle should accidentally fall,
+  There'll be $bottles(num.--) hanging on the wall.
+
+nums =:
+  zipmap (2 .. 10):
+    qw(two three four five six seven eight nine ten)
+
+defn- bottles(num):
+  case num:
+    0    : 'no green bottles'
+    1    : 'one green bottle'
+    else : "$(nums.$num) green bottles"

solutions/yamlscript/circular-buffer/1/circular-buffer.ys

@@ -0,0 +1,6 @@
+!yamlscript/v0
+
+# ?????
+
+defn run(capacity operations):
+  -{}

solutions/yamlscript/collatz-conjecture/1/collatz-conjecture.ys

@@ -0,0 +1,11 @@
+!yamlscript/v0
+
+defn steps(number):
+  number > 0 ||:
+    die: 'Only positive integers are allowed'
+
+  loop num number, steps 0:
+    cond:
+      num.eq(1) : steps
+      num:even? : recur(num.div(2), steps.++)
+      else      : recur(num.mul(3).++, steps.++)

solutions/yamlscript/darts/1/darts.ys

@@ -0,0 +1,8 @@
+!yamlscript/v0
+
+defn score(x y):
+  condp ge math/hypot(x y):
+    1    : 10
+    5    : 5
+    10   : 1
+    else : 0

solutions/yamlscript/diamond/1/diamond.ys

@@ -0,0 +1,13 @@
+!yamlscript/v0
+
+defn rows(letter):
+  ipad =:
+    letter.0:N.sub(64).mul(2).sub(3) * ' '
+
+  loop C letter.0, I ipad, O '', dmnd '':
+    line =: I.?.if("$O$C$I$C$O\n" "$O$C$O\n")
+    dmnd =: dmnd.?.if("$line$dmnd$line" line)
+
+    if I.?:
+      recur: C.--, I.chop(2), "$O ", dmnd
+      else: dmnd

solutions/yamlscript/difference-of-squares/1/difference-of-squares.ys

@@ -0,0 +1,11 @@
+!yamlscript/v0
+
+defn square-of-sum(number):
+  sqr: sum(1 .. number)
+
+defn sum-of-squares(number):
+  sum: (1 .. number).map(sqr)
+
+defn difference-of-squares(number):
+  square-of-sum(number) -
+  sum-of-squares(number)

solutions/yamlscript/eliuds-eggs/1/eliuds-eggs.ys

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

solutions/yamlscript/etl/1/etl.ys

@@ -0,0 +1,6 @@
+!yamlscript/v0
+
+defn transform(legacy):
+  into {}:
+    for [score words] legacy, word words:
+      -[lc(word) to-int(score)]

solutions/yamlscript/food-chain/1/food-chain.ys

@@ -0,0 +1,28 @@
+!yamlscript/v0
+animals-and-comments =::
+- fly: I don't know why she swallowed the fly. Perhaps she'll die.
+- spider: It wriggled and jiggled and tickled inside her.
+- bird: How absurd to swallow a bird!
+- cat: Imagine that, to swallow a cat!
+- dog: What a hog, to swallow a dog!
+- goat: Just opened her throat and swallowed a goat!
+- cow: I don't know how she swallowed a cow!
+- horse: She's dead, of course!
+defn recite(start-verse end-verse):
+  reduce(build-verse [] (start-verse.-- .. end-verse.--)):drop-last
+defn build-verse(accumulated-verses current-verse):
+  current-animal =: animals-and-comments.$current-verse.first().0
+  accumulated-verses .=: conj("I know an old lady who swallowed a $current-animal.")
+  accumulated-verses .=: conj(animals-and-comments.$current-verse.first().1)
+  conj _ '':
+    or _ accumulated-verses:
+      when 0 < current-verse < animals-and-comments.#.--:
+        conj _ animals-and-comments.0:first.1:
+          reduce _ accumulated-verses (current-verse .. 1):
+            fn(verse-lines verse-num):
+              conj verse-lines:
+                predator =: animals-and-comments.$verse-num.first().0
+                prey =: animals-and-comments.nth(verse-num.--):first.0
+                S("She swallowed the $predator to catch the $prey."):
+                  .call(fn([line] if((prey != 'spider') line
+                   replace(line /\./ replace(animals-and-comments.1:first.1 /It/ ' that'))))_)

solutions/yamlscript/grains/1/grains.ys

@@ -0,0 +1,7 @@
+!yamlscript/v0
+
+defn square(square):
+  (1 <= square <= 64) ||:
+    die: 'square must be between 1 and 64'
+
+  pow 2: square - 1

solutions/yamlscript/hamming/1/hamming.ys

@@ -0,0 +1,7 @@
+!yamlscript/v0
+
+defn distance(strand1 strand2):
+  strand1.# == strand2.# ||:
+    die: 'strands must be of equal length'
+
+  len: map(ne strand1 strand2).filter(a)

solutions/yamlscript/hello-world/1/hello-world.ys

@@ -0,0 +1,4 @@
+!YS-v0
+
+defn hello():
+  'Hello, World!'

solutions/yamlscript/isogram/1/isogram.ys

@@ -0,0 +1,7 @@
+!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"

solutions/yamlscript/largest-series-product/1/largest-series-product.ys

@@ -0,0 +1,13 @@
+!yamlscript/v0
+
+defn largest-product(digits span):
+  cond:
+    span < 0          : die('span must not be negative')
+    span > digits.#   : die('span must be smaller than string length')
+    digits =~ /[^\d]/ : die('digits input must only contain digits')
+
+  digits.split(''):
+    .map(to-num)
+    .partition(span 1)
+    .map(\(_.mul(*)))
+    .max(*)

solutions/yamlscript/leap/1/leap.ys

@@ -0,0 +1,6 @@
+!yamlscript/v0
+
+defn leap-year(year):
+  (year % 4):zero? &&:
+    (year % 100):pos? ||:
+      (year % 400):zero?

solutions/yamlscript/list-ops/1/list-ops.ys

@@ -0,0 +1,28 @@
+!yamlscript/v0
+
+defn append(list1 list2):
+  list1 + list2
+
+defn concat(lists):
+  lists.mapcat(a)
+
+defn filter(list function):
+  list.filter(function)
+
+defn length(list):
+  list:count
+
+defn map(list function):
+  list.map(function)
+
+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