Project Euler 0-to-12 BQN Solutions

euler-0000.bqn

#! /usr/bin/env bqn

#### Project Euler - Problem 0
#    https://projecteuler.net/register

# A number is a perfect square, or a square number, if it is the square of a
# positive integer.
# For example, 25 is a square number because 5^2 = 5 x 5 = 25; it is also an
# odd square.

# The first 5 square numbers are: 1,4,9,16,25, and the sum of the odd squares
# is 1 + 9 + 25 = 35.

# Among the first 640 thousand square numbers, what is the sum of all the odd
# squares?

####

OneUpTo ← 1 + ↕
IsOdd ← 1 = 2⊸|
OddNumbersUpTo ← IsOdd⊸/ OneUpTo
OddSquaresUpTo ← ט OddNumbersUpTo
SumOfOddSquaresUpTo ← +´ OddSquaresUpTo

# Sumofoddsquaresupto 640000
# 4.3690666666263704e16 # Incorrect due to floating point precision limits

# Run expression in bc (to avoid floating point precision limits)
BC ← {
  bc_expr ← 𝕩 ∾ "
quit"
  tmp_file ← "tmp.bc"
  tmp_file •file.Chars bc_expr
  result ← ¯1↓ 1 ⊑ •SH ⟨"bash", "-c", "bc -q " ∾ tmp_file⟩
  •file.Remove tmp_file
  result
}

# Generate expressions
JoinWith ← ∾ 1⊸↑ ∾ <∘⊣ ∾¨ 1⊸↓
FormatSumOfOddSquaresUpTo ← " + " JoinWith •Fmt¨∘OddSquaresUpTo
expr ← FormatSumOfOddSquaresUpTo 640000

# Run It
•Show BC expr
# "43690666666560000"

euler-0001.bqn

#! /usr/bin/env bqn

#### Problem 1 - Multiples of 3 or 5 
#    https://projecteuler.net/problem=3
 
# If we list all the natural numbers below 10 that are multiples of 3 or 5, we
# get 3, 5, 6 and 9. The sum of these multiples is 23.
 
# Find the sum of all the multiples of 3 or 5 below 1000.

####

OneUpTo ← 1↓↕ # Exclude zero, exclude upper bound
IsMultipleOf ← 0 = |

# Note: From now on, this only works if both arguments are non-scalar.
IsMultipleOfOr ← ⌈´ (<˘ IsMultipleOf⌜)
FilterMultipleOfOr ← IsmultipleOfOr / ⊢
SumMultipleOfOr ← +´ FilterMultipleOfOr

•Show 3‿5 SumMultipleOfOr OneUpTo 1000

euler-0002.bqn

#! /usr/bin/env bqn

#### Problem 2 - Even Fibonacci Numbers
#    https://projecteuler.net/problem=2
 
# Each new term in the Fibonacci sequence is generated by adding the previous
# two terms. By starting with 1 and 2, the first 10 terms will be:

# 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, ...
 
# By considering the terms in the Fibonacci sequence whose values do not exceed
# four million, find the sum of the even-valued terms.

####

# Extend an existing Fibonacci sequence (expected to have at least two
# elements)
ExtendFib ← {𝕩 ∾ +´(¯2↑𝕩)}

# Get an n-length Fibonacci sequence by Repeating "ExtendFib" until length
# reached (starting with a "1, 2" seed)
GetFib ← { ExtendFib⍟(𝕩-2) 1‿2 }

IsEven ← 0=2⊸|
IsSmall ← 4_000_000⊸>

ValidFibsUpTo ← (IsEven ∧ IsSmall)⊸/ GetFib

•Show +´ ValidFibsUpTo 50

euler-0003.bqn

#! /usr/bin/env bqn

#### Problem 3 - Largest Prime Factor
#    https://projecteuler.net/problem=3
 
# The prime factors of 13195 are 5, 7, 13 and 29.

# What is the largest prime factor of the number 600851475143 ?

# Note; "Factor" is synonymous with "divisor" (That is, 'n' is a factor/divisor
# of 'm' if m mod n = 0) 

####

IsDivisor ← 0 = |
PossibleDivisors ← 2↓↕
PossibleDivisorsUpToSqrt ← {1↓ 1+ ↕ ⌊√𝕩}

