text:
Embiggen your input
This is a bit similar to this dust covered entry but I'm hoping my spin on it makes it unique enough. Not been able to find anything dissuading me from posting this but there is quite the sea out there.
Anyway! The challenge:
Your code receives a string of characters; It converts this into an ASCII-art style version of the same string, but with a catch.
Input transformation

The only characters to be supported are A-Z and 0-9
Lower case letters are transformed into uppercase
Anything else is silently removed

Character drawing

Each "pixel" of the enlarged font is drawn from the input string
The n'th pixel is equal to the n'th character in the input string. If n is greater than the length of the input string, wrap around back to the beginning
Individual letters are drawn left-to-right, top-to-bottom
Subsequent letters pick up their "pixel character" index from where the last letter left off (e.g. with an input length of 10, if the first letter had 9 pixels, the second letter's first pixel will be drawn with the 10th input character, the second pixel will be drawn with the 1st input character)
Each letter is drawn in a 5x5 grid, fully padded with spaces. You can find the font you are to use pre-rendered for you in this pastebin or a bit further down in this post
Every letter is drawn on the same line, so the total number of line breaks in your output will be 4
Every letter is seperated by 2 columns of spaces

The font
 000
0  00
0 0 0
00  0
 000

111
  1
  1
  1
11111

2222
    2
 222
2
22222

3333
    3
  333
    3
3333

  44
 4 4
44444
   4
   4

55555
5
5555
    5
5555

 6666
6
6666
6   6
 666

77777
    7
   7
  7
 7

 888
8   8
 888
8   8
 888

 999
9   9
 9999
    9
9999

 AAA
A   A
AAAAA
A   A
A   A

BBBB
B   B
BBBB
B   B
BBBB

 CCCC
C
C
C
 CCCC

DDDD
D   D
D   D
D   D
DDDD

EEEEE
E
EEE
E
EEEEE

FFFFF
F
FFF
F
F

 GGGG
G
G  GG
G   G
 GGGG

H   H
H   H
HHHHH
H   H
H   H

IIIII
  I
  I
  I
IIIII

JJJJJ
  J
  J
  J
JJ

K   K
K  K
KKK
K  K
K   K

L
L
L
L
LLLLL

M   M
MM MM
M M M
M   M
M   M

N   N
NN  N
N N N
N  NN
N   N

 OOO
O   O
O   O
O   O
 OOO

PPPP
P   P
PPPP
P
P

 QQ
Q  Q
Q QQ
Q  Q
 QQ Q

RRRR
R   R
RRRR
R  R
R   R

 SSSS
S
 SSS
    S
SSSS

TTTTT
  T
  T
  T
  T

U   U
U   U
U   U
U   U
 UUU

V   V
V   V
 V V
 V V
  V

W   W
W   W
W W W
WW WW
W   W

X   X
 X X
  X
 X X
X   X

Y   Y
 Y Y
  Y
  Y
  Y

ZZZZZ
   Z
  Z
 Z
ZZZZZ

Yes I know the 4 and Q are ugly
An example
Input
0123456789

Output
 012   567    6789   0123     34   45678   9012  34567   234    567
3  45    8        0      4   5 6   9      3          8  5   6  8   9
6 7 8    9     123     567  78901  0123   4567      9    789    0123
90  1    0    4          8     2       4  8   9    0    0   1      4
 234   12345  56789  9012      3   5678    012    1      234   5678

Another example
Input
a3 B'2

Output
 A3B   B2A3   2A3B   2A3B
2   A      B  2   A      2
3B2A3    2A3  3B2A    A3B
B   2      B  3   B  2
A   3  2A3B   2A3B   A3B2A

Standard loopholes are forbidden. Code golf so no green tick will be given.

What's the '?

@l4m2 Just illustrating that anything failing to match [A-Z\d] is removed

I'd suggest guaranteeing that the input will only contain [A-Z\d] - I don't think filtering invalid characters adds anything to the challenge.

Related, related

@Shaggy Perhaps. But by the same token I don't think it removes anything from the challenge

What is the significance of Individual letters are drawn left-to-right, top-to-bottom when Every letter is drawn on the same line, so the total number of line breaks in your output will be 4?

related

@Adám To try to communicate that all the "large letters" are all on the same "large line" as it were. I struggled for a while with how to phrase it. Basically I don't want people submitting answers where they output 1 letter, issue a line break and ouput the next letter as that trivializes the challenge.

May we have a trailing space column?

@Adám So the spaces can be included in the font setup? Since rtrim isn't exactly challenging I'll allow it.

Related.

Would a single leading space on each line be allowed?

@Shaggy Yea I'll allow that

Wait, what about two leading spaces on each line then?

@Adám Go for it

Mildly related.

What about THREE leading spaces? Surely you'll not allow that!

@MagicOctopusUrn That would be absurd!

would you say it's fair also to describe this challenge as kolmogorov-complexity since compactly representing the information in the font glyphs is a big part of it?

Python 2, 413 411 373 364 352 345 bytes
-1 byte thanks to Kevin Cruijssen.
-9 bytes thanks to Jo King.
-1 byte thanks to Lynn.
Data string contains unprintables, escaped version below.
k=list(filter(str.isalnum,input()))
q=range(5);o=['']*5;r=k*25;d=0
for c in'uM<LxSe#ye>El4NpD@$	gh>I,m]aB>e,]?kFLyglxV!%w832wGj%uT{Hr*K,*[P\n6.&ED#T}^DLI&p7f\d`*lG!FacG\rz?!A':d*=126;d+=ord(c)-1
for c in k:
 for i in q:
	for y in q+[999]*2:o[i]+=d>>int(c,36)*25+i*5+y&1and r.pop(0)or' '
print'\n'.join(o).upper()

Try it online!
As each character has 25 pixels it can be easily encoded in 25 bits. The base 126 number 'uM\x04<L\x10x\x14Se#ye\x0f>El4NpD@$\tgh>\x1d\x10\x15I,\x0em]a\x0e\x03B>e\x15,\x0c]\x03?kFL\x01\x0byglxV!\x18\x16\x0c\x0b\x10\x0b%w832wGj%uT{Hr*K,*[P\n6.&ED#T\x0c}^\x1c\x0fD\x17LI&p7\x17f\\d`*\x01l\x1bG\x12!Fac\x05\x08\x0eG\rz?!\x1aA' encodes all chars, the 0 is encoded by the least significant 25 bits, the 1 by the next 25 bits and the Z is encoded by the 25 most significant bits. A single character is encoded in the following order:
00 01 02 03 04
05 06 07 08 09
10 11 12 13 14
15 16 17 18 19
20 21 22 23 24

(00 is the least significant bit, 25 the most significant one)
Spaces are encoded by a zero, non-spaces by a one. Example:
77777      11111
    7      00001
   7   =>  00010  => (0001000100010001000011111)
  7        00100
 7         01000

Ungolfed
k = list(filter(str.isalnum,input()))  # keep only alphanumeric characters of the input
o = ['']*5   # this list contains the output, initially 5 empty lines
r = k * 25   # make a copy of the input 25-times the length, these chars will be used for the pixels
data = 0
#  data encoded in base 126
b92d = 'uM<LxSe#ye>El4NpD@$	gh>I,m]aB>e,]?kFLyglxV!%w832wGj%uT{Hr*K,*[P\n6.&ED#T}^DLI&p7f\d`*lG!FacG\rz?!A'
for c in b92d:          # convert base 92 to base 10
  d*=126;d+=ord(c)-1

for c in k:             # iterate over the filtered input
  a_index = int(c, 36)  # the index of the current char in '0..9A..Z' / '0..9a..z'
  for i in range(5):    # for each row of the output
    for y in range(5)+[999]*2:  # for each pixel in the row, th two 999's are used for spaces
      is_set = data >> (a_index*25 + i*5 + y) & 1  # We shift the to the right to have ...
                                                   # the current pixels value at the LSB:
                                                   # 25 bits for each char that came before
                                                   # 5 bits for each previous row and 1 bit
                                                   # for every pixel in the same row
      o[i] += is_set and r.pop(0) or ' '           # If the current pixel is set, append ...
                                                   # ... a character from the input to the current row
print '\n'.join(o).upper()  # print the output

Try it online!

Letters should be separated by two spaces, so the +' ' should be +'  '. Nice answer regardless, so +1 from me.

you do need the .upper() somewhere though, otherwise the inner letters end up lowercase

@JoKing You're right, fixed it.

Love this encoding trick.   Did you choose base 92 because that's the largest standard encoding consisting of printable ascii?  could you have gone higher?  also i googled but wasn't able to fine info on base 92 - do you have a link?

@Jonah There is no such standard as base 92-encoding, thats why I implemented my own decoding logic. As long as you have enough distinct digits, you can use any base >1.

@Jonah turns out I can get higher bases to work, thank you!

@ovs, ah, i didn't  read closely enough, so you did.  could it save bytes to use a standard high-base encoding?

APL (Dyalog Unicode), 228 225 224 214 bytes
Full program. Prompts stdin for string. Prints to stdout. About half of the code is just decoding the encoded alphabet.
⍉↓(⍴t)⍴r\i⍴⍨+/r←,t←(⊂a⍳i←(1(819⌶)⍞)∩a←⎕D,⎕A)⌷0(220⌶)¯1(219⌶)¯125+⎕AV⍳_________________________________________________________________________________________________________________________________________________

_…_ represents the following 143-byte LZ4-encoded string in quotes: "⊥\u0004pæ€}€\\⊃⌿Æ€â<Å€∧€ÀÆ€Ð┬:Ëcü\u0000≥ðè⊤õ⍨¢∧·èý\u0005þÐÕ\u001EÐ  :\u001Eè⌊×ßi[B⊂ɫoÃ£à oéìÐ⍙⊃Ý∣à)≥èB⊃\u001B\u001F⊥ä{⌿⍨ G⍺\u001B⌿Æ\u001F∇x└îR`:└è→⊂\u0000ê∧⍒\u0003ɫqè$$ÛD⊥â∊\u001B\u001Eéu|\u001B@4A|⍪┌nàkááÐ€€€€€€€"
Try it online!
_…_ 143-byte LZ4-encoded string in quotes
⎕AV⍳ ɩndices of that in the Atomic Vector (the character set)
¯125+ add -125 to that (to get signed 8-bit integers)
¯1(219⌶) LZ4 decompress
0(220⌶) deserialise to a 36 layer, 5 row, 5 column Boolean array
(…)⌷ index into that using the following indices:
 ⎕A uppercase Alphabet
 ⎕D, prepend the Digits
 a← store in a (for alphabet)
 (…)∩ intersection of the following and that (removes invalid input):
  ⍞ prompt for text input from stdin (console)
  1(819⌶) fold to uppercase (819 looks like Big, 1 is for yes big as opposed to small)
 i← store in i (for input)
 a⍳ ɩndices of that in a
 ⊂ enclose (to index with each one representing the leading coordinate)
t← store in t (for text)
, ravel (flatten)
r← store in r (for ravelled)
+/ sum that (i.e. number of characters needed to paint the artwork)
i⍴⍨ cyclically reshape the input to that length
r\ expand that; insert a spaces at 0s, consume letters at 1s
(…)⍴` reshape to the following shape:
 ⍴t the shape of the text
↓ split the N-by-5-by5 array into an N-by-5 matrix of art lines
⍉ transpose into a 5-by-N matrix of art lines (this aligns corresponding lines of the characters)
By default, APL separates simple elements of a nested array with 2 spaces.

Not quite! There needs to be 2 spaces between each letter

@Scoots OK, fixed.

@Adám something's wrong with C and D

Python 2, 428 bytes
s=filter(str.isalnum,input().upper());x=s
R=['']*5
for c in s:
 i=0;exec"n=int('RAAAOQQ2RBAQBQRRBDRRDCDDAQ8QBRDDDDDRXDDF0XX6CCDDCDCCCD00ECNLDDEDC0DDD66YYABH0A3RQQRQCDOOFR00OCHHDQIQA0D6H0000DXL0CXYXDDDCDCCDD00ECDFDCEEX0D6N6044AQARRQYQADQBQRCBDRKDRDDAC9DQ0A0DD0R'[i*36+ord(c)%55%45],36);R[i]+=bin(n+36*(n<30)<<2)[3:].replace(*'0 ').replace(*'1.');i+=1;"*5
 while'.'in`R`:R=eval(`R`.replace('.',x[0],1));x=x[1:]+s
print'\n'.join(R)

Try it online!

The letters are encoded as follows:
Each unique part (there are 23) is converted to binary, and a 1 is added in front. Then it is converted to base 36.
  part      bin      1+bin     int     base36
'  ...' -> 00111 -> 100111 ->   39  ->   13

The resulting base-36 numbers are:
[10,12,13,14,16,18,19,1A,1B,1C,1D,1E,1F,1H,1I,1K,1L,1N,1O,1Q,1R,X,Y]

The initial 1 is removed, so we have a single character:
[0,2,3,4,6,8,9,A,B,C,D,E,F,H,I,K,L,N,O,Q,R,X,Y]

Each letter (A-Z0-9) is then encoded to five of these new chars.
0 = ' ... ','.  ..','. . .','..  .',' ... ' -> A,F,H,L,A
1 = '...  ','  .  ','  .  ','  .  ','.....' -> O,0,0,0,R
etc.

Into five lists:
'AOQQ2RBRAAAQBQRRBDRRDCDDAQ8QBRDDDDDR'
'F0XX6CCXDDDDCDCCCD00ECNLDDEDC0DDD66Y'
'H0A3RQQYABRQCDOOFR00OCHHDQIQA0D6H000'
'L0CXYXD0DXDDCDCCDD00ECDFDCEEX0D6N604'
'ARRQYQA4AQDQBQRCBDRKDRDDAC9DQ0A0DD0R'

To map the input to an index in these lists, the ordinal is modded:
'0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ'
ord(c) = [48-57, 65-90]
ord(c)%55%45 = [3-9, 0-2, 10-35]

Because the ordinals are not 0-35, but slightly mixed, the 5 lists are rearranged, and concatenated:
'RAAAOQQ2RBAQBQRRBDRRDCDDAQ8QBRDDDDDR'
'XDDF0XX6CCDDCDCCCD00ECNLDDEDC0DDD66Y'
'YABH0A3RQQRQCDOOFR00OCHHDQIQA0D6H000'
'0DXL0CXYXDDDCDCCDD00ECDFDCEEX0D6N604'
'4AQARRQYQADQBQRCBDRKDRDDAC9DQ0A0DD0R'
->
'RAAAOQQ2RBAQBQRRBDRRDCDDAQ8QBRDDDDDRXDDF0XX6CCDDCDCCCD00ECNLDDEDC0DDD66YYABH0A3RQQRQCDOOFR00OCHHDQIQA0D6H0000DXL0CXYXDDDCDCCDD00ECDFDCEEX0D6N6044AQARRQYQADQBQRCBDRKDRDDAC9DQ0A0DD0R'

For each char in the input, it's 5 letters are found, and converted to a ints(base36):
n=int('RAAA...D0R'[i*36+ord(c)%55%45],36)
                   i*36                    #get row i
                        ord(c)%55%45       #n -> 0..35
  int(                               ,36)  #convert to int

If the number is below 30, 36is added (the missing 1we removed earlier)
n+36*(n<30)

Then the number is converted back to binary, and 0s and 1s are converted to and .. Two spaces are added at the end during the conversion.
bin(n+36*(n<30)<<2)[3:].replace(*'0 ').replace(*'1.')

    n+36*(n<30)                                       #add leading base36 '1'
               <<2                                    #add 2 0's to end
bin(              )                                   #convert to binary string
                   [3:]                               #remove '0b1' from front
                       .replace(*'0 ').replace(*'1.') #replace 0 and 1

Eg.
C    base36    int     <<2       bin-str        str
3 ->   13   ->  39  ->  156 -> 0b10011100 -> '  ...  '

For each . in the result, it is replaced by the next character from the input (iterated by x)
while'.'in`R`:R=eval(`R`.replace('.',x[0],1));x=x[1:]+s

Nice! Could I trouble you for an explanation of how this works? At the moment this is wizardry to my eyes.

@Scoots On it! :)

Thanks for adding that :) The cleverness I see in the answers on this site never fails to impress me

Since the parts are 5 bits, why not use base 32 instead?

Java 8, 917 907 bytes
int i,l;String[]S;s->{String q=" ",t="",r[]={t,t,t,t,t};S=s.toUpperCase().replaceAll("[^A-Z0-9]",t).split(t);i=-1;l=S.length;for(String c:S){r[0]+=s("12357BDEFHIJKLMNPRTUVWXYZ",c)+s("012356789ABCDEFGIJOPQRSTZ",c)+s("0123456789ABCDEFGIJOPQRSTZ",c)+s("023456789ABCDEFGIJOPRSTZ",c)+s("567CEFGHIJKMNSTUVWXYZ",c)+q;r[1]+=s("05689ABCDEFGHKLMNOPQRSUVW",c)+s("4MNXY",c)+s("1IJT",c)+s("04KMQXYZ",c)+s("023789ABDHMNOPRUVW",c)+q;r[2]+=s("0456ABCDEFGHKLMNOPQRUW",c)+s("245689ABEFHKPRSV",c)+s("012345689ABEFHIJKMNPQRSTWXYZ",c)+s("23456789ABGHPQRSV",c)+s("0349ADGHMNOUW",c)+q;r[3]+=s("0268ABCDEFGHKLMNOPQRUW",c)+s("0VWXZ",c)+s("17IJTY",c)+s("4KNQRVWX",c)+s("035689ABDGHMNOSUW",c)+q;r[4]+=s("12359ABDEFHIJKLMNPRSWXZ",c)+s("012356789BCDEGIJLOQSUZ",c)+s("01235689BCDEGILOQSTUVYZ",c)+s("012345689BCDEGILOSUZ",c)+s("12ACEGHIKLMNQRWXZ",c)+q;}return"".join("\n",r);}String s(String...s){return s[0].contains(s[1])?S[++i%l]:" ";}

Will golf it down from here to at least halve the current byte-count hopefully..
Try it online.
Explanation:
int i,                         // Index-integer on class-level
    l;                         // Length-integer on class-level
String[]S;                     // String-array of characters on class-level

s->{                           // Method with String as both parameter and return-type
  String q="  ",               //  Temp String containing two spaces to reduce bytes
         t="",                 //  Temp Empty String to reduce bytes
         r[]={t,t,t,t,t};      //  Start with five empty rows
  S=s.toUpperCase()            //  Transform the input-String to uppercase
     .replaceAll("[^A-Z0-9]",t)//  Remove all non alphanumeric characters
     .split(t);                //  And transform it into a String-array of characters
  i=-1;                        //  Set the index-integer on -1 to start with
  l=S.length;                  //  Set the length of the modified input
  for(String c:S){             //  Loop over the characters of the modified input:
    r[0]+=                     //   Append to the first row:
          s("12357BDEFHIJKLMNPRTUVWXYZ",c)      // The first pixel
          +s("012356789ABCDEFGIJOPQRSTZ",c)     // The second pixel
          +s("0123456789ABCDEFGIJOPQRSTZ",c)    // The third pixel
          +s("023456789ABCDEFGIJOPRSTZ",c)      // The fourth pixel
          +s("567CEFGHIJKMNSTUVWXYZ",c)         // The fifth pixel
          +q;                                   // Two trailing spaces
    r[1]+=                     //   Append to the second row:
          s("05689ABCDEFGHKLMNOPQRSUVW",c)      // The first pixel
          +s("4MNXY",c)                         // The second pixel
          +s("1IJT",c)                          // The third pixel
          +s("04KMQXYZ",c)                      // The fourth pixel
          +s("023789ABDHMNOPRUVW",c)            // The fifth pixel
          +q;                                   // Two trailing spaces
    r[2]+=                     //   Append to the third row:
          s("0456ABCDEFGHKLMNOPQRUW",c)         // The first pixel
          +s("245689ABEFHKPRSV",c)              // The second pixel
          +s("012345689ABEFHIJKMNPQRSTWXYZ",c)  // The third pixel
          +s("23456789ABGHPQRSV",c)             // The fourth pixel
          +s("0349ADGHMNOUW",c)                 // The fifth pixel
          +q;                                   // Two trailing spaces
    r[3]+=                     //   Append to the fourth row:
          s("0268ABCDEFGHKLMNOPQRUW",c)         // The first pixel
          +s("0VWXZ",c)                         // The second pixel
          +s("17IJTY",c)                        // The third pixel
          +s("4KNQRVWX",c)                      // The fourth pixel
          +s("035689ABDGHMNOSUW",c)             // The fifth pixel
          +q;                                   // Two trailing spaces
    r[4]+=                     //   Append to the fifth row:
          s("12359ABDEFHIJKLMNPRSWXZ",c)        // The first pixel
          +s("012356789BCDEGIJLOQSUZ",c)        // The second pixel
          +s("01235689BCDEGILOQSTUVYZ",c)       // The third pixel
          +s("012345689BCDEGILOSUZ",c)          // The fourth pixel
          +s("12ACEGHIKLMNQRWXZ",c)             // The fifth pixel
          +q;}                                  // Two trailing spaces
  return"".join("\n",r);}      //  Return the rows joined with new-lines

//  Separated method with String-varargs parameter and String return-type
String s(String...s){
  return s[0].contains(s[1])?  //  If the String contains the character-String:
                               //   Increase `i` by 1 first with `++i`
    S[++i%l]                   //   Then return the i'th character of the modified input
                               //   with wraparound by using modulo-`l`
   :                           //  Else:
    " ";}                      //   Return a space

You don't seem to have a self-contained example. Class fields, methods and lambdas. I +1'd for taking the time to to it as expected, but the manner here seems a bit invalid.

@OlivierGrégoire Hmm, I thought class-level fields were allowed, as long as you don't set them on class-level (the function need to be run multiple times without resetting anything to be self-contained). Which is why I have the i=-1 inside the lambda. But maybe I'm incorrect and it isn't allowed according to the meta? EDIT: Something similar is done pretty often in C answers.

I don't know. That's why I used the word "seems". But that'd be a derived way to instanciate primitive values to their default, having significant impact for a lot of golfing answer. For instance: int i;f->{for(;i++<10;)print(i);} is 1 byte shorter than f->{for(int i=0;i++<10;)print(i);}.

@OlivierGrégoire That's why I stated the i=-1 is inside the lambda function. Your example doesn't work if you run the same lambda twice, mine does, which is the key difference here. int i;f->{for(i=0;i++<10;)print(i);} would be allowed for example (although not really shorter).

Japt v2.0a0 -R, 213 211 210 209 206 193 191 190 188 187 bytes
u f\w Ën36 g`...`ò4)nLõd)¤®Í?FgT°:SÃò5n)ù6ÃÕm¸

Try it or test all characters (the extra bytes are due to TIO not supporting Japt v2)

Explanation
Lookup Table
Every group of 4 characters in the backtick enclosed string (represented by ... above to save space and because it contains a bunch of unprintables) is the binary representation of each character (0 for spaces, 1 for characters) with the newlines removed and converted to base-100.
Example
ZZZZZ -> 11111
   Z  -> 00010
  Z   -> 00100 -> 1111100010001000100011111 -> 32575775 -> !::L
 Z    -> 01000
ZZZZZ -> 11111
The Code
u f\w Ën36 g`...`ò4)nLõd)¤®Í?FgT°:SÃò5n)ù6ÃÕm¸     :Implicit input of string U
u                                                  :Uppercase
  f                                                :Match
   \w                                              :  RegEx /[a-z0-9]/gi
      Ë                                            :Map each D in array F
       n36                                         :  Convert D from base-36 to decimal
           g                                       :  Index into
            `...`                                  :    The string described above
                 ò4                                :    Partitions of length 4
                   )                               :  End Indexing
                    n                              :  Convert from base
                     Lõ                            :    Range [1,100]
                       d                           :    Get characters at those codepoints
                        )                          :  End base conversion
                         ¤                         :  Convert to binary
                          ®                        :  Map
                           Í                       :    Convert from binary to decimal
                            ?                      :    If truthy (i.e, 1)
                             Fg                    :      Get the element in F at index
                               T°                  :        T (initially 0) postfix incremented
                                 :                 :    Else
                                  S                :      Space
                                   Ã               :  End map
                                    ò              :  Partitions of length
                                     5n            :    -5 (i.e., weighted towards the end)
                                       )           :  End partition
                                        ù6         :  Left pad each with spaces to length 6
                                          Ã        :End map
                                           Õ       :Transpose
                                            m      :Map
                                             ¸     :  Join with spaces
                                                   :Implicit output joined with newlines

Ruby, 366 bytes
->s{s.tr!('^0-9A-Za-z','');b=([s]*s.size).map(&:chars);%w(esuu6vfveeeufuvvfhvvhghheucufvhhhhhv j411agg1hhhhghgggh44igrphhihg4hhhaa2 l4e7vuu2efvughssjv44sgllhumue4hal444 p4g121h4h1hhghgghh44ighjhgii14hara48 evvu2ue8euhufuvgfhvohvhhegdhu4e4hh4v).map{|x|w=t='';s.chars{|c|c=~/\w/&&w+="%5b  "%x[c.to_i 36].to_i(36)};w.size.times{|i|t+=w[i]>?0?b[i/7].rotate![-1]:' '};t}}

Try it online!
This can be golfed a lot, but now I've run out of time and ideas. It was harder than I first thought just to get it working.
How it works:
It's not so hard to understand, I'll just explain how the alphabet is coded with an example. Every line of every character is converted to binary and then to base-36.
 AAA   -> 01110 -> E
A   A  -> 10001 -> H
AAAAA  -> 11111 -> V
A   A  -> 10001 -> H
A   A  -> 10001 -> H

The first step is stripping all non-alphanumeric characters from the input string.
Then I generate a lookup table for the final rendering, because I want to print line for line.
After that, iterating on the alphabet line, I create the binary pattern of the letters.
Finally I replace 0 with spaces and 1 with characters from the lookup table.
Feel free to golf further, I know this could be 20-30 bytes shorter (using gsub instead of tr, and so on), but I'm not interested now, unless I can make the alphabet table drastically smaller.

Charcoal, 172 164 bytes
≔⁺⭆χιαα≔Φ↥Ｓ№αιθＦθ«Ｅ⁵⭆§⪪”)∧%"<⁰ＥＴV´el⟧2[◧À&η²p.±‹§Ｋ×GＲ←∨�X¶⌈hＦ)ξυ9ＤUuqε↘Ｚ)s⎚H⊙←<¿.＆]～b≧✂⪪XïＪ61%ZWm/ειK⮌λ﹪▷(σΠＮc←º✳Ｆb⌕⊘¹ÞＥpＭ＆➙δl◨α↑j≕ςL¡ρG⁰/y”⁵⁺κ×⁵⌕αι⎇Ｉμ§θ⊖Ｌ⊞Ｏυω Ｍ⁷±⁵

Try it online! Link is to verbose version of code. Explanation:
≔⁺⭆χιαα

Prefix the digits to the predefined uppercase alphabet.
≔Φ↥Ｓ№αιθ

Uppercase the input and filter out all the unsupported characters.
Ｆθ«

Loop over the remaining characters.
Ｅ⁵

Loop over each row, implicitly printing each result on its own line.
⭆§⪪”...”⁵⁺κ×⁵⌕αι

The compressed string is @ovs's large integer constant, converted to binary and reversed. It is then sliced into 180 substrings of 5 characters, and the relevant substring for the current character and row is then looped over.
⎇Ｉμ§θ⊖Ｌ⊞Ｏυω

If the bit was set then cyclically print the next character of the filtered input otherwise print a space.
Ｍ⁷±⁵

Position the cursor ready to print the next character.

Perl 5 with -nlaF/[^A-Za-z0-9]+|/, 247 bytes
@l{0..9,A..Z}=unpack("b*",q&....!.?.......G...../.......\....c|...C......'..N.>..c.1~B......I1..~.5.8k....^|!...}.......BH.1..."1..."*FE.....&)=~/.{25}/g;eval'$;[$j%5].=($l{+uc}=~/.{5}/g)[$j++%5]=~s/./$&?uc$F[$i++%@F]:$"/ger.$"x2;'x5for@F;say for@

Try it online!

Explanation
First a lookup table is created in %l using the packed data. This data is a 900-bit binary string of each char packed as a 25-bit binary string (stored as 113 bytes - only 1 more byte than charcoal!), similar to some other answers, so A is:
 AAA
A   A
AAAAA
A   A
A   A

which, using 0 for space and 1 for A is:
01110
10001
11111
10001
10001

and without the line breaks is:
0111010001111111000110001

Once the lookup is initialised, we iterate over each valid char in @F (which is populated using Perl's -autosplit option) appending to each of the 5 elements of the list @; for each row in the array from the lookup, replacing all 1s with uc$F[$i++%@F] which is the $ith character (modulo @F which is the length of @F) converted to uppercase, and all 0s with $" which defaults to space. Once each index in @; is populated for each character in @F, say prints each line with a trailing newline.
Note: the string after unpack contains unprintables which are escaped using \xXX notation. Verification for score of 247.

SOGL V0.12, 165 164 163 bytes
⁰CīøDs8↓3‛⁸⁷ω8<t↑\≈⅓dPb¦l═│Æ¹č<⁷i3ζ°@Ο≠ΖηKπ⁴Φd←⅔Ωī$∞ΧΗf▼xƧqWƨ∑ģpc!ƨ@┐Γ<§5ΛMn«Ιq;⁾№╔1xdψBN≤⁴ζ8□\b╗³╤>↔²Μ±}H}≤╬bφIæ7“2─{rƧ- W}⁰∑M¼nEU{SUZ+;W:?ew;cF+C}X}⁰┌cŗā;{√┼@L*┼

Try it Here!
Explanation:
...“                 big long number of the character data
    2─               convert to a base 2 string
      {r    }        for each number in it
        Ƨ- W           get it's index in "- ": space for 0, dash for 1
             ⁰∑      join up the results
               M¼n   split into groups of 25 - the letters
                  E  save that in variable E

U{                 }⁰ map over the input uppercased
  SUZ+                  push 1234567890 + the alphabet
      ;W                get the current characters index in that string
        :?       }      duplicate, if not 0 (aka if found)
          e               push the variable E
           w              get in it the duplicated number'th item
                            this leavesleaving the array below the item
            ;             get the array ontop
             cF+C         append the character to the array C
                  X     and remove the top item - either the duplicate or the array

┌             push "-"
 c            load the variable C
  ŗ           cycically replace "-" in maps result with the characters of C
   ā          push an empty array - the output
    ;{        for each item in the result of the replacement
      √         squareify it
       ┼        and append that to the output array
        @L*┼    top-to-bottom, left-to-right add 10 spaces to the array

JavaScript (Node.js), 365 347 bytes
Saved 1 byte thanks to @Scoots
Returns an array of 5 strings. Includes a leading space on each row.
37 36 bytes are lost in converting everything to uppercase and matching [A-Z0-9] :-/
a=>(a=a.toUpperCase(s=[...'     ']).match(/[A-Z\d]/g)).map(x=c=>(g=n=>n<35&&g(n+1,s[n<25?n/5|0:n%5]+=Buffer("mJ*Z?<^#?.&+o@V+`L7ho=Jkm?`:Tm)Km?ZZo@p*#MmjoCZ[=('ZoC#;?-g[RZW[>.cJ#Mmm?<^;Vp5[#p*]?,iM#KAm$$:Mm?0*R[#;-46B#qC;o==*X$(km?0-XDc=$.Mm#%]=X$*-?1M[".slice(parseInt(c,36)*(i=v=4))).map(c=>v+=c%80*80**--i)|v>>n&n<25?a[++x]||a[x=0]:' '))(0))&&s

Try it online!
Character encoding
Characters are encoded upside-down and converted to a custom base-80 with an offset of 4, using the ASCII range [35..114].
Values 35 to 79 are directly mapped to the corresponding ASCII character, while values 0 to 34 are mapped to
characters 80 to 114. This allows to decode by just taking the ASCII code modulo 80.
For instance, 'F' is encoded as "RZW[":
....#     00001
....#     00001
..### --> 00111 --> 0000100001001110000111111 --[decimal]--> 1088575 --[-4]--> 1088571
....#     00001
#####     11111

floor(1088571 / 80**3)        = 2    --> (( 2 + 45) mod 80) + 35 = 82  --> 'R'
floor(1088571 / 80**2) mod 80 = 10   --> ((10 + 45) mod 80) + 35 = 90  --> 'Z'
floor(1088571 / 80)    mod 80 = 7    --> (( 7 + 45) mod 80) + 35 = 87  --> 'W'
1088571                mod 80 = 11   --> ((11 + 45) mod 80) + 35 = 91  --> '['

Starting with i = v = 4, it is decoded back to a 25-bit integer by doing:
Buffer("RZW[").map(c => v += c % 80 * 80 ** --i)

In the full code, we actually process an unbounded slice() of the encoded stream, which means that we are likely to iterate significantly more than 4 times. This is not a problem because all iterations with i < 0 will only affect the decimal part of the result, which is ignored anyway by the bitwise operations that immediately follow.
Try it online!

Can you replace toUpperCase with the i flag in the RegEx?

@Shaggy That would let the lowercase characters unchanged in the output, which I think is not allowed.

Ah, looks like you're right, I'd missed that. Best update my own solution!

Could you save a byte by matching [A-Z\d] instead of [A-Z0-9]?

Excel VBA, 816 bytes
An anonymous VBE immediate window function that takes input from range [A1] and outputs to the console.
As far as I am aware, this is the first VBA answer to use base64 compression.
For i=1To[Len(A1)]:c=Mid(UCase([A1]),i,1):y=y &IIf(c Like"[0-9A-Z]",c,""):Next:l=Len(y):Set d=New MSXML2.DOMDocument:Set d=d.createElement("b64"):d.DataType="bin.base64":d.Text="HxHxCSEqRkVUjLvGSJSK0cUYIyGEfB8cfFH66Ju0kkHoo3cxRhdnzTHGuuOHEMIouYyYEPI/IeTH+GN8ccIHIYf/Qw6/jzH6ByF8PvroY/zR+fCic9FFh4gI30UPnw8efiG+Mj6c4D90wX9CCHe5Tgc=":b=d.nodeTypedValue:For i=0To 112:k=Right("00000" &Evaluate("=Dec2Bin("&b(i)&")"),8)&k:Next:For i=1To 5:For j=1To l:c=UCase(Mid(y,j,1)):Z=c Like"[0-9]":s=s &IIf(c Like"[A-Z]",Mid(k,IIf(Z,1,25*(Asc(c)-55)+5*i),5)&" ",IIf(Z,Mid(k,25*(Asc(c)-48)+5*i,5)&" ","")):Next:s=Replace(Replace(s,0," "),1,"#") &vbLf:Next:Do:i=InStr(1+(g*l+h)*6+g,s,"#"):p=(p-e)Mod l:e=i<(g*l+h+1)*6+g:s=IIf(e,Left(s,i-1)&Replace(s,"#",Mid(y,p+1,1),i,1),s):g=g-(0=e):h=h-(g>4):g=g Mod 5:Loop While InStr(1,s,"#"):?s

Note: This answer depends on the Microsoft XML, v3.0 VBA reference
Example I/O
[A1]="'0123456789"
For i=1To[Len(A1)]:c=Mid(UCase([A1]),i,1):y=y &IIf(c Like"[0-9A-Z]",c,""):Next:l=Len(y):Set d=New MSXML2.DOMDocument:Set d=d.createElement("b64"):d.DataType="bin.base64":d.Text="HxHxCSEqRkVUjLvGSJSK0cUYIyGEfB8cfFH66Ju0kkHoo3cxRhdnzTHGuuOHEMIouYyYEPI/IeTH+GN8ccIHIYf/Qw6/jzH6ByF8PvroY/zR+fCic9FFh4gI30UPnw8efiG+Mj6c4D90wX9CCHe5Tgc=":b=d.nodeTypedValue:For i=0To 112:k=Right("00000" &Evaluate("=Dec2Bin("&b(i)&")"),8)&k:Next:For i=1To 5:For j=1To l:c=UCase(Mid(y,j,1)):Z=c Like"[0-9]":s=s &IIf(c Like"[A-Z]",Mid(k,IIf(Z,1,25*(Asc(c)-55)+5*i),5)&" ",IIf(Z,Mid(k,25*(Asc(c)-48)+5*i,5)&" ","")):Next:s=Replace(Replace(s,0," "),1,"#") &vbLf:Next:Do:i=InStr(1+(g*l+h)*6+g,s,"#"):p=(p-e)Mod l:e=i<(g*l+h+1)*6+g:s=IIf(e,Left(s,i-1)&Replace(s,"#",Mid(y,p+1,1),i,1),s):g=g-(0=e):h=h-(g>4):g=g Mod 5:Loop While i<InStrRev(s,"#"):?s
 012  567   6789  0123    34  45678  9012 34567  234   567
3  45   8       0     4  5 6  9     3         8 5   6 8   9
6 7 8   9    123    567 78901 0123  4567     9   789   0123
90  1   0   4         8    2      4 8   9   0   0   1     4
 234  12345 56789 9012     3  5678   012   1     234  5678

Ungolfed and Explained
The major part of this solution storing the large font as a base 64 string. This is done by first converting the font to binary, where 1 represents an on pixel and 0 represents an off pixel. For example, for 0, this is represented as
      ###     01110
     #  ##    10011
0 -> # # # -> 10101 --> 0111010011101011100101110
     ##  #    11001
      ###     01110

With this approach, the alphanumerics can then be represented as
0: 0111010011101011100101110    1: 1110000100001000010011111
2: 1111000001011101000011111    3: 1111000001001110000111110
4: 0011001010111110001000010    5: 1111110000111100000111110
6: 0111110000111101000101110    7: 1111100001000100010001000
8: 0111010001011101000101110    9: 0111010001011110000111110
A: 0111010001111111000110001    B: 1111010001111101000111110
C: 0111110000100001000001111    D: 1111010001100011000111110
E: 1111110000111001000011111    F: 1111110000111001000010000
G: 0111110000100111000101111    H: 1000110001111111000110001
I: 1111100100001000010011111    J: 1111100100001000010011000
K: 1000110010111001001010001    L: 1000010000100001000011111
M: 1000111011101011000110001    N: 1000111001101011001110001
O: 0111010001100011000101110    P: 1111010001111101000010000
Q: 0110010010101101001001101    R: 1111010001111101001010001
S: 0111110000011100000111110    T: 1111100100001000010000100
U: 1000110001100011000101110    V: 1000110001010100101000100
W: 1000110001101011101110001    X: 1000101010001000101010001
Y: 1000101010001000010000100    Z: 1111100010001000100011111

These segments were concatenated and converted to MSXML base 64, rendering
HxHxCSEqRkVUjLvGSJSK0cUYIyGEfB8cfFH66Ju0kkHoo3cxRhdnzTHGuuOHEMIouYyYEPI/IeTH+GN8ccIHIYf/Qw6/jzH6ByF8PvroY/zR+fCic9FFh4gI30UPnw8efiG+Mj6c4D90wX9CCHe5Tgc=

The subroutine below takes this, back converts to binary, and uses this a reference from which to build an output string, line by line, grabbing first the top 5 pixels of each character, then the second row and so on until the string is constructed.
The subroutine then iterates over the output string and replaces the 'on' pixels with characters from the input string.
''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
''
''  Embiggen Function
''
''  @Title  :   Embiggen
''  @Author :   Taylor Scott
''  @Date   :   15 June 2018
''  @Desc   :   Function that takes input, value, and outputs a string in which
''              value has been filtered to alphnumerics only, each char is then
''              scaled up to a 5x5 ASCII art, and each 'pixel' is replaced with
''              a char from value. Replacement occurs letter by letter, line by
''              line
''
''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
Function EMBIGGEN(ByVal value As String) As String

    Dim DOM         As New MSXML2.DOMDocument, _
        bytes()     As Byte

    Dim isNum       As Boolean, _
        found       As Boolean, _
        index       As Integer, _
        length      As Integer, _
        line        As Integer, _
        letter      As Integer, _
        pos         As Integer, _
        alphanum    As String, _
        char        As String, _
        filValue    As String, _
        outValue    As String

    ''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
    ''
    ''  Filter input
    ''
    ''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
    For letter = 1 To Len(value) Step 1             ''  Iterate Accross `Value`
        Let char = Mid$(UCase(value), letter, 1)    ''  Take the nth char
        ''  If the char is alphnumeric, append it to a filtered input string
        Let filValue = filValue & IIf(char Like "[0-9A-Z]", char, "")
    Next letter
    Let length = Len(filValue)                      ''  store length of filValue

    ''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
    ''
    ''  Convert Constant from Base 64 to Byte Array
    ''
    ''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
    With DOM.createElement("b64")           ''  Construct b64 DOM object
        Let .DataType = "bin.base64"        ''  define type of object`
        ''  Input constructed constant string shown above
        Let .Text = "HxHxCSEqRkVUjLvGSJSK0cUYIyGEfB8cfFH66Ju0kkHoo3cxRhdnz" & _
                     "THGuuOHEMIouYyYEPI/IeTH+GN8ccIHIYf/Qw6/jzH6ByF8PvroY/" & _
                     "zR+fCic9FFh4gI30UPnw8efiG+Mj6c4D90wX9CCHe5Tgc="
        Let bytes = .nodeTypedValue         ''  Pass resulting bytes to array
    End With

    ''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
    ''
    ''  Convert Byte Array to Byte String
    ''
    ''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
    For index = 0 To 112 Step 1
        '' convert each byte to binary, fill left with `0`s and prepend
        Let alphanum = _
            Right("00000" & Evaluate("=Dec2Bin(" & bytes(index) & ")"), 8) & _
            alphanum
    Next index

    ''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
    ''
    ''  Construct Embiggened Binary String of Input Value
    ''
    ''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
    For line = 1 To 5 Step 1                ''  iterate across lines
        For letter = 1 To length Step 1     ''  iterate across letters
            ''  take the corresponding letter from
            Let char = UCase(Mid(filValue, letter, 1))
            If char Like "[0-9]" Then       '' if it is a number,
                ''  Add the 5 bit corresponding to number at line
                Let outValue = outValue & _
                    Mid$(alphanum, 25 * Val(char) + 5 * line, 5) & " "
            ElseIf char Like "[A-Z]" Then   '' if it is a letter,
                ''  Add the 5 bits corresponding to letter at line
                Let outValue = outValue & _
                    Mid$(alphanum, 25 * (Asc(char) - 55) + 5 * line, 5) & " "
            End If
            Next letter
        Let outValue = outValue & IIf(line < 5, vbLf, "")
    Next line
    Let outValue = Replace(Replace(outValue, 0, " "), 1, "#")

    ''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
    ''
    ''  Replace #s with Input Value
    ''
    ''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
    Let pos = 0                             ''  Reset position in filValue
    Let line = 0                            ''  Reset line index
    Let letter = 0                          ''  Reset letter index
    Do
        ''  Find the index of the first `#` starting at line and letter
        Let index = _
            InStr(1 + (line * length + letter) * 6 + line, outValue, "#")
        ''  Iterate position in filValue if a `#` is found in that letter & line
        Let pos = (pos - found) Mod length
        ''  check to see if found index is in the correct letter
        Let found = index < (line * length + letter + 1) * 6 + line
        ''  iff so, replace that # with letter in filValue corresponding to pos
        Let outValue = IIf(found, _
            Left(outValue, index - 1) & _
                Replace(outValue, "#", Mid(filValue, pos + 1, 1), index, 1), _
            outValue)
        ''  if not found, them iterate line
        Let line = line - (found = False)
        ''  iterate letter every five iterations of line
        Let letter = letter - (line > 4)
        ''  Ensure that line between 0 and 4 (inc)
        Let line = line Mod 5
    ''  Loop while there are '#'s in outValue
    Loop While InStr(1, outValue, "#")

    ''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
    ''
    ''  Output
    ''
    ''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
    Let EMBIGGEN = outValue

    ''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
    ''
    ''  Clean Up
    ''
    ''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
    Set DOM = Nothoing
End Function

C (gcc), 792 690 bytes
#define S strlen
#define V v[1][i]
#define A putchar(32);
#define F(x)(((G(x,0)*92+G(x,1))*92+G(x,2))*92+G(x,3))*92+G(x,4))
#define G(x,y)(f[(x-(x<58?48:55))*5+y]-35)
i,j,l;main(c,v)char**v;{l=S(v[c=1]);char*x[l],t[l+1],*p=t,*f="$dKqK&>%Q3&R`ms&RYXg#gAB/&b_R/$n>Pw&]?vO$cbu+$ccG#$csC+&X7sS$n0w[&X+={&b^%s&b^$W$n3qS%(4\\_&^Bjg&^Bj/%(Pec$xx%S%+L`/%*jjw$cel7&X7oS$NWLO&X7u3$n.U+&^BhG%(')k%'|*/%(+:'%%UO;%%U=K&]`{+";*x=t;for(;i<l;i++){V>96?V-=32:V;(V>47)&(V<58)|(V>64)&(V<91)?*(p++)=V:V;}*p=0;for(;c<S(t);)x[c++]=((__builtin_popcount(F(t[c-1])+x[c-1]-t)%S(t))+t;for(c=6;--c;){for(i=0;i<S(t);i++){for(j=5,l=1<<c*5+3;j--;)if((l>>=1)&F(t[i]){putchar(*x[i]++);!*x[i]?x[i]=t:x;}else A A A}puts(p);}}

Try it online!
Managed to squeeze this under 800 with some variable reuse. Opted to store the font as an array of ints, as although storing it as one long string looked like an attractive idea so many of the 8-bit chunks of the font weren't a nice convenient ASCII character that the escape codes were taking up more characters than the int array did.
Edit: Got under 700 by switching to a string encoding after all - somewhat inspired by many of the other responses here I cobbled together a base-92 representation using (most of) the printable ASCII characters. The representation does include backslashes which need an extra to be escaped but that only happens once in the font.
Other than that there isn't much that's too flashy going on - the input (consisting of the first command-line argument) is copied into a stack array, minus any characters that aren't in the font and with lowercase letters replaced with their uppercase versions, what "pixel" character each full letter starts on is computed (using __builtin_popcount has a painfully long name but was still better than any method of counting on bits I could think of), and then the printing goes through line by line. The compiler of course outputs several times the program length in warnings.
Somewhat degolfed below for your viewing pleasure:
//The defines are listed here for reference. Some are replaced in the below code but I still use F() because it's long.
#define S strlen
#define V v[1][i]
#define A putchar(32);
#define F(x)(((G(x,0)*92+G(x,1))*92+G(x,2))*92+G(x,3))*92+G(x,4))  //How to lookup a font character given an input char x
#define G(x,y)(f[(x-(x<58?48:55))*5+y]-35)                         //Used for looking up the individual parts of a character font
i, j, l;                                           // Declaring some int variables for later use.
main(c,v) char**v; {                               // Declaring afterwards lets us have the int arg default without declaring it
  l = strlen(v[c=1]);                              // Using l as a local variable to shorten S(v[1]) and also giving c an initial value here where there was a spare 1, saving a character over writing the full c=1 init in a later for loop.
  char t[l+1], *p=t, *x[l];                        // Declaring char arrays and char*s and char* arrays. t is oversized if there are any invalid characters in the input, but that's not important for golfing.
  char *f="$dKqK&>%Q3&R`ms&RYXg#gAB/&b_R/$n>Pw&]?vO$cbu+$ccG#$csC+&X7sS$n0w[&X+={&b^%s&b^$W$n3qS%(4\\_&^Bjg&^Bj/%(Pec$xx%S%+L`/%*jjw$cel7&X7oS$NWLO&X7u3$n.U+&^BhG%(')k%'|*/%(+:'%%UO;%%U=K&]`{+";      // The font, encoded base-92 with 5 characters to a letter in the order 0123456789ABCDEF... etc.
  *x=t;                                            // The first character's "pixels" will start at the beginning of the valid input.
  for(; i<strlen(l); i++){                         // Speaking of which, now validate the input.
    v[1][i] > 96 ? v[1][i] -= 32 : v[1][i];        // Change lowercase characters to uppercase. If they aren't actually lowercase characters but have ascii value >96, they won't end up valid after this either and will be edited out on the next line. The false case does nothing, but since with the macro it is one character using the ternary operator saves a character over an if statement even though that case ends up redundant.
    (v[1][i]>47)&(v[1][i]<58)|(v[1][i]>64)&(v[1][i]<91)?*(p++)=v[1][i]:v[1][i];        // If the character is now either a numeral or an uppercase letter, set the next spot in the t array by way of the pointer p and then increment said pointer.
  }
  *p=0;                                            // Add the null terminator to the t array, our validated input string.
  for(;c<strlen(t);) {                             // Now find out at what index each letter should start getting "pixels" from.
    x[c++] = ((__builtin_popcount(F(t[c-1])+x[c-1]-t)%strlen(t))+t;          // Use the builtin to get the number of on bits/pixels in the previous letter, then add that to the previous letter's starting pixel and take the modulus strlen() of the valid string.
  }
  for(c=6; --c;){                                  // Now start the actual printing. For each line...
    for(i=0; i<strlen(t); i++){                    // For each letter...
      for(j=5, l=1<<c*5+3; j--;) {                 // For each pixel of the 5 on this line...
        if((l>>=1) & F(t[i]) {                     // If it is on...
          putchar(*x[i]++);                        // Print it and increment the pixel-fetching pointer for this letter.
          !*x[i]?x[i]=t:x;                         // If said pointer hit the end of the valid input go back to the beginning.
        } else {
          putchar(32);                             // If it is an off pixel, print a space.
        }
      }
      putchar(32);                                 // After a letter, print two spaces.
      putchar(32);
    }
    puts(p);                                       // This is the cheapest way in character count I could come up with to output a newline. p currently points to the end of t, so it is an empty string and puts just adds a newline.
  }
}

609 bytes


text:
Upper or Lower Wythoff?
First, let's talk about Beatty sequences. Given a positive irrational number r, we can construct an infinite sequence by multiplying the positive integers to r in order and taking the floor of each resulting calculation. For example,

If r > 1, we have a special condition. We can form another irrational number s as s = r / (r - 1). This can then generate its own Beatty sequence, Bs. The neat trick is that Br and Bs are complementary, meaning that every positive integer is in exactly one of the two sequences.
If we set r = ϕ, the golden ratio, then we get s = r + 1, and two special sequences. The lower Wythoff sequence for r:
1, 3, 4, 6, 8, 9, 11, 12, 14, 16, 17, 19, 21, 22, 24, 25, 27, 29, ...

and the upper Wythoff sequence for s:
2, 5, 7, 10, 13, 15, 18, 20, 23, 26, 28, 31, 34, 36, 39, 41, 44, 47, ...

These are sequences A000201 and A001950 on OEIS, respectively.
The Challenge
Given a positive input integer 1 <= n <= 1000, output one of two distinct values indicating whether the input is in the lower Wythoff sequence or the upper sequence. The output values could be -1 and 1, true and false, upper and lower, etc.
Although your submitted algorithm must theoretically work for all inputs, in practice it only has to work with the first 1000 input numbers.
I/O and Rules

The input and output can be given by any convenient method.
The input and output can be assumed to fit in your language's native number type.
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.

It's basically "golf the lower Wythoff sequence" because the upper Wythoff sequence requires 1 more op than the lower one (squaring phi).

JavaScript (ES6), 50 35 bytes

f=(n,s="1",t=0)=>s[n-1]||f(n,s+t,s)
<input type=number min=1 oninput=o.textContent=this.value&&f(this.value)><pre id=o>

Outputs 1 for lower and 0 for upper. Explanation: Partial lists of boolean values can be constructed using a Fibonacci-like identity: given two lists, starting with 1 and 10, each subsequent list is the concatenation of the previous two, resulting in 101, 10110, 10110101 etc. In this case it's slightly golfier to have a fake 0th entry of 0 and use that to construct the second element of the list.

How the what...

I love how the explanation made me understand less +1. Partial boolean whoozits steal the identity of a man named Fibbonacci, who is then connected together with his grandchildren to fake the entry of construction.

I was curious to know how far this 33-byte version could work by using an approximation. The answer is apparently up to n = 375.

Python, 25 bytes
lambda n:-n*2%(5**.5+1)<2

Try it online!
Uses the very simple condition:

n is in the lower Wythoff sequence exactly if -n%phi<1.

Note that the modulo result is positive even though -n is negative, matching how Python does modulo.

Proof: Let a = -n%phi, which lies in the range 0 <= a < phi. We can split
  -n modulo phi as -n = -k*phi + a for some positive integer k.
  Rearrange that to n+a = k*phi.
If a<1, then n = floor(n+a) = floor(k*phi), and so is in the lower
  Wythoff sequence.
Otherwise, we have 1 <= a < phi so
n+1 = floor(n+a) = floor(k*phi)
n > n+a-phi = k*phi - phi = (k-1)*phi

so n falls in the gap between floor((k-1)*phi) and floor(k*phi)
  and is missed by the lower Wythoff sequence.

This corresponds to this code:
lambda n:-n%(5**.5/2+.5)<1

Try it online!
We save a byte by doubling to -(n*2)%(phi*2)<2.

Could you explain how the formula comes about? I tried to derive it from the sequence definitions, but got lost in the woods.

@sundar Added a proof.

This exact same technique works in Ruby and JavaScript (at least), too

Haskell, 26 bytes
(l!!)
l=0:do x<-l;[1-x..1]

Try it online!
No floats, unlimited precision. Thanks for H.PWiz for two bytes.

This would also be 26 bytes, but I don't understand why it doesn't work

@H.PWiz I think it's because the empty list is a fixed point.

Ah, I hadn't considered that, and was comparing it with an "equivalent" method that used ~(x:t). Thanks

@H.PWiz / xnor Technically in Haskell the fixed point used is the denotationally smallest one, here bottom / undefined. The fact that there are two different defined ones as well is just accidental.

05AB1E, 9 bytes
L5t>;*óså

Try it online!

0 means upper, 1 means lower. Try the first 100: Try it online!

    CODE   |      COMMAND      # Stack (Input = 4)
===========+===================#=======================
L          | [1..a]            # [1,2,3,4]
 5t>;      | (sqrt(5) + 1)/2   # [phi, [1,2,3,4]]
     *     | [1..a]*phi        # [[1.6,3.2,4.8,6.4]]
      ó    | floor([1..a]*phi) # [[1,3,4,6]]
       så  | n in list?        # [[1]]

Raw Command Dump:
----------------------------------
Depth: 0
Stack: []
Current command: L

----------------------------------
Depth: 0
Stack: [[1, 2, 3, 4]]
Current command: 5

----------------------------------
Depth: 0
Stack: [[1, 2, 3, 4], '5']
Current command: t

----------------------------------
Depth: 0
Stack: [[1, 2, 3, 4], 2.23606797749979]
Current command: >

----------------------------------
Depth: 0
Stack: [[1, 2, 3, 4], 3.23606797749979]
Current command: ;

----------------------------------
Depth: 0
Stack: [[1, 2, 3, 4], 1.618033988749895]
Current command: *

----------------------------------
Depth: 0
Stack: [[1.618033988749895, 3.23606797749979, 4.854101966249685, 6.47213595499958]]
Current command: ó

----------------------------------
Depth: 0
Stack: [[1, 3, 4, 6]]
Current command: s

----------------------------------
Depth: 0
Stack: [[1, 3, 4, 6], '4']
Current command: å
1
stack > [1]

I had the same, but using ï :)

@emigna I was surprised phi wasn't in the mathematical constants. 5t>; to a 2 byter may not be worth it though...

Yeah, I was half-remembering that it might have been (but it's not). It seems like something we should add.

@Emigna I'm fairly certain the Jelly answer is legitimately this but with a phi built-in hahah.

Haha I had the same but using ï and ¢ lol :) All our solutions are so closely related

Would you please decompose and explain your solution?

@JeffZeitlin done. P.S. adding an argument to any 05AB1E answer -d will result in the debug dump; this is essentially a decomposition of any answer.

"Try the first 100" the first 99 actually. The G should be ƒ in the header of TIO. ;)

Jelly, 5 bytes
N%ØpỊ

Try it online!
Saved 1 byte thanks to xnor's Python golf.

Jelly, 6 bytes
×€ØpḞċ

Try it online!
Returns 1 for lower and 0 for upper.
×€ØpḞċ – Full Program / Monadic Link. Argument: N.
×€     – Multiply each integer in (0, N] by...
  Øp   – Phi.
    Ḟ  – Floor each of them.
     ċ – And count the occurrences of N in that list.

Checking \$(0,\:N]\cap \mathbb{Z}\$ is most definitely enough because \$\varphi > 1\$ and \$N > 0\$ and therefore \$0 < N < N\varphi\$.

I'm guessing one of those is a 1-byte constant for phi :P?

Nope, a two-byte one: Øp

Hehe, better than my 4-byte one in 05AB1E: 5t>;

Python 2, 39 33 32 bytes
-6 bytes thanks to Mr. Xcoder
-1 byte thanks to Zacharý

lambda n,r=.5+5**.5/2:-~n//r<n/r

Try it online!
Returns False for lower and True for upper

lambda n,r=(1+5**.5)/2:-~n//r<n/r saves 6 bytes.

Also, lambda n,r=.5+5**.5/2:-~n//r<n/r should work as well to shave one byte

Brain-Flak, 78 bytes
([{}]()){<>{}((([()]))){{<>({}())}{}(([({})]({}{})))}<>([{}]{}<>)}<>({}()){{}}

Try it online!
Outputs nothing for lower and 0 for upper.  Changing to a more sensible output scheme would cost 6 bytes.

Julia 0.6, 16 bytes
n->n÷φ<-~n÷φ

Try it online!
While playing around with the numbers, I came across this property: floor(n/φ) == floor((n+1)/φ) if n is in the upper Wythoff sequence, and floor(n/φ) < floor((n+1)/φ) if n is in the lower Wythoff sequence. I haven't figured out how this property comes about, but it gives the correct results at least upto n = 100000 (and probably beyond).

Old answer:
Julia 0.6, 31 bytes
n->n∈[floor(i*φ)for i∈1:n]

Try it online!
Returns true for lower and false for upper Wythoff sequence.

As n/φ of the numbers up to n are lower and the others are upper, the average difference between successive lower numbers is φ; dividing the lower numbers by φ gives you a sequence where the average difference is 1; this makes it possible for the floor of that sequence to be the integers. My maths isn't good enough to take it any further though.

Arn, 9 bytes
2>6Yx!¦ü#

Try it!
Explained
Unpacked: phi-1<%phi
I found another way of calculating this:

is true if n is in the Lower Wythoff Sequence

This example merely uses this formula (it was shorter than 1>((n_)%phi). And here is how it works:
    phi  Builtin for the Golden Ratio
  -      Minus
    1    Literal one
<        Is less than
    _    Variable initialized to STDIN, implied
  %      Modulo
    phi

Returns true if lower, false if upper

Please do add in a link to your language's online intepreter. Would be helpful for checking the solution.

Yeah sorry, I posted this before I made an online interpreter. A link has been added

Great to know! Nice answer.

Wolfram Language (Mathematica), 26 bytes
#~Ceiling~GoldenRatio<#+1&

Try it online!
An integer n is in the lower Wythoff Sequence iff ceil(n/phi) - 1/phi < n/phi.
Proof that ceil(n/phi) - 1/phi < n/phi is...
Sufficient:

Let ceil(n/phi) - 1/phi < n/phi.

Then, ceil(n/phi) * phi < n + 1.

Note n == n/phi * phi <= ceil(n/phi) * phi.

Hence, n <= ceil(n/phi) * phi < n + 1.

Since n and ceil(n/phi) are integers, we invoke the definition
of floor and state floor(ceil(n/phi) * phi) == n, and n is in the lower
Wythoff sequence.

Necessary; proof by contrapositive:

Let ceil(n/phi) - 1/phi >= n/phi.

Then, ceil(n/phi) * phi >= n + 1.

Note n + phi > (n/phi + 1) * phi > ceil(n/phi) * phi

Hence n > (ceil(n/phi) - 1) * phi.

Since (ceil(n/phi) - 1) * phi < n < n + 1 <= ceil(n/phi) * phi, n is not in the lower Wythoff sequence.

This also doesn't have any rounding error.

APL (Dyalog Extended), 21 19 13 bytes
⊢∊∘⌊⍳×1+∘÷⍣=≢

-6 bytes from Adám after conversion to tacit function.
Try it online!
Old answer:
{⍵∊⌊((1+∘÷⍣=1)×⍳⍵)}

Uses the same approach as Magic Octopus Urn's answer.
-2 bytes from ZippyMagician.
Prints 1 for upper and 0 for lower sequence.
Explanation
{⍵∊⌊((2÷¯1+5*÷2)×⍳⍵)}
                 ⍳⍵   Generate list of 1 to n
     (2÷¯1+5*÷2)×     Multiply it by the golden ratio
   ⌊                  Floor the entire list
 ⍵∊                   is n in the list?

Try it online!

-2 bytes

I'll keep that snippet somewhere, thanks!

13 bytes: ⊢∊∘⌊⍳×1+∘÷⍣=≢ Try it online!

I should get a lot more experience with trains and tacit functions.

Pyth, 8 bytes
/sM*.n3S

Try it here!
Returns 1 for lower and 0 for upper.

Java 10, 77 53 52 bytes
n->{var r=Math.sqrt(5)/2+.5;return(int)(-~n/r)<n/r;}

Port of @Rod's Python 2 answer.
-1 byte thanks to @Zacharý.
Try it online.

Old 77 76 bytes answer:
n->{for(int i=0;i++<n;)if(n==(int)((Math.sqrt(5)+1)/2*i))return 1;return 0;}

-1 byte thanks to @ovs' for something I recommended myself last week.. xD
Returns 1 for lower; 0 for upper.
Try it online.
Explanation:
n->{                    // Method with integer as both parameter and return-type
  for(int i=0;++i<=n;)  //  Loop `i` in the range [1, `n`]
    if(n==(int)((Math.sqrt(5)+1)/2*i))
                        //   If `n` is equal to `floor(Phi * i)`:
      return 1;         //    Return 1
  return 0;}            //  Return 0 if we haven't returned inside the loop already

i*Phi is calculated by taking (sqrt(5)+1)/2 * i, and we then floor it by casting it to an integer to truncate the decimal.

++i<=n on your old answer can be i++<n.

@ovs of course.. >.< I actually recommended this golf to someone else last week, lol.. Thanks.

I think this should work for -1 byte:n->{var r=Math.sqrt(5)/2+.5;return(int)(-~n/r)<n/r;}

@Zacharý It indeed does, thanks!

Japt, 10 bytes
Returns true for lower and false for upper.
õ_*MQ fÃøU

Try it online!
Explanation:
õ_*MQ fÃøU
             // Implicit U = Input
õ            // Range [1...U]
 _           // Loop through the range, at each element:
  *MQ        //   Multiply by the Golden ratio
      f      //   Floor
       Ã     // End Loop
        øU   // Return true if U is found in the collection

I had this for 10 bytes too.

Haskell, 153 139 126 79 bytes
Unlimited Precision!
l=length
f a c|n<-2*l a-c,n<0||l a<a!!n=c:a|1>0=a
g x=x==(foldl f[][1..x+1])!!0

Try it online!
Explanation
Instead of using an approximation of the golden ratio to calculate the result meaning they are prone to errors as the size of the input rises.  This answer does not.  Instead it uses the formula provided on the OEIS that a is the unique sequence such that
∀n . b(n) = a(a(n))+1

where b is the ordered compliment.

"All" wasn't even true before you got outgolfed...

@Neil Good point.  I must have missed your answer.

Although your answer is limited by the fact that javascript doesn't have an integral type?

Well, it will run out of memory well before then...

Brachylog, 8 bytes
≥ℕ;φ×⌋₁?

Try it online!
The predicate succeeds if the input is in the lower Wythoff sequence and fails if it is in the upper Wythoff sequence.
 ℕ          There exists a whole number
≥           less than or equal to
            the input such that
  ;φ×       multiplied by phi
     ⌋₁     and rounded down
       ?    it is the input.

If failure to terminate is a valid output method, the first byte can be omitted.

This is probably the very first time φ is used in a Brachylog program. At long last!

cQuents, 5 bytes
?F$`g

Try it online!
Explanation
?         output true if in sequence, false if not in sequence
          each term in the sequence equals:

 F        floor (
  $               index *
   `g                     golden ratio
     )                                 ) implicit

K (oK), 20 bytes
Solution:
x in_(.5*1+%5)*1+!x:

Try it online!
Explanation:
x in_(.5*1+%5)*1+!x: / the solution
                  x: / save input as x
                 !   / generate range 0..x
               1+    / add 1
              *      / multiply by
     (       )       / do this together
           %5        / square-root of 5
         1+          / add 1
      .5*            / multiply by .5
    _                / floor
x in                 / is input in this list?

MATL, 8 bytes
t:17L*km

Try it online!
Explanation
t      % Implicit input. Duplicate
:      % Range
17L    % Push golden ratio (as a float)
*      % Multiply, element-wise
k      % Round down, element-wise
m      % Ismember. Implicit output

TI-BASIC (TI-84), 18 bytes
max(Ans=iPart((√(5)+1)/2randIntNoRep(1,Ans

Input is in Ans.
Output is in Ans and is automatically printed.
Prints 1 if input is in the lower sequence or 0 if it's in the upper sequence.
Coincidentally, this program will only run for \$0<N<1000\$ .
Example:
27
             27
prgmCDGFA
              1
44
             44
prgmCDGFA
              0

Explanation:
max(Ans=iPart((√(5)+1)/2randIntNoRep(1,Ans    ;full program, example input: 5
                        randIntNoRep(1,Ans    ;generate a list of random integers in [1,Ans]
                                               ; {1, 3, 2, 5, 4}
              (√(5)+1)/2                      ;calculate phi and then multiply the resulting
                                              ;list by phi
                                               ; {1.618 4.8541 3.2361 8.0902 6.4721}
        iPart(                                ;truncate
                                               ; {1 4 3 8 6}
    Ans=                                      ;compare the input to each element in the list
                                              ;and generate a list based off of the results
                                               ; {0 0 0 0 0}
max(                                          ;get the maximum element in the list and
                                              ;implicitly print it

Note:  TI-BASIC is a tokenized language.  Character count does not equal byte count.

MathGolf, 5 bytes
╒φ*i╧

Try it online.
Explanation:
╒      # Push a list in the range [1, (implicit) input-integer]
 φ*    # Multiply each value by the golden ratio 1.618033988749895
   i   # Floor each by casting it to an integer
    ╧  # Check if the (implicit) input-integer is in this list
       # (after which the entire stack joined together is output implicitly as result)

source: Stack Exchange

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

sort: votes


text:
Finding Fastest Frog's Frolicks
A frog sits on a lily pad wishing it were on the other side of the river.  There are some lily pads of varying sizes between the frog and the other side of the river.  Larger lily pads allow the frog to jump further than smaller ones and the frog wishes to reach the other side of the river in as few jumps as possible.
You will receive a list of lilypads represented by natural numbers (includes zero), each number being the maximum number of spaces that the frog can jump when he sits on that lily pad.  The frog can and often will need to jump fewer than the maximum spaces. The frog will start on the zeroth lilypad and end when his index is out of bounds for the list of the lilypads (on the other bank).  You will need to output the series of jumps that gets the frog to the other bank.  You can output either then length of the jump or the indices of the lilypads the frog lands on.  If the input has multiple optimal solutions you need only output 1.
Since frogs don't own computers you are going to need to make your code as short as possible (the frog counts in bytes) so the frog can understand it.

Test cases
Outputs the sizes of the jumps
[4,2,2,1,1] -> [4,1]
[5,3,1,1,2,0,1] -> [4,2,1]
[6,9,1,2,1,1,1] -> [1,6]

very closely related (return # of jumps rather than sequence of jumps)

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


text:
Replace me by the sum of my cyclic successors!
I have a simple challenge for you this time. Given an array of positive integers A (or the equivalent in your language), replace each entry Ai with the sum of the next Ai elements of A, cycling back from the beginning if there are not enough items.
As usual, you can compete in any programming language and can take input and provide output through any standard method and in any reasonable format, while taking note that these loopholes are forbidden by default. You may optionally take the size of A as input too. This is code-golf, so the shortest submission (in bytes) for every language wins.
Examples / Test Cases
Given [1,3,4,5], your code should output [3,10,13,14], because 1 is replaced by 3, 3 is replaced by 4+5+1=10 (notice how it wrapped back from the start), 4 by 5+1+3+4=13 and 5 by 1+3+4+5+1=14.
Given [3,2,1,9], your program should produce [12,10,9,33], because we substitute 3 with 2+1+9=12, 2 with 1+9=10, 1 with 9 and 9 with 3+2+1+9+3+2+1+9+3=33 (notice how we wrapped back from the start more than once).
Some more test cases for you to choose from:
[4,3,2,1]                       -> [10,7,5,4]
[3,2,1,9]                       -> [12,10,9,33]
[1,3,4,5]                       -> [3,10,13,14]
[4,4,3,2,2]                     -> [11,11,8,6,8]
[3,5,3,2,1]                     -> [10,14,6,4,3]
[3,2,4,3,2,1,1]                 -> [9,7,7,4,2,1,3]
[7,8,6,5,4,3,2,1,5]             -> [29,33,20,15,11,8,6,5,30]
[28,2,4,2,3,2,3,4,5,3]          -> [137,6,10,5,9,7,12,38,39,34]
[1,2,3,4,5,4,3,2,1,2,3,4,3,2,1] -> [2,7,13,14,12,8,5,3,2,7,9,7,4,2,1]

MATL, 10 9 bytes
"G@:X@+)s

Try it online!
	% implicit input
"	% for loop, iterate over the input array
G	% push input x
@	% push for loop index, x[i]
:	% range, push [1,...,x[i]]
X@	% push for loop index, i
+	% sum, so stack holds [i+1,...,i+x[i]]
)	% index, modularly, so gets the cyclic successors
s	% sum cyclic successors, leaving the sum on the stack
	% implicit end of for loop
	% implicit output of stack

J, 33 bytes
[:({.+/@{.}.)"1 i.@#|."{($~>./*#)

ungolfed
[: ({. +/@{. }.)"1 i.@# |."0 _ ($~ (>./ * #))

explanation

Try it online!

fancy explanation :o

Cool picture over there, but I recommend putting the explanation in text form too, since images might not last forever. ;)

This looks like a roguelike game.

What's the score if you rewrite my K solution in J?

Jelly, 6 bytes
ṙJṁS¥"

Try it online!

...ah ninja'd :(

@JonathanAllan TBF, I already sort of had this lying for a minute or two when you posted yours (I thought the integer itself had to be included as well, so with an extra + at the end). Also, eh, maybe you will ninja me next time. :)

Python, 55 bytes
lambda a:[sum((-~v*a)[i:i+v])for i,v in enumerate(a,1)]

Try it online!

not too familiar with python can you explain the part in parens after sum?

Firstly the ~ operator is a bitwise not, it's effectively shorthand for -1-v, so -~v is shorthand for -(-1-v) which is just 1+v (but avoids parentheses like (1+v)*a). Secondly in Python one may multiply a list by an integer to repeat it (e.g. ['a','b']*3 is ['a','b','a','b','a','b']). The -~v*a could be replaced by a+v*a for the same byte count. Lastly the [i:i+v] is a slice indexing, keeping elements i to i+v-1 (0-indexed) only.

C (gcc), 86 85 bytes

Saved a byte thanks to Jakob.

C(y,c,l,i,k)int*y;{for(l=~0;++l<c;printf("%d,",k))for(k=i=0;i++<y[l];k+=y[(l+i)%c]);}

Try it online!

-1 byte: for(k=i=0;i++<y[l];)k+=y[(l+i)%c];

Have my upvote for C(y,c,l,i,k).

Haskell, 50 47 44 bytes
zipWith((sum.).take)<*>scanr(:)[].tail.cycle

Try it online!
                    -- <*> in function context is Haskell's S combinator, i.e.
                    --     (zipWith ... <*> scanr ...) arg
                    -- resovles to
                    --     zipWith ... arg (scanr ... arg)
zipWith             -- so we zip
                    --   the input list and
 scanr(:)[]         --   the tails (tails of [1,2,3] are [[1,2,3],[2,3],[3],[]])
      tail          --   of the tail of
          cycle     --   and infinite cycle of the input list
                    -- with the function
 (sum.).take        --   take that many elements given by the element
                    --   of the input list from the list given by the inits
                    --   and sum it

Nice job!
Actually, scanr(:)[] is tails

@Damien: tails. Right! Thanks!

K4 / K (oK), 20 19 bytes
Solution:
+/'x#'1_(1+2##x)#x:

Try it online!
Examples:
q)k)+/'x#'1_(1+2##x)#x:1 3 4 5
3 10 13 14
q)k)+/'x#'1_(1+2##x)#x:4 3 2 1
10 7 5 4
q)k)+/'x#'1_(1+2##x)#x:3 2 4 3 2 1 1
9 7 7 4 2 1 3
q)k)+/'x#'1_(1+2##x)#x:1 2 3 4 5 4 3 2 1 2 3 4 3 2 1
2 7 13 14 12 8 5 3 2 7 9 7 4 2 1

Explanation:
Reshape input, drop first, take x length of each, sum up.
+/'x#'1_(1+2##x)#x: / the solution
                 x: / store input as x
                #   / reshape
        (      )    / do this together
             #x     / count x
           2#       / duplicate (2-take)
         1+         / add 1
      1_            / 1 drop (_), remove first element
   x#'              / x take each-both
+/'                 / sum (+/) each

R, 62 58 bytes
function(a,l)diag(diffinv(matrix(a,max(a)*l+1,l))[a+2,])-a

Try it online!
An alternative to the other R solution. In the comments JayCe made a mention of cumsum which triggered something in my brain to use diffinv and matrix recycling instead of rep.
Explanation:
Given input array a, let M=max(a) and l=length(a).
Observe that M+l is the maximum possible index we'd need to access, and that M+l<=M*l+1, since if M,l>1,M+l<=M*l (with equality only when M=l=2) and if l==1 or M==1, then M+l==M*l+1.
By way of example, let a=c(4,3,2,1). Then M=l=4.
We construct the M*l+1 x l matrix in R by matrix(a,max(a)*l+1,l). Because R recycles a in column-major order, we end up with a matrix repeating the elements of a as such:
      [,1] [,2] [,3] [,4]
 [1,]    4    3    2    1
 [2,]    3    2    1    4
 [3,]    2    1    4    3
 [4,]    1    4    3    2
 [5,]    4    3    2    1
 [6,]    3    2    1    4
 [7,]    2    1    4    3
 [8,]    1    4    3    2
 [9,]    4    3    2    1
[10,]    3    2    1    4
[11,]    2    1    4    3
[12,]    1    4    3    2
[13,]    4    3    2    1
[14,]    3    2    1    4
[15,]    2    1    4    3
[16,]    1    4    3    2
[17,]    4    3    2    1

Each column is the cyclic successors of each element of a, with a across the first row; this is due to the way that R recycles its arguments in a matrix.
Next, we take the inverse "derivative" with diffinv, essentially the cumulative sum of each column with an additional 0 as the first row, generating the matrix
      [,1] [,2] [,3] [,4]
 [1,]    0    0    0    0
 [2,]    4    3    2    1
 [3,]    7    5    3    5
 [4,]    9    6    7    8
 [5,]   10   10   10   10
 [6,]   14   13   12   11
 [7,]   17   15   13   15
 [8,]   19   16   17   18
 [9,]   20   20   20   20
[10,]   24   23   22   21
[11,]   27   25   23   25
[12,]   29   26   27   28
[13,]   30   30   30   30
[14,]   34   33   32   31
[15,]   37   35   33   35
[16,]   39   36   37   38
[17,]   40   40   40   40
[18,]   44   43   42   41

In the first column, entry 6=4+2 is equal to 14=4 + (3+2+1+4), which is the cyclic successor sum (CSS) plus a leading 4. Similarly, in the second column, entry 5=3+2 is equal to 10=3 + (4+1+2), and so forth.
So in column i, the a[i]+2nd entry is equal to CSS(i)+a[i]. Hence, we take rows indexed by a+2, yielding a square matrix:
     [,1] [,2] [,3] [,4]
[1,]   14   13   12   11
[2,]   10   10   10   10
[3,]    9    6    7    8
[4,]    7    5    3    5

The entries along the diagonal are equal to the cyclic successor sums plus a, so we extract the diagonal and subtract a, returning the result as the cyclic successor sums.

Can't wait for the explanation!

@JayCe added! as so often happens, explaining it led to another golf; I always recommend adding an explanation so you or others following behind can find another approach, although I don't always have time to do that, haha.

The common element to both solutions is the efficient generation of a long-enough recycling of either the index or the elements themselves, since 1-indexed languages can't gracefully use modular arithmetic to get back to the beginning of the array.

@ngm yeah, for sure. I do like your use of Map, and originally this was like 68 bytes before I figured out I could take l as an input!

05AB1E, 8 7 bytes
εL¾+èO¼

Try it online!
Explanation
ε        # apply to each element x of the input
 L       # push range [1 ... x]
  ¾+     # add counter to each (initially 0)
    è    # cyclically index into input with each
     O   # sum
      ¼  # increment counter

R, 89 64 bytes
j=rep(x<-scan(),max(x));Map(function(u,v)sum(j[v+1:u]),x,seq(x))

Try it online!
Main idea to to generate a way-long-enough cycling index vector you can use to get the needed elements from the input vector.
Original version:
function(x,i=seq(x),j=rep(i,max(x))){for(k in i){T=c(T,sum(x[j[(k+1):(k+x[k])]]))};T[-1]}

Try it online!

Since it’s allowed to take the length as an additional argument...75

69 funny I had started something similar but using cumsum and got lost in the process... nice solution!

66( using Map. The output is a bit ugly so the TIO link un lists it. I guess a full program would be even shorter !

it is

63 bytes

@JayCe I found another diffinv answer to this question, clocking in at 62 bytes!

Jelly, 7 bytes
R+"Jị⁸§

Try it online!

Attache, 26 bytes
{Sum=>_[(_2+1:_)%#_]}#Iota

Try it online!
Explanation
This is a fork of two functions:

{Sum=>_[(_2+1:_)%#_]}
Iota

What this means is, the right tine Iota is applied to the argument x and is passed as the second argument to the center tine (the first function). So this becomes, for input x:
{Sum=>_[(_2+1:_)%#_]}[x, Iota[x]]

Replacing those in for _ and _2:
Sum => x[(Iota[x] + 1:x) % #x]

Iota[x] returns an array of the indices of x. It's equivalent to 0...#x. #x is a short way of saying the size of x, or Size[x]. In essence, this function is mapping the Sum function over the second expression:
x[(Iota[x] + 1:x) % #x]

The outer x[...] bit means that ... will generate a series of indices to be selected from x. The most important part of generating the indices is this:
Iota[x] + 1:x

This expression uses a bit of vectorization. To visualize this, let's suppose the input is x := [1, 3, 4, 5]. Then, this expression is equivalent to:
Iota[[1, 3, 4, 5]] + 1:[1, 3, 4, 5]
[0, 1, 2, 3] + [1:1, 1:3, 1:4, 1:5]
[0, 1, 2, 3] + [[1], [1, 2, 3], [1, 2, 3, 4], [1, 2, 3, 4, 5]]
[0 + [1], 1 + [1, 2, 3], 2 + [1, 2, 3, 4], 3 + [1, 2, 3, 4, 5]]
[[0 + 1], [1 + 1, 1 + 2, 1 + 3], [2 + 1, 2 + 2, 2 + 3, 2 + 4], [3 + 1, 3 + 2, 3 + 3, 3 + 4, 3 + 5]]
[[1], [2, 3, 4], [3, 4, 5, 6], [4, 5, 6, 7, 8]]

This is a list of indices which represent the indices next N elements in x mod #x. To make them safe for retrieval, we take this array mod #x:
(Iota[x] + 1:x) % #x

This gives us the proper indices, which are then obtained from x and each array is summed, giving the proper results.
Other attempts
36 bytes: {Sum@_&Get=>((_2+1.._2+_)%#_)}#Iota - I forgot x[...] fully vectorizes, so that becomes:
30 bytes: {Sum=>_[(_2+1.._2+_)%#_]}#Iota - but then I realized the _2+ in the inner range could be factored out, which means we could save parentheses by using : instead of .., giving us the current version.

Charcoal, 12 bytes
ＩＥθΣＥι§θ⊕⁺κλ

Try it online! Link is to verbose version of code. Explanation:
  θ             Input array
 Ｅ              Map over elements
     ι          Current element
    Ｅ           Map over implicit range
           λ    Inner index
          κ     Outer index
         ⁺      Sum
        ⊕       Increment
       θ        Input array
      §         Cyclically index
   Σ            Sum
Ｉ               Cast to string
                Implicitly print on separate lines

Julia 0.6, 63 55 53 bytes
A->[sum(repmat(A,v+1)[i+1:i+v])for(i,v)=enumerate(A)]

Try it online!

Older solution:
Julia 0.6, 65 bytes
A->(l=length(A);[sum(A[mod1(j,l)]for j∈i+1:i+A[i])for i∈1:l])

Try it online!

Another solution. Not great by bytecount, but I like it, and it's probably more efficient than the other two, especially if the input has big numbers.
Julia 0.6, 69 bytes
A->(l=length(A);[sum([A;A][i+1:i+A[i]%l])+A[i]÷l*sum(A)for i∈1:l])

Try it online!

Java 8, 87 bytes
A curried void lambda taking an int[] list and int length.
l->s->{for(int i=-1,j,t;++i<s;System.out.println(t))for(j=t=0;j++<l[i];)t+=l[(i+j)%s];}

Try It Online. Note that I've shadowed System.out in this program in order to grab results for prettier printing.

JavaScript ES6, 65 bytes
a=>a.map((x,y)=>{for(s=0,i=y;i<y+x;)s+=a[++i%a.length];return s})

Straightforward solution. Ungolfed:
a => a.map((x,y) => {
    var s = 0;
    for (i = y; i < y + x; i++) {
        s += a[i % a.length];
    }
    return s;
});

JavaScript's map() function is perfect for the job, it runs the given callback against each element and replaced it by the result of the callback. The callback receives two parameters, the first x is the value and the second y is the index. By taking the modulus i % a.length we can easily loop over the array, multiple times if needed.
Test snippet
(Put the input as JSON notation)

let f = a=>a.map((x,y)=>{for(s=0,i=y;i<y+x;)s+=a[++i%a.length];return s})
<input id=I type="text" size=70 value="[4,3,2,1]"><button onclick="console.log(f(JSON.parse(I.value)))">Run</button>

Pyth, 13 11 bytes
.esm@Q+dkSb

Saved 2 bytes thanks to Mr. Xcoder.
Try it here
Explanation
.esm@Q+dkSb
.e         Q   For each index k and value b in (implicit) input...
         Sb    ... get the list [1, ..., b]...
   m  +dk      ... add k to each...
    @Q         ... and index into the input...
  s            ... then take the sum.

11 bytes.

Perl 5 with -M5.010, 42 bytes
say sum+((@F,@F)x$_)[++$-..($-+$_-1)]for@F

Try it online!

Canvas, 10 bytes
²Ｘ｛ｘ＋⁸＠］∑］

Try it here!
Explanation:
{         ] map over the items in the input
 ²X           save this loops counter on X (because of a bad design choice..)
   {    ]     map over 1..current item
    x+          add to it X
      ⁸@        and index in the input using that
         ∑    sum the map

QBasic 1.1, 115 bytes
INPUT L
DIM A(L)
FOR I=0TO L-1
INPUT C
A(I)=C
NEXT
FOR I=0TO L-1
S=0
FOR C=I+1TO I+A(I)
S=S+A(C MOD L)
NEXT
?S
NEXT

First input is the length L, then L subsequent inputs are the elements in order. L outputs represent the resulting array, with the elements in the order they're presented.

Perl 6, 50 32 bytes
{$_>>.&{.[++$+ ^$^a X%+$_].sum}}

Try it online!
I'm new to golfing in Perl 6, so I'm sure this can be shorter. Not new anymore, and back to golf this!

Japt, 7 bytes
ËÆg°EÃx

Try it here

JavaScript, 46 bytes
a=>a.map(g=(x,y)=>x--&&a[++y%a.length]+g(x,y))

Try it online

APL+WIN, 37 bytes
Prompts for input:
+/¨v↑¨⊂[2](⍳⍴v)⌽((⍴v),⍴n)⍴n←(+/v)⍴v←⎕

Try it online! Courtesy of Dyalog Classic
Explanation:
n←(+/v)⍴v←⎕ prompts for input and creates a repeating vector of length max v

((⍴v),⍴n)⍴n converts n to a matrix of length v x length n

(⍳⍴v)⌽ rotates each row of n by the size of each element of v

⊂[2] converts each row of m to an element in a nested vector

+/¨v↑¨ selects the number of elements from each element of the nested vector according to v and sums

JavaScript, 65 bytes 3̶0̶0̶ ̶b̶y̶t̶e̶s̶
golfed
n=>n.map((z,x)=>{for(s=0,i=x;i<z+x;)s+=n[++i%n.length];return s})

ungolfed
     f = n=>n.map((z,x)=>{
            for(s=0,i=x;i<z+x;)s+=n[++i%n.length];
            return s
            }
        );
console.log(f(process.argv[2].slice(1, -1).split(", ").map(x=>+x)))

Try it online!
(ungolfed version above)
I'm new to this codegolf thing!

*updated! thanks to the useful links provided in comments, I managed to reduce the size to 65 bytes!

Welcome to the site.  There are a couple of ways this could be improved.  You could use single character variable names, and you can remove extra-white space.  (operators don't need to be surrounded by spaces.)

Beyond Cat Wizard's tips, we have a collection of Tips for golfing in JavaScript. As you say you are new to golfing, you may also find interesting the generic Tips for golfing in  too.

You should add the golfed version before the ungolfed one

You're assuming the array is assigned o a predefined variable (n), which we don't allow. Welcome to PPCG, though :)

Here's a 59 byte version.

58 bytes

Ruby, 38 bytes
->a{w=0;a.map{|x|(a*-~x)[w+=1,x].sum}}

Try it online!

Pip -rn, 14 bytes
$+g@(_+\,B)MEg

Takes input numbers on successive lines of stdin; gives output numbers on successive lines of stdout. Try it online!
Explanation
             g  List of lines of stdin (from -r flag)
           ME   Enumerate and map this function to the (index, value) pairs:
       \,B       One-based range(value)
     _+          To each element, add the index of that value
  g@(     )      Use the resulting range to slice into the original list g
                 (cyclical indexing is built in)
$+               Sum the numbers in the slice
                Output the list of results one per line (from -n flag)

Or, using a worked example:
             g  [1 3 4 5]
           ME
       \,B      [(1,2) (1,4) (1,5) (1,6)]
     _+         [(1,2) (2,5) (3,7) (4,9)]
  g@(     )     [[3] [4 5 1] [5 1 3 4] [1 3 4 5 1]]
$+              [3 10 13 14]

APL (Dyalog Classic), 12 bytes
+/¨⊢⍴¨⍳∘≢⌽¨⊂

Try it online!
uses ⎕io←1

Thunno 2, 6 bytes
ıRṅ+iS

Try it online!
Explanation
ıRṅ+iS  # Implicit input
ı       # Map over the input:
 R      #  [1..item]
  ṅ+    #  Plus 0-based index
    i   #  Index into input
     S  #  Sum the list
        # Implicit output

Vyxal, 10 bytes
ėƛ÷$?$›ǓẎ∑

Try it Online!
Explanation
ėƛ÷$?$›ǓẎ∑  # Implicit input
ėƛ          # Enumerate (index, item) and map over:
  ÷$        #  Dump onto stack and swap
    ?$›Ǔ    #  Rotate input left by (index + 1)
        Ẏ∑  #  Take the first (item) elements and sum
            # Implicit output

Cjam, 23 bytes
_ee{~,\)f+1$f=:+\}/;]S*

Try it online!

Factor + math.unicode sequences.repeating, 51 bytes
[ dup [ 1 + rotate swap cycle Σ ] with map-index ]

Try it online!

Arturo, 55 bytes
$[a][i:1map a'x[sum map i..i+x-1'y[a\[y%size a]]i:i+1]]

Try it
$[a][                  ; a function taking an argument a
  i: 1                 ; assign 1 to i
  map a' x[            ; map over a and assign current element to x
    sum                ; sum
    map i..i+x-1 'y [  ; map over i to i+x-1, the indices in a that form our desired sum; assign current elt to y
      a\[y % size a]   ; index a at y modulo the length of a
    ]                  ; end map
    i: i + 1           ; increment i
  ]                    ; end map
]                      ; end function

Thunno, \$ 15\log_{256}(96)\approx \$ 12.35 bytes
AEeAuR1++z0sAIS

Attempt This Online!

Vyxal, 44 bitsv2, 5.5 bytes
ż~+rİṠ

Try it Online!
What is this goofy 10 byte nonsense I see?
Explained
ż~+rİṠ
ż       # Push the range [1, len(input)]
 ~+     # And add it to the input without popping
   r    # Vectorise range with the input. This essentially generates a list of indices of the next n items after each item in the input.
    İ   # Index that list of indices into the input.
     Ṡ  # And sum each list.

Created with the help of Luminespire.