Exercise Implementation Tracker

[ErikSchierboom]

Practice exercise implementation tracker

If you want to take on an exercise, you can pick from the not yet done and mark it with your name in working on, so other people will know.

Working on

Not yet done

• Alphametics
• Book Store
• Bowling
• Circular Buffer
• Go Counting
• Grade School
• Grep
• Ledger
• List Ops
• Markdown
• Poker
• POV
• Rail Fence Cipher
• Rational Numbers
• REST API
• Satellite
• Say
• SGF Parsing
• Tournament
• Transpose
• Two Bucket
• Variable Length Quantity
• Wordy
• Zipper

Implemented (92)

• acronym
• affine-cipher
• allergies
• all-your-base
• anagram
• armstrong-numbers
• atbash-cipher
• binary-search
• bob
• bottle-song
• change
• clock
• collatz-conjecture
• connect
• crypto-square
• darts
• diamond
• difference-of-squares
• diffie-hellman
• dnd-character
• dominoes
• eliuds-eggs
• etl
• flatten-array
• food-chain
• forth
• game-of-life
• gigasecond
• grains
• hamming
• hello-world
• high-scores
• house
• isbn-verifier
• isogram
• killer-sudoku-helper
• kindergarten-garden
• knapsack
• largest-series-product
• leap
• luhn
• matching-brackets
• matrix
• meetup
• micro-blog
• minesweeper
• nth-prime
• nucleotide-count
• ocr-numbers
• palindrome-products
• pangram
• parallel-letter-frequency
• pascals-triangle
• perfect-numbers
• phone-number
• pig-latin
• prime-factors
• protein-translation
• proverb
• pythagorean-triplet
• queen-attack
• raindrops
• rectangles
• resistor-color
• resistor-color-duo
• resistor-color-trio
• reverse-string
• rna-transcription
• robot-name
• robot-simulator
• roman-numerals
• rotational-cipher
• run-length-encoding
• saddle-points
• scrabble-score
• secret-handshake
• series
• sieve
• simple-cipher
• space-age
• spiral-matrix
• square-root
• state-of-tic-tac-toe
• strain
• sublist
• sum-of-multiples
• triangle
• twelve-days
• two-fer
• word-count
• word-search
• yacht
• zebra-puzzle

Foregone (13)

• bank-account
• binary-search-tree
• complex-numbers
• custom-set
• dot-dsl
• error-handling
• hangman
• lens-person
• linked-list
• paasio
• react
• simple-linked-list
• tree-building

[ErikSchierboom]

I'd like to do largest-series-product

[vaeng]

I'll start easy and try leap

[ErikSchierboom]

That's actually not that easy, but there is a video to help out: https://www.youtube.com/watch?v=H7GJbSHgWjw&ab_channel=TacitSanctuary

[SleeplessByte]

/≠=0◿4_100_400 <input>

Apparently.

From the comment:

It's a variadic exclusive or. It's only true if an odd number of inputs are true; it fits here since each condition is a subset of the prior and reverses the result. xor can also be thought of as a conditional toggle (a xor b = if b then not a else a).

Always great when kagi gives no real results, but once I clicked / (reduce) + ≠ (not equals) + = (equals) + ◿ (modulus) + _ (array syntax), and then cried a little, I understand.

◿2_3_4_10_100 10_10_10_10_10

# equivalent
◿2_3_4_10_100 10

# returns
[0 1 2 0 10]

So first give me an array that is the remainder of input / value:

◿4_100_400 <input>

For each item, does it compare to 0 (aka is it divisible?)

=0◿4_100_400 2100
[1 1 0]

=0◿4_100_400 2024
[1 0 0]

=0◿4_100_400 2017
[0 0 0]

But with reduce, the function not equals is called against the previous value.

\≠=0◿4_100_400 2100
[1 0 0]

\≠=0◿4_100_400 2024
[1 1 1]

\≠=0◿4_100_400 2017
[0 0 0]

You can compare the answers (steps) here with the previous each result.
The first item in the array should always be the same.
Then, in the reduce against not equals, the value will be a 1 if the previous result does not match the current one.

[1 -> 1] these are the same so, 0
[1 -> 0] these are different, so 1

In the 2100 case, what happens is:

◿4_100_400 2100
[0 0 100]

=0◿4_100_400 2100
[1 1 0]

# In other words
2100 % 4   => 0    =>   0 == 0   => 1
2100 % 100 => 0    =>   0 == 0   => 1
2100 % 400 => 100  => 100 == 0   => 0

The first value (1) is the initial reduced value [1]
The second value (1) is compared to the result (1). 1 ≠ 1 => 0
The last value (0) is compared to the result (0) 0 ≠ 0 => 0

Therefore: not leap.