# Note: We check only up to "sqrt(x)" because it represents the mid-point of a
# pair of factors. If a larger one existed, we would have found its smaller
# pair already.
IsPrime ← { ¬∨´ 𝕩 IsDivisor˜¨ (PossibleDivisorsUpToSqrt 𝕩)}

# Note: We first find all small divisors by checking up to sqrt(x), and then
# generate the pair divisors.
SmallDivisors ← { 
  divs ← PossibleDivisorsUpToSqrt 𝕩
  (𝕩 IsDivisor˜ divs) / divs
}
Divisors ← { 
  divs ← SmallDivisors 𝕩
  ∧ divs ∾ (𝕩 ÷ divs)
}
PrimeDivisors ← { 
  divs ← Divisors 𝕩
  (IsPrime¨ divs) / divs
}
LargestPrimeDivisor ← ¯1↑ PrimeDivisors

•Show Largestprimedivisor 600851475143
# 6857

euler-0004.bqn

#! /usr/bin/env bqn

#### Problem 4 - Largest Prime Factor
#    https://projecteuler.net/problem=4

# A palindromic number reads the same both ways. The largest palindrome made
# from the product of two 2-digit numbers is 9009 = 91 * 99.

# Find the largest palindrome made from the product of two 3-digit numbers.

####

# twoDigitNumbers ← 10 + ↕90
# threeDigitNumbers ← 100 + ↕900

NDigitNumbers ← {
  base ← 10⋆(𝕩-1)
  base + ↕9×base
}

NDigitNumberPairProducts ← {∧ ⍷ ⥊ ×⌜˜ (NDigitNumbers 𝕩)}

IsPalindrome ← {
  string ← •Repr 𝕩
  string ≡ ⌽ string
}

NDigitNumberPairProductPalindromes ← {
  pairs ← NDigitNumberPairProducts 𝕩
  (IsPalindrome¨ pairs) / pairs
}

•Show ¯1↑ Ndigitnumberpairproductpalindromes 3
# 906609

euler-0005.bqn

#! /usr/bin/env bqn

#### Problem 5 - Smallest Multiple
#    https://projecteuler.net/problem=5

# 2520 is the smallest number that can be divided by each of the numbers from 1
# to 10 without any remainder.

# What is the smallest positive number that is "evenly divisible" (divisible
# with no remainder) by all of the numbers from 1 to 20?

####

# Note: 
# - This is basically calulating the LCM (Least Common Multiple), which is best
#   done by first calculating the GCD (Greatest Common Divisor), which in turn
#   can be computed fast with the "Euclidean Algorithm."
# - While LCM and GCD are defined for two values (say, "gcd(x,y)"), they are
#   both associative, meaning we can use "fold" to calculate them for many
#   values.
# - BQN includes `•math.GCD` and `•math.LCM` functions, but we'll implement
#   them by hand.

# Get GCD of two values using the Euclidiean Algorithm. 
# - This is based on:
#   - the set of divisors of x and y are equal to the set of divisors of x and
#     `x % y` (where x is the largest number)
#   - `gcd(x,0) = x`
# - Replace one value with the module of both (we don't care about finding out
#   which is larger, as if we mix them up the first step will just swap them).
#   Repeat until the small value is zero, then the large value is the GCD.
GCD ← {𝕨 = 0 ? 𝕩 ; (𝕨 | 𝕩) 𝕊 𝕨 }

# Get LCM using DBC
# - The formula is:   `LCM(x,y) = (x*y)/GCD(x,y)`
# - Which comes from:  `x*y = LCM(x,y) * GCD(x,y)`
# - This makes sense if you consider that:
#   - LCM(x,y) is the product of prime factors to the minimum exponent
#   - GCD(x,y) is the product of prime factors to the maximum exponent
#   - Both multiplication above end up adding all exponents 
LCM ← { (𝕨×𝕩) ÷ (𝕨 GCD 𝕩)}

•Show LCM´ 1+↕20
# 232792560

euler-0006.bqn

#! /usr/bin/env bqn

#### Problem 6 - Sum Square Difference
#    https://projecteuler.net/problem=6

# The sum of the squares of the first ten natural numbers is,
# 1^2 + 2^2 + ... + 10^2 = 385.
# 
# The square of the sum of the first ten natural numbers is,
# (1 + 2 + ... + 10)^2 = 55^2 = 3025.
# 
# Hence the difference between the sum of the squares of the first ten natural
# numbers and the square of the sum is 3025 - 385 = 2640.
# 
# Find the difference between the sum of the squares of the first one hundred
# natural numbers and the square of the sum.

