text:
Jumping Numbers
A jumping number is defined as a positive number n which all pairs of consecutive decimal digits differ by 1. Also, all single digit numbers are considered jumping numbers. eg. 3, 45676, 212 are jumping numbers but 414 and 13 are not. The difference between 9 and 0 is not considered as 1
The challenge
Create a program that output one of the following results:

Given an input n output the first n jumping numbers.
Given an input n output the nth term of the sequence.

Note

Any valid I/O format is allowed
1-index or 0-index is allowed (please specify)

Here are some jumping numbers:
1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 12, 21, 23, 32, 34, 43, 45, 54, 56, 65, 67, 76, 78, 87, 89, 98, 101, 121, 123, 210, 212, 232, 234, 321, 323, 343, 345, 432, 434, 454, 456, 543, 545, 565, 567, 654, 656, 676, 678, 765, 767, 787, 789, 876, ...

This is also A033075

Is this 0 or 1 Indexed?

@TaylorScott The sequence consists in only positive numbers. If you mean the input n then it is up to you.

I'm guessing "Any valid I/O format is allowed" includes outputting the numbers as lists of decimal digits, but just wanted to confirm - ?

Yes @JonathanAllan

Haskell, 57 bytes
(l!!)
l=[1..9]++[x*10+t|x<-l,t<-[0..9],(mod x 10-t)^2==1]

Try it online!

Jelly, 8 bytes
1DI*`ƑƊ#

A full program accepting an integer, n, from STDIN which prints a list of the first n positive jumping numbers.
Try it online!
How?
Acceptable incremental differences between digits are 1 and -1 while others from [-9,-2]+[2,9] are not. This lines up with integers which are invariant when raised to themselves. i.e. \$x^x=x\$ since:
$$0^0=1$$
$$1^1=1$$
$$2^2=4$$
$$\cdots$$
$$-1^{-1}=-1$$
$$-2^{-2}=-\frac{1}{4}$$
$$\cdots$$
1DI*`ƑƊ# - Main Link: no arguments (accepts a line of input from STDIN)
       # - count up keeping the first (input) n matches...
1        - ...start with n equal to: 1
      Ɗ  - ...match function: last three links as a monad:  e.g. 245       777      7656
 D       -   convert to a list of decimal digits                 [2,4,5]   [7,7,7]  [7,6,5,6]
  I      -   incremental differences                             [2,1]     [0,0]    [-1,-1,1]
     Ƒ   -   invariant under?:
    `    -     using left argument as both inputs of:
   *     -       exponentiation (vectorises)                     [4,1]     [1,1]    [-1,-1,1]
         -                                            --so we:   discard   discard  keep
         - implicitly print the list of collected values of n

05AB1E (legacy), 5 bytes
The input is 1-indexed.
Code:
µN¥ÄP

Uses the 05AB1E encoding. Try it online!

Explanation
µ          # Get the nth number, starting from 0, such that...
   Ä       #   The absolute values
 N¥        #   Of the delta's of N
    P      #   Are all 1 (product function, basically acts as a reduce by AND)

Right tool for the job.

Python 2, 79 75 bytes
-4 bytes by xnor
f=lambda n,i=1:n and-~f(n-g(i),i+1)
g=lambda i:i<10or i%100%11%9==g(i/10)>0

Try it online!
Derived from Chas Brown's answer. The helper function g(i) returns whether i is a jumping number. Iff the last two digits of a number n have absolute difference 1, then n%100%11 will be either 1 or 10, so n%100%11%9 will be 1.

Nice trick with the %11. You can do f=lambda n,i=1:n and-~f(n-g(i),i+1) if you switch to one-indexing.

APL (Dyalog Unicode), 36 bytesSBCS
1-indexed. Thanks to dzaima for their help with golfing this.
Edit: -15 bytes from ngn.
1+⍣{∧/1=|2-/⍎¨⍕⍺}⍣⎕⊢0

Try it online!
Explanation
We have f⍣g⍣h, where, as ⍣ is an operator, APL translates this to (f⍣g)⍣h. (In contrast with functions where 2×3+1 is translated 2×(3+1))
1+⍣{...}⍣⎕⊢0  This is equivalent to
               "do {check} we find the n-th integer that fulfils {check}"

1+⍣{...}   ⊢0  Start with 0 and keep adding 1s until the dfn
               (our jumping number check in {}) returns true.
        ⍣⎕    We take input n (⎕) and repeat (⍣) the above n times
               to get the n-th jumping number.

{∧/1=|2-/⍎¨⍕⍺}  The dfn that checks for jumping numbers.

         ⍎¨⍕⍺   We take the base-10 digits of our left argument
                 by evaluating each character of the string representation of ⍺.
     |2-/        Then we take the absolute value of the pairwise differences of the digits
 ∧/1=            and check if all of the differences are equal to 1.

10⊥⍣¯1⊢⍺ -> ⍎¨⍕⍺

it's much shorter with ⍣ instead of recursion: {1+⍣{∧/1=|2-/⍎¨⍕⍺}⍣⍵⊢0} or 1+⍣{∧/1=|2-/⍎¨⍕⍺}⍣⎕⊢0

"⍣ is an operand" - it's an "operator" (i this mistake in chat and corrected it, but it seems you picked up the initial version. sorry)

C (gcc), 90 bytes
f(n,K,b,k){for(K=0;n;b&&printf("%d,",K,n--))for(b=k=++K;k/10;)b*=abs(k%10-(k/=10)%10)==1;}

Try it online!

Japt, 14 bytes
Outputs the first nth term, 1-indexed.
_ì äa dÉ ªU´}f

Try it
(I know, I know, I'm supposed to be taking a break but I'm in golf withdrawal!)

Haha, maybe go learn a new golfing language to cure your withdrawal. :P

Haskell, 69 bytes

Thanks to Joseph Sible for enforcing the challenge rules and saving three bytes.
Saved two bytes thanks to nimi.

(filter(all((==1).abs).(zipWith(-)<*>tail).map fromEnum.show)[1..]!!)

Try it online!

This appears to answer the question "is this a jumping number?" for a given input number, which isn't what the challenge asked for.

@JosephSible You are correct. Thank you for noting.

Also, now that that's fixed, you can make g 3 bytes shorter by rewriting it to be pointfree, then using <*>: g=all((==1).abs).(zipWith(-)<*>tail).map(read.pure).show

@JosephSible Thank you.

@nimi Done. Thank you.

Python 2, 88 87 bytes
f=lambda n,i=2:n and f(n-g(i),i+1)or~-i
g=lambda i:i<10or abs(i/10%10-i%10)==1==g(i/10)

Try it online!
Returns the 0-indexed jumping number (i.e., f(0) => 1, etc).

@lirtosiast : That's OK, please donate your answer to your favorite charity :). It's sufficiently different to merit a separate response (as well as being cross-language appropriate).

Jelly, 9 bytes
-1 by Jonathan Allan
1DạƝ=1ẠƲ#

Try it online!
1-indexed.

9 bytes by reading STDIN

JavaScript (ES7), 60 bytes
Returns the \$n\$th term of the sequence (1-indexed).
f=(n,k)=>[...k+''].some(p=x=>(p-(p=x))**2-1)||n--?f(n,-~k):k

Try it online!

Swift, 228 bytes
func j(n:Int){
var r:[Int]=[]
for x in 0...n{
if x<=10{r.append(x)}else{
let t=String(x).compactMap{Int(String($0))}
var b=true
for i in 1...t.count-1{if abs(t[i-1]-t[i]) != 1{b=false}}
if b{r.append(x)}
}
}
print(r)
}
j(n:1000)

Try it online!

Python 3, 122 121 bytes
g=lambda s:len(s)==1or 1==abs(ord(s[0])-ord(s[1]))and g(s[1:])
def f(n,i=1):
	while n:
		if g(str(i)):n-=1;yield i
		i+=1

Try it online!
-1 byte by changing f from printing, to a generator function.
g is a recursive helper function which determines if a string s is a "jumping string" (this works since the character codes for 0 to 9 are in order and contiguous).
f is a generator function that takes in n and yields the first n jumping numbers.

R, 85 bytes
i=scan();j=0;while(i)if((j=j+1)<10|all(abs(diff(j%/%10^(0:log10(j))%%10))==1))i=i-1;j

Try it online!
Suspect this can be golfed more. Reads the number using scan() and outputs the appropriate jumping number.

Perl 5, 56 bytes
map{1while++$n=~s|.(?=(.))|abs$&-$1!=1|ger>9}1..<>;say$n

Try it online!
1-indexed, outputs the nth jumping number

Wolfram Language (Mathematica), 85 bytes
If[#<10,#,t=n=1;While[t<=#,{-1,1}~SubsetQ~Differences@IntegerDigits@n++~If~t++];n-1]&

Try it online!
returns the n-th number

Factor, 129 bytes
: f ( x -- ) 1 [ [ dup 10 >base >array differences [ abs 1 = ] all? ] [ 1 + ] until
dup . 1 + [ 1 - ] dip over 0 > ] loop 2drop ;

Try it online!
Outputs the first n jumping numbers

Catholicon, 5 bytes
ρHṘḃǰ

Try it online!


text:
Unique Brick Tilings Within A Rectangle
I was browsing Stackoverflow and saw this question about tiling an MxN rectangle, and I thought it would be great for golfing. Here is the task.
Given the dimension M and N, write a program that outputs how many unique ways a MxN rectangle (N is the number of rows, not columns. Not that it really matters) can be tiled given these constraints.

All tiles are 2x1 or 3x1
All tiles stay within their row (ie they are all horizontal)
Between every two adjacent rows tiles should not be aligned, except on the two ends
M and N are guaranteed to be at least 1

For example, a valid tiling of a 8x3 matrix would be
  2    3     3
  |    |     |
  v    v     v
 _______________
|___|_____|_____|
|_____|_____|___|
|___|_____|_____|

But the following would be invalid, because the rows align
  2    3     3
  |    |     |
  v    v     v
 _______________
|___|_____|_____|
|_____|___|_____|
|_____|_____|___|

Test cases:
8x3: 4
3x1: 1
1x1: 0
9x4: 10
Code golf, so shortest answer wins.

Your description of the size of the tiles seems to use a different convention from the size of the rectangle. Are the tiles actually 2x1 or 3x1? Also is the output for 4x1 zero?

Welcome. Nice challenge concept, however it's usually best to use the sandbox to hammer out challenge ideas before posting them to main.

@FryAmTheEggman It looks like OP has tried to make |s not contribute to the length of the row, by using a representation like this (where, if there's not a pipe (|), there's a space).

Related: Build a steady brick wall

what is the purpose of reversing the standard order of rows X columns?  it seems to promote confusion without adding any value.

@Jonah, like I said it doesn't really matter. I was just trying to minimize differences from the original question

The referenced question on SO is no more.

Jelly, 20 bytes
2*ḃ€2‘ÄṪ⁼¥Ƈ⁸ṗfƝẸ$€ċ0

Try it online!

I know speed wasn’t part of the spec, but this timed out on even 11x10 when run on tio. I’d be interested in an explanation to understand why.

@NickKennedy That's too big an input. For width 11, each row can have one of 9 different tilings. For width 11 and height 10, there are 9¹⁰=3486784401 possible walls, including invalid ones. That's how Cartesian power works. Obviously, TIO doesn't have the time to let my solution compute the whole array of walls (it times out after 60 seconds). I'll add an explanation when I get the time to.

thanks. I’ve looked at jelly a little, but at the moment I’m reliant on commented explanations to understand what people’s code does. I’d assumed given the time issue that your code brute forces the solution, which is a sensible way of minimising code requirements.

Out of interest I’ve recreated in Jelly the method in my R code using the first part of your code. It’s at Try it online! and while it’s considerably longer than yours, it handles larger numbers. Note it doesn’t handle 1 row properly at present. I suspect it could be much more concise, but I’m new to Jelly.

JavaScript (ES6),  119 110 106 96  91 bytes
Takes input as \$(N,M)\$.
f=(n,m,p=0,g=(w,h=x=>g(p[g[w-=x]=1,w]||w)*g[w]--)=>w>3?h(2)+h(1):w>1&&f(n,m-1,g))=>m?g(n):1

Try it online!
Commented
NB: This code uses 3 different functions that call each other. This makes it a bit difficult to keep track of the scope of the variables. Keep in mind that \$g\$ is defined within the scope of \$f\$ and \$h\$ is defined within the scope of \$g\$.
f = (                    // f is a recursive function taking:
  n,                     //   n = number of columns
  m,                     //   m = number of rows
  p = 0,                 //   p = object holding the previous row
  g = (                  //   g = recursive function taking:
    w,                   //     w = remaining width that needs to be filled in the
                         //         current row
    h = x =>             //     h = helper function taking x
                         // h body:
      g(                 //   recursive call to g:
        p[g[w -= x] = 1, //     subtract either 2 or 1 from w and mark this width as used
          w              //     test p[w]
        ]                //     pass p[w] if p[w] = 1 (which will force the next iteration
                         //     to fail immediately)
        || w             //     otherwise, pass w
      )                  //   end of recursive call
      * g[w]--           //   then restore g[w] to 0
  ) =>                   // g body:
    w > 3 ?              //   if w > 3, we need to insert at least 2 more bricks:
      h(2) + h(1)        //     invoke h with x = 2 and x = 1
    :                    //   else:
      w > 1              //     this is the last brick; we just check if it can be inserted
      &&                 //     abort if w is equal to 1 (a brick does not fit in there)
      f(                 //     otherwise, do a recursive call to f:
        n,               //       n is unchanged
        m - 1,           //       decrement m
        g                //       pass g as the new reference row
      )                  //     end of recursive call
) =>                     // f body:
  m ? g(n) : 1           //   yield 1 if we made it to the last row or call g otherwise

R, 243 231 bytes
function(m,n,i=2*0:(m%/%6)+m%%2,j=i+(m-3*i)/2,M=Map)`if`(m<2,0,sum((e=eigen(lengths(outer(p<-unlist(M(M,list(function(x,y)cumsum(2+1:y%in%x)),M(combn,j,i,s=F),j),F),p,Vectorize(intersect)))<2))$ve%*%diag(e$va^(n-1))%*%solve(e$ve)))

Try it online!
Version with line breaks:
function(m,n,i=2*0:(m%/%6)+m%%2,j=i+(m-3*i)/2,M=Map)`if`(m<2,0,
sum((e=eigen(lengths(outer(p<-unlist(M(M,list(function(x,y)cumsum(2+1:y%in%x)),
M(combn,j,i,s=F),j),F),p,Vectorize(intersect)))<2))$ve%*%diag(e$va^(n-1))%*%solve(e$ve)))

Note no recursion, and handles fairly large values of m and n (e.g. 24x20 -> 3.3e19)
Here's a commented answer that works more or less the same as the above, but I've unnested all of the functions so it's actually readable:
f <- function(m,n) {
  # First work out what potential combinations of 2s and 3s add up to m
  i <- 2*0:(m %/% 6) + m %% 2 # Vector with numbers of possible 3s
  j <- i + (m - 3 * i) / 2 # Vector with total number of 2s and 3s
  if (m < 2) {
    0 # If wall less than 2 wide, no point in continuing because answer is 0
  } else {
    # Work out all possible positions of threes for each set
    positions_of_threes <- Map(combn, j, i, simplify = FALSE)
    # Function to work out the cumulative distance along the wall for a given
    # Set of three positions and number of bricks
    make_cumulative_bricks <- function(pos_threes, n_bricks) {
      bricks <- 1:n_bricks %in% pos_threes
      cumsum(2 + bricks)
    }
    # Find all possible rows with cumulative width of wall
    # Note because this is a `Map` with depth two that needs to be vectorised
    # for both `positions_of_threes` and `j`, and we're using base R, the
    # function `make_cumulative_bricks` needs to be placed in a list
    cum_bricks <- Map(Map, list(make_cumulative_bricks), positions_of_threes, j)
    # Finally we have the list of possible rows of bricks as a flat list
    cum_bricks_unlisted <- unlist(cum_bricks, recursive = FALSE)
    # Vectorise the intersect function
    intersect_v <- Vectorize(intersect, SIMPLIFY = FALSE)
    # Find the length of all possible intersects between rows
    intersections <- outer(cum_bricks_unlisted, cum_bricks_unlisted, intersect_v)
    n_intersections <- lengths(intersections)
    # The ones not lined up will only have a single intersect at `m`
    not_lined_up <- n_intersections == 1
    # Now use method described at https://stackoverflow.com/a/9459540/4998761
    # to calculate the (matrix of TRUE/FALSE for lined-up) to the power of `n`
    eigen_nlu <- eigen(not_lined_up)
    final_mat <- eigen_nlu$vectors %*%
      diag(eigen_nlu$values ^ (n - 1)) %*%
      solve(eigen_nlu$vectors)
    # The sum of this matrix is what we're looking for
    sum(final_mat)
  }
}
f(20,20)

The method for taking a matrix and repeatedly multiplying it by itself is from a question on stackoverflow. This approach works here because it effectively calculates the cumulative number of branches through the different possible rows of bricks.
If external packages are allowed, I can get it down to 192:
function(m,n,i=2*0:(m%/%6)+m%%2,j=i+(m-3*i)/2,M=purrr::map2)`if`(m<2,0,sum(expm::`%^%`(lengths(outer(p<-unlist(M(M(j,i,combn,s=F),j,M,~cumsum(2+1:.y%in%.)),F),p,Vectorize(intersect)))<2,n-1)))

Jelly, 26 bytes
2*ḃ€2‘ÄṪ⁼¥Ƈ⁸œ&L¬ɗþ`æ*⁴’¤SS