The 2024 case:

◿4_100_400 2024
[0 24 24]

=0◿4_100_400 2024
[1 0 0]

# In other words
2024% 4   => 0    =>   0 == 0   => 1
2024% 100 => 24   =>  24 == 0   => 0
2024% 400 => 24   =>  24 == 0   => 0

The first value (1) is the initial reduced value [1]
The second value (1) is compared to the result (0). 1 ≠ 0 => 1
The last value (0) is compared to the result (1) 0 ≠ 1 => 1

Therefore: leap.

It works because for each division the result (1 or 0) needs to be different from the previous, and you need an odd number of 1 (divisible by x) for the entire thing to be 1.

I can now rest in peace(s)

Playground (pad): https://www.uiua.org/pad?src=0_14_0-dev_2__TGVhcCDihpAgL-KJoD0w4pe_NF8xMDBfNDAwCgriiLVMZWFwIFsyMDAwIDIwMDEgMjAwNCAyMDE3IDIwMjQgMjEwMF0KIyBleHBlY3RlZDogWzEgMCAxIDAgMSAwXQo=

[vaeng]

I think we found our first deep -dive 🎉🥳

[SleeplessByte]

Here are three more options:

The sum of "which are divisible" must be an odd number

I think, if my thought process is right, then the following is equivalent

=1◿2/+=0◿4_100_400 <input>

If each divisible item is counted as a 1 and each item that yields a remainder is 0, then the sum of all the 1 and 0 gives us an odd number when it's leap and even number when it's not.

Filter array for 1 (indicating divisibility) and get the length of the array

Alternatively, one can filter all the items for 1s (▽ =1.) and then count (⧻) the 1s

⧻▽ =1. <array> is always equivalent to /+ in this context because filtering for 1 and then getting the length, is the same as summing all the 1.

=1◿2⧻▽ =1. =0◿4_100_400 <input>

Simplify that

But then we don't need the earlier equality comparison and can count what's divisible exactly:

◿2⧻▽ =0. ◿4_100_400 <input>

[ErikSchierboom]

Fantastic writeup! I'm happy for you to join in adding some exercises :) (if you'd like and have time)

[SleeplessByte]

Ok. One more and then I need to go do something else. This is way too interesting.

Here is big brain mode:

=⊢↘ 1 datetime °datetime [<input> 2 29] 2

Or alternatively written:

=2⊢↘1 datetime °datetime [<input> 2 29]

• Convert the input array [year month day] to a timestamp using
  • ° (un) inverting the behaviour of the function
  • datetime timestamp to datetime array
• Convert the timestamp back into a datetime array
• ↘ (drop) the first element (the year)
• ⊢ (first) return the first element (the month)
• ...it should be February!

And yes =29⊢↘2 works for the same reason.

If we need to turn this into a function, a bit of reshuffling is necessary.

Reordering the stack

Okay, the input is not at the end, so it cannot be "inserted" from the top, yay. But that can be fixed using:

• ⊃ (fork): Call two functions on the input (or with a|b|c|...|n, n function! This is called a function pack)
• ⋅ (gap): Discard the top stack value then call a function
• ∘ (identity): Do nothing

The date we want looks like [<input> 2 29] (which is year-2-29). Therefore the input needs to be reordered

Reorder ← [⊃(⋅⋅∘|⋅∘|∘)]

• [<make an array of what's here]
• ⊃(call|on|each|function|from|right|to|left)
  • ⋅⋅∘: this is equivalent to drop(2).first on an array, so third on the stack
  • ⋅∘: this is equivalent to drop(1).first on an array, so second on the stack
  • ∘: this is equivalent to first on an array, so top of the stack

Leap ← =2⊢↘1 datetime °datetime [⊃(⋅⋅∘|⋅∘|∘)] 29 2

∵Leap[2000 2001 2004 2017 2024 2100]
# expected: [1 0 1 0 1 0]

# [⊃(⋅⋅∘|⋅∘|∘)] 29 2 2000
# => [2000 ⊃(⋅⋅∘|⋅∘)]
# => [2000 2 ⊃(⋅⋅∘)]
# => [2000 2 29]

[ErikSchierboom]

I'll do isogram

[SleeplessByte]

@vaeng let me know when you have something. I'm happy to write all of the above as approaches.

[vaeng]

@SleeplessByte

=1◿2/+=0◿4_100_400

It's my first dive into an array language, and this is what I came up with in #9, after I understood that I had an array in an array and thus needed deshaping. Fixed that, thank you

[SleeplessByte]

=1 can always be dropped, so yeah nice! You basically did the condensed version of the first solution in #7 (comment)

#7 (comment) still my best one though.

I'll start writing deep dive docs

[ErikSchierboom]

I'll do difference-of-squares