####

SumOfSquaresOfFirstN ← {+´ 2⋆˜ (1+↕𝕩)}
SquareOfSumOfFirstN ← { 2⋆˜ +´ (1+↕𝕩)}

•Show {(SquareOfSumOfFirstN 𝕩) - SumOfSquaresOfFirstN 𝕩} 100
# 25164150

euler-0007.bqn

#! /usr/bin/env bqn

#### Problem 7 - 10001st Prime
#    https://projecteuler.net/problem=7

# By listing the first six prime numbers: 2, 3, 5, 7, 11, and 13, we can see
# that the 6th prime is 13.
 
# What is the 10001st prime number?

####

IsDivisor ← 0 = |
PossibleDivisors ← 2↓↕
PossibleDivisorsUpToSqrt ← {1↓ 1+ ↕ ⌊√𝕩}
IsPrime ← { ¬∨´ 𝕩 IsDivisor˜¨ (PossibleDivisorsUpToSqrt 𝕩)}

GetPrimesUpToNatural ← {
  seq ← 2↓↕𝕩
  (IsPrime¨ seq) / seq
}

# Note: Alternatively, we could automatically calculate an upper bound with the
# "Prime Number Theorem."
GetNthPrimeNumber ← {
  checkUpToNatural ← 𝕨
  index ← 𝕩 - 1
  primes ← GetPrimesUpToNatural checkUpToNatural
  index ⊑ primes
}

•Show 110_000 GetNthPrimeNumber 10_001
# 104743

euler-0008.bqn

#! /usr/bin/env bqn

#### Problem 8 - Largest Product in a Series
#    https://projecteuler.net/problem=8

# The four adjacent digits in the following 1000-digit number that have the
# greatest product are 9 * 9 * 8 * 9 = 5832.
 
# 73167176531330624919225119674426574742355349194934
# 96983520312774506326239578318016984801869478851843
# 85861560789112949495459501737958331952853208805511
# 12540698747158523863050715693290963295227443043557
# 66896648950445244523161731856403098711121722383113
# 62229893423380308135336276614282806444486645238749
# 30358907296290491560440772390713810515859307960866
# 70172427121883998797908792274921901699720888093776
# 65727333001053367881220235421809751254540594752243
# 52584907711670556013604839586446706324415722155397
# 53697817977846174064955149290862569321978468622482
# 83972241375657056057490261407972968652414535100474
# 82166370484403199890008895243450658541227588666881
# 16427171479924442928230863465674813919123162824586
# 17866458359124566529476545682848912883142607690042
# 24219022671055626321111109370544217506941658960408
# 07198403850962455444362981230987879927244284909188
# 84580156166097919133875499200524063689912560717606
# 05886116467109405077541002256983155200055935729725
# 71636269561882670428252483600823257530420752963450
 
# Find the thirteen adjacent digits in the 1000-digit number that have the
# greatest product. What is the value of this product?

####

input ← "7316717653133062491922511967442657474235534919493496983520312774506326239578318016984801869478851843858615607891129494954595017379583319528532088055111254069874715852386305071569329096329522744304355766896648950445244523161731856403098711121722383113622298934233803081353362766142828064444866452387493035890729629049156044077239071381051585930796086670172427121883998797908792274921901699720888093776657273330010533678812202354218097512545405947522435258490771167055601360483958644670632441572215539753697817977846174064955149290862569321978468622482839722413756570560574902614079729686524145351004748216637048440319989000889524345065854122758866688116427171479924442928230863465674813919123162824586178664583591245665294765456828489128831426076900422421902267105562632111110937054421750694165896040807198403850962455444362981230987879927244284909188845801561660979191338754992005240636899125607176060588611646710940507754100225698315520005593572972571636269561882670428252483600823257530420752963450"

StrToDigits ← {𝕩 - '0'}

# Note: The "Window" operator (↕) returns a matrix, so we use "Cell" (˘) to
# operate on each segment.
NSizedSegmentProducts ← ×´˘ {𝕨 ↕ StrToDigits 𝕩}

LargestNSizedSegmentProduct ← ⌈´ NSizedSegmentProducts

•Show 13 LargestNSizedSegmentProduct input
# 23514624000

euler-0009.bqn

#! /usr/bin/env bqn