Try it online!
Broken down:
Generate a list of possible walls as cumulative sums with the end removed:
2*ḃ€2‘ÄṪ⁼¥Ƈ⁸

Find the outer table of all possible walls against each other that don’t have any intersections:
œ&L¬ɗþ`

Take this matrix to the power of (N-1) and then sum it all up:
æ*⁴’¤SS

Uses the first bit from @EriktheOutgolfer’s answer to generate the list of possible walls, and then uses the matrix intersection and matrix exponentiation approach from my R answer. As such, it works well even with large N. This is my first Jelly answer, and I suspect it can be golfed more. I’d also ideally like to change the first section so that the time and memory requirements don’t scale exponentially with M.

05AB1E, 42 bytes
Åœʒ23yåP}€œ€`Ùε.¥¦¨}IиI.ÆÙεøyíø‚€€üQOO_P}O

I'm almost too ashamed to post this, and it can definitely be golfed by A LOT with a different approach, but since it took a while to complete I decided to post it anyway and golf it down from here. The challenge looks easier than it is imo, but I'm definitely using a wrong approach here and I have the feeling 05AB1E could do around 25 bytes..
Try it online. NOTE: Not only is it long, it's also inefficient, since the 9x4 test case runs in about 40 seconds on TIO..
Explanation:
Åœ             # Get all possible ways to sum to the (first) implicit input
               #  i.e. 8 → [[1,1,1,1,1,1,1,1],[1,1,1,1,1,1,2],[1,1,1,1,1,3],[1,1,1,1,2,2],[1,1,1,1,4],[1,1,1,2,3],[1,1,1,5],[1,1,2,2,2],[1,1,2,4],[1,1,3,3],[1,1,6],[1,2,2,3],[1,2,5],[1,3,4],[1,7],[2,2,2,2],[2,2,4],[2,3,3],[2,6],[3,5],[4,4],[8]]
  ʒ23yåP}      # Only leave those consisting of 2s and/or 3s
               #  → [[2,2,2,2],[2,3,3]]
         €œ    # For each: get all permutations
           €`  # Flatten this list of lists once
             Ù # And uniquify it (leaving all possible distinct rows of bricks)
               #  → [[2,2,2,2],[3,3,2],[3,2,3],[2,3,3]]
ε    }         # For each:
 .¥            #  Get the cumulative sum
   ¦¨          #  With the leading 0 and trailing first input removed
               #   → [[2,4,6],[3,6],[3,5],[2,5]]
      Iи       # Repeat this list the second input amount of times
               #  i.e. 3 → [[2,4,6],[3,6],[3,5],[2,5],[2,4,6],[3,6],[3,5],[2,5],[2,4,6],[3,6],[3,5],[2,5]]
        I.Æ    # Get all combinations of lists the size of the second input
           Ù   # And uniquify the result (leaving all possible distinct walls)
               #  → [[[2,4,6],[3,6],[3,5]],[[2,4,6],[3,6],[2,5]],[[2,4,6],[3,6],[2,4,6]],[[2,4,6],[3,6],[3,6]],[[2,4,6],[3,5],[2,5]],[[2,4,6],[3,5],[2,4,6]],[[2,4,6],[3,5],[3,6]],[[2,4,6],[3,5],[3,5]],[[2,4,6],[2,5],[2,4,6]],[[2,4,6],[2,5],[3,6]],[[2,4,6],[2,5],[3,5]],[[2,4,6],[2,5],[2,5]],[[2,4,6],[2,4,6],[3,6]],[[2,4,6],[2,4,6],[3,5]],[[2,4,6],[2,4,6],[2,5]],[[2,4,6],[2,4,6],[2,4,6]],[[3,6],[3,5],[2,5]],[[3,6],[3,5],[2,4,6]],[[3,6],[3,5],[3,6]],[[3,6],[3,5],[3,5]],[[3,6],[2,5],[2,4,6]],[[3,6],[2,5],[3,6]],[[3,6],[2,5],[3,5]],[[3,6],[2,5],[2,5]],[[3,6],[2,4,6],[3,6]],[[3,6],[2,4,6],[3,5]],[[3,6],[2,4,6],[2,5]],[[3,6],[2,4,6],[2,4,6]],[[3,6],[3,6],[3,5]],[[3,6],[3,6],[2,5]],[[3,6],[3,6],[2,4,6]],[[3,6],[3,6],[3,6]],[[3,5],[2,5],[2,4,6]],[[3,5],[2,5],[3,6]],[[3,5],[2,5],[3,5]],[[3,5],[2,5],[2,5]],[[3,5],[2,4,6],[3,6]],[[3,5],[2,4,6],[3,5]],[[3,5],[2,4,6],[2,5]],[[3,5],[2,4,6],[2,4,6]],[[3,5],[3,6],[3,5]],[[3,5],[3,6],[2,5]],[[3,5],[3,6],[2,4,6]],[[3,5],[3,6],[3,6]],[[3,5],[3,5],[2,5]],[[3,5],[3,5],[2,4,6]],[[3,5],[3,5],[3,6]],[[3,5],[3,5],[3,5]],[[2,5],[2,4,6],[3,6]],[[2,5],[2,4,6],[3,5]],[[2,5],[2,4,6],[2,5]],[[2,5],[2,4,6],[2,4,6]],[[2,5],[3,6],[3,5]],[[2,5],[3,6],[2,5]],[[2,5],[3,6],[2,4,6]],[[2,5],[3,6],[3,6]],[[2,5],[3,5],[2,5]],[[2,5],[3,5],[2,4,6]],[[2,5],[3,5],[3,6]],[[2,5],[3,5],[3,5]],[[2,5],[2,5],[2,4,6]],[[2,5],[2,5],[3,6]],[[2,5],[2,5],[3,5]],[[2,5],[2,5],[2,5]]]
ε              # Map all walls `y` to:
 ø             #  Zip/transpose; swapping rows and columns
 yí            #  Reverse each row in a wall `y`
   ø           #  Also zip/transpose those; swapping rows and columns
 ‚             #  Pair both
  €            #  For both:
   €           #   For each column:
    ü          #    For each pair of bricks in a column:
     Q         #     Check if they are equal to each other (1 if truthy; 0 if falsey)
    O          #    Then take the sum of these checked pairs for each column
   O           #   Take the sum of that entire column
   _           #   Then check which sums are exactly 0 (1 if 0; 0 if anything else)
   P           #   And check for which walls this is only truthy by taking the product
}O             # After the map: sum the resulting list
               # (and output it implicitly as result)

Charcoal, 89 bytes
Ｎθ⊞υ⟦⟧≔⟦⟧ηＦυＦ⟦²¦³⟧«≧⁺∧Ｌι§ι⁰κ¿⁼κθ⊞ηι¿‹κθ⊞υ⁺⟦κ⟧ι»≔Ｅη⟦ι⟧ζＦ⊖Ｎ«≔ζι≔⟦⟧ζＦιＦη¿¬⊙§κ⁰№λμ⊞ζ⁺⟦λ⟧κ»ＩＬζ

Try it online! Link is to verbose version of code. Works for rectangles of size up to about 12 on TIO, but could be made about three times faster at a cost of 2 bytes by using bit twiddling instead of list intersection. Explanation:
Ｎθ

Input the width.
⊞υ⟦⟧

Start with a row with no bricks.
≔⟦⟧η

Start with no completed rows.
Ｆυ

Loop over the rows.
Ｆ⟦²¦³⟧«

Loop over the bricks.
≧⁺∧Ｌι§ι⁰κ

Add the brick width to the current row width.
¿⁼κθ⊞ηι

If this results in the input width then add this row to the list of completed rows.
¿‹κθ⊞υ⁺⟦κ⟧ι»

Otherwise if this is still less than the input width then add the new row to the list of rows, thus causing it to be picked up by a later iteration.
≔Ｅη⟦ι⟧ζ

Make a list of walls of one row.
Ｆ⊖Ｎ«

Loop over one less than the height.
≔ζι

Save the list of walls.
≔⟦⟧ζ

Clear the list of walls.
Ｆι

Loop over the saved list of walls.
Ｆη

Loop over the completed rows.
¿¬⊙§κ⁰№λμ⊞ζ⁺⟦λ⟧κ»

If the row can be added to this wall then add that to the list of walls.
ＩＬζ

Output the length of the final list of walls.

source: Stack Exchange

license: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/4.0/

sort: votes


text:
Average Idle-Dice Rolling
So I ran into this progressive/idle game cleverly called Idle Dice. Has a variety of random effects applied to a pretty typical progression formula game. Warning, time sink! Play at your own risk.
However after you have 5 dice (summed the usual way) along with some bonuses for various matches (pair, two pair, three of a kind, etc), but after that you eventually get multiplier dice. These five dice are all multiplied against the total rolled by the first five dice and multiplicatively combine with each other.
Even later on you get access to a roulette wheel which can (if it lands on the right wedges) "skip 10 minutes." Sometimes longer, but all intervals are some multiple of 10 minutes.
Your task:
Given the multiplier dice I have, how much will I make when I land on the "skip 10 minutes" wedge of the roulette wheel (figuring I can calculate the 20 minute and 1 hour wedges from there)? We'll ignore any upgraded multipliers and focus solely on the flat base values of each die (incremental games, being what they are, get to obscenely large values in a hurry).
Input

Five values in any reasonable format. Each value represents the number of faces of each of the five multiplier dice.

Missing dice can either be explicitly specified (as 0) or left absent, your choice as long as it is made clear how your program accepts it.
You can assume input values of 0, 2, 4, 6, 8, 10, 12, 20, and 100 will be used.
For example an input of [6,6,4,2] would indicate that there are 2 six-sided multiplier dice, 1 four sided, and 1 two sided, while 6 6 4 2 0 would also be acceptable.

How the dice roll

All ten dice are rolled once a second
The five base dice are summed
The sum is multiplied by each of the five multiplier's dice's face value
That total is multiplied by the score bonus (if any)

The dice

The five basic (six sided) dice will be assumed all present.

Score bonus values:
We'll assume the following score multipliers (which apply to the face results of the base 5 dice, not the multiplier dice):

Pair: 2
Triplet: 7
Two-Pair: 5
Four of a Kind: 60
Straight: 20
Full House (pair + triplet): 30
Five of a Kind: 1500

This page has the odds listed out for the likelyhood of any given result, except a straight for some reason, which is 240/7776 (what's called a Large Straight, rather than a Short Straight).
Note: My original test cases were computed using an incorrect value of 2600/7776 odds for a Pair (correct value should be 3600). Given the existing answers, I am not fixing this.
Output:
Compute the expected average total over a 10 minute period (600 rolls) based on the inputs provided, assuming all dice are uniformly distributed. Output need only be accurate to the nearest whole value, but more precision is allowed.
Test cases
Two extra decimal-fractions of precision included for convenience.
[2] -> 111643.52
[4] -> 186072.53
[6] -> 260501.54
[8] -> 334930.56
[10] -> 409359.57
[12] -> 483788.58
[20] -> 781504.63
[100] -> 3758665.12
[2,2,2] -> 251197.92
[4,2,2] -> 418663.19
[6,6,6] -> 3191143.90
[2,2,2,2,2] -> 565195.31
[6,6,6,6,6] -> 39091512.83
[10,8,6,4,2] -> 24177799.48
[100,20,2,2,2] -> 133197695.3
[100,20,12,2,2] -> 577190013.02
[100,20,12,10,8] -> 6349090143.23
[100,100,100,100,100] -> 24445512498226.80

Note: Before you port the R answer note that it is not meeting requirements (for example the result for 20,20,20,20,20 is off by 1).

Could you check the results for 100,20,12,10,8 and 100,100,100,100,100?

@JonathanAllan I may have miscalculated when I was writing up the post, double checking...

@JonathanAllan Corrected. I also noticed a discrepancy in recalculating that I'd mis-typed the odds for a Pair as 2600 (instead of 3600), but given the existing answers I will not be fixing that. [100,100,100,100,100] was off only in the last 3 digits, [100,20,12,10,8] was horrifically wrong. Thanks for the spot-check; those two I'd calculated differently, as the values were so large, and likely made a mistake somewhere.

Looks like there may be more miscalculations - see this Python 3 @ TIO (tinyurl used as link too long for comment) - this limits pairs to 2600, and finds a "multiplier" of 75319.29012345678 (I believe the correct one, with all 3600 pairs, to be 76805.5555555555 = 600*995400/6^5)

@JonathanAllan Ah, I know what it is. And its my own stupid fault too (sigh (I graduated college and forgot how to Math)). Straights are counted again in the no match count of 720. Option (a) leave the challenge alone or option (b) update all the test cases and invalidate answers.

@Draco18s I believe you should be OK to invalidate answers so long as you comment and notify each answerer.

R, 50 32 bytes
function(M)prod(M/2+.5)*691250/9

Try it online!
-17 Bytes thanks to Nick Kennedy, and thanks to Jonathan Allan for suggesting a precision fix, with no byte loss!
Ignores any missing bonus dice. Just a brute force approach.
Works pretty well, but integers get promoted to doubles once we get past the 2-billion mark (2^31-1), leading to a loss of precision.
Because the "regular" and "bonus" dice are independent, \$E[RB]=E[R]E[B]\$, easing the calculations to simply calculating \$E[B]\$ (which is again the prod of the expected values of each die) and scaling by \$E[R]\$, easily calculated from the given test cases.

How about [https://tio.run/##K/qfpmCj@z@tNC@5JDM/T8NXs6AoP0VDw1fbUFPfSFPL3MTEyFLPwPB/mkayhpGBpiYXmKEDhFC2oYGOhY6ZjgmSgIGOkYEOqhqwkCFU7D8A Try it online!]? Only 33 bytes

Works with all examples too: Try it online!

@NickKennedy nice! Edited; found another byte to golf off as well.

The example 100,20,12,10,8 seems off by a lot? 76189081718.75 vs 6349089943. Are we supposed to be accurate to the nearest whole number?

@dana I think the question is wrong since both answers agree

While the precision loss at 2^31 may help, this is still off by 1 for five 20 sided dice. I think (although am not 100% certain) that 74429.012 would do.

...also I believe that an answer should theoretically give the correct answer if precision were not lost (which would, I believe, require 74429.01234615).

The expectation is 600*964600/6/6/6/6/6 so function(M)prod((M+1)/2)*6028750/81 would work properly for 35.

@JonathanAllan thanks, that's an excellent suggestion.

...and if the post gets matched to reality that will become 600*995400/6/6/6/6/6 = 691250/9 :)

@JonathanAllan no idea why it took me so long to fix that, but thanks for both suggestions!

Jelly, 16 bytes
‘HP×“¡LT⁼þd+’÷Ø%

Try it online!
‘              Add 1 to each input element
 H             Halve; this is the expected value of each die.
  P            Product.
   ×“¡LT⁼þd+’  Multiply by 319670173900294.
   ÷Ø%         Divide by 2^32.
               319670173900294/2^32 is approximately 74429.01234615,
                 the expected value of the dice before the multiplier.

By the law of total expectation, the expected product of independent random values is the product of the expected values. The expected value of each n-sided multiplier die is simply (n+1)/2.

‘HP×“©Ȥ^ƭẈr’÷ȷ8 is spot on and saves a byte :)

...in fact, since the true expectation is 964600*600/6/6/6/6/6 = 6028750/81, we can do ‘HP×“_qż’÷81 for 12 bytes.

JavaScript, 35 bytes
Port of Giuseppe's R solution.
a=>a.map(n=>x*=++n/2,x=74429.01)&&x

Try It Online!

Output need only be accurate to the nearest whole value

Japt, 19 18 bytes
rÈ*°Y/2}6028750/81

-1 byte thanks to @Shaggy
Try it online!
With slightly less precision: 17 bytes
rÈ*½*(YÄ}74429.01

...except for the fact that it fails to satisfy requirements - "Output need only be accurate to the nearest whole value".

@JonathanAllan Does this work, then? It seems like 74429.012 fails for smaller values.

Looks like it; what is #Ÿ835086950#“Ñ/2pH?

@JonathanAllan 319670173900294/(2^32) with marginal compression using charcodes- shoco doesn't work on numbers, argh. There's probably a better way to compress numbers but this is all I can think of, still new to the language

Would multiplying by 6028750 and then dividing by 81 be shorter? (I believe that is the actual value i.e. 600*964600/6^5)

@JonathanAllan seems to give me a different result

@JonathanAllan https://www.wolframalpha.com/input/?i=319670173900294+%2F+(2%5E32) gives a different fraction

Well, it's a different number. Where does 319670173900294/(2^32) come from? Is 600*964600/6^5 not the correct expectation for the 600 rolls?

@JonathanAllan It does not match the output given in the question. I'll think about this more.

Hmm, it matches all but the last two to the 2dp given... (and the penultimate example looks way off, so we cannot compare that).

...and now matches all to 1dp and all but the last to 2dp.

@JonathanAllan Got it, thanks!

-1 byte

@Shaggy Ooh, nice, thanks

05AB1E, 12 bytes
>;P•₅·e•*81/

Port of @lirtosiast's Jelly answer combined with @JonathanAllan's comment (which states \$6028750/81 == 964600*600/6/6/6/6/6\$).
Try it online or verify all test cases.
Explanation:
>             # Increase each value in the (implicit) input-list by 1
              #  i.e. [100,20,12,2,2] → [101,21,13,3,3]
 ;            # Halve each value in the list
              #  i.e. [101,21,13,3,3] → [55.5,10.5,6.5,1.5,1.5]
  P           # Take the product of this list
              #  i.e. [55.5,10.5,6.5,1.5,1.5] → 7754.90625
   •₅·e•*     # Multiply it by the compressed integer 6028750
              #  i.e. 7754.90625 * 6028750 → 46752391054.6875
         81/  # Then divide it by 81
              #  i.e. 46752391054.6875 / 81 → 577190013.0208334
              # (and output implicitly as result)

See this 05AB1E answer of mine (section How to compress large integer?) to understand why •₅·e• is 6028750.

all_licenses: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/4.0/


text:
45 degree quine
A very simple golf this time, but should be fun to do.
Challenge
Output your code, but rotated 45 (or -45) degrees. E.g:
lorem ipsum dolor sit amet
becomes
                         t
                        e
                       m
                      a

                    t
                   i
                  s

                r
               o
              l
             o
            d

          m
         u
        s
       p
      i

    m
   e
  r
 o
l

This logic follows for newlines, too:
lorem ipsum dolor sit amet
consectetur adipiscing
becomes
                         t
                        e
                       m
                      a
                       g
                    t n
                   i i
                  s c
                   s
                r i
               o p
              l i
             o d
            d a

          m r
         u u
        s t
       p e
      i t
       c
    m e
   e s
  r n
 o o
l c

Of course, the difficulty is that you have to output your own code in this format.
Scoring
Find position b (the amount of bytes in your code). on the X-axis of the formula \$y=\left(\frac{b}{8}-15\right)^2-n\$ (given n is the number of newlines). The lower the score, the better. Newlines are encouraged, as they made rendering it harder. Also, -15 bonus points for doing -45 degrees, as opposed to 45. My examples were -45 degrees.
Rules

Standard loopholes apply.
No reading your own source.
There must be a space between one line of code and the next, if you choose to do so
Every line must be at least 5 characters long.
Newlines cannot be replaced with '\n'. Tabs should be replaced with two spaces.
Every line must do something; when removed, the program must not work
No trailing newlines (unless for an implicit return) or no-ops.
Blank newlines should be rendered with a space in its place (you can assume its a line of contents ' ')

What does "There must be a space between one line of code and the next, if you choose to do so" mean?

If you take a look at my second example, the text that was originally on two lines is now on one line, separated by space. E.g you can see it goes 'L C' on the bottom row of the second example, not 'LC'

Also, the scoring system seems to mean that there's no point to having code under 120 bytes?

I am sad that the second line is two columns right instead of one right and one down.

May we print anything to STDERR?

How does the scoring work? I feel like I did it wrong, I hv=ave the smallest byte count, but the highest score? My program fits all of the rules too! I feel like I'm missing something here...

Just FYI, this isn't code-golf anymore, it's code-challenge, since the criterion isn't strictly lowest byte count.

I think what @dfeuer meant was whether the space between characters was optional or not, since you specify the conflicting statements There must be a space and if you choose to do so

@JoKing If you choose to have newlines in your code

How do trailing newlines get rotated?  Do I need to add any characters for them?

@SriotchilismO'Zaic There can't be trailing newlines, since each line must have at least 5 chars

What do you mean by Every line must do something; when removed, the program must not work? For example, my Perl 6 solution still runs when one of my padded lines is removed but it doesn't produce the correct output anymore. Similarly, most one-line solutions will still run when the newlines are removed, and they do produce the correct output (nothing). Do you mean to invalidate my solution or the other solutions?

Are we allowed trailing spaces? Can we see an example of quines rotated 45 degrees, rather than -45. Especially multi-line please

Gol><>, 120 bytes, score 0
sP#|oao|o `FLFl                                                                                "

