Four Spiraling Axes

Question

Take the numbers 0, 1, 2, 3, 4, ... and arrange them in a clockwise spiral, starting downward, writing each digit in its own separate square.

Then, given one of four distinct and consistent ASCII characters (your choice) representing an axis, and an input integer n, output the first n terms of the sequence described by selecting squares along the corresponding axis.

For example, below is the arranged spiral up to partway through 29. Suppose we use u / d / l / r for our four characters, representing up / down / left / right. Then, given u as input, we output 0, 5, 1, 4 ... (the positive y-axis) up to the nth term. If we were instead given l as input, then it would be 0, 3, 1, 1 ... up to the nth term.

  2---3---2---4---2---5---2
  |                       |
  2   1---3---1---4---1   6
  |   |               |   |
  2   2   4---5---6   5   2
  |   |   |       |   |   |
  1   1   3   0   7   1   7
  |   |   |   |   |   |   |
  2   1   2---1   8   6   2
  |   |           |   |   |
  0   1---0---1---9   1   8
  |                   |   |
  2---9---1---8---1---7   2

These are sequences on OEIS:

• http://oeis.org/A033953 for the positive x-axis
• http://oeis.org/A033988 for the positive y-axis
• http://oeis.org/A033989 for the negative x-axis
• http://oeis.org/A033990 for the negative y-axis

Examples

d 19
[0, 1, 1, 8, 3, 7, 6, 2, 1, 5, 1, 1, 6, 2, 2, 1, 3, 4, 0]

r 72
[0, 7, 1, 7, 4, 2, 8, 1, 1, 3, 1, 2, 0, 2, 3, 1, 3, 4, 6, 5, 5, 5, 7, 7, 8, 8, 9, 6, 8, 1, 1, 1, 2, 3, 1, 8, 0, 6, 1, 7, 0, 9, 2, 8, 4, 3, 2, 1, 1, 7, 2, 6, 2, 1, 3, 3, 5, 5, 3, 2, 2, 0, 4, 3, 2, 5, 4, 6, 5, 0, 5, 1]

u 1
[0]

Rules

• If applicable, you can assume that the input/output will fit in your language's native Integer type.
• If you're using integers to represent the four axes, you can use negative integers without breaking the rules.
• The input and output can be given by any convenient method.
• Either a full program or a function are acceptable. If a function, you can return the output rather than printing it.
• Standard loopholes are forbidden.
• This is code-golf so all usual golfing rules apply, and the shortest code (in bytes) wins.

Answer 1

Python 2, 94 89 84 83 74 72 70 bytes

I used WolframAlpha and determined that an upper bound of 5ⁿ > 4n²+3n seems to be enough. It can be changed to 9ⁿ at no cost. For trying larger inputs, use 9*n*n instead of 5**n to avoid running out of memory.

lambda d,n:["".join(map(str,range(5**n)))[x*(4*x+d)]for x in range(n)]

Try it online!

The inputs for directions are:

• 3: right
• -3: down
• -1: left
• 1: up

Saved 14 bytes thanks to Rod
Saved 2 bytes thanks to Jonathan Allan

Answer 2

MATL, 32 bytes

tE1YLtn:qVXzw)3Lt3$)iX!w:qyfYm+)

Input is n, a, where a represents the axis as follows:

• 0: left;
• 1: up;
• 2: right;
• 3: down.

Output is a string.

Try it online! Or verify all test cases.

Answer 3

Jelly,  19  18 bytes

Uses the 5ⁿ trick from mbomb007's Python answer

4,0jḅɗ@€ị5*D€FʋṖ0;

A dyadic link taking n on the left and d and integer from: [-3,-1,1,3]:[v,<,^,>]

Try it online!

A 20 byte alternative that is both much faster and does not segfault for such small n is:

²×5D€ƲFị@4,0jḅɗ@€Ṗ0;

Try it online!

How?

4,0jḅɗ@€ị5*D€FʋṖ0; - Link: integer, n; integer, d
     ɗ@€           - last three links as a dyad with sw@pped arguments for €ach (of implicit range [1,n])
4,0                -   literal list [4,0]
   j               -   join with d = [4,d,0]
    ḅ              -   convert from base n = 4*n^2+d*n+0
        ị          - index into...
              ʋ    - last four links as a monad:
         5         -   five
          *        -   exponentiate = 5^n
           D€      -   decimal list of each (in implicit range [1,5^n])
            F      -   flatten into a single list of the digits
               Ṗ   - pop (drop the final element)
                0; - prepend a zero

Answer 4

will work for considerable n (like +1000)

JavaScript (Node.js), 104 bytes

f=(d,n)=>--n?[...f(d,n),C(n*(4*n+d))]:[0]
C=(n,N=i=0)=>n>N?C(n-N,(p=10**i)*9*++i):+((p+--n/i|0)+"")[n%i]

Try it online!

Explanation

• 3: right
• -3: down (-3 is legit according to comments)
• -1: left
• 1: up (like @mbomb007)

C- nth digit of Champernowne's constant

________________________________________________________

Less efficient method (wont work for 1000+)

JavaScript (Node.js), 81 bytes

f=(d,n)=>eval(`for(r=[],s=i=I="";I<n;)(s+=i++)[u=I*(4*I+d)]&&r.push(s[I++,u]),r`)

Try it online!

Answer 5

Stax, 13 bytes

â╞ê←τ"(]]⌐┘?N

Run and debug it

It takes input with the direction, followed by the count. Right, up, left, and down are 1, 3, 5, and 7 respectively. It takes a full minute to run the three provided test cases.