#### Problem 9 - Special Pythagorean Triplet
#    https://projecteuler.net/problem=9

# A Pythagorean triplet is a set of three natural numbers, a < b < c, for which,
# a^2 + b^2 = c^2.
 
# For example, 3^2 + 4^2 = 9 + 16 = 25 = 5^2.
 
# There exists exactly one Pythagorean triplet for which a + b + c = 1000. Find
# the product abc.

####

# Note: 
# - The equation above is the one from the "Pythagorean theorem," with the
#   "Pythagorean triplet" being the set of numbers that satisfy it.
# - Fun fact: Fermat's Last Theorem says that there are no solutions if the
#   exponent is greater than 2.

GetABPairs ← {
  target ← 𝕩
  abMax ← ⌊ 𝕩 ÷ 2 # Can't be higher than integer division by two
  candidates ← ⥊ (↕abMax) ∾⌜ ↕abMax

  # remove when a is not less than b
  IsABeforeB ← {
    a‿b ← 𝕩
    a < b
  }
  (IsABeforeB¨ candidates) / candidates
}

GetABCCandidates ← {
  pairs ← GetABPairs 𝕩
  candidates ← {
    a‿b ← 𝕩
    c ← 1000 - (a + b)
    a‿b‿c 
  }¨ pairs

  # remove when b is more than b
  IsBBeforeC ← {(1 ⊑ 𝕩) < (2 ⊑ 𝕩)}
  (IsBBeforeC¨ candidates) / candidates
}

IsPythagoreanTriplet ← {
  a‿b‿c ← 𝕩
  ((a⋆2) + (b⋆2)) = (c⋆2)
} 

GetValidTriplets ← {
  candidates ← GetABCCandidates 𝕩
  (IsPythagoreanTriplet¨ candidates) / candidates
}

•Show ×´ 0 ⊑ GetValidTriplets 1000
# 31875000

euler-0010.bqn

#! /usr/bin/env bqn

#### Problem 10 - Summation of Primes
#    https://projecteuler.net/problem=10

# The sum of the primes below 10 is 2 + 3 + 5 + 7 = 17.

# Find the sum of all the primes below two million.

####

# Note: We can't use the the "trial division" algorithm of problem 7 here (even
# if optimized with sqrt) because it gets two slow around two million. We use
# the Sieve of Eratosthenes.

# NOTE: 
#  - On each step, we can actually start counting at the square of each prime
#    `p`. Here's why: Every multiple of p before (p^2) is a composite in which
#    dividing by p would produce either a prime smaller than p, or a number
#    divisible by a prime smaller than p. All of those were covered by previous
#    steps, so we're ok.
#  - For the reason above, we only need to check up to `sqrt(n)`, because any
#    prime above would not need to do anything before n.
#  - This implementation could have been more readable if I had made the
#    candidates start at 0 instead of 2, but YOLO again. I spent too much time
#    already on this.
GetPrimesUpToNaturalWithSieve ← {
  len ← 𝕩
  candidates ← 2+↕(len - 1)
  current ← 0 ⊑ candidates
  upperBound ← ⌊√𝕩  
  isPrimeMask ← (len - 1) ⥊ 1

  # Iterative step
  {
    # Dummy argument to make this block be treated as a function. Note: Yes,
    # this is hacky, and relies on the fact that BQN has no nullary functions.
    # This might be an anti-pattern, but YOLO.
    𝕩 

    # Bail out if current is already marked as non-prime
    (0 = (current - 2) ⊑ isPrimeMask) ? current ↩ current + 1;

    # Update mask
    MultiplesOfWBeforeXStartingAtSquareOfW ← {1↓ 𝕨 × 1+ ↕(⌊ 𝕩 ÷ 𝕨)} 
    nonPrimesForStep ← current MultiplesOfWBeforeXStartingAtSquareOfW len
    isPrimeMask  ↩ (0˙¨)⌾((nonPrimesForStep - 2)⊸⊏) isPrimeMask

    # Update current
    current ↩ current + 1

  # Repeat sqrt(n) times
  } ⍟ upperBound @
  
  isPrimeMask / candidates
}

•Show +´ GetPrimesUpToNaturalWithSieve 2_000_000
# 142913828922

euler-0011.bqn

#! /usr/bin/env bqn

#### Problem 11 - Summation of Primes
#    https://projecteuler.net/problem=11

# In the 20 * 20 grid below, four numbers along a diagonal line have been marked.
 