Adding a ton of no-ops makes my score really low, so I'm just going to go with it even though it hurts my heart to see so many no-ops doing absolutely nothing :(
Try it online!
golfed answer, 16 bytes, Score : 152?!
sP#|oao|o `FLFl"

Wow, that is much smaller and more correct than my previous answer!!! (my other ones were backwards!)
Try it online!

try adding no-ops till your byte count is 120, you'll have a score of 0

You can get a negative score if you combined no-ops with new lines

@EmbodimentofIgnorance So basically if I am patient enough, and have enough time to waste, I can get an ridiculously low score?!

That is exactly what I'm saying, and why the current scoring system is broken.

@EmbodimentofIgnorance I feel like the scoring should just be based off of bytes, and perhaps penalties for trailing newlines, rather than this weird equation

C# (Visual C# Interactive Compiler), Score 50.765625
var s="var s={0}{1}{0};for(int i=0;;)WriteLine(new String(' ',i)+string.Format(s,(char)34,s)[i++]);";for(int i=0;;)WriteLine(new String(' ',i)+string.Format(s,(char)34,s)[i++]);

Try it online!
Also prints to STDERR, if this is invalid I will change it.

Japt -S, 25 bytes, Score: 116
25Çî iRiZgQi"25Çî iRiZgQi