# 08  02  22  97  38  15  00  40  00  75  04  05  07  78  52  12  50  77  91  08
# 49  49  99  40  17  81  18  57  60  87  17  40  98  43  69  48  04  56  62  00
# 81  49  31  73  55  79  14  29  93  71  40  67  53  88  30  03  49  13  36  65
# 52  70  95  23  04  60  11  42  69  24  68  56  01  32  56  71  37  02  36  91
# 22  31  16  71  51  67  63  89  41  92  36  54  22  40  40  28  66  33  13  80
# 24  47  32  60  99  03  45  02  44  75  33  53  78  36  84  20  35  17  12  50
# 32  98  81  28  64  23  67  10 *26* 38  40  67  59  54  70  66  18  38  64  70
# 67  26  20  68  02  62  12  20  95 *63* 94  39  63  08  40  91  66  49  94  21
# 24  55  58  05  66  73  99  26  97  17 *78* 78  96  83  14  88  34  89  63  72
# 21  36  23  09  75  00  76  44  20  45  35 *14* 00  61  33  97  34  31  33  95
# 78  17  53  28  22  75  31  67  15  94  03  80  04  62  16  14  09  53  56  92
# 16  39  05  42  96  35  31  47  55  58  88  24  00  17  54  24  36  29  85  57
# 86  56  00  48  35  71  89  07  05  44  44  37  44  60  21  58  51  54  17  58
# 19  80  81  68  05  94  47  69  28  73  92  13  86  52  17  77  04  89  55  40
# 04  52  08  83  97  35  99  16  07  97  57  32  16  26  26  79  33  27  98  66
# 88  36  68  87  57  62  20  72  03  46  33  67  46  55  12  32  63  93  53  69
# 04  42  16  73  38  25  39  11  24  94  72  18  08  46  29  32  40  62  76  36
# 20  69  36  41  72  30  23  88  34  62  99  69  82  67  59  85  74  04  36  16
# 20  73  35  29  78  31  90  01  74  31  49  71  48  86  81  16  23  57  05  54
# 01  70  54  71  83  51  54  69  16  92  33  48  61  43  52  01  89  19  67  48
 
# The product of these numbers is 26 * 63 * 78 * 14 = 1788696.
 
# What is the greatest product of four adjacent numbers in the same direction
# (up, down, left, right, or diagonally) in the 20 * 20 grid?

####
 
input ← 08‿02‿22‿97‿38‿15‿00‿40‿00‿75‿04‿05‿07‿78‿52‿12‿50‿77‿91‿08‿49‿49‿99‿40‿17‿81‿18‿57‿60‿87‿17‿40‿98‿43‿69‿48‿04‿56‿62‿00‿81‿49‿31‿73‿55‿79‿14‿29‿93‿71‿40‿67‿53‿88‿30‿03‿49‿13‿36‿65‿52‿70‿95‿23‿04‿60‿11‿42‿69‿24‿68‿56‿01‿32‿56‿71‿37‿02‿36‿91‿22‿31‿16‿71‿51‿67‿63‿89‿41‿92‿36‿54‿22‿40‿40‿28‿66‿33‿13‿80‿24‿47‿32‿60‿99‿03‿45‿02‿44‿75‿33‿53‿78‿36‿84‿20‿35‿17‿12‿50‿32‿98‿81‿28‿64‿23‿67‿10‿26‿38‿40‿67‿59‿54‿70‿66‿18‿38‿64‿70‿67‿26‿20‿68‿02‿62‿12‿20‿95‿63‿94‿39‿63‿08‿40‿91‿66‿49‿94‿21‿24‿55‿58‿05‿66‿73‿99‿26‿97‿17‿78‿78‿96‿83‿14‿88‿34‿89‿63‿72‿21‿36‿23‿09‿75‿00‿76‿44‿20‿45‿35‿14‿00‿61‿33‿97‿34‿31‿33‿95‿78‿17‿53‿28‿22‿75‿31‿67‿15‿94‿03‿80‿04‿62‿16‿14‿09‿53‿56‿92‿16‿39‿05‿42‿96‿35‿31‿47‿55‿58‿88‿24‿00‿17‿54‿24‿36‿29‿85‿57‿86‿56‿00‿48‿35‿71‿89‿07‿05‿44‿44‿37‿44‿60‿21‿58‿51‿54‿17‿58‿19‿80‿81‿68‿05‿94‿47‿69‿28‿73‿92‿13‿86‿52‿17‿77‿04‿89‿55‿40‿04‿52‿08‿83‿97‿35‿99‿16‿07‿97‿57‿32‿16‿26‿26‿79‿33‿27‿98‿66‿88‿36‿68‿87‿57‿62‿20‿72‿03‿46‿33‿67‿46‿55‿12‿32‿63‿93‿53‿69‿04‿42‿16‿73‿38‿25‿39‿11‿24‿94‿72‿18‿08‿46‿29‿32‿40‿62‿76‿36‿20‿69‿36‿41‿72‿30‿23‿88‿34‿62‿99‿69‿82‿67‿59‿85‿74‿04‿36‿16‿20‿73‿35‿29‿78‿31‿90‿01‿74‿31‿49‿71‿48‿86‿81‿16‿23‿57‿05‿54‿01‿70‿54‿71‿83‿51‿54‿69‿16‿92‿33‿48‿61‿43‿52‿01‿89‿19‿67‿48