Run it online

Perl 6, Score -14
<+map
{say(
~($_,)
.indent(
$++))
},[Z]
"<$_>[]~~
.EVAL#1234567"
.words
.map:{
.fmt(
"%-14s"
).comb
}>[]~~
.EVAL#1234567

Try it online!
New solution since my old one (below) might (?) be invalidated by the new rules. The output looks like:
< { ~ . $ } " . . . . " ) } .
 + s ( i + , < E w m f % . > E
  m a $ n + [ $ V o a m - c [ V
   a y _ d ) Z _ A r p t 1 o ] A
    p ( , e ) ] > L d : ( 4 m ~ L
         ) n     [ # s {   s b ~ #
            t     ] 1       "     1
             (     ~ 2             2
                    ~ 3             3
                       4             4
                        5             5
                         6             6
                          7             7
                           "

I'm not sure if this is valid output since there's no example of a normal 45 degree quine in the question itself (this one is mirrored as well as rotated).
Perl 6, Score: -8
<+map {say .indent($++),' 'x($++ <5)*16},"<$_>~~.EVAL".comb#123>>~~.EVAL

Try it online!
Pads the code by 8 lines of 5 space characters, and then adds trailing spaces to the first 5 lines.

Doesn't this break the rule Every line must be at least 5 characters long?

@Emigna Ah, missed that. Fixed

Nice! If this program is -14 bytes, I can just download it over and over again! Free storage!

@Redwolf This isn't [tag:code-golf], the score is from a (rather bad) formula which goes negative with enough newlines

Charcoal, 40 bytes, score 100
≔´α´↗´´´≔´Ｆ´α´↗´⁺´´´´´ι´↗´αα↗´≔Ｆα↗⁺´´ι↗α

Try it online!
Based off the standard Charcoal quine

37 bytes: ≔´α´↶´¹´´´≔´Ｆ´α´⁺´´´´´ι´αα↶¹´≔Ｆα⁺´´ια

@Neil Technically, you're just making the score worse :o

The reason for this is that making really short quines isn't really much of a challenge any more, so instead the longer it is the higher the score (for a little while)

@GezaKerecsenyi Yeah that's not going to work... basically every single quine under our definition is payload-capable so they can be lengthened arbitrarily

Couldn't you add no-ops to make your score smaller (like spaces)?


text:
Arrays Start at \$\pi\$
Your task is to take an array of numbers and a real number and return the value at that point in the array. Arrays start at \$\pi\$ and are counted in \$\pi\$ intervals. Thing is, we're actually going to interpolate between elements given the "index". As an example:
Index:    1π   2π   3π   4π   5π   6π
Array: [ 1.1, 1.3, 6.9, 4.2, 1.3, 3.7 ]

Because it's \$\pi\$, we have to do the obligatory trigonometry, so we'll be using cosine interpolation using the following formula:
\${\cos(i \mod \pi) + 1 \over 2} * (\alpha - \beta) + \beta\$
where:

\$i\$ is the input "index"
\$\alpha\$ is the value of the element immediately before the "index"
\$\beta\$ is the value of the element immediately after the "index"
\$\cos\$ takes its angle in radians

Example
Given [1.3, 3.7, 6.9], 5.3:
Index 5.3 is between \$1\pi\$ and \$2\pi\$, so 1.3 will be used for before and 3.7 will be used for after. Putting it into the formula, we get:
\${\cos(5.3 \mod \pi) + 1 \over 2} * (1.3 - 3.7) + 3.7\$
Which comes out to 3.165
Notes

Input and output may be in any convenient format
You may assume the input number is greater than \$\pi\$ and less than array length * \$\pi\$
You may assume the input array will be at least 2 elements long.
Your result must have at least two decimal points of precision, be accurate to within 0.05, and support numbers up to 100 for this precision/accuracy. (single-precision floats are more than sufficient to meet this requirement)

Happy Golfing!

FYI golfers, it might be shorter to write rewrite $(\cos(x)+1)/2$ as $\cos(x/2)^2$ using the half-angle formula for $\cos$.

Can I take in a dictionary with doubles as its keys? The doubles will be whole numbers, of course.

@EmbodimentofIgnorance, sure. I doubt that's going to help you, but that's a perfectly reasonable representation of arrays since that's how Lua does it.

@KevinCruijssen I don't see why that would matter. 3.7 is between pi and 2pi.

R, 59 53 bytes
function(x,i)x[0:1+i%/%pi]%*%c(a<-cos(i%%pi/2)^2,1-a)

Try it online!
Nothing too clever here - just an R version of the formula in the question.
Thanks @MickyT for saving a byte, and to @Giueseppe and indirectly @xnor for another two, and thanks to @RobinRyder for saving a further 3.

I think you can drop a byte with ...*(cos(i%%pi)+1)/2

@MickyT thanks, I had originally put the +1 in the parentheses, but had added a redundant pair of parentheses so ending up with 60 bytes

56 bytes following xnor's comment about the half-angle formula.

53 bytes

Python 3.8 (pre-release), 85 74 bytes
-8 bytes thanks to @xnor
-2 bytes thanks to @Quintec
This takes advantage of the Python 3.8 pre-release's new := assignment operator. Other than that, this is really just the equation written out in Python.
import math
lambda l,i:cos(i%math.pi/2)**2*(l[(j:=int(i/pi))-1]-l[j])+l[j]

Usage:

>>> p=lambda l,i:cos(i%math.pi/2)**2*(l[(j:=int(i/pi))-1]-l[j])+l[j]
>>> print(p([1.3, 3.7, 6.9],5.3))
3.165249203414993

Try it online!

You can just assign j the first place it's mentioned -- part of the power of assignment expressions is that they evaluate to the value as well as assigning it.

Another byte save: Use trig identities to convert (cos(i%pi)+1)/2  to cos(i%pi/2)**2

@xnor Good point. I knew I was using that wrong

@xnor I don't understand the trig identity magic, but I appreciate the tip. Updating answer

You can drop the p= since anonymous functions are ok

@Quintec Thanks. Answer updated

Forgot to update bytecount :)

Whoops, thanks. Fixed

Now Python beat me :(

Jelly, 17 bytes
d©ØPṪÆẠ‘H×I_@Ḋ}®ị

A full program accepting \$i\$ and the array which prints the interpolated value.
Try it online!
How?
Interpolates between all neighbours using \$\frac{\cos(i \mod \pi)+1}2\$ then picks the relevant value.
d©ØPṪÆẠ‘H×I_@Ḋ}®ị - Link: number, i; list of numbers, A
  ØP              - pi (ish) = 3.141592653589793
d                 - divmod = [i//pi, i%pi]
 ©                - (copy to register for later)
    Ṫ             - tail (gets i%pi leaving register copy as [i//pi])
     ÆẠ           - cosine = cos(i%pi)
       ‘          - increment
        H         - halve
         ×        - multiply by A (vectorises)
          I       - increments -- i.e. (cos(i%pi)+1)(r-l)/2 for neighbours [l,r]
             Ḋ}   - dequeue A
           _@     - swapped arg subtract (vectorises) -- i.e. r-(cos(i%pi)+1)(r-l)/2
                  -                                         = r+(cos(i%pi)+1)(l-r)/2
               ®  - recall value from the register
                ị - index into (vectorises) -- i.e. [β+(cos(i%pi)+1)(α-β)/2]
                  - implicit print of Jelly representation (only 1 entry so [] wont appear)

C# (Visual C# Interactive Compiler), 69 bytes
n=>m=>(Math.Cos(m%Math.PI)+1)/2*(n[m=(int)(m/Math.PI)-1]-n[++m])+n[m]

I beat Python! Darn it, Python beat me. I beat Python again!
Try it online!

Look on the bright side. Neither of us stood a chance against Jelly

@senox13 Except maybe Stax

Röda, 51 bytes
f a,i{j=i//PI;[(cos(i%PI)+1)/2*(a[j-1]-a[j])+a[j]]}

Try it online!

Japt, 47 46 38 bytes
u0;J=V/MP[A=UgJc) nUgJf))½McVuMP)Ä]×+A

To be continued... (golfing)
Try it online!

APL+WIN, 39 37 bytes
2 bytes saved thanks to Adám
2⊃m+(-/m←⎕[0 1+⌊n÷○1])÷2÷1+2○(○1)|n←⎕

Try it online!Dyalog Classic
Explanation:
n←⎕ prompt for input of integer

2÷1+2○(○1)|n evaluate first term of formula

[0 1+⌊n÷○1] identify indices of alpha and beta

m←⎕[...] prompt for input of vector and select alpha and beta

-/m alpha-beta

2⊃m+ take result of adding beta to complete the equation

×.5× → ÷2÷ and m[2] → 2⊃m

Stax, 17 bytes
≈ëBü☺ÆssÅ¢â)KjjïΔ

Run and debug it
Unpacked, ungolfed, and commented it looks like this.
VP|%    divmod with pi;  push div and mod results separately
|7^h    do (cos(modpart) + 1) / 2
sX      swap the original div result to top of stack, store it in the x register
v       decrement
;:-     pairwise differences of array
@       get element at index
N*      negate and multiply
;x@     get element from the original array at the x index, where x is the register
+       add

Run this one

Haskell, 65 bytes
v!i|(c,r)<-properFraction$i/pi=cos(r*pi/2)^2*(v!!(c-1)-v!!c)+v!!c

Try it online!
Note: the array is represented as a list.
Thanks to @xnor for the half-angle tip.

Ruby, 67 bytes
->a,i{z=Math::PI;Math.cos(i%z/2)**2*(a[-1+j=(i/z).to_i]-a[j])+a[j]}

Try it online!

Jelly, 23 20 18 bytes
³%ØPÆẠ×_++H
÷ØPịÇ/

Try it online!
÷ØPịṁØ½µ³%ØPÆẠ×I_@SH    Dyadic link, arguments x (index) and Z (array):
÷ØP                     x/pi
   ị                    Index (into Z).
                        When x/pi is an integer, returns that elt of Z.
                        Otherwise returns 2 elements at floor and ceiling.
     Ø½                   [1,2] (generic 2 element array)
    ṁØ½                 Mold; shape like [1,2] to ensure we have 2 elements.
       µ                Start a new, monadic chain with the result [a,b]
        ³%ØPÆẠ×I_@SH    Monadic chain
        ³               x
         %ØP            x mod pi
            ÆẠ          Unarccosine; cos(x mod pi).
               I          Increment; b-a.
              ×I        (b-a) cos(x mod pi)
                  S       a+b
                _@S     a + b - (b-a) cos(x mod pi)
                   H    Halve; this is equivalent to our desired result.

05AB1E, 22 21 20 19 bytes
žq‰`Å¾>;UÝèÐÁ-θX*-θ

Try it online or verify some more test cases.
Explanation:
žq‰        # Take the divmod PI of the (implicit) input-decimal
           # (part = input integer-divided by PI, remainder = input modulo-PI)
           #  i.e. 5.3 → [1, 2.158...]
   `       # Push both values separately to the stack
    Å¾     # Take the cosine of the remainder
           #  i.e. 2.158... → -0.554...
      >    # Increase it by 1
           #  i.e. -0.554... → 0.554...
       ;   # Halve it
           #  i.e. 0.554... → 0.222...
        U  # Pop and store it in variable `X`
    Ý      # Pop the part, and push a list in the range [0, part]
           #  i.e. 1 → [0, 1]
     è     # (0-based) index all of them into the (implicit) input-list
           #   i.e. [1.3, 3.7, 6.9] and [0, 1] → [1.3, 3.7]
Ð          # Triplicate this list
 Á         # Rotate the last copy once towards the right
           #  i.e. [1.3, 3.7] → [3.7, 1.3]
  -        # Subtract the values in the top two lists from one another
           #  i.e. [1.3, 3.7] and [3.7, 1.3] → [-2.4, 2.4]
   θ       # Pop and only leave the last value of this list
           #  i.e. [-2.4, 2.4] → 2.4
    X*     # Multiply it by `X`
           #  i.e. 2.4 * `X`=0.222... → 0.534...
     -     # Subtract it from each of the values in the list we triplicated
           #  i.e. [1.3, 3.7] - 0.534... → [0.765..., 3.165...]
      θ    # And only leave the last value of this list
           #  i.e. [0.765..., 3.165...] → 3.165...
           # (which is output implicitly as result)

C (GCC) 99 79 bytes
-20 bytes ceilingcat
float P=3.141593;b;
#define f(i,a)(cos(fmod(i,P))+1)/2*(a[b=i/P-1]-a[++b])+a[b]

Try it online!
Calling code
int main() {
  float a[3] = {1.3,3.7,6.9};
  printf("%f\n", f(5.3,a));
}

note that it needed the compiler flag -lm to link with math libraries, so +3 bytes if you count that.