array ← 20‿20 ⥊ input

# Note: Since the operation is "product", up/down and left/right are the same.

rows ← <˘ array
columns ← <˘⍉ array

GetDiagonals ← {
  # To get diagonals so that:
  # - There is no out-of-bound issues
  # - Diagonals above and below the main diagonal are consideres
  # ... we join the array with a square array of size = num rows
  # Yes, this is strange, but visually it works.
  rowsNum ← ≠ 𝕩
  zeroArray ← (∾˜ rowsNum) ⥊ 0
  zeroPaddedArray ← 𝕩 ∾˘ zeroArray

  # Pass 𝕨 of 1 to get diagonals, and ¯1 to get antidiagonals.
  rowIndices ← 𝕨 × ↕ rowsNum


  diagonalsInColumns ← rowIndices ⌽˘ zeroPaddedArray
  diagonalsInRows ← ⍉ diagonalsInColumns

  <˘ diagonalsInRows
}

diagonals ← 1 GetDiagonals array
antiDiagonals ← ¯1 GetDiagonals array

lists ← ∾´ rows‿columns‿diagonals‿antiDiagonals
segmentsOfFour ← ∾ (4↕¨ lists)

•Show ⌈´ (×´˘ segmentsOfFour)
# 70600674

euler-0012.bqn

#! /usr/bin/env bqn

#### Problem 12 - Highly Divisible Triangular Number
#    https://projecteuler.net/problem=12
 
# The sequence of triangle numbers is generated by adding the natural numbers. So
# the 7th triangle number would be 1 + 2 + 3 + 4 + 5 + 6 + 7 = 28. The first ten
# terms would be: 1, 3, 6, 10, 15, 21, 28, 36, 45, 55, ...
 
# Let us list the factors of the first seven triangle numbers:
 
#  1 ; 1
#  3 ; 1, 3
#  6 ; 1, 2, 3, 6
# 10 ; 1, 2, 5, 10
# 15 ; 1, 3, 5, 15
# 21 ; 1, 3, 7, 21
# 28 ; 1, 2, 4, 7, 14, 28
 
# We can see that 28 is the first triangle number to have over five divisors.
 
# What is the value of the first triangle number to have over five hundred divisors?

# Note: The solution picked here is a bit brute-force. The number of divisors
# can be computed from the prime factorization, but this is a bit more complex
# and likely requires having a prime table available.

####

Divisors ← { 
  IsDivisor ← 0 = |
  PossibleDivisorsUpToSqrt ← {1↓ 1+ ↕ ⌊√𝕩}
  SmallDivisors ← { 
    divs ← PossibleDivisorsUpToSqrt 𝕩
    (𝕩 IsDivisor˜ divs) / divs
  }

  divs ← SmallDivisors 𝕩
  ⍷ ∧ 1 ∾ divs ∾ (𝕩 ÷ divs) ∾ 𝕩
}

GetFirstNthTriangleNumbers ← +` 1+ ↕
GetNthTriangleNumber ← +´ 1+ ↕

# Found boundary 13_000 by trial and error
triangles ← GetFirstNthTriangleNumbers 13_000
numDivisors ← (≠ Divisors)¨ triangles

nthResultTriangle ← 0 ⊑ / (500 < numDivisors)

•Show nthResultTriangle ⊑ triangles
# 76576500