Attache, 54 bytes
${Cos[y%PI/2]^2*&`-@(j:=x[1'-1*Floor[y'-y/PI]-1])+j@1}

Try it online!
Explanation
${Cos[y%PI/2]^2*&`-@(j:=x[1'-1*Floor[y'-y/PI]-1])+j@1}
${                                                   }  parameters: x, y
  Cos[y%PI/2]^2                                         the scaling function factor
               *                                        times
                     j:=                                set j to
                        x[                     ]        the element in x at
                          1'-1*Floor[y'-y/PI]-1         the closest indices scaled by PI
                &`-@(                           )       spread subtraction over bounds
                                                 +j@1   add the upper bound


text:
Compound Interest... with Wizard Money
Gringotts isn't just a vault, but a reputable financial institution and wizards need loans too. Since you don't want to be screwed over by the Gringotts goblins, you decided it would be a good idea to write a program to calculate interest. Interest is compounded only yearly.
Your task is to calculate total owed amount after interest given the principal, interest rate, and time (whole years), operating in whole denominations of wizard money, rounding down to the nearest whole Knut. There are 29 Bronze Knuts in a Silver Sickle and 17 Sickles in a Gold Galleon.
Example
Loan taken out:
 23 Knuts
 16 Sickles
103 Galleons
@ 7.250%
For 3 years

Total owed after interest:
 24 Knuts
  4 Sickles
128 Galleons

Notes and Rules

Input and output may be in any convenient format. You must take in Knuts, Sickles, Galleons, interest rate, and time. All but interest rate will be whole numbers. The interest rate is in increments of 0.125%.
Input money is not guaranteed to be canonical (i.e. you can have 29 or more Knuts and 17 or more Sickles.)
Output must be the canonical representation. (i.e. less than 29 Knuts and less than 17 Sickles)
Totals owed, up to 1,000 Galleons, should be accurate to within 1 Knut per year of interest when compared with arbitrary precision calculations.

You may round down after each year of interest or only at the end. Reference calculations can take this into account for accuracy checks.

Happy golfing!

Can we take the interest rate as a decimal instead of a percentage? (e.g., 0.0725 instead of 7.25)

@Shaggy I would also like to know this

If the loan is exactly 1 Knut, and the interest is 99% per year, and the term is 1 year, should the result be "1 Knut" or "2 Knuts"?

In other words, please clarify the mathematical meaning of the phrase rounding down

@Shaggy: of course. It's just a different representation, which is fair game for I/O

@ChasBrown: 1 Knut. Truncate/floor function to the nearest whole Knut.

Can you add some more test cases/reference calculations so we can verify rule compliance?

R, 70 62 bytes
function(d,i,y)(x=d%*%(a=c(1,29,493))*(1+i)^y)%/%a%%c(29,17,x)

Try it online!
Takes input as d: deposit in knuts, sickles, galleons; i: interest rate as decimal; y: years. Outputs final deposit in knuts, sickles, galleons. Thanks to @Giuseppe for using matrix multiplication to save some bytes (and pointing out how to avoid the need to wrap at 1e99).

I don't know R; what does having them wrap around win you?

@dfeuer they’re taken mod 1e99, so if your galleons get that high they’ll drop to zero

What I'm wondering is what you gain by taking them mod 1e99.

Most R functions are vectorised. In this case, I'm passing the output through the %% function, which is mod. Ideally, I'd like to leave the galleons alone, but taking a number mod infinity returns NaN, and so I've just used a really large number (but one that is small in bytes). The alternatives I've come up with are longer (e.g. [https://tio.run/##JYrLCsIwEEV/xU1gpl41k6ilj3xJUSgpgSwSQe2iiN8eA97N4Rzus4TdeChhzf4dH5kWRGxI7rUmWhqanSeB6XDuLNd9siNKDck@8n1jdVIzD3mS3tzcH0p5qn9pa/@WQNUs5ArRlqGPujUXWC4/ Try it online!])

@NickKennedy you could do 9e99 as well...Also, you can golf down to 63 bytes

or perhaps this for 62 bytes which (should) yield no wrap-around.

@Giuseppe thanks, matrix multiplication works well here

Python 3.8 (pre-release), 75 74 71 bytes
-1 bytes thanks to @EmbodimentofIgnorance
-3 bytes thanks to @xnor
This takes Knuts, Sickles, and Galleons as ints, interest as a float (decimal, not percentage), and years as an int. It returns a tuple containing the number after interest of Knuts, Sickles, and Galleons, respectively.
lambda K,S,G,R,Y:((k:=int((K+G*493+S*29)*(1+R)**Y))%29,k//29%17,k//493)

Usage:
>>> print(I(23,16,103,0.0725,3))
(24, 4, 128)

Try it online!

Good catch. Updating answer

The question says operating in whole denominations of wizard money, rounding down. I took rounding down to mean chop off everything after the decimal point.
Using the header definitely sounds like an easier way to do things. I'll do that for future posts, thanks

That sounds a lot more like "truncating" than "rounding"; but I have asked the OP for clarification (because nit-picking is the name of the game here at PPCG :) ).

I don't disagree with you, that's just the meaning I've always seen used for rounding down, because you always round to the integer below your result. Otherwise it's just normal rounding. Letting OP decide is a good idea

FYI, a useful trick to make anonymous functions testable on TIO is to put I\= in the header like this. Also, it looks like k//29//17 can be k//493.

Both excellent points. Answer updated

APL+WIN, 37 28 26 bytes
⌊a⊤((a←0 17 29)⊥⎕)×(1+⎕)*⎕

2 bytes saved thanks to lirtosiast
Try it online! Courtesy of Dyalog Classic
Explanation:
(1+⎕)*⎕ prompts for years followed by decimal interest rate and calculates
         compounding multiplier

((a←0 17 29)⊥⎕) prompts for Galleons, Sickles and Knuts and converts to Knuts

⌊a⊤ converts back to Galleons, Sickles and Knuts and floor
    after applying compound interest.

⌊a⊤(⎕⊥⍨a←0 17 29)×⎕*⍨1+⎕ for 24?

@lirtosiast Thanks but I am afraid my ancient APL+WIN interpreter does not have the ⍨ function. By all means submit this as your own APL solution.

@lirtosiast Thanks again I have taken the 2 bytes resulting from the assignment to a.

Perl 6, 47 bytes
((1+*)*** *(*Z*1,29,493).sum+|0).polymod(29,17)

Try it online!
I'm surprised I managed to get this into an anonymous Whatever lambda! Especially the part where it's more *s than anything else. Takes input as interest rate (e.g. 0.0725), years, [Knuts, Sickles, Galleons] and returns a list of currencies in the same order.
Explanation:
 (1+*)           # Add one to the interest rate
      ***        # Raise to the power of the year
          *      # And multiply by
           (*Z*1,29,493).sum      # The number of Knuts in the input
                            +|0   # And floor it
(                              ).polymod(29,17)   # Get the modulos after divmoding by 29 and 17

I'm surprised you didn't come up with a way to also get the number of Knuts/Sickles/Galleons also to fit into whatevers. Then it'd just be eh, like ************************* ;-)

@guifa The Whatevers are the inputs, so there can only really be 3 of them (though I can split up the currency input for some more *s but more bytes). The rest of the *s are from multiplication (*) and exponentials (**)

I meant if you got the conversion rates (the 29/17 number) into them too.  But of course it was a joke because you need to use those numbers more than once.  Sorry if my humor didn't go through

Jelly, 29 bytes
“¢×ø‘©×\
÷ȷ2‘*⁵×÷¢S×¢d®U1¦Ṫ€Ḟ

A full program accepting arguments: rate; [Galleons, Sickles, Knuts]; years.
Prints [Galleons, Sickles, Knuts].
Try it online!
Floors at the end of the entire term.
÷ȷ2 may be removed if we may accept the rate as a ratio rather than a percentage.
How?
“¢×ø‘©×\ - Link 1 multipliers: no arguments
“¢×ø‘    - list of code-age indices = [1,17,29]
     ©   - (copy this to the register for later use)
       \ - reduce by:
      ×  -   multiplication  = [1,17,493]

÷ȷ2‘*⁵×÷¢S×¢d®U1¦Ṫ€Ḟ - Main Link
 ȷ2                  - 10^2 = 100
÷                    - divide = rate/100
   ‘                 - increment = 1+rate/100
     ⁵               - 5th command line argument (3rd input) = years
    *                - exponentiate = (1+rate/100)^years --i.e. multiplicand
      ×              - multiply (by the borrowed amounts)
        ¢            - call last Link as a nilad
       ÷             - divide (all amounts in Galleons)
         S           - sum (total Galleons owed)
           ¢         - call last Link as a nilad
          ×          - multiply (total owed in each of Galleons, Sickles, Knuts)
             ®       - recall from register = [1,17,29]
            d        - divmod (vectorises) = [[G/1, G%1], [S/17, S^17], [K/17, K%17]]
              U1¦    - reverse first one = [[G%1, G/1], [S/17, S%17], [K/17, K%17]]
                 Ṫ€  - tail €ach = [G/1, S%17, K%17]
                   Ḟ - floor (vectorises)

TI-BASIC (TI-84), 96 90 Bytes
:SetUpEditor C:Ans→∟C:∟C(1)+29∟C(2)+493∟C(3)→T:T(1+∟C(4))^∟C(5)→T:remainder(iPart(T),493→R:{remainder(R,29),iPart(R/29),iPart(T/493)}

Input is Ans, a list with 5 items: Knuts, Sickles, Galleons, Interest (decimal), and Time (years).
Output is in Ans and is automatically printed out when the program completes.
Un-golfed:
:SetUpEditor C
:Ans→∟C
:∟C(1)+29∟C(2)+493∟C(3)→T
:T(1+∟C(4))^∟C(5)→T
:remainder(iPart(T),493→R
:{remainder(R,29),iPart(R/29),iPart(T/493)}

Example:
{32,2,5,0.05,5}
       {32 2 5 .05 5}
prgmCDGF1
            {12 10 6}

Explanation:
:SetUpEditor C
:Ans→∟C

A new list, ∟C, is created and Ans is stored into it.
:∟C(1)+29∟C(2)+493∟C(3)→T

The Knuts, Sickles, and Galleons are converted into Knuts and stored into T.
:T(1+∟C(4))^∟C(5)→T

Takes the amount of Knuts and applies compound interest to it.
Interest is calculated here.
:remainder(iPart(T),493→R

Stores the Integer Part of T modulo 493 into R.  Used to shorten byte count.
:{remainder(R,29),iPart(R/29),iPart(T/493)}

Evaluates a list with 3 items (Knuts, Sickles, and Galleons).  The list is automatically stored into Ans.

Note:  Byte count is evaluated by taking the byte count given in [MEM]→[2]→[7] (program list in RAM) and subtracting the amount of characters in the program name and an extra 8 bytes used for the program:
103 - 5 - 8 = 90 bytes

Intel 8087 FPU assembly, 86 bytes
d9e8 d906 7f01 dec1 8b0e 8301 d9e8 d8c9 e2fc df06 7901 df06 8701 df06
7b01 df06 8501 df06 7d01 dec9 dec1 dec9 dec1 dec9 9bd9 2e89 01df 0687
01df 0685 01d9 c1de c9d9 c2d9 f8d8 f2df 1e7b 01d8 fadf 1e7d 01d9 c9d9
f8df 1e79 01

Unassembled and documented:
; calculate P+I of loan from wizard
; input:
;   G: number of Galleons (mem16)
;   S: number of Sickles (mem16)
;   K: number of Knuts (mem16)
;   R: interest rate (float)
;   T: time in years (mem16)
;   GS: Galleons to Sickles exchange rate (mem16)
;   SK: Sickles to Knuts exchange rate (mem16)
; output:
;   G: number of Galleons (mem16)
;   S: number of Sickles (mem16)
;   K: number of Knuts (mem16)
WIZ_INT_CALC    MACRO   G, S, K, R, T, GS, SK
                LOCAL   LOOP_EXP
                    ; - calculate interet rate factor
    FLD1            ; load 1
    FLD   R         ; load interest rate
    FADD            ; ST = rate + 1
    MOV   CX, T     ; Exponent is count for loop
    FLD1            ; load 1 into ST as initial exponent value
LOOP_EXP:           ; loop calculate exponent
    FMUL  ST,ST(1)  ; multiply ST = ST * ST(1)
    LOOP  LOOP_EXP
                    ; - convert demonimations to Knuts
    FILD  K         ; load existing Knuts
    FILD  SK        ; load Sickles to Knuts rate
    FILD  S         ; load existing Sickles
    FILD  GS        ; load Galleons-to-Sickles exchange rate
    FILD  G         ; load existing Galleons
    FMUL            ; multiply galleons to get sickles
    FADD            ; add existing sickles
    FMUL            ; multiply sickles to get knuts
    FADD            ; add existing knuts
    FMUL            ; calculate P+I (P in Knuts * Interest factor)
                    ; - redistribute demonimations to canonical form
    FLDCW  FRD      ; put FPU in round-down mode
    FILD   SK       ; load Sickles to Knuts rate
    FILD   GS       ; load Galleons-to-Sickles exchange rate
    FLD    ST(1)    ; copy Galleons-to-Sickles exchange rate to stack for later
    FMUL            ; multiply to get Galleons-to-Knuts rate
    FLD    ST(2)    ; push original total Knuts from ST(2) into ST (lost by FPREM)
    FPREM           ; get remainder
    FDIV   ST,ST(2) ; divide remainder to get number of Sickles
    FISTP  S        ; store Sickles to S
    FDIVR  ST,ST(2) ; divide to get number of Galleons
    FISTP  G        ; store Galleons to G
    FXCH            ; swap ST, ST(1) for FPREM
    FPREM           ; get remainder to get number of Knuts
    FISTP  K        ; store Knuts to K
        ENDM

Implemented as a MACRO (basically a function), this is non-OS-specific machine-code using only the Intel 80x87 FPU / math co-processor for calculation.
Example test program with output:
    FINIT           ; reset FPU

    WIZ_INT_CALC    G,S,K,R,T,GS,SK     ; do the "Wizardy"

    MOV  AX, K      ; display Knuts
    CALL OUTDEC     ; generic decimal output routine
    CALL NL         ; CRLF

    MOV  AX, S      ; display Sickles
    CALL OUTDEC     ; generic decimal output routine
    CALL NL         ; CRLF

    MOV  AX, G      ; display Galleons
    CALL OUTDEC     ; generic decimal output routine
    CALL NL         ; CRLF

    RET             ; return to DOS

K   DW  23          ; initial Kunts
S   DW  16          ; initial Sickles
G   DW  103         ; initial Galleons
R   DD  0.0725      ; interest rate
T   DW  3           ; time (years)
GS  DW  17          ; Galleons to Sickles exchange rate
SK  DW  29          ; Sickles to Knuts exchange rate
FRD DW  177FH       ; 8087 control word to round down

Output

Japt, 48 bytes
XÄ pY *(U*493+V*29+W)f
Uu493
[Uz493 ,Vz29 ,Vu29]

My first try at Japt, going for @Shaggy's bounty! Needless to say, this isn't very golfy :(
Try it Online!

Haskell, 73 bytes
(g#s)k r n|(x,y)<-truncate((493*g+29*s+k)*(1+r)^n)%29=(x%17,y)
(%)=divMod

Try it online!
Thanks to @Laikoni for two bytes.
The dirty tricks: the number of coins in the input is floating point (Double), while the number of coins in the output is integral (Integer). The result is a nested pair ((Galleons, Sickles), Knotts) to avoid having to flatten to a triple.
Explanation
-- Define a binary operator # that
-- takes the number of Galleons
-- and Slivers and produces a
-- function taking the number of
-- Knots, the rate, and the
-- number of years and producing
-- the result.
(g#s) k r n
   -- Calculate the initial value
   -- in Knotts, calculate the
   -- final value in Knotts,
   -- and divide to get the number
   -- of Galleons and the
   -- remainder.
  |(x,y)<-truncate((493*g+29*s+k)*(1+r)^n)%29
  -- Calculate the number of Slivers
  -- and remaining Knotts.
  =(x%17,y)
(%)=divMod

Save two bytes with (truncate$ ... ) -> truncate( ... ) and (g#s)k r n instead of c g s k r n.

@Laikoni, thanks a lot!

@Laikoni, I'd really appreciate if you could find me a couple bytes in https://codegolf.stackexchange.com/questions/55960/im-not-the-language-youre-looking-for/180958#180958, if you have the time.

I'll look into it when I find the time. Meanwhile, I can point you to our Haskell chat room Of Monads and Men and also to this question which you might enjoy given your Hugs/GHC polyglots.

Stax, 24 bytes
»♀(╪M╢ú!!«ε◘÷╛SI►U/)-f!ö

Run and debug it
Input is space separated values. interest years knuts sickles galleons
Output is newline separated.
knuts
sickles
galleons

C# (Visual C# Interactive Compiler), 86 bytes
(a,b,c)=>((k=(int)((a.a*493+a.b*29+a.c)*Math.Pow(1+b,c)))/493,(k%=493)/29,k%29);int k;

Takes inout as a named tuple with 3 values representing knuts, sickles, and galleons, and interest rate as a double (not a percentage). I really wish C# had an exponentation operator. Math.Pow is way too long :(
Try it online!

K, 46 Bytes
c:1000 17 29
t:{c\:{z(y*)/x}[c/:x;1+y%100;z]}

c store the list for base-conversion
t is the function that calculates total amount
Use example:
t[103 16 23;7.25;3]

writes (128;4;24.29209)
Explanation:

c/:x transform the list (galleon; sickle; knuts) to kuts
1+y%100 calculate rate of interest (example 1.0725 for 7.25% rate)
lambda {z(y*)\x} does the work: iterate 3 times, applying interes*main, and returns final main.
c\: generates galleon, sickles, knuts from knuts

NOTE.- if you don't need a names-function, we can use a lambda, saving 2 bytes
{c\:{z(y*)/x}[c/:x;1+y%100;z]}inputArgs

Batch, 171 bytes
@set i=%4
@set/af=0,i=8*%i:.=,f=%,f*=8
@set/ai+=%f:~,1%,k=%1*493+%2*29+%3
@for /l %%y in (1,1,%5)do @set/ak+=k*i/800
@set/ag=k/493,s=k/29%%17,k%%=29
@echo %g% %s% %k%

Takes input as command-line arguments in the order Galleons, Sickles, Knuts, interest, years. Interest is a percentage but expressed without the % sign. Truncates after every year. Output is in the order Galleons, Sickles, Knuts. Supports at least 5000 Galleons. Explanation:
@set i=%4
@set/af=0,i=8*%i:.=,f=%,f*=8

Batch only has integer arithmetic. Fortunately, the interest rate is always a multiple of 0.125. We start by splitting on the decimal point, so that i becomes the integer part of the interest rate and f the decimal fraction. These are then multiplied by 8. The first digit of f is now the number of eighths in the percentage interest rate.
@set/ai+=%f:~,1%,k=%1*493+%2*29+%3

This is then extracted using string slicing and added on to give an interest rate in 1/800ths. The number of Knuts is also calculated.
@for /l %%y in (1,1,%5)do @set/ak+=k*i/800

Calculate and add on each year's interest.
@set/ag=k/493,s=k/29%%17,k%%=29
@echo %g% %s% %k%

Convert back to Galleons and Sickles.

05AB1E (legacy), 24 bytes
>Im•1ýÑ•3L£I*O*ï29‰ć17‰ì

Port of @JoKing's Perl 6 answer, so make sure to upvote him as well if you like this answer!
I'm using the legacy version due to a bug in the new version where £ doesn't work on integers, so an explicit cast to string § (between the second • and 3) is required (until the bug is fixed).
Takes the interest as decimal, followed by the year, followed by the list of [Knuts, Sickles, Galleons].
Try it online.
Explanation:
>                      # Increase the (implicit) interest decimal by 1
                       #  i.e. 0.0725 → 1.0725
 Im                    # Take this to the power of the year input
                       #  i.e. 1.0725 and 3 → 1.233...
•1ýÑ•                  # Push compressed integer 119493
     3L                # Push list [1,2,3]
       £               # Split the integer into parts of that size: [1,19,493]
        I*             # Multiply it with the input-list
                       #  i.e. [1,19,493] * [23,16,103] → [23,464,50779]
          O            # Take the sum of this list
                       #  i.e. [23,464,50779] → 51266
           *           # Multiply it by the earlier calculated number
                       #  i.e. 51266 * 1.233... → 63244.292...
            ï          # Cast to integer, truncating the decimal values
                       #  i.e. 63244.292... → 63244
             29‰       # Take the divmod 29
                       #  i.e. 63244 → [2180,24]
                ć      # Extract the head; pushing the remainder-list and head separately
                       #  i.e. [2180,24] → [24] and 2180
                 17‰   # Take the divmod 17 on this head
                       #  i.e. 2180 → [128,4]
                    ì  # And prepend this list in front of the remainder-list
                       #  i.e. [24] and [128,4] → [128,4,24]
                       # (which is output implicitly as result)

See this 05AB1E tip of mine (section How to compress large integers?) to understand why •1ýÑ• is 119493.

APL(NARS), 37 char, 74 bytes
{(x y z)←⍵⋄⌊¨a⊤(z⊥⍨a←0 17 29)×x*⍨1+y}

translation of the very good and very few bytes APL solution by Graham user
to a solution that use one function instead of standard input...
test and how to use it:
  f←{(x y z)←⍵⋄⌊¨a⊤(z⊥⍨a←0 17 29)×x*⍨1+y}
  f 3 0.0725 (103 16 23)
128 4 24

(i don't say i had understood algorithm)

Perl 5, 70 bytes
$,=$";say 0|($_=(<>+<>*29+<>*493)*(1+<>)**<>)/493,0|($_%=493)/29,$_%29

Try it online!


text:
(bit)Wise Images
Given a truth table and two images, use the truth table as a bitwise operation to the two images.
For example with the truth table:
  1 0
1 0 0
0 1 0

(Note that the top is the first image and the left is the second)
and the two images (0, 2, 4) (a 1x1 image, with the numbers being RGB values) and (30, 20, 10):
You would apply the above truth table to the numbers 0 and 30, of which's binary representations are 00000 and 11110.
Using the truth table as a bitwise operation would get us 00000, or in decimal form 0.
This means that the red value of the first pixel would be 0.
Continuing this with the other RGB values would get us 2 and 4 for green and blue respectively.
So the output for this would be a 1x1 image with the only pixel having an RGB value of 0, 2, 4.
For images greater than 1x1, you apply the truth table for both corresponding pixels on both images and output it to the output image.
For example, if we had a pixel which is located at (x, y) in the image, you would apply the truth table to the R, G, and B values for the (x, y) position in the first image and the (x, y) position in the second. Once you have done this, the (x, y) position in the output image is the output of the truth table applied to the R, G, and B values.
NOTES:
You can use any default input or output method.
You can assume that the two input images are the same dimensions.
You can use any Standard Image I/O that supports RGB.
The truth table can be in any format you want.
As always, since this is code golf, lowest byte-count wins!

Could you explain how an example bigger than 1x1 would work?

@xnor You would apply the operation to every pixel

Can we take the pixels as a flat list, or does it have to be 2D?

@xnor If the image is an n by 1 image, then it's okay. Otherwise, it can't be a flast list

Does "any image format" include a raw 2D array of RGB tuples? e.g. [[[12,34,26],[227,162,201]],[[54,231,43],[1,2,3]]] as a 2x2 "image"?

...and does it include a raw 2D array of RGB bytes? i.e. [[[[0,0,0,0,1,1,0,0],[0,0,1,0,0,0,1,0],[0,0,0,1,1,0,1,0]],...],...] being Kamil's [[[12,34,26],...],...].

Also, can we take the truth table as four 0/1 variables? As a single 4-bit number?

@Kamil Yes, any image format, whether it is made up or not as long as it satifies our cirteria

@JonathanAllan See above

Wait, why did this get voted as unclear?

I downvoted this question because it is trivial in its current form (see Adám's answer). I'm guessing it was closed as unclear for the same reason.

@lirtosiast Okay, thanks for explaining!

APL (Dyalog Unicode), 3 bytesSBCS
Full program. Prompts for first image, then truth table, then second image, all from STDIN. Images must be given as bit arrays (for example, 8 × height × width × 3, but this doesn't actually matter). The truth table must be given as a Boolean APL function. And yes, those are three identical boxes:
⎕⎕⎕

Try it online!
⎕ prompt for the first image
⎕ prompt for the function, and apply it with the following left argument:
⎕ prompt for the second image

Ah, I thought the characters just weren't rendering for me

@JoKing APL renders right on almost all systems.

If only my browser displayed this characters correctly

@MilkyWay90 As Adam said, the characters are rendering correctly; it's just that they are all the same box character

@JoKing oh okay. I couldn't see the previous comments (maybe they were deleted)

@MilkyWay90 It says so in the post itself: And yes, those are three identical boxes: I've made it italic now.

@Adám Oh, sorry


text:
Compare four integers, return word based on maximum
This function should take four integer inputs (a,b,c,d) and return a binary word based on which values equal the maximum of the four.
The return value will be between 1 and 0xF.
For example:
a = 6, b = 77, c = 1, d = 4
returns 2 (binary 0010; only 2nd-least significant bit is set corresponding to b being sole max value)
a = 4, b = 5, c = 10, d = 10
returns 0xC (binary 1100; 3rd- and 4th-least significant bits set corresponding to c and d equaling max value)
a = 1, b = 1, c = 1, d = 1
returns 0xF (binary 1111; all four bits set because all values equal the max)
Here is a simple implementation:
int getWord(int a, int b, int c, int d)
{
    int max = a;
    int word = 1;
    if (b > max)
    {
        max = b;
        word = 2;
    }
    else if (b == max)
    {
        word |= 2;
    }
    if (c > max)
    {
        max = c;
        word = 4;
    }
    else if (c == max)
    {
        word |= 4;
    }
    if (d > max)
    {
        word = 8;
    }
    else if (d == max)
    {
        word |= 8;
    }
    return word;
}

return value can be string of 0's and 1's, bool / bit vector, or integer

What kind of branching can we use?

@ASCII-only I updated my question, does that clarify?

Also, what would inequality/equality return? 1/0?

@ASCII-only yes.

I have a solution in a golfing language, which uses the builtins Reverse, Maximum, Equality-check, Join, Convert from binary to integer, Convert from integer to hexadecimal. Does this means my score is 1 due to the Equality-check? I have the feeling this is too much focused on regular languages, and even for those it's not 100% clear what the scoring for let's say a Maximum-builtin.. :S

I would suggest you try to: 1. change this question to code-golf, which only care about the number of bytes. 2. or, restrict to some certain language (certain version of compiler/interpreter please), and list all statements and operators allowed, and how to score them.

1 is a better option, IMO. I think this makes a perfectly good code-golf question and I can't see any benefit that would come from restricting the languages available for answers

I updated my question to remove the criteria. Let me know it it's still unclear

Should I output a decimal number? Or may I output 4 binary digits instead?

I somehow managed to submit an answer after this was closed

I have voted to reopen after the (somewhat strange) rules were revised. Should the output be binary, decimal or hex? It's still not clear to me. Maybe I am missing something?

I have updated my question regarding return value. Hopefully it's no longer unclear.

Jelly, 2 bytes
Takes input as [d,c,b,a]. Returns a list of Booleans.
Ṁ=

Try it online!
Ṁ Maximum
= equal to (implies the other argument is the original argument; vectorises)

R, 17 bytes
max(a<-scan())==a

Try it online!
Returns a vector of booleans. Since this output has been confirmed, this is preferable over numerical output, as that one is almost twice longer:
R, 33 bytes
sum(2^which(max(a<-scan())==a)/2)

Try it online!

APL (Dyalog Unicode), 4 bytesSBCS
Anonymous tacit prefix function. Takes [a,b,c,d] as argument. Returns a bit-Boolean array.*
⌈/=⌽

Try it online!
⌈/ Does the maximum of the argument
= equal (vectorises)
⌽ the reverse of the argument?
* Note that APL stores arrays of Booleans using one bit per value, so this does indeed return a 4-bit word, despite the display form being 0 0 1 0.

Haskell, 20 18 bytes
2 bytes saved thanks to proud haskeller
map=<<(==).maximum

Try it online!

You can output a string.

Writing map instead of (<$>) would be two bytes shorter!

@proudhaskeller Good catch.  Can't believe that I didn't see that one.

05AB1E, 3 2 bytes
ZQ

Input as a list of [d,c,b,a], output as a list of boolean.
Try it online or verify all test cases.
Explanation:
Z    # Take the maximum of the implicit input-list
 Q   # Check for each in the (implicit) input-list if it equals this value
     # (and output implicitly as result)

OP has been updated — you don't need to convert to hex.

Perl 6, 12 bytes
{$_ X==.max}

Try it online!
Anonymous code block that takes a list of integers and returns a list of booleans. If we need to return as a number, it's +4 bytes to wrap the inside of the code block with 2:[...].
Explanation:
{          }  # Anonymous code block
 $_           # With the input
    X==       # Which values are equal
       .max   # To the maximum element

OP now says you don't need to wrap.

Japt, 5
m¶Urw

Try it!
-4 bytes thanks to @Oliver!
-2 bytes thanks to @Shaggy!
Input is a 4-element array in the following format:
[d, c, b, a]

Output is an array of bits.

Of course there is ;) There are apparently a lot of shortcuts to learn.

If a boolean array is an acceptable output, this can be 7 bytes

@Oliver, 5 bytes ;)

You guys are pretty good :) That's interesting how rw converts to r("w") does a reduce by repeatedly getting the max. Same with m¶ getting converted to U.m("===", ...). In any case, thanks for the tips!

x86 machine code (MMX/SSE1), 26 bytes (4x int16_t)
x86 machine code (SSE4.1), 28 bytes (4x int32_t or uint32_t)
x86 machine code (SSE2), 24 bytes (4x float32) or 27B to cvt int32
(The last version that converts int32 to float isn't perfectly accurate for large integers that round to the same float.  With float input, rounding is the caller's problem and this function works correctly if there are no NaNs, identifying floats that compare == to the max.  The integer versions work for all inputs, treating them as signed 2's complement.)
All of these work in 16/32/64-bit mode with the same machine code.
A stack-args calling convention would make it possible to loop over the args twice (finding max and then comparing), possibly giving us a smaller implementation, but I haven't tried that approach.
x86 SIMD has vector->integer bitmap as a single instruction (pmovmskb or movmskps or pd), so it was natural for this even though MMX/SSE instructions are at least 3 bytes long.  SSSE3 and later instructions are longer than SSE2, and MMX/SSE1 instructions are the shortest.  Different versions of pmax* (packed-integer vertical max) were introduced at different times, with SSE1 (for mmx regs) and SSE2 (for xmm regs) only having signed word (16-bit) and unsigned byte.
(pshufw and pmaxsw on MMX registers are new with Katmai Pentium III, so really they require SSE1, not just the MMX CPU feature bit.)
This is callable from C as unsigned max4_mmx(__m64) with the i386 System V ABI, which passes an __m64 arg in mm0.  (Not x86-64 System V, which passes __m64 in xmm0!)
   line         code bytes
    num  addr
     1                         global max4_mmx
     2                             ;; Input 4x int16_t in mm0
     3                             ;; output: bitmap in EAX
     4                             ;; clobbers: mm1, mm2
     5                         max4_mmx:
     6 00000000 0F70C8B1           pshufw    mm1, mm0, 0b10110001   ; swap adjacent pairs
     7 00000004 0FEEC8             pmaxsw    mm1, mm0
     8
     9 00000007 0F70D14E           pshufw    mm2, mm1, 0b01001110   ; swap high/low halves
    10 0000000B 0FEECA             pmaxsw    mm1, mm2
    11
    12 0000000E 0F75C8             pcmpeqw   mm1, mm0               ; 0 / -1
    13 00000011 0F63C9             packsswb  mm1, mm1               ; squish word elements to bytes, preserving sign bit
    14
    15 00000014 0FD7C1             pmovmskb  eax, mm1          ; extract the high bit of each byte
    16 00000017 240F               and       al, 0x0F          ; zero out the 2nd copy of the bitmap in the high nibble
    17 00000019 C3                 ret

size = 0x1A = 26 bytes

If there was a pmovmskw, what would have saved the packsswb and the and (3+2 bytes).  We don't need and eax, 0x0f because pmovmskb on an MMX register already zeros the upper bytes.  MMX registers are only 8 bytes wide, so 8-bit AL covers all the possible non-zero bits.
If we knew our inputs were non-negative, we could packsswb  mm1, mm0 to produce non-negative signed bytes in the upper 4 bytes of mm1, avoiding the need for and after pmovmskb.  Thus 24 bytes.
x86 pack with signed saturation treats the input and output as signed, so it always preserves the sign bit.  (https://www.felixcloutier.com/x86/packsswb:packssdw).  Fun fact: x86 pack with unsigned saturation still treats the input as signed.  This might be why PACKUSDW wasn't introduced until SSE4.1, while the other 3 combinations of size and signedness existed since MMX/SSE2.

Or with 32-bit integers in an XMM register (and pshufd instead of pshufw), every instruction would need one more prefix byte, except for movmskps replacing the pack/and.  But pmaxsd / pmaxud need an extra extra byte...
callable from C as unsigned max4_sse4(__m128i); with x86-64 System V, or MSVC vectorcall (-Gv), both of which pass __m128i/__m128d/__m128 args in XMM regs starting with xmm0.
    20                         global max4_sse4
    21                             ;; Input 4x int32_t in xmm0
    22                             ;; output: bitmap in EAX
    23                             ;; clobbers: xmm1, xmm2
    24                         max4_sse4:
    25 00000020 660F70C8B1         pshufd    xmm1, xmm0, 0b10110001   ; swap adjacent pairs
    26 00000025 660F383DC8         pmaxsd    xmm1, xmm0
    27
    28 0000002A 660F70D14E         pshufd    xmm2, xmm1, 0b01001110   ; swap high/low halves
    29 0000002F 660F383DCA         pmaxsd    xmm1, xmm2
    30
    31 00000034 660F76C8           pcmpeqd   xmm1, xmm0               ; 0 / -1
    32
    33 00000038 0F50C1             movmskps  eax, xmm1          ; extract the high bit of each dword
    34 0000003B C3                 ret

size = 0x3C - 0x20 = 28 bytes

Or if we accept input as float, we can use SSE1 instructions.  The float format can represent a wide range of integer values...
Or if you think that's bending the rules too far, start with a 3-byte 0F 5B C0             cvtdq2ps  xmm0, xmm0 to convert, making a 27-byte function that works for all integers that are exactly representable as IEEE binary32 float, and many combinations of inputs where some of the inputs get rounded to a multiple of 2, 4, 8, or whatever during conversion.  (So it's 1 byte smaller than the SSE4.1 version, and works on any x86-64 with just SSE2.)
If any of the float inputs are NaN, note that maxps a,b exactly implements (a<b) ? a : b, keeping the element from the 2nd operand on unordered.  So it might be possible for this to return with a non-zero bitmap even if the input contains some NaN, depending on where they are.
unsigned max4_sse2(__m128);
    37                         global max4_sse2
    38                             ;; Input 4x float32 in xmm0
    39                             ;; output: bitmap in EAX
    40                             ;; clobbers: xmm1, xmm2
    41                         max4_sse2:
    42                         ;    cvtdq2ps  xmm0, xmm0
    43 00000040 660F70C8B1         pshufd    xmm1, xmm0, 0b10110001   ; swap adjacent pairs
    44 00000045 0F5FC8             maxps     xmm1, xmm0
    45
    46 00000048 660F70D14E         pshufd    xmm2, xmm1, 0b01001110   ; swap high/low halves
    47 0000004D 0F5FCA             maxps     xmm1, xmm2
    48
    49 00000050 0FC2C800           cmpeqps   xmm1, xmm0               ; 0 / -1
    50
    51 00000054 0F50C1             movmskps  eax, xmm1          ; extract the high bit of each dword
    52 00000057 C3                 ret

size = 0x58 - 0x40 = 24 bytes

copy-and-shuffle with pshufd is still our best bet: shufps dst,src,imm8 reads the input for the low half of dst from dst.  And we need a non-destructive copy-and-shuffle both times, so 3-byte movhlps and unpckhps/pd are both out.  If we were narrowing to a scalar max, we could use those, but it costs another instruction to broadcast before compare if we don't have the max in all elements already.

Related: SSE4.1 phminposuw can find the position and value of the minimum uint16_t in an XMM register.  I don't think it's a win to subtract from 65535 to use it for max, but see an SO answer about using it for max of bytes or signed integers.

JavaScript (ES6), 30 bytes
Takes input as ([d,c,b,a]). Returns 4 Boolean values.
a=>a.map(x=>x==Math.max(...a))

Try it online!

OP has clarified that you can indeed return 4 Boolean values.

Java (JDK), 78 bytes
a->{int m=a[0],w=1,p=1;for(int t:a){w=t<m?w:p|(t>m?(m=t)^m:w);p*=2;}return w;}

Try it online!

Takes the input as an array of [a,b,c,d].

Here's a JS version that outputs as binary
update: Shorter with join, and without the lookup:
JavaScript (Node.js), 42 bytes
a=>a.map(x=>+(x==Math.max(...a))).join('')

Try it online!
Previous, with lookup, 49 bytes
a=>a.map(x=>[0,1][+(x==Math.max(...a))]).join('')

Try it online!
Previous, with reduce, 52 bytes:
a=>a.reduce((y,x)=>y+[0,1][+(x==Math.max(...a))],'')

Try it online!

fa=>a.map(x=>+(x==Math.max(...a))).join('')
console.log(f([ 4, 1,77, 6])) // 0010
console.log(f([10,10, 5, 4])) // 1100
console.log(f([ 1, 1, 1, 1])) // 1111

You can safely remove [0,1][...] since you're using an index that already is either $0$ or $1$.

@Arnauld seems obvious now. Thanks!

C# (Visual C# Interactive Compiler), 26 bytes
n=>n.Select(a=>a==n.Max())

Try it online!
Takes input in format [d,c,b,a]. All the others down below take input as [a,b,c,d]
C# (Visual C# Interactive Compiler), 35 bytes
n=>n.Select((a,b)=>n[3-b]==n.Max())

Returns an IEnumerable<bool>.
Try it online!
C# (Visual C# Interactive Compiler), 39 bytes
n=>n.Select((a,b)=>n[3-b]==n.Max()?1:0)

Returns an IEnumerable<int>, which represent bits.
Try it online!
C# (Visual C# Interactive Compiler), 49 bytes
n=>{for(int i=4;i-->0;Write(n[i]==n.Max()?1:0));}

Prints a binary string to STDOUT.
Try it online!

IEnumerable<bool> is acceptable.

Python 3.8 (pre-release), 67 bytes
Lambda function that takes in 4 integers, bit shifts the boolean result of their comparison to the maximum value with some help from Python 3.8's new assignment operator, and returns the bitwise OR of the results
lambda a,b,c,d:((m:=max(a,b,c,d))==d)<<3|(m==c)<<2|(m==b)<<2|(a==m)

Try it online!

:= reminds me of the old days where that was the assignment operator with Lotus Notes formula. Guess I'll have to take a look at 3.8 for old times sake :)

Ruby, 34 22 bytes
Takes input as an array [d, c, b, a] and returns an array of 1s and 0s.
->r{r.map{|e|e/r.max}}

Try it online!

1. Python 3.5, 90 bytes
Takes sequence of numbers as parameters. Returns "binary" string
import sys;v=[*map(int,sys.argv[1:])];m=max(v);s=""
for e in v:s=str(int(e==m))+s
print(s)

example:
$ ./script.py 6 77 1 4 77
10010

Explanation
import sys
# convert list of string parameters to list of integers
v=[*map(int,sys.argv[1:])]
# get max
m=max(v)
# init outstring
s=""
# walk through list
for e in v:
    # prepend to outstring: int(True)=>1, int(False)=>0
    s=str(int(e==m))+s
# print out result
print(s)

Python 3, 59 bytes 66 bytes
def f(l):
 n=max(a)
 for i in 0,1,2,3:a[i]=a[i]==n
 return a[::-1]

Try it online!
Takes input as [a,b,c,d] and outputs a list of booleans.
Edited to be a proper function, then saved 2 bytes by removing brackets around the conditional.

Hello and welcome to PPCG. As it stands, your answer has the form of a snippet, which is disallowed. Please fix your answer to conform with our I/O consensus, i.e. make it a function or full program.

Edited. First time around. Appreciate the heads up!

You can reduce it to 37 bytes using this list comprehension within a lambda. Welcome to PPCG, and enjoy your stay!

@ValueInk Removing the superfluous whitespace saves yet another byte.

C# (Visual C# Interactive Compiler), 51 bytes
x=>{for(int m=x.Max(),i=4;i-->0;)x[i]=x[i]==m?1:0;}

Try it online!
Above is an anonymous function that outputs by modifying an argument. Output is an array of 1's and 0's.
Below is a recursive function that outputs an integer.
C# (Visual C# Interactive Compiler), 60 bytes
int f(int[]x,int i=3)=>i<0?0:2*f(x,i-1)|(x[i]==x.Max()?1:0);

Try it online!
Both functions take input as a 4-element array.
[d, c, b, a]

You don't need to output an integer.

@Adam - thanks :) I realized this after posting while I was working on my other answer. Before I had a chance to change, there was another C# answer that used a lot of the good tricks.

PHP, 54 bytes
while($i<4)$argv[++$i]<max($argv)||$r+=1<<$i-1;echo$r;

or
while($i<4)$argv[++$i]<max($argv)||$r+=1<<$i;echo$r/2;

take input from command line arguments. Run with -nr or try them online.

Python 2, 35 bytes
lambda i:[int(x==max(i))for x in i]

Try it online!
Takes input in the format [d,c,b,a] as with the accepted answer from Adám so I guess it is OK.
Alternative for 41 if it's not...
Python 2, 41 bytes
lambda i:[int(x==max(i))for x in i][::-1]

Try it online!

Python 3, 42 bytes
f=lambda a:list(map(lambda x:x==max(a),a))

Simply returns a list of whether the element is the max for each element in the input. -2 bytes if you don't count the f= assignment.
Try it online!

f= doesn't count except in recursive functions

Batch, 92 bytes
@set m=%1
@set f=@for %%i in (%*)do @
%f%set/a"m=m+(m-=%%i)*(m>>31)
%f%cmd/cset/a!(m-%%i)

Takes arguments as command-line parameters in reverse order. Works by arithmetically calculating the maximum of the parameters by reducing over them and adding on only positive differences from the running maximum, then mapping over each parameter again this time comparing it to the maximum. Conveniently cmd/cset/a doesn't output a newline, so the results are automatically concatenated together. The %f% simply saves 5 bytes on what would be a repeated construct.


text:
Check if all vowels exist in pairs of strings
Your program should find the number of string pairs (pairs of 2) that contain all vowels (a e i o u), when given an integer N and N strings.
There are easy ways to do this, but I'm looking for the quickest possible solution.
Example:
INPUT:
4
password
unique
orbiting
ointmental

OUTPUT:
2

EXPLANATION:
password has a,o
unique has u,e,i
orbiting has o,i
ointmental has o,i,e,a

The pairs
password and unique
ointmental and unique
are the 2 successful combinations.

Here's a sample DataSet
 where N = 10000

Welcome to PPCG! I think this is a promising first challenge! For the example input, any solution will be limited by the IO speed. Do you have a larger test set? Are all input words random English dictionary words, or do they need to meet certain criteria? For what input are we measuring fastest-code? You could have a specific list of N words, or you could take the average when selecting N random words a few times. On what machine are we measuring? Can we use multiple cores to speed up calculations?

@maxb Inputs don't necessarily have to be of any format. They can be words or even random, meaningless bunches of characters.

Then that needs to be specified. A solution where <1% of all pairs contain all vowels can look very different from a solution where 50% of all pairs are positives. We will try to optimize for the challenge. To refine what you have, look at some previous fastest-code challenges and what information they contain. As a small example, if all input strings are 1000 random characters, almost every input contains all vowels, so the algorithm to find the number of collisions would be different compared to having English words as input.

How long will the words be?

Will there ever be words that contain all five vowels? E.g. education

@ Adám  It doesn't have to be a word. The inputs can be just meaningless strings like absdfterc or any other combination.

I'd recommend having a large test case to test against, as well as specifying the specs of the computer the code will be running on.

I've updated the question to have a dataset of 10000 10 lettered words.

@ViswalahiriHejeebu Thank you for the large dataset, but what is the answer for it?

I'm sorry I didn't mention. The answer is 1968503.

What is the maximum length for a string (if any)? Is 'aeiou', 'aeiou' a valid pair?

Also, CPU specs very much needed.

The maximum length for each string is a 1000 characters, and 'aeiou', 'aeiou'  can be considered as a valid pair.

Java openjdk8
Using bit arrays,
Coding each word on an int where if a is present the lowest bit is 1, if e the second is 1, etc.
For example password has a and o, so its code is 1|8 == 9  == 0b01001.
As we only need the number of pairs we can store the number of words for each code in an array of size 32.
Then for each pair of different indexes except the last (31) where first is less than second and where bitwise or of indexes is 31,  we multiply the number of words with code, and the last is particular because it's the only one that can make a pair with a word of the same code, and also with any word.
public static void main( String[] args ) {
    int[] a = new int[ 32 ];
    int count = 0;
    try (Scanner scan = new Scanner( System.in )) {
        while ( scan.hasNext() ) {
            String s = scan.next();
            a[ code( s ) ]++;
        }
    }

    int t = 0;
    for ( int i = 0 ; i < 31 ; ++i ) {
        count += a[ i ];
        for ( int j = i + 1 ; j < 31 ; ++j ) {
            if ( ( i | j ) == 31 ) {
                t += a[ i ] * a[ j ];
            }
        }
    }

    t += a[ 31 ] * count + a[ 31 ] * ( a[ 31 ] - 1 ) / 2;
    System.out.println( t );
}

// a e i o u
// 1 2 4 8 16
public static int code( String s ) {
    int r = 0;
    for ( char c : s.toCharArray() ) {
        r |= c == 'a' ? 1 : c == 'e' ? 2 : c == 'i' ? 4 : c == 'o' ? 8 : c == 'u' ? 16 : 0;
    }
    return r;
}

TIO
C++
translating to C++ is straightforward
test with 100 first words
test on TIO with 10000 words of dataset
1968503

Real time: 0.419 s
User time: 0.315 s
Sys. time: 0.099 s
CPU share: 98.83 %
Exit code: 0

Fails on ["education","automobile"]

@adam, thank you the case a[31] was count twice, fixed

The C++ implementation was great.

@VHejeebu I've just noticed the getline can return an empty string so a check ìf(!input.empty()) must be done arround a[code(input)]++

C++ link updated

APL (Dyalog Unicode)
Two solutions designed by my esteemed colleague Marshall, master of speeding up APL. The formulas used are both in '70s APL, so they works in APL\360 on an IBM/360 mainframe. They are anonymous prefix functions taking a character matrix as argument. N is not needed but may be supplied as optional (and ignored) left argument.
The first solution is O(n2)
A naive approach:
{0.5×(+/,(⍉i)∧.∨i)-+/∧⌿i←∨/'aeiou'∘.=⍵}

Try it online!
Processes* the large data set in about 4.5 ms. TIO takes about twice that.
{…} "dfn"; the argument is ⍵:
 'aeiou'∘.=⍵ equality 3D array with vowels along the first axis, words along the middle axis and characters along the last axis
 ∨/ OR-reduction along the last axis; this gives us a 5-row table with one column per word
 i← store that in i (for in)
 ∧⌿ AND-reduction along the first axis; this gives us a mask of words that contain all vowels
 +/ sum; count of words containing all vowels (we need to discount their "self-pairs")
 (…)- subtract that from the following:
  (⍉i)∧.∨i the Boolean matrix where the OR of corresponding masks is all-true.
  , ravel (flatten)
  +/ sum; this gives us the count of ordered pairs
 0.5× halve; this gives us the count of unordered pairs
The second solution is O(n)
Breaks even with the above O(n2) solution at about 150 words of 10 evenly distributed characters. It requires 0-based indexing, and a pre-computed 32-by-32 Boolean vowel signature pairing table:
{
    a←0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
    a[2⊥∨/'aeiou'∘.=⍵]+←1
    (0.5×l×¯1+l←a[31])++/,p×a∘.×a
}

Processes* the large dataset in 0.09 ms. TIO's timing is too inconsistent to make any conclusions, but it is likely that it takes about twice the time here too.

* 64-bit Dyalog APL 17.0 on 2.6 Ghz i7-4720HQ