text:
Return the highest possible placement value based on the input
Introduction
The challenge itself was something I came across and had to try and figure out for a personal of project of mine. I ended up branching out and asking family members if they could provide an equation to meet the requirements.
Note: I have (with the help of others) found a solution for this but now I'm just trying to see how others would approach this.
Challenge
Take the following scenario where the left hand side number is N (the input):
N    Output
0 -> 9
1 -> 99
2 -> 999
3 -> 9999
4 -> 99,999
5 -> 999,999
...
15 -> 9,999,999,999,999,999

So, essentially, for an input number N, your program must provide the highest integer with N + 1 decimal places.
Note: Commas are not required to separate the numbers, I placed them above purely for readability.
Criteria of Success
The criteria of success is based on the following:

Shortest in terms of code size

Also can we output as a list ie [9, 9, 9]

@Okx no, it has to be a single number. So 3 => 9999 and cannot be [9,9,9,9].

Top of Hot Network Questions with a score of one. I'm thinking the idea about preventing HNQ when number of answers > score is a decent one.

@CAD97 meta it?

@Script47 It was brought up on Mother Meta but nothing was ever done about it.

Someone should write an answer in 99, although I'm not sure how to do multiply/power in that esolang. ;)

You're getting a lot of downvotes because of the overly complicated explanation for what is, essentially, either print n+1 9s or print 10^n-1

@KevinCruijssen challenge accepted

@Script47 It seems arbitrary to print N + 1 nines instead of just just N nines.

Neim, 3 bytes
>9

Explanation:
>      Increment input
 9    Repeat 9

Try it online!

Holy moly, 3 bytes? That's insanity.

@Script Nothing surprising. Javascript/Python takes 3 builtins, this also takes 3 builtins.

05AB1E, 3 bytes
Code:
>°<

Uses the 05AB1E encoding. Try it online!
Explanation:
>      # Increment the implicit input
 °     # Compute 10 ** (input + 1)
  <    # Decrement the result

Proton, 11 bytes
(1+)+("9"*)

Try it online!
This is a function.
Explanation
(1+)+("9"*)  Function
 1+          Anonymous function; add the input to 1
      "9"*   Anonymous function; multiply "9" by the input
    +        Function Composition; add the input to 1 then multiply "9" by this number
(  ) (    )  Brackets for order of operations

:o proton beats python with its function composition for once :D

Alternatives with same byte-count: ("9"*)+(+9) or ("9"*)+(9+). +(+n) prepends, +(n+) appends to the string ("9"*) which is the same as in @HyperNeutrino's answer above.

@KevinCruijssen Oh cool, thanks! I forgot that "9"+9 worked in Proton

APL+WIN, 9 5 bytes
Thanks to ngn for -3 bytes and Adám for -1 byte
Prompts for integer input:
1⎕/⍕9

Save a byte with '9' → ⍕9.

and another three with (1+⎕)⍴ -> 1⎕/

@ngn Very clever!

J, 7 bytes
Anonymous tacit prefix function
9^&.>:]

Try it online!
9^…] nine raised to the power of the argument
 &.… while both nine and the argument are under the influence of
  >: increment
I.e. increment nine and the argument, then power, then un-increment, i.e. decrement. Effectively ((9+1)^(n+1))-1.

Also 7 bytes for output as a string: '9'$~>:

@GalenIvanov Sure, but this solution is way cooler :-)

Of course, your solution is incomparably cooler. it's always a pleasure to use &. :)

@GalenIvanov Yes, I hope to get Under into APL next year, ⍢.

99, 90 bytes
 999
9999 9 9
99999 99 9 9999 9
999 999 9999 9

99999
999 999 9
 999999 999
 9 9999

Try it online!
Possibly not optimal, but it was fun to write.
EDIT: looks like I was right, as Jo King outgolfed me by not incrementing the input and being smarter about the gotos.
 999			assign input to tri-nine
9999 9 9		assign 0 to quad-nine
99999 99 9 9999 9	assign 81 to quint-nine for printing
999 999 9999 9		increment tri-nine

99999			print 81/nine (the numeral nine)
999 999 9		decrement tri-nine
 999999 999		if tri-nine is zero exit program (goto outside program)
 9 9999			else goto line nine

Well done. Too bad the byte-count isn't 99 as well. ;p

99, 69 bytes
9999 9 9
99999 99 9 9999 9
 999

99999
 99 999
999 999 9
 9 9999

Try it online!
Appropriate (but it's a pity that this didn't end up at 99 bytes)
Explanation
9999 9 9           9999 = 9-9
99999 99 9 9999 9  99999 = 99-9+(9-9)-9 = 9*9
 999               999 = input*9

Filler to get up to line 9

99999      Print (9*9)/9 as a number
 99 999    Jump to line 99 if 999 is 9-9
999 999 9  999 = 999 - 9
 9 9999    Jump unconditionally to line 9

the number 9 now just looks weird to me.

Actually, 3 bytes
u╤D

Explanation:
u    Increment input
 ╤   10 ** x
  D  Decrement

Try it online!

Haskell, 14 13 bytes
f n=10*10^n-1

Or for string output 15 bytes, f n='9'<$[0..n]
Thanks to @EsolangingFruit for a byte.
Try it online!

f n=10*10^n-1 saves a byte.

MATL, 6 bytes
Q10w^q

Try it online!
Explanation:
Q       % Grab input and increment by 1
 10     % Push 10
   w    % Swap stack
    ^   % Raise 10 to the power of input+1
     q  % Decrement by 1

Pyth, 4
*\9h

Online test.
Explanation
    Q  # Implicit input
   h   # Increment
*\9    # Repeat string "9" n+1 times

Nice, I got t^Th, also 4 bytes.

I got *p\9 with length 4. https://pyth.herokuapp.com/?code=%2ap%5C9&input=1&test_suite=1&test_suite_input=0&debug=0

@NeverHopeless I see it works, but how?  e.g. with input 4, I think this translates to print "9", 4 times; yet 5 "9"s are a printed?

@DigitalTrauma, by enabling debugging I found that there are two print functions 'Pprint' and 'imp_print' in this statement imp_print(times(Pprint("9"),Q))  and it is written here: https://pyth.herokuapp.com/rev-doc.txt that p  <any>                  Print A, with no trailing newline. **Return A**. So my understanding is that Pprint prints Q times and 'p' token return that character which is printed by 'imp_print' that is why it appears Q+1 times.

@NeverHopeless Makes sene - thanks!

dc, 8
A?1+^1-p

Try it online!
Explanation
A         # Push 10
 ?        # Push input
  1+      # Increment input
    ^     # Raise 10 to the (input + 1)th power
     1-   # Decrement
       p  # Print

Zsh, 19 bytes
Zsh does a better job than Bash (needs eval):
printf 9%.s {0..$1}

Try it online!
Alternative, 20 bytes
This works for both Zsh and Bash (due to Digital Trauma):
echo $[10**($1+1)-1]

Try it online!

Shorter for bash: echo $[10**($1+1)-1]

@DigitalTrauma: Oh nice, works for Zsh as well (edited it in)!

Python 3, 16 bytes
lambda a:"9"*-~a

Try it online!
Just a simple anonymous function.

JavaScript (Node.js), 18 bytes
x=>"9".repeat(x+1)

Try it online!

Or alternatively n=>10**-~n-1

Though I never specified, it would be ideal to get it a int rather than a string. Nevertheless, good answer.

@Arnauld it seems that with with your code when n = 15 the output is 10000000000000000.

@Script47 JS can't support numbers greater than 9007199254740991.  So, yes, it works up to n=14.

@Arnauld ah, right, did not know that. Thank you very much. Any ideas why it is limited as such? Meaning, was it because of technological limitations when JS first came and it hasn't changed or is it something else?

@Script47 Here is why. (Of course, you can manipulate numbers greater than that, but they will be rounded.)

Alternative to @Arnauld's version: n=>"10e"+n-1

Jelly, 4 bytes
‘⁵*’

Try it online!
‘⁵*’ - Main link. Argument: n (integer)
‘    - n+1
 ⁵*  - 10 ** (n+1)
   ’ - (10 ** (n+1)) - 1

Husk, 4 bytes
R'9→

Try it online!
R'9→  -- example input: 3
   →  -- increment: 4
R'9   -- replicate the character '9': ['9','9','9','9']
      -- implicitly print "9999"

Japt, 5 4 bytes
°Uî9

Try it online!
Shaved off that one byte thanks to Shaggy's clever eyes. You can see the edit history for a number of 5-byte solutions.

4 bytes: °Uî9

@Shaggy Nice! You should post it as an answer.

It's just a variation on your first solution so work away. Also, I have a 3 byte solution to post after lunch.

Canvas, 3 bytes
╵9×

Try it here!
╵    increment the input
 9   push "9"
  ×  repeat the "9" input+1 times

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

Try it online!
This uses the -A to enable ASCII output. Bonus round: A version without -A.
Brain-Flak, 50 bytes
({}(())){({}<((({})(({}){}){}){})>[()])}{}({}[()])

Try it online!

46 bytes

Momema, 21 bytes
a00+1*0-8 9a=+*0-+1_A

Try it online! Requires the -i interpreter flag.
Explanation
A brief rundown of Momema's features:

Its only data type is the unbounded integer. It has a double-ended tape (indexed by unbounded integers) where every number is initialized to zero.
Strings of digits are integer literals which evaluate to themselves. Leading zeroes are parsed as their own integers.
+ab evaluates to the sum of a and b.
-a evaluates to the negation of a.
*a evaluates to the value of cell a on the tape.
=a evaluates to 0 if a evaluates to 0, and = otherwise.
At the top level, ab stores b at cell a on the tape. Attempting to write a number to -8 writes its decimal representation to STDOUT instead.
At the top level, [w]a (where [w] is any string of lowercase letters) acts like "relative jump forward by a jump instructions that share the label [w]."
The Momema reference implementation accepts a flag -i, which activates interactive mode. In interactive mode, _[W] (where [W] is any string of uppercase letters) is called a hole and evaluates to a number read from STDIN. However, it caches the number with its label, so if a hole with the same label is ever evaluated again it will be reused.

Knowing this, here's how you expand this program:
a   0                                                                                # do {
0   (+ 1 (* 0))                                                                             #   n = n + 1
-8  9                                                                                #   print 9
a   (= (+ (* 0) (- (+ 1 _A))))                                                              # while (n != input)

(This still parses, by the way; the Momema parser treats parentheses the same way as whitespace.)

a   0

Jumps forward by 0 a instructions (i.e. does nothing). This is only here to serve as a jump target later.
0   (+ 1 (* 0))

Increments the value of cell 0 (initially 0) and stores it back in cell 0.
-8  9

-8 is memory-mapped for numeric I/O, so this outputs 9 to STDOUT.
a   (= (+ (* 0) (- (+ 1 _A))))

Compute tape[0] - (input + 1). If it is zero (i.e. both sides were equal), then = maps the result to 0, making it a no-op. Control runs off of the end of the program. However, if it is nonzero, this is a 1. Since there are no a instructions after here, it wraps around to the beginning of the program.

brainfuck, 24 23 bytes
thanks to Jo King for -1 byte
-[++>+[+<]>]>+<,+[->.<]

Try it online! Takes input as ASCII

Most people wouldn't begrudge you removing that leading >

@JoKing The next time I should have a closer look while copying from the esolang page :). Thank you

Whitespace, 79 bytes
[S S S T    S T S N
_Push_10][S N
S _Duplicate_10][S N
S _Duplicate_10][S N
S _Duplicate_10][T  N
T   T   _Read_STDIN_as_integer][T   T   T   _Retrieve_input][N
S S N
_Create_Label_LOOP][S S S T N
_Push_1][T  S S T   _Subtract][S N
S _Duplicate][N
T   T   S N
_If_negative_Jump_to_Label_EXIT][S N
T   _Swap][S T  S S T   S N
_Copy_2st][T    S S N
_Multiply][S N
T   _Swap][N
S N
N
_Jump_to_Label_LOOP][N
S S S N
_Create_Label_EXIT][T   S S S _Add][T   N
S T _Print_as_integer]

Letters S (space), T (tab), and N (new-line) added as highlighting only.
[..._some_action] added as explanation only.
Try it online (with raw spaces, tabs and new-lines only).
Explanation in pseudo-code:
Integer i = STDIN as integer
Integer j = 10
Start LOOP:
  i = i - 1
  If i is negative (-1): Go to function PRINT_AND_EXIT
  j = j * 10
  Go to next iteration of LOOP

function PRINT_AND_EXIT:
  j = j + i (Since i=-1 at this point, this is basically j = j - 1)
  Print j as integer
  Exit with error

Example run (n=4):
Command   Explanation                   Stack              HEAP    STDIN   STDOUT  STDERR

SSSTSTSN  Push 10                       [10]
SNS       Duplicate top (10)            [10,10]
SNS       Duplicate top (10)            [10,10,10]
SNS       Duplicate top (10)            [10,10,10,10]
TNTT      Read STDIN as integer         [10,10,10]         {10:4}  4
TTT       Retrieve                      [10,10,4]          {10:4}
NSSN      Create Label_LOOP             [10,10,4]          {10:4}
 SSSTN     Push 1                       [10,10,4,1]        {10:4}
 TSST      Subtract (4-1)               [10,10,3]          {10:4}
 SNS       Duplicate top (3)            [10,10,3,3]        {10:4}
 NTTSN     If neg.: Jump to Label_EXIT  [10,10,3]          {10:4}
 SNT       Swap top two                 [10,3,10]          {10:4}
 STSSTSN   Copy 2nd                     [10,3,10,10]       {10:4}
 TSSN      Multiply (10*10)             [10,3,100]         {10:4}
 SNT       Swap top two                 [10,100,3]         {10:4}
 NSNN      Jump to Label_LOOP           [10,100,3]         {10:4}

 SSSTN     Push 1                       [10,100,3,1]       {10:4}
 TSST      Subtract (3-1)               [10,100,2]         {10:4}
 SNS       Duplicate top (2)            [10,100,2,2]       {10:4}
 NTTSN     If neg.: Jump to Label_EXIT  [10,100,2]         {10:4}
 SNT       Swap top two                 [10,2,100]         {10:4}
 STSSTSN   Copy 2nd                     [10,2,100,10]      {10:4}
 TSSN      Multiply (100*10)            [10,2,1000]        {10:4}
 SNT       Swap top two                 [10,1000,2]        {10:4}
 NSNN      Jump to Label_LOOP           [10,1000,2]        {10:4}

 SSSTN     Push 1                       [10,1000,2,1]      {10:4}
 TSST      Subtract (2-1)               [10,1000,1]        {10:4}
 SNS       Duplicate top (1)            [10,1000,1,1]      {10:4}
 NTTSN     If neg.: Jump to Label_EXIT  [10,1000,1]        {10:4}
 SNT       Swap top two                 [10,1,1000]        {10:4}
 STSSTSN   Copy 2nd                     [10,1,1000,10]     {10:4}
 TSSN      Multiply (1000*10)           [10,1,10000]       {10:4}
 SNT       Swap top two                 [10,10000,1]       {10:4}
 NSNN      Jump to Label_LOOP           [10,10000,1]       {10:4}

 SSSTN     Push 1                       [10,10000,1,1]     {10:4}
 TSST      Subtract (1-1)               [10,10000,0]       {10:4}
 SNS       Duplicate top (0)            [10,10000,0,0]     {10:4}
 NTTSN     If neg.: Jump to Label_EXIT  [10,10000,0]       {10:4}
 SNT       Swap top two                 [10,0,10000]       {10:4}
 STSSTSN   Copy 2nd                     [10,0,10000,10]    {10:4}
 TSSN      Multiply (10000*10)          [10,0,100000]      {10:4}
 SNT       Swap top two                 [10,100000,0]      {10:4}
 NSNN      Jump to Label_LOOP           [10,100000,0]      {10:4}

 SSSTN     Push 1                       [10,100000,0,1]    {10:4}
 TSST      Subtract (0-1)               [10,100000,-1]     {10:4}
 SNS       Duplicate top (-1)           [10,100000,-1,-1]  {10:4}
 NTTSN     If neg.: Jump to Label_EXIT  [10,100000,-1]     {10:4}
NSSSN      Create Label_EXIT            [10,100000,-1]     {10:4}
TSSS       Add (10000+-1)               [10,99999]         {10:4}
TNST       Print as integer             [10]               {10:4}          99999
                                                                                error

Stops program with error: No exit defined.

Perl 5, 7 bytes
$_=9x$_

Try it online!

You don't need the quotes there.  Try it online!

Good spot, thx.

AWK, 26 bytes
{for(;a++<$1;){printf"9"}}

Try it online!

Julia, 14 bytes
f(n)="9"^(n+1)
That's if the result can be a string.

SNOBOL4 (CSNOBOL4), 30 bytes
	OUTPUT =DUPL(9,INPUT + 1)
END

Try it online!

Gol><>, 5 bytes
PR`9H

Try it online!
This is a Gol><> function which takes the stack content as input.
Example full program & How it works
1AG9G
PR`9H

1AG    Register row 1 as function G
   9G  Call G with stack [9]

P      Increment
 R`9   Push char '9' that many times
    H  Print the stack content as chars and halt

TI-Basic, 7 bytes
10^(Ans+1)-1

Fairly straightforward...

Yeah, no idea why this got flagged.

@Ste Blame SE automatic bots. Why must  answers here have explanation?

CJam, 6 bytes
qi)'9*

Try it online!

Befunge-98 (FBBI), 13 12 bytes
-1 byte thanks to Jo King
&#9':_@#\-1,

Try it online!

IBM/Lotus Notes Formula, 16 bytes
@Power(10;i+1)-1

Simple port of my Python answer. One of the nice things about formula is that if you pass it a list it will apply the same function to each list member.

Symbolic Python, 40 37 bytes
__=-~(_==_)
_=(__+__**-~__)**-~_+~_+_

Try it online!

Ungolfed
# implicit input stored in _
__  = -~(_==_)             # __ = -~True = 1 + True = 1 + 1 = 2
_=(__+__**-~__)**-~_+~_+_  # _  = (2 + 2 ** -~2) ** -~_ + ~_ + _
                                = (2 + 2**3) ** (_ + 1) - -~_ + _
                                = 10 ** (_ + 1) - (_ + 1) + _
                                = 10 ** (_ + 1) - 1
# implicit output of _

other 37 byte solutions
__=_==_
_=(-~__*-~-~-~-~__)**-~_+~_+_

Try it online!
_=(-~(_==_)*-~-~-~-~(_==_))**-~_+~_+_

Try it online!

Symbolic Python, 29 bytes
multiplies the string '9' by _ + 1
_=`-~-~(_==_)*-~-~(_==_)`*-~_

Try it online!

Charcoal, 5 4 bytes
×9⊕Ｎ

Try it online!
Explanation
×9     Repeat "9"
  ⊕Ｎ ++(next number as input) times

Tcl, 26 bytes
puts [expr 10*10**$argv-1]

Try it online!

Common Lisp, 30 bytes
(lambda(n)(1-(expt 10(1+ n))))

Try it online!

JavaScript (ES6), 18 bytes
Just throwing out a recursive solution to the problem:
f=n=>n?9+f(n-1):''

Evaluates the expression ''+9+9+9+9... (depending on n).
Because the first operand is a string, all the + operators are treated as concatenation instead of addition.
In my Chrome, works up to f(11424) before hitting a stack overflow.

f=n=>n?9+f(n-1):''

for(i = 0; i < 100; i += 10) {
  console.log(f(i));
}

PHP, 25 bytes
Try it online
Code
(Passing $arguments to the script)
<?=str_repeat(9,$argv+1);

Or a recursive function, 42 Bytes
Try it online!
function f($u){echo($u<0)?"":"9".f($u-1);}

GolfScript, 6 bytes
~)'9'*

Try it online!
Explanation:
~)'9'* Full program, implicit input
       Stack: '5'
~      Evaluate
       Stack: 5
 )     Increment
       Stack: 6
  '9'  Push '9'
       Stack: 6 '9'
     * Repeat
       Stack: '999999'
       Implicit output

GolfScript, 7 bytes
~)10\?(

Try this one!
Explanation:
~)10\?( Full program, implicit input
        Stack: '5'
~)      Evaluate and increment (as above)
        Stack: 6
  10\?  Raise 10 to that power
        Stack: 1000000
      ( Decrement
        Stack: 999999
        Implicit output

Stax, 4 bytes
^|Av

Run and debug it
Packed would not be any shorter.
Explanation:
^|Av Full program, implicit input
^    Increment
 |A  Raise ten to that power
   v Decrement
     Implicit output

Stax, 4 bytes
^'9*

Run and debug it
^'9* Full program, implicit input
^    Increment
 '9* Repeat "9"
     Implicit output

Phooey, 11 bytes
&.+1[$i9-1]

Try it online!
Explanation
&.+1[$i9-1]
&.              take numeric input
  +1            add 1
    [   -1]     until that is zero:
     $i9        output 9s

Attache, 9 bytes
{N!-~_&9}

Try it online!
Alternatives
10 bytes: {"9"*t-~_}
13 bytes: (pointfree) 9&Resize@1&`+
Explanation
{N!-~_&9}
{       }     anonymous lambda taking input `_`
   -~_        input + 1
      &9      9s repeated that much (array of 9s)
 N!           cast to integer

Red, 24 bytes
func[n][loop n[prin"9"]]

Outputs a string
Try it online!

Python 2, 20 18 bytes
lambda i:10**-~i-1

Try it online!
Don't think it needs an explanation.
-2 with thanks to @ovs

Triangularity, 31 bytes
...)...
..IE@..
.)10^).
@_+....

Try it online!
Also 31 bytes
...)...
..IE)..
.@_rM..
"9"}""J

Try it online!

Java 8, 27 25 bytes
n->n+=Math.pow(10,n+1)+~n

Try it online.
This is basically a shorter version of n->(long)Math.pow(10,n+1)-1, because n+=...-n saves a byte in comparison to (long).... (And combining -n-1 to +~n saves a second byte in this case.)

Swift 4, 47 34 32 bytes
-13 -15 bytes thanks to @Mr. Xcoder
{(0...$0).map{_ in"9"}.joined()}

Try it online!

{(0...$0).map{_ in"9"}.joined()} saves another 2 bytes. Honestly, I should sometimes follow my own tips.

Prolog (SWI), 34 23 20 bytes
X+Y:-Y is 10*10^X-1.

Try it online!
Call as <input>+<result variable>.

Excel, 12 bytes
=10^(A1+1)-1

Or alternatively, to better handle larger values (>10) for 13 bytes
=REPT(9,A1+1)

Ruby, 11 bytes
->n{?9*-~n}

Try it online!

C (gcc) (-lm), 22 bytes
f(n){n=pow(10,-~n)-1;}

Try it online!
Saved 4 bytes thanks to Kevin Cruijssen.

Why the int? Just f(n){n=pow(10,-~n)-1;} also works, doesn't it?

Suggest exp10(...) instead of pow(10,...)

Cubix, 15 bytes
Iu9)^>Os(?@.>sW

Try it online!
Expands to the following cube:
    I u
    9 )
^ > O s ( ? @ .
> s W . . . . .
    . .
    . .

Japt -P, 3 bytes
ò@9

Try it

Explanation
ò       :Range [0,input]
 @      :Pass each through a function
  9     :  Return 9
        :Implicitly join and output


text:
Write a Quine Suite
We've had a lot of quine challenges, but a lot of the quine formats are similar, lets create some variance in our quines.
Your task is to create a selection of programs in the same language (at least 2), all of which output their own source code, however, none of these programs can share any characters.
For example, if you create a program using:
printf+qw(printf+qw(%s)x2)x2

Your next program cannot include any of:
%()+2finpqrstwx

and so on.
Rules

You may use unicode characters, but you must still score in bytes.
All programs must meet the community definition of a proper quine. This means that the empty string does not count as a valid quine, among other things.
Standard loopholes are forbidden.
Functions or full programs are allowed as long as they meet the above definition.
Symbol independent languages (including Lenguage and Headsecks) are disallowed.
Most programs wins, with shortest total code as a tie breaker.

Since there are close votes I'll undelete the sandbox post for discussion: https://codegolf.meta.stackexchange.com/a/16053/9365

I notice that the sandbox comments mention that function submissions are allowed, but the challenge says nothing about it - I was assuming the opposite as the default for quines.

@ØrjanJohansen Perhaps I misunderstand the rules, but I thought function submissions were allowed by default for all questions. At least one function exists in the Golf You A Quine For Great Good question: https://codegolf.stackexchange.com/a/60148/9365

Related (Kind of the converse challenge - your quines have to output each other instead of themselves)

What about trailing newlines? If one of my quines prints one, does the other have to avoid doing so? (I suspect that most answers don't do this.)

@Nathaniel Assuming TIO shows trailing newlines properly (I know it does for Haskell and it seems to do so for Ruby, but I don't know how to test in the golflangs), all the submissions with TIO links handle trailing newlines properly (only Ruby has one). That leaves yours and Javascript, and the latter returns strings from functions so I suspect it works as well.

@ØrjanJohansen I see. I've added a version to my answer that avoids the trailing newline in one of the quines. If the OP clarifies the rules I will use that and update my score.

@Nathaniel as long as the input hash matches the output, it's fine in my understanding. I'm not sure where the community stands on having a trailing newline printed when one doesn't exist in the source? Personally I'd be happy to see solutions with a newline output if it showcases a higher number of quines since I'm interested in seeing other approaches. I wonder if a meta question is necessary (orbhas already been answered?)

@DomHastings I couldn't find a meta question, so I asked one.

V, 3, 5 quines, 46 bytes
2A2A

Try it online!
Hexdump:
00000000: 3241 3241                                2A2A

Explanation:
2     " 2 times...
 A    " (A)ppend the following text...
  2A  "   '2A'

5a5a

Try it online!
Hexdump:
00000000: 35ad adad 6135 adad ad61                 5...a5...a

Explanation:
5---        " 5 - 3 times...
    a       " (a)ppend the following text...
     5---a  "   '5---a'

1«I1«I

Try it online!
Hexdump:
00000000: 31ab 4931 ab49                           1.I1.I

Explanation:
1«      " 1 + 1 times...
  I     " (I)nsert the following text...
   1«I  "   '1«I'

Here's where they start to get funky...
ñi34x@-qPÉÑ~ÿ

Try it online!
Hexdump:
00000000: f169 1633 341b 7840 2d71 50c9 d17e ff    .i.34.x@-qP..~.

Explanation:
ñ                       " Wrap all the following in macro '"q':
 i<C-v>34               "   Insert character code 34 `"`
         <esc>          "   Return to normal mode
              x         "   Delete the character we just inserted. Now, running `@-` will be equal to running `"`
                  P     "   Paste...
               @-       "   From Register...
                 q      "   "q
                   ÉÑ   "   Insert 'Ñ' at the beginning of this line
                     ~  "   Toggle the case of the character we just inserted
                      ÿ "   Black magic

:norm é:":p

Try it online!
Hexdump:
00000000: 3a6e 6f72 6d20 e93a 223a 70              :norm .:":p

Explanation:
:norm       " Run the following commands as if typed:
      é:    "   insert ':'. Somehow also does black magic and resets the value of '":`
        ":p "   Paste the last ex command to be run ('norm é:":p')

This answer is filled with black magic. Quines 1 and 4 are not new, but the other 3 all have never been found before, so more than half of these quines were just discovered today.

The third program is trolling. "You're a normie :p"

@mbomb007 Obligatory REEEEEE--

Jelly, 2 3 4 5 quines, 14 18 81 65 59 56 326 265 247 229 216 bytes
3 bytes
”ṘṘ

Try it online!
Standard quine. ”Ṙ is the one character literal for Ṙ. Ṙ prints the string representation of this then the string Ṙ implicitly gets printed.
4 bytes
⁾⁾ḤḤ

Try it online!
⁾ begins a two character string literal and Ḥ doubles it's argument. With a string input, Ḥ gets mapped onto each character. Thus Ḥ acting on the string ⁾Ḥ yields ⁾⁾ḤḤ, the source code.
11 bytes
ȮṾṖƊ}“ȮṾṖƊ}

Try it online!
On the right hand side, “ȮṾṖƊ} is the string literal for ȮṾṖƊ}. The string closing character is tacitly added at EOF.
To the left of the string literal, Ɗ wraps ȮṾṖ into a single monad and } turns it into a dyad which uses it's right argument, the string literal. Ȯ prints the string (ȮṾṖƊ}), Ṿ creates a string representation of the string (“ȮṾṖƊ}”) and Ṗ removes the ” character. The string “ȮṾṖƊ} is left after the monad and is implicitly printed.
38 49 36 bytes
32,52,52,7884,106,64,44,7884 44Ọj@,Ọ

Try it online!
First time I've ever used a space in Jelly golfing.
The list of numbers at the beginning holds the ord of the rest of the characters in code. After that:
jṛ44Ọ$,Ọ
j           Join this list with...
 ṛ          right argument. Avoiding using ¤ so I can use it in the next program.
  44Ọ       chr(44)==',': [106, ',', ...]
     $      Causes Ọ to act on 44 before j acts on it.
      ,     Pair this list with...
       Ọ    chr of each number in the list. Yields jṛ44Ọ$,Ọ

270 198 180 162 bytes
⁽¢_;⁽⁽¤;⁽¡_;⁽⁽¡;⁽¡¤;⁽$+;⁽⁽y;⁽Ẹ$;⁽⁺$;⁽AƑ;⁽?€;⁽b⁽;⁽¢¡;⁽_⁽;⁽¡¡;⁽¤ị;⁽ØJ;⁽µṭ;⁽€⁽;⁽¡S;⁽;⁽;⁽¡ʠ;⁽¤ị;⁽ØJ;⁽¤F;⁽ḊṄ;⁽ȧF
¢_⁽¤¡_⁽¡¡¤$+⁽yẸ$⁺$AƑ?€b⁽¢¡_⁽¡¡¤ịØJµṭ€⁽¡S;⁽¡ʠ¤ịØJ¤FḊṄȧF

Try it online!
Uses base 250 numbers and indexes into Jelly code page. Saved 72 bytes by changing the algorithm. Was using each number to index in to Jelly's code page but am now converting the integer back to base 250 then indexing into Jelly's code page, basically halving the number of literals I need in the first line. This also reduces the number of unique characters needed, but I can't think of a way to make any more quines.
I've used up ⁾“” which create string literals and Ọ and ØJ which create strings from numbers. I can't think of any other ways of making strings. I still have the digit 9 and ‘’ available, so if there is a another way of making strings from numbers it may be possible to make another quine.

Haskell, 3 quines, 1119 bytes
Quine 1, 51 bytes
An anonymous IO action printing directly to stdout.
putStr`mappend`print`id`"putStr`mappend`print`id`"

Try it online!
Quine 2, 265 bytes
The function f takes a dummy argument and returns a string.
f	c=[b=<<g]!!0++show	g;b	c=[[[show	9!!0,show	1!!0..]!!6..]!!c];g=[93,0,90,52,82,89,52,51,51,94,84,24,24,39,34,34,106,95,102,110,0,94,50,89,0,90,52,82,82,82,106,95,102,110,0,48,24,24,39,35,106,95,102,110,0,40,24,24,39,37,37,84,24,24,45,37,37,84,24,24,90,84,50,94,52]

Try it online!
Quine 3, 803 bytes
Everything after the LANGUAGE pragma is an anymous function taking a dummy argument and returning a string.
{-#LANGUAGE CPP#-}(\q(_:_:_:_:_:_:_:_:z)y(#)_->(y(\k x->'&':q:k:q:x)#y(\k x->'%':q:'\\':k:q:x)$y(:)#y(:)$ \x->x)z)'\''__TIME__(\(?)v k x->v$k?x)$ \(&)(%)v->v&'{'&'-'&'#'&'L'&'A'&'N'&'G'&'U'&'A'&'G'&'E'&' '&'C'&'P'&'P'&'#'&'-'&'}'&'('%'\\'&'q'&'('&'_'&':'&'_'&':'&'_'&':'&'_'&':'&'_'&':'&'_'&':'&'_'&':'&'_'&':'&'z'&')'&'y'&'('&'#'&')'&'_'&'-'&'>'&'('&'y'&'('%'\\'&'k'&' '&'x'&'-'&'>'%'\''&'&'%'\''&':'&'q'&':'&'k'&':'&'q'&':'&'x'&')'&'#'&'y'&'('%'\\'&'k'&' '&'x'&'-'&'>'%'\''&'%'%'\''&':'&'q'&':'%'\''%'\\'%'\\'%'\''&':'&'k'&':'&'q'&':'&'x'&')'&'$'&'y'&'('&':'&')'&'#'&'y'&'('&':'&')'&'$'&' '%'\\'&'x'&'-'&'>'&'x'&')'&'z'&')'%'\''%'\\'%'\''%'\''&'_'&'_'&'T'&'I'&'M'&'E'&'_'&'_'&'('%'\\'&'('&'?'&')'&'v'&' '&'k'&' '&'x'&'-'&'>'&'v'&'$'&'k'&'?'&'x'&')'&'$'&' '%'\\'&'('&'&'&')'&'('&'%'&')'&'v'&'-'&'>'&'v'

Try it online!
Characters
Quine 1:

"S`adeimnprtu

Quine 2:
	!+,.0123456789;<=[]bcfghosw

Quine 3:
 #$%&'()-:>?ACEGILMNPTU\_kqvxyz{}

How it works
Quine 1
putStr`mappend`print`id`"putStr`mappend`print`id`"

Quine 1 is a modified version of my recent Golf you a quine answer (with improvements by H.PWiz):

Since full programs are not needed, main= has been removed.
<> and $ have been replaced by their near-synonyms mappend and id.

This frees up the vital characters =<> and the helpful operator $ for the other quines.
Quine 2
f	c=[b=<<g]!!0++show	g;b	c=[[[show	9!!0,show	1!!0..]!!6..]!!c];g=[93,0,......]

Quine 2 uses somewhat similar methods to program 2 of my recent Mutually Exclusive Quines answer, but adapted to quine itself directly and especially to avoid using character literals, which are needed for quine 3. Both of these are achieved with the help of the show function, which by sheer luck hasn't had any of its characters used yet.
This quine uses tabs instead of spaces, but I've used spaces below for readability.

g is the quine data, as a list of integers at the end of the code. Each number represents a character from the rest of the code.

The numbers are shifted by 9, so that tab is 0. This makes the encoding a bit shorter by allowing the lowercase letters for the function and variable names to fit in 2 digits.

b c=[[[show 9!!0,show 1!!0..]!!6..]!!c] is a function to convert a number to a character (actually a one-character string).

[[show 9!!0,show 1!!0..]!!6..] is a character range starting with a tab character, which is indexed into with !!c.
The tab character itself is produced by indexing into another range [show 9!!0,show 1!!0..], starting with the digit characters '9' and '1' and jumping down in steps of 8.
The digit characters are produced by indexing into the show string of the corresponding digit.

f c=[b=<<g]!!0++show g is the main function. c is a dummy argument.

b=<<g uses =<< to convert each number in g to its character. (The use of =<< rather than e.g. map is why b needs to wrap its returned character in a list.)
show g gives the string representation of g's list, and ++ concatenates the strings.
Because =<< has lower precedence than ++, some bracketing is needed. To avoid using () (reserved for quine 3), [...]!!0 indexes into a list with one element.

Quine 3
By design of the other quines, quine 3 still has access to parentheses, lambda expressions, character literals, and the string/list constructor :. This will be enough to construct a function that prepends the quine's code to a string.
Unfortunately, all lower case vowels (except sometimes y) have been used, leaving no useful alphanumeric builtin functions. Also []"" are gone. This leaves no normal way to construct an empty string to start pretending the code to.
However, nearly all uppercase letters are still available, so a LANGUAGE pragma to get a language extension is possible. Again by sheer luck, CPP (enable C preprocessor) is the only language extension named with only uppercase letters. And CPP macros often have uppercase names.
So to get the essential empty string, the quine enables CPP, uses the __TIME__ macro to get a string constant of the form "??:??:??" (conveniently guaranteed to always have the same length), and pattern matches on it.
{-#LANGUAGE CPP#-}(\q(_:_:_:_:_:_:_:_:z)y(#)_->(y(\k x->'&':q:k:q:x)#y(\k x->'%':q:'\\':k:q:x)$y(:)#y(:)$ \x->x)z)'\''__TIME__(\(?)v k x->v$k?x)$ \(&)(%)v->v&'{'&'-'&......

After the language pragma, the quine consists of a lambda expression binding its parameters to these four arguments (leaving a final dummy parameter _ to be applied later):

q bound to '\'', giving a single quote character;
_:_:_:_:_:_:_:_:z bound to __TIME__, aka a string like "??:??:??", thus making z an empty string;
y bound to (\(?)v k x->v$k?x), a lambda combinator used to help convert the quine data from left associated ("foldl") to right associated ("foldr") form;
The operator (#) bound to \(&)(%)v->v&'{'&'-'&..., the quine data itself.

The quine data is given in a form of Church encoding, a lambda expression with parameters (&)(%)v.

By applying the expression to particular values to instantiate (&), (%) and v, this encoding can be used either to build the core code of the quine or to rebuild the quine data representation itself.
By Haskell's default fixity rule, & and % become left associative operators inside the lambda. Thus the character parameters become combined with the initial v starting from the left.
For most characters k, there is a corresponding &'k'.
When k is ' or \, which need to be escaped inside character literals, the encoding is instead %'\k'.

Since the data encoding is left associative, but strings are built in a right associative manner, the combinator y = (\(?)v k x->v$k?x) is introduced to bridge the mismatch.

y(...) is intended to build suitable functions for using as the quine data's (&) and (%) operators.
v is a function from strings to strings (the quine data's intended vs being examples).
k is a character, x a string, and ? an operator that combines them into a new string. (For the core code, (?)=(:). For actually reconstructing the quine data representation, it's more complicated.)
Thus y(?)v k = \x->v$k?x is another function from strings to strings.
As an example of how this changes associativity, if (&)=y(:):
(v&k1&k2&k3) x
= (((v&k1)&k2)&k3) x
= y(:)(y(:)(y(:)v k1)k2)k3 x
= y(:)(y(:)v k1)k2 (k3:x)
= y(:)v k1 (k2:(k3:x))
= v (k1:(k2:(k3:x)))
= v (k1:k2:k3:x)

More generally, when (#) is the quine data function and f1,f2 are functions combining characters with strings:
(y(f1)#y(f2)$v) x
= (...(y(f1)(y(f1)v '{') '-')...) x
= v(f1 '{' (f1 '-' (... x)))

applying the quine data function with (&)=y(f1) and (%)=y(f2), and this uses the prescribed f1 and f2 to combine the quine data's characters with x, and then passes the resulting string to v.
The body of the main lambda expression puts this all together:
(y(\k x->'&':q:k:q:x)#y(\k x->'%':q:'\\':k:q:x)$y(:)#y(:)$ \x->x)z

'&':q:k:q:x for a character k prepends &'k' to the string x, while '%':q:'\\':k:q:x prepends %'\k', which are their original quine data forms.
Thus y(\k x->'&':q:k:q:x)#y(\k x->'%':q:'\\':k:q:x are the right parameters for rebuilding the quine data representation, prepended to the final z (the empty string), and then passed on to the following function.
y(:)#y(:) are the right parameters to prepend the quine's core code to a string, without other modification.
Finally the \x->x gets to do nothing with the constructed quine, which is returned.

Perl 6, 3 quines, 274 bytes
Quine 1, 52 bytes
my&d={S{\d}=$_};say
d
Q{my&d={S{\d}=$_};say
d
Q{4}}

Try it online!
Quine 2, 102 bytes
printf	|(q[printf	|(q[@]xx	2	Z~|(q[printf	|(q[!3]]Xx	qw[1	0]))]xx	2	Z~|(q[printf	|(q[!3]]Xx	qw[1	0]))

Try it online!
Quine 3, 120 bytes
<'.EVAL'.UC,' GIVEN ',｢｢PRINT "<'.EVAL'.UC,' GIVEN ',｢｢".UC,.UC,"｣｣>.LC",".EVAL.EVAL".UC｣｣>.lc.EVAL.EVAL

Try it online!
Verification of distinct sets of bytes
There was a lot of maneuvering in getting that third quine. Perl 6 has 4 methods of output (that I'm aware of), say, put, print and printf. Both say and put output newlines, as I can't use both. put, print, printf all contain p and t. We can get around this partially by using EVAL to use the uppercase PRINT. From there, I don't think it's possible to get 4 quines... (though perhaps something like shell "echo 'quine'" might work)
We can then get around spacing issues by using different type of whitespace to separate operators, spaces, tabs and newlines.
Explanations:
Quine 1:
my&d={        };         # Declare a function d which
      S{\d}=$_           # Which substitutes a digit with the string again
                say      # Print with a newline
d                        # The function
Q{my&d={S{\d}=$_};say    # Applied to the string with the program
d
Q{4}}                    # With a digit where the it should be inserted again

Quine 2:
This is a quine in the format printf |(q[printf q[%s]]xx 2), i.e. it formats a copy of the string into itself. However we can't use s since that's used in the previous quine's say. So we use the string OR operator (~|) on @ and !3, to produce the %s part, but we can't do that to both the format string and the string to be inserted, so we have to do Z~ with the extra string and an empty string, though we then can't use , to separate the two, so we then do Xx qw[1   0] to string multiply by 1 and 0.
printf |(                                  )      # Print with formatting
         q[...]       # The string of the program
               xx 2   # Duplicated
                    Z~| (                 )     # String or'd with
                         q[...]                 # A copy to insert the %s
                                Xx              # String multiplied to
                                   qw[1 0]      # itself and an empty string

Quine 3:
This is an EVAL quine that tries its best to make everything uppercase to avoid conflict with the other quines. This involves a lot of EVALs as well as quite a few lc and uc to convert between cases.
<...>.lc.EVAL        # Evaluate the lowercase version of the string which results in
.EVAL  given  ｢print "<'.eval'.uc,' given ',｢｢".uc,.uc,"｣｣>.lc",".eval.eval".uc｣
             .EVAL   # Evaluate again

.EVAL  given  ｢...｣   # Set the string to $_ and pass it to .EVAL
print "<'.eval'.uc,' given ',｢｢".uc       # Print the first half of the quine uppercased
                                   ,.uc   # Print the string uppercased
                                       ,"｣｣>.lc"  # Print the .lc part lowercased
                                                ,".eval.eval".uc # Print the EVAL part uppercased

MathGolf, 4 5 6 quines, 193,535 bytes
9 bytes
ÿ'ÿ⌐_'ÿ⌐_

Try it online!
45 bytes
û]∙ûxôû¬ûûûûû╡¬ûô╡û╡xûxxû¬ô]∙xô¬ûûû╡¬ô╡╡xxx¬ô

Try it online!
49 bytes
ùa6æù\a\ù+6┼ù\ùùùùù\ù§\+ùΣ\Σa6æ\a\+6┼\ùùùù\§\+Σ\Σ

Try it online!
99 bytes
"""▐ ⌠▌ ⌠▌ ⌠▌ ⌠ ⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠ ⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠"`~

Try it online!
4488 bytes
♠((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((♠((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((♠(((((((((((((((((((((((((((((((♠((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((♠((((((♠((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((♠((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((♠((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((♠((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((♠(((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((♠(((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((♠((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((♠((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((♠((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((♠((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((♠(((((((((((((((((((((((((((((((♠((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((♠((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((♠(((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((♠((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((♠((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((♠((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((♠((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((♠(((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((♠(((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((♠((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((♠((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((♠(((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((♠((((((((((((((((((((((((((((((((((((((((((((DÄß─·ö♠,♦M-$*DÄß─ö7($$$qq$Äq╘

Try it online!
188,845 bytes
I'm can't really link to this one, so here's a Perl 6 program that generates the actual quine
Verification of distinctness
I can most definitely squeeze another quine out of this, though I think I've run out of ways to push strings straight to the stack, so I'll have to resort to stranger methods. Even stranger methods incoming as I try for a sixth quine. In some cases the quines could be shorter, but I'm reducing used bytes in preparation.
Okay, I might technically be able to do one more quine, since I still have a few operators that I need (push string, increment string, duplication, mapping, popping), it's the looping that constricts us. The {} are the only operators that can can indicate a code block of arbitrary length, and I really need them in the 6th quine. I could use some of the other code blocks, but they're limited, and I doubt the looping sections are going to be that short, since we're running out of easy operators.
Okay, some belated explanations:
All the quines have almost the same structure:

Push a string, or list of strings, or list of characters to the stack.
Combine it all into one list
Duplicate the list
Map over the copy, printing/pushing the characters used to get the original characters
Print the original list of characters as a string

Quine 1:
This is basically the same as the one I posted in the normal quine question.
ÿ'ÿ⌐_'ÿ⌐_
ÿ            Push the next 4 bytes as a string
 'ÿ⌐_        Stack ["'ÿ⌐_"]
     'ÿ      Push the byte ÿ (I realise I could have used this in a later quine)
       ⌐     Rotate the ÿ to the bottom of the stack : ["ÿ", "'ÿ⌐_"]
        _    Duplicate top of stack: ["ÿ", "'ÿ⌐_", "'ÿ⌐_"]
             Implicitly print stack joined together : ÿ'ÿ⌐_'ÿ⌐_

Quine 2
û                Push the next 2 bytes as a string
 ]∙              Stack: ["]∙û"]
   û  û...      Repeat this for the rest of the code
           ]              Wrap the stack in an array : [["]∙","xô"...]]
            ∙             Triplicate                 : [[..],[..],[..]]
             x            Reverse the top array
              ô           Loop over the array, executing the next 6 instructions
                          Stack: [[..],[..],str]
               ¬          Rotate the stack : [str,[..],[..]]
                ûûû╡      Push the string "ûû" and discard the left character
                    ¬     Rotate the "û" to the bottom : ["û",str,[..],[..]]
                          This produces the initialisation part
                     ô    Loop over the array with the next 6 characters again
                      ╡╡xxx¬      Basically discard the string
                            ô     Flatten the last copy of the array onto the stack
                                  Implicitly output the code

Quine 3:
ùa6æù\a\ù+6┼ù\ùùùùù\ù§\+ùΣ\Σa6æ\a\+6┼\ùùùù\§\+Σ\Σ
ù...          Push the next 3 bytes as a string
              You know how this goes
    a         Wrap the top element in an array
     6æ       Repeat the next 4 instructions 6 times
       \      Swap the two top items
        a     Wrap the top item in an array
         \    Swap back
          +   Combine the two arrays
              This puts all the strings into a single array
           6            Push a 6
            ┼           Push the element two items down (the array)
             \          Swap with the 6 (this basically duplicates the array)
              ùùùù      Push "ùùù"
                  \§    Swap and get the 6th character (wrapping)
                    \   Swap with array : ["ù", [..]]
                     +  Prepend to array (implicitly mapping)
                      Σ\Σ     Join both the lists to strings and output

Quine 4:
"""▐ ⌠▌ ⌠▌ ⌠▌ ⌠ ⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠ ⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠"`~
""             Push the empty string
  "..."        Push some code : ['','...']
       `       Copy the top two elements of the stack : ['','...','','...']
        ~      Evaluate the top element as code : ['','...','']
▐              Prepend the empty string to the code
  ⌠            Push a space and increment by 2 to get a quote
   ▌           Prepend to the array
     ⌠▌ ⌠▌ ⌠   Repeat three more times, leaving the last on top : ['', '""...','"']
              ⌠⌠...       Push a space and increment until it reaches a '`'
                    ⌠⌠... Repeat for the '~' : ['','"""...','"','`','~']
                          Implicitly output

Quine 5:
♠              Push 256
 ((...         Decrement until it reaches the correct byte representing the code
               Repeat for each character of the code
      DÄ       Repeat the next instruction 14 times
        ß      Wrap the top 4 elements in an array
         ─     Flatten the resulting monstrosity
          ·    Triplicate the array
           ö   Map the next 7 instructions over the array
                      Stack : [[..],[..],num]
            ♠         Push 128
             ,        Reverse subtraction : [[..],[..],128-num
              ♦M-$    Push the ( character
                  *   Repeat it 128-num times
                   DÄß─         Gather that up in an array and flatten again
                       ö        Map the next 6 instructions
                        7($$$qq
                    7($$$q    Print a ♠, without newline
                              q   Print the brackets without newline
                                  Stack : [[..],[..]]
                               $     Map the number to their values in the code page
                                Äq   Map print over each element
                                  ╘  Discard the last element of the stack

Quine 6:
The reason this quine is so much longer than the others is that incrementing strings uses unicode representations, which really sucks for the some of the characters in the code, especially when we're trying to create the character ⌂ in the code, which inflates the code by over 8000 characters, which then inflates the representation part by a very large amount.
⌂         Push an * character
 ))...    Increment until we reach the right character + 8
      ♫{ }            Repeat 10000 times
        α             Wrap the top two elements in an array
          ♫{     }    Then repeat 10000 times
            m{{}}     Shallowly flatten the array
                  h∞<     Double the array
                     m{          Map the doubled array to
                       ïí½<¿{    If it is the first half of the array
                             ⌂⌂  Push two asterisks
                               )))...    Increment into a '⌂' (there are something like 8000 )s here, with a couple of ! to help
                                     @   Rotate the top three elements
                                         Stack : ["⌂",char,"*"]
                                      0{     α4<{}=}←  Repeat while the asterisk is not the char
                                        ⌂⌡)   Push a )
                                           @  Rotate it under the char
                                            ) Increment the asterisk
                                                     ;;   Pop the extra copies of the character
                                                       }{  Else
                                                         ⌡⌡⌡⌡}   Subtract 8 from the character
                                                              }{}  End map and flatten array
                                                                   Print implicitly

This last quine would be reduced significantly if MathGolf was consistent on whether strings used the native code page or not.

I'm amazed by your ingenuity, I'd love some explanations on how you managed to come up with these. The first one I recognize from the original quine challenge, but the rest look like they took forever to come up with.

@maxb I'm working on a sixth quine, and I'll post explanations once I either post that or give up on it. btw, the chr/ord and incrementing characters commands seem inconsistent. The first uses the code page, where the second uses typical unicode (which is what is making the 6th quine so long)

I realized that some time after implementing it, I just used chr/ord for one of them, I should make both use the code page instead I think.

Python 2, 2 quines, 434 353 349 446 bytes
This was mostly just to see if I could do it in Python.
30 bytes (including a trailing newline):
z='z=%r;print z%%z';print z%z

and 416 bytes, with no trailing newline:
exec"696d706f7274207379730a793d222222696d706f7274207379730a793d7b7d0a7379732e7374646f75742e777269746528276578656322272b792e666f726d6174282722272a332b792b2722272a33292e656e636f6465282268657822292b27222e6465636f64652822686578222927292222220a7379732e7374646f75742e777269746528276578656322272b792e666f726d6174282722272a332b792b2722272a33292e656e636f6465282268657822292b27222e6465636f6465282268657822292729".decode("hex")

(Golfed 81 bytes thanks to Lynn but added a load due to caring about the newline.)
Explanation
The first one is just the standard short Python quine, but modified not to use _. Since this is Python 2 it also doesn't use ( or ).
The second one took some thought. The long string is encoded using the hex codec (thus guaranteeing that it will only contain 0-9 and a-f) and decodes as
import sys
y="""import sys
y={}
sys.stdout.write('exec"'+y.format('"'*3+y+'"'*3).encode("hex")+'".decode("hex")')"""
sys.stdout.write('exec"'+y.format('"'*3+y+'"'*3).encode("hex")+'".decode("hex")')

This uses quine trickery to get its own source code, then encodes it using hex_codec, and then prints it surrounded by exec"".decode("hex"), using sys.stdout.write to avoid printing a newline. Running this code outputs the second quine, which is how I generated it.
I suspect that more than two is impossible in Python, though I would like to see it if I'm wrong!
If you don't mind eval quines
Ørjan Johansen suggested the following for the pre-encoded second quine
y="""import sys
sys.stdout.write('exec"'+('y='+'"'*3+y+'"'*3+';exec y').encode("hex")+'".decode("hex")')""";exec y

which would score 30+248=278 bytes for the following output:
exec"793d222222696d706f7274207379730a7379732e7374646f75742e777269746528276578656322272b2827793d272b2722272a332b792b2722272a332b273b65786563207927292e656e636f6465282268657822292b27222e6465636f64652822686578222927292222223b657865632079".decode("hex")

The use of exec in this way is not cheating according to the PPCG proper quine rules but it feels somewhat cheaty to me (elegant and clever, but still cheaty), because some characters are being used as both code and data. (Although my version does use exec, the code and the data are separate.) So I will keep my score at 446.

"hex" works instead of "hex_codec", which should save you a few bytes!

Huh, that seems to work indeed. Thank you!

Oh, exec is also a statement in Python 2, so you don't need the outermost parens.

That works too, thanks again!

Might something of the form y="""...""";exec y be shorter for the pre-encoded second one?

Why don't you just add a blank line at the end of the first quine if trailing newlines matter...?

@mbomb007 in the note at the end I do include a trailing newline on the end of the first quine. But I also had to modify the second quine so that it doesn't print a newline, because otherwise the newline would be a character in common between the two quines.

@ØrjanJohansen I might be missing something, but it's not clear how that would work. The exec needs to be printed in order to appear in the quine.

Like this. I understand this is a pretty standard quine trick in languages with exec/eval.

@ØrjanJohansen interesting, thanks, I'll update the answer later

Why not reuse the same format as the first quine? Like this?

@JoKing no particular reason, other than that I wasn't try to golf it that hard originally. That's much better - I'll update the answer again tomorrow.

print '<tab>', does not add a space in the end. Using this you can 85 bytes off of Jo King's suggestion: https://tio.run/##hZC9CoNAEAbrvIYgpygin97uSfBNbPzZYBojYmF8eXNqEYkBiz1YdoaB699j@@qwLDJJ7XCZNODt1Yyk4phBGQmnugaTZkOaEmDdUMFwCW3JEhnEXoQSelBKGgYgs/KAvVUbD8ukq/@P0fXegJ1j91j9Nq@LV704W1tO1Ej9asRzWpkc/7Ysc67m3B3u/fDsxkJtv1KowJtdd/Yj6Q50UKhfv1Ch2tXd3MSTd9JU@AE

Japt, 2 3 quines, 106 172 bytes
The first one is a pretty verbose version of my N char quine answer.
[91,57,49,100,185,44,85,44,186,57,51,100,185,44,186,49,48,100,185,44,186,85,109,100,185,172,93,172]
[91d¹,U,º93d¹,º10d¹,ºUmd¹¬]¬

Try it here.
The second quine is ETHProduction's greater good quine, which is a good standard quine for Japt.
"iQ ²"iQ ²

Try it here.
The third one uses `` and char-code XORing to store the data.
T=`f=fR;Zff-R-ReX%`;`T=\``+T+Tc^#

Try it here.
Since ()' are still available, it might be possible to squeeze out one more quine.

I really, really want to try to golf the first one but I know that, with a few beers on board, as soon as I try to change a single character, my brain will explode! Damned quines!

@Shaggy Taking the bottom line and running it through "'[+U+']+R+(Umd)¬"q mc gives you the first line for quick updates, if that's any help.

I've also refactored the first solution to have more core symbols available, it might be practically possible to add one more quine now.

Wait, now your score is higher!

@Shaggy Intentionally so, I'm trying to make room for another quine, not make it shorter.

For 2 quines you could do "iQ ²"iQ ² and z`r^96d)p`r^96d)p (ignore the leading z), maybe that'll give you some inspiration?

Javascript ES6, 2 quines, 43 + 22 = 65 bytes
Quine 1:
(function f(){return[,f,'))'].join('(')}())

Quine 2:
g=z=>"g="+g+";g``";g``

You could save a few bytes by not invoking the functions and then by using a template literal in the second one.

So JavaScript outgolfs japt

@dylnan Not until it adds a third quine.

@Shaggy hey, thanks for your input, but I'm confused - shouldn't a quine be a full program? If it can be a function, must it print only itself? So would g=z=>"g="+g be a valid JS quine?

@Nit I'll see what I can do :P when dylnan commented, japt had only 2 quines as well

Gol><>, 2 3 quines, 17 28 27 26 bytes
6 bytes
"r2ssH

Try it online!
11 10 9 bytes
'3d*Wo{|;

Try it online!
11 bytes
Eh`#Ma0piS0

Try it online!
Gol><> has three ways to print any char:

o Pop one value and print as char
H Pop everything, print as char, and halt
S"..." Print string literal without affecting the stack at all

But I couldn't find a way to write a quine using S"..." as the only output method, so I came up with the above two, utilizing the two kinds of string literals.
The third one (by Jo King) uses the p command to create the " in S" on the fly, which in turn prints everything except the zero at the end. Then Eh prints the zero and exits.
Now that we used up all the output commands AND the p command, I believe it's impossible to create another quine (unless someone comes up with the S" quine without p).

How about this for S"..."?

Ruby, 2 quines, 27 + 44 = 71 bytes
$><<<<2*2<<2
$><<<<2*2<<2
2

Try it online!
s=%q{s=%q{S};s[?S]=s;puts s};s[?S]=s;puts s

Try it online!
I'm mainly limited by methods of output, here. There are quite a few ways of manipulating strings, but aside from $><< all the usable output methods seem to intersect too much. I think there might be a way out with eval but it's tricky having to nest multiple string manipulations of different kinds.

><>, 2 quines, 8 + 16 = 24 bytes
8 bytes
#o<}-1:"

Try it online!
Taken from this answer.

16 bytes
'r3d*d8*7+e0p>>|

Try it online!
This is based on the 'r3d*>o< quine, except o and < cannot be used, so I replaced < with | and dynamically created o (111 = 8*13 + 7) and placed it where the 2nd > is.

2 quines is the limit
Unfortunately, we're limited by the number of output commands. n is not useful because it only outputs numbers, so o must be executed in any quine. The only way to dynamically create o is with p. So one quine can use o, and another can create it with p, but there can be no 3rd quine.
It might be possible to have a third quine leave the source code on the stack if that counts.

Java 10, 2 quines, 1448 1248 bytes
1350 1122 bytes
\u0076\u002D\u003E\u007B\u0076\u0061\u0072\u0020\u0072\u003D\u0022\u0076\u002D\u003E\u007B\u0076\u0061\u0072\u0020\u0072\u003D\u0025\u0063\u0025\u0073\u0025\u0031\u0024\u0063\u003B\u0072\u002E\u0066\u006F\u0072\u006D\u0061\u0074\u0028\u0072\u002C\u0033\u0034\u002C\u0072\u002C\u0039\u0032\u0029\u002E\u0063\u0068\u0061\u0072\u0073\u0028\u0029\u002E\u0066\u006F\u0072\u0045\u0061\u0063\u0068\u0028\u0063\u002D\u003E\u0053\u0079\u0073\u0074\u0065\u006D\u002E\u006F\u0075\u0074\u002E\u0070\u0072\u0069\u006E\u0074\u0066\u0028\u0025\u0031\u0024\u0063\u0025\u0063\u0025\u0033\u0024\u0063\u0075\u0025\u0025\u0030\u0034\u0058\u0025\u0031\u0024\u0063\u002C\u0063\u0029\u0029\u003B\u007D\u0022\u003B\u0072\u002E\u0066\u006F\u0072\u006D\u0061\u0074\u0028\u0072\u002C\u0033\u0034\u002C\u0072\u002C\u0039\u0032\u0029\u002E\u0063\u0068\u0061\u0072\u0073\u0028\u0029\u002E\u0066\u006F\u0072\u0045\u0061\u0063\u0068\u0028\u0063\u002D\u003E\u0053\u0079\u0073\u0074\u0065\u006D\u002E\u006F\u0075\u0074\u002E\u0070\u0072\u0069\u006E\u0074\u0066\u0028\u0022\u005C\u005C\u0075\u0025\u0030\u0034\u0058\u0022\u002C\u0063\u0029\u0029\u003B\u007D

Try it online.
Equivalent to:
v->{var r="v->{var r=%c%s%1$c;r.format(r,34,r,92).chars().forEach(c->System.out.printf(%1$c%c%3$cu%%04X%1$c,c));}";r.format(r,34,r,92).chars().forEach(c->System.out.printf("\\u%04X",c));}

Explanation:
v->{                   // Method with empty unused parameter and no return-type
  var r="v->{var r=%c%s%1$c;r.format(r,34,r,92).chars().forEach(c->System.out.printf(%1$c%c%3$cu%%04X%1$c,c));}";
                       //  Unformatted source code
  r.format(r,34,r,92)  //  Formatted quine
   .chars()            //  Loop over the characters as integers
   .forEach(c->System.out.printf("\\u%04X",c));}
                       //   Print "\u" with hexadecimal value of these characters

126 bytes
v->{int i='}'-'[';var s="v->{int i='}'-'[';var s=%c%s%c;System.console().printf(s,i,s,i);}";System.console().printf(s,i,s,i);}

System.console() will return null when none is provided, so TIO returns a NullPointerException in this case.
To prove it's a working quine, replace System.console() with System.out: Try it online.
Explanation:
v->{              // Method with empty unused parameter and no return-type
  int i='}'-'[';  //  Integer `i` = 34 (unicode value for double-quote)
  var s="v->{int i='}'-'[';var s=%c%s%c;System.console().printf(s,i,s,i);}";
                  //  Unformatted source code
  System.console().printf(s,i,s,i);}
                  //  Print formatted quine

General explanation:
In Java a quine is usually done like this:

The String s contains the unformatted source code.
%s is used to input this String into itself with the s.format(...).
%c, %1$c and the 34 are used to format the double-quotes.
s.format(s,34,s) puts it all together.

In which case the shortest quine lambda-function in Java 10 would be this (82 bytes):
v->{var s="v->{var s=%c%s%1$c;return s.format(s,34,s);}";return s.format(s,34,s);}

Try it online.
Since the only way to have two quines in Java is using the unicode version with \uHEXA, which is converted to characters during compilation, I'm unable to use the characters 0123456789ABCDEF\u in the non-unicode version. So, the smaller non-unicode version will use System.console() instead of return or System.out (both containing a 'u'), and will use '}'-'[' and two times %c instead of 34 and %1$c.
Some things to note about the unicode version:

I'm on purpose using %04X instead of %04x (for uppercase Hexadecimal instead of lowercase).
I'm using 92, %c and %3$c to format the slashes.
Using a capital \U instead of lowercase \u isn't allowed apparently, otherwise I would have just used return in the shorter non-unicode version.

source: Stack Exchange

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

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

sort: votes


text:
How Much Ya Bench?
Inspired by the challenge A pile of weights.
Challenge
Given an integer as a weight in pounds, output an ASCII barbell that can represent the weight.  Weights will come in the form of the barbell (which will weigh 45lbs) and plates with the following weights: 45lbs, 35lbs, 25lbs, 10lbs, and 5lbs.  Weights will be represented as follows:
Barbell:
 ___________                         ___________
|___________|::===================::|___________|

45lbs:    35lbs:     25lbs:    10lbs:    5lbs:
 __         _
|  |       | |        .-.        _
|  |       | |        | |       | |       .-.
|  |       | |        | |       | |       | |
|  |       | |        | |       |_|       '-'
|__|       |_|        '-'

Rules
•The barbell is always needed, so the minimum weight is 45lbs.
•The weights must be equal on both sides of the barbell.  You cannot have a 45lbs plate on one end and only a 25lbs plate on the other.
•The maximum weight is 415lbs.  Anything above this would not fit on the barbell.
•Weights will always be loaded so the heaviest weights are on the inside of the barbell.
•You must use the heaviest plates available.  To represent 55lbs on one side, you must use the plates (45lbs + 10lbs). Both (25lbs + 10lbs + 10lbs) and (35lbs + 10lbs) are invalid.
•Any input that cannot be represented is considered invalid.  You can handle invalid cases if you like by outputting the nearest valid weight, but it is not required.
Test Cases
Input:
45
Output:
 ____________                         ____________
|____________|::===================::|____________|

Input:
135
Output:
           __                         __
          |  |                       |  |
 _________|  |                       |  |_________
|_________|  |::===================::|  |_________|
          |  |                       |  |
          |__|                       |__|

Input:
415
Output:
  __ __ __ __                         __ __ __ __
 |  |  |  |  |                       |  |  |  |  |
 |  |  |  |  |                       |  |  |  |  |
||  |  |  |  |::===================::|  |  |  |  ||
 |  |  |  |  |                       |  |  |  |  |
 |__|__|__|__|                       |__|__|__|__|

Input:
175
Output:
           __                         __
       _ _|  |                       |  |_ _
 _____| | |  |                       |  | | |_____
|_____| | |  |::===================::|  | | |_____|
      |_|_|  |                       |  |_|_|
          |__|                       |__|

Input:
105
Output:
           .-.                       .-.
 ________.-| |                       | |-.________
|________| | |::===================::| | |________|
         '-| |                       | |-'
           '-'                       '-'
Input:
355
Output:

     __ __ __                         __ __ __
 _ _|  |  |  |                       |  |  |  |_ _
| | |  |  |  |                       |  |  |  | | |
| | |  |  |  |::===================::|  |  |  | | |
|_|_|  |  |  |                       |  |  |  |_|_|
    |__|__|__|                       |__|__|__|

Input:
215
Output:
         _ __                         __ _
        | |  |                       |  | |
 _____.-| |  |                       |  | |-._____
|_____| | |  |::===================::|  | | |_____|
      '-| |  |                       |  | |-'
        |_|__|                       |__|_|

As my first challenge, recommendations to improve wording or address something I've missed are welcome.

Similar challenge found here.

I feel like this is too similar to these existing questions. Try coming up with an entirely new challenge idea.

Don't be discouraged though, this was a well-formed question that already existed. You did a wonderful job including needed information and got no downvotes. That's amazingly good compared to most first asked questions :).

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


text:
Sum power of digits
Challenge :
Given two non-negative integers (X and Y > 1) calculate the sum of digits of their powers . i.e : sum of digits of X ^ Y .

Input :
Two non-negative integers X and Y

Output :
The sum of digits of X raised to power Y X ^ Y.
Examples :
5 , 2                    ---> 7
9 , 4                    ---> 18
3 , 17                   ---> 27

Both numbers will be greater than 1

Restrictions :
This is code-golf so shortest code (in bytes) for each language wins.

Notes :
All input will be valid. i.e : Both inputs will be greater than 1 and will be integers.

You shouldn't immediately answer your own question. It is generally frowned upon.

related

@fəˈnɛtɪk : ok , will take care not to do this again

I'm not really sure how a question that has 14 answers can get 8 downvotes with no negative comments to explain why. Perhaps I don't fully understand the rules. Anyone care to explain?

@ElP See https://codegolf.stackexchange.com/questions/156100/quartic-summation#comment380406_156100

I'm tempted to answer 1 since in base X>1, Xis 10, so X^Y is 1 followed by Y zeros. that's always the sum of the digits, and the question didn't specify what base must be used.

@KellyLowder : You have to pass all the tests that are given at the least and if answering in 1 will pass the above mentioned tests (no converting) then be my guest. (Also nice idea. )

Pari/GP, 21 bytes
(x,y)->sumdigits(x^y)

Try it online!

Jelly, 3 bytes
Jelly trivialises this task
*DS

A dyadic link accepting a positive integer, X, on the left and a positive integer, Y, on the right which returns the resulting positive integer.
Try it online!
How?
*DS - Link: X, Y
*   - exponentiate X to the Y
 D  - to a list of its digits
  S - sum

C, 60 56 Bytes
This is my first time golfing, and I think this code can be shortened. Feel free to help and improve this.
Edit: Does not work when you give it a and b such that a^b is over 2^31.
4 Bytes saved thanks to Dennis.
i,q;f(a,b){for(i=0,q=pow(a,b);q;q/=10)i+=q%10;return i;}

test it by editing the numbers in the printf

Welcome to PPCG! If you declare i and q as globals, you can save a few bytes by using a `for loop. Try it online!

Python 3, 34 bytes
lambda a,b:sum(map(int,str(a**b)))

Try it online!

APL+WIN, 8 bytes
Prompts for y followed by x:
+/⍎¨⍕⎕*⎕

J, 12 bytes 11 bytes
-1 byte thanks to Cows quack
1#.,.&.":@^

Try it online!
^ power
,.&.": convert to list of digits
1#. add up the digits

Try 1#.,.&.":@^

@Cows quack - Thanks, I should have tried it :)

Haskell, 29 28 bytes
x%y=sum[read[d]|d<-show$x^y]

Try it online!
-1 byte thanks to user9549915

28 bytes

Neim, 2 bytes

Power ; implicitly coerce to list; sum
Try it online!

Funky, 31 bytes
a=>b=>{n=0fors in''..a^b n-=-s}

Try it online!

Charcoal, 6 bytes
ＩΣＩＸＮＮ

Try it online! Link is to verbose version of code. Explanation:
    Ｎ   First input as a number
     Ｎ  Second input as a number
   Ｘ    Power
  Ｉ     Cast to string
 Σ      Sum of digits
Ｉ       Cast to string
        Implicitly print

One of the few times such a hacky sum builtin is useful :P

Japt, 5 bytes
Saved 1 byte thanks to @Shagy
pV ìx

Try it online!

Welcome to Japt! You can save a byte by removing the space before x; N.ì(f) converts N to an array of digits, passes that array through f and then converts back to an integer.

JavaScript (Node.js), 37 32 bytes
-5 bytes thanks to @Shaggy.
X=>Y=>eval([...''+X**Y].join`+`)

Try it online!
Explanation :
X =>                      // First input X
    Y =>                  // second input Y
        eval(             // evaluate
            [...''+       // convert what is next to string and map to array
            X**Y].        // X raised to power Y
                join`+`   // join them into a string with a plus sign between each
        )                 // The whole thing gets evaluated using `eval`

32 bytes

Pyth, 6 bytes
ssM`^F

Try it online!
If the list input isn't allowed, you can just replace the F with E and it'll take in two integers (one on each line) but do the operation in reverse order from input order.

Ruby, 24 bytes
->x,y{(x**y).digits.sum}

Try it online!

JavaScript (Node.js), 36 bytes
X=>g=(Y,d=X**Y)=>d&&d%10+g(Y,d/10|0)

Try it online!

Perl 6, 16 bytes
(* ***).comb.sum

Try it online!

Stax, 4 bytes
║▼δ&

Run and debug it
Unpacked:
|*E|+

Run and debug this one
Explanation:
|*E|+ Full program, implicit input
      Stack: 5 2
|*    Power
      Stack: 25
  E   Decimal digits
      Stack: [ 2, 5 ]
   |+ Sum array
      Stack: 7
      Implicit output

Gol><>, 11 bytes
XWaSD}|lR+B

Try it online!
A function that accepts X and Y on the stack and leaves the result as the only value on the stack.
Example full program & How it works
1AGIE;IGN
XWaSD}|lR+B

1AG          Register row 1 as function G
   IE;       Take input X as int; halt if EOF
      I      Take input Y as int
       GN    Call G with stack [X Y] and print the result as int
             Repeat indefinitely

X            n = X**Y
 W    |      While top is nonzero...
  aSD          Pop n, push n / 10 and n % 10
     }         Move the remainder to the bottom
             Now the stack contains the digits
       lR+   Sum everything
          B  Return

PHP, 44 Bytes
No loop, passing both arguments to the script.
Try it Online
Code
<?=array_sum(str_split($argv[0]**$argv[1]));

This just takes both arguments calculates X to the power of Y, explodes the string into an array and adds each digit

Husk, 3 bytes
Σd^

Try it online! Takes Y followed by X.


text:
Golf me the Schlosberg Numbers
Schlosberg Numbers
In issue 5 of Mathematical Reflections, Dorin Andrica proposed the problem of characterising the positive integers n such that  is an even integer. Eight people submitted correct solutions showing that these are the integers n for which  is even. The published solution was by Joel Schlosberg, so I call them the Schlosberg numbers.
These numbers may be found in OEIS as sequence A280682.
Your challenge is: given n, output the nth Schlosberg number. (0 or 1 indexed)
The first 50 Schlosberg numbers are:
0
4
5
6
7
8
16
17
18
19
20
21
22
23
24
36
37
38
39
40
41
42
43
44
45
46
47
48
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
100
101
102
103
104
Normal rules and the shortest code wins!

Why specifically the 1st 50? What about taking n and outputting a(n); outputting indefinitely; or taking n and outputting up to a(n)?

@JonathanAllan True, I went with the first 50, because that was what I was testing when I wrote it myself. while there are only a few answers I shall change it

..and what about the other options which are oft-used for sequence based challenges?

@JonathanAllan sorry I'm not familiar with all the ins and outs of sequence challenges.

FYI for next time, it's generally not recommended to update the requirements after answers have been posted.

@EriktheOutgolfer yet asking for such specifics is bound to have people ask, so in this case, change, live & learn.

@EriktheOutgolfer okay thank you, I figures as there were only a few answers it would not have a major impact, but thank you

@JonathanAllan isn't that exactly what the sandbox is for?

@JonathanAllan I am just saying generally, in this case it was probably the best option (the sandbox isn't very prominent for new users too).

@hakr14 supposedly

Can we use 0-based indexing, i.e., return 0 for input 0?

@Dennis yes, will clarify

Given n how?  As a command-line argument?  As user input?  As a function argument?

What do you mean by "the first documented solution was by Joel Schlosberg"?

@PeterTaylor if you go through the OEIS documentation, the link to the original solution to the question was first solved by Joel Schlosberg

@dan04 my understanding is than on PPCG that is up to you

What I see in that reference is that Schlosberg was one of eight people to solve a problem set by Dorin Andrica, so perhaps Andrica Numbers would be a more appropriate name. But the problem was to find all positive integers n such that \sum_{k=1}^n \lfloor \frac{n}{k} \rfloor is an even integer. That problem doesn't appear anywhere in this question, so I can't understand how it makes any sense to refer to "the solution".

Thanks @PeterTaylor, I must not have read it clearly, feel free to modify the question to reflect this

Haskell, 32 bytes
(filter(even.floor.sqrt)[0..]!!)

Try it online!

Husk, 9 bytes
!fȯ¦2⌊√ΘN

Try it online!
Explanation
!f(¦2⌊√)ΘN  -- 1-indexed number, eg: 4
        ΘN  -- natural numbers with 0: [0,1,2,3,4,5,6,7,8,9..
 f(    )    -- filter by
  (   √)    -- | square root: [0,1,1.414213562373095,1.7320508075688774,2,2.23606797749979,2.449489742783178,2.6457513110645903,2.82842712474619,3,..
  (  ⌊ )    -- | floor: [0,1,1,1,2,2,2,2,2,3,..
  (¦2  )    -- | divisible by 2: [1,0,0,0,1,1,1,1,1,0,..
            -- : [0,4,5,6,7,8,..
!           -- get element: 6

Python 3, 42 bytes
f=lambda n,k=1:n and-~f(n-(k**.5%2<1),k+1)

Try it online!

Python 3, 49 bytes
def f(n):
 k=(1+(8*n+1)**.5)//4
 return n+2*k*k+k

Try it online!
A slightly different approach. First, if we subtract the sequence 0,1,2,... from the sequence of Schlosberg numbers, we get the sequence 0,3,3,3,3,3,10,10,10,10,10,10,10,10,10,21. Ignoring repetitions, the sequence 0,3,10,21,... is the sequence a(k) = 2k^2+k. If we can find k, the nth Schlosberg number is then n+a(k).
Given k, each a(k) is repeated 4k+1 times. Summing the length of the first k blocks, we get that the kth block of repetition ends at entry n=2k^2-k. Inverting this, we get k=(1+sqrt(8n+1))/4, which gives an explicit formula for k.

@Reesi82 def f(n):k=(1+(8*n+1)**.5)//4;return n+2*k*k+k saves three bytes of whitespace. In Python 2, you could replace return with print.

J, 22 bytes
{.[:I.0=2|3<.@%:@i.@*]

Try it online!

Thanks for the answer, however I have updated the requirements to output the nth number. sorry for the inconvenience

@george - updated

R, 37 bytes
function(n)(x=0:n^2)[!x^.5%/%1%%2][n]

Try it online!
1-based indexing.

mIRC Scripting, 171 bytes
a {
  %s = 0
  %x = -1
  while 1 {
    inc %x 2
    %i = %x
    while %i {
      echo - %s
      inc %s
      dec %i
    }
    inc %x 2
    inc %s %x
  }
}

I didn't yet see this method for generating new Schlosberg numbers, so above is just a simple one that reads like pseudocode. We start at 0, display 1 number, increase 3, display 5, increase 7, display 9, etc. A simple pattern emerges.

Jelly, 7 bytes
½ḞḂ¬Ʋ#Ṫ

A full program accepting n from STDIN
Try it online!
How?
½ḞḂ¬Ʋ#Ṫ - Main link: no arguments
     #  - take input (n) from STDIN & count up (i=0,1,...) collecting truthy results of:
    Ʋ   -   last four links as a monad:
½       -     square root
 Ḟ      -     floor      (½Ḟ could also be Æ½ - integer square root)
  Ḃ     -     bit (modulo by 2 - i.e. isOdd?)
   ¬    -     logical NOT
      Ṫ - tail (get the nth rather than the first n)
        - implicit print to STDOUT

Pyth, 10 bytes
e.fiI2s@Z2

Try it here!
Explanation

e.fiI2s@Z2 – Full program.
 .f        – Find the first N positive integers satisfying the requirements (var: Z).
e          – And take the last one (i.e. the Nth).
       @Z2 – Take the square root of Z.
      s    – Convert to an integer.
   iI2     – Check if 2 is invariant over applying GCD with the above (i.e. is it even?)

05AB1E, 5 bytes
µNtóÈ

Try it online!

Japt, 11 8 bytes
È¬f v}iU

Try it

JavaScript, 36 34 bytes
0-indexed
n=>(g=i=>i**.5&1||n--?g(++i):i)(0)

2 bytes saved thanks to l4m2

Test it

o.innerText=[...Array(50).keys()].map(
n=>(g=i=>i**.5&1||n--?g(++i):i)(0)
).join`, `

Perl 6, 27 bytes
{grep(+^*.sqrt%2,0..*)[$_]}

Try it online!

Ruby, 45 44 42 bytes
->n,i=-1{(i+=1)**0.5%2<1||n+=1while n>i;i}

Try it online!

C (gcc), 57 56 bytes

Saved a byte thanks to ceilingcat; golfed e>=++b*b to e/++b/b.

b,e;r(g){for(e=0;g&&++e;b&1&&--g)for(b=0;e/++b/b;);g=e;}

Try it online!

Tcl, 84 bytes
proc S {x n\ 0 i\ 1} {while \$i<$x {if 1>int(floor([incr n]**.5))%2 {incr i}}
set n}

Try it online!

Forth (gforth), 81 bytes
Sequence is 1-indexed [f(1) is 0]
: f 0 0 begin over s>f fsqrt f>s 1 and 0= - 1 under+ dup 3 pick = until drop 1- ;

Try it online!
Explanation
0 0              \ place the loop index and sequence index on the stack
begin            \ start an indefinite loop
   over          \ grab a copy of the loop index
   s>f sqrt f>s  \ get the square root of the index and truncate
   1 and 0=      \ determine if result is even
   -             \ if even, add 1 to sequence tracker (-1 is default for "true" in forth)
   1 under+      \ add 1 to the loop index
   dup 3 pick =  \ check if the current sequence position is the one that was requested
until            \ end the loop if condition above is true
drop 1-          \ drop the loop index and subtract 1 from the loop index to get the result

Ruby, 39 38 bytes
->n{(0..n*4).select{|x|x**0.5%2<1}[n]}

Try it online!
0-indexed. Instead of simple looping, this approach takes a large enough sequence of numbers and selects only those that fulfill the condition. The particular multiplier n*4 is necessary to cover the case n=1 => 4 (n*n doesn't fit here), and due to the pattern in the sequence, the value of the nth number fluctuates around n*2, so taking n*4 should always be large enough.

APL+WIN, 29 26 bytes
3 bytes saved thanks to Cows quack
Prompts for integer input:
(0,(~2|⌊r*.5)/r←⍳n×3)[n←⎕]

Explanation:
[n←⎕] prompts for input and selects the nth value of the result

(0,(~2|⌊r*.5)/r←⍳n×3)[n←⎕] create a vector of all results up to n×3
which works up to limit of machine. ×2 works up to n~10E7

Would (0,(~2|⌊r*.5)/r←⍳n×3)[n←⎕] work?

@Cowsquack. It would indeed for a 3 byte saving. Thanks.

Jelly, 9 bytes
ḤḶ²Ḷœ^/ị@

Try it online!
Unfortunately it's longer than the other answer, but I do like this approach.
Explanation
The goal is to get the ranges from each even square to each subsequent odd square, excluding the odd square. We can do this by taking the symmetric set difference of some even number of ranges from zero to just below each square.
Ḥ   Double the input N to ensure it's even.
Ḷ   Lowered range, from 0 to 2N-1.
²   Square to get the first 2N squares.
Ḷ   Get the lowered ranges up to each square.
œ^/ Fold symmetric set difference over the ranges.
ị@  Select the Nth value.

These answers are not the most efficient ways to solve the problem, however I do think they are interesting.
Haskell, 37 33 bytes
(!!)$do x<-[0,2..];[x^2..x^2+2*x]

Try it online!
Haskell, 45 42 bytes
y#x=not$y^2>x||(y+1)#x
(filter(0#)[0..]!!)

Try it online!

You're better off using do in cases like this

Also (x+1)^2-1 = x^2+2*x

@H.PWiz Thanks! I tried a do, but I didn't know you could use a semicolon like that.

dc, 31 bytes
sn_1[d]sD[1+dv2%0=Dzln!<M]dsMxp

Try it online! (1-indexed)
Rather simple. D is a macro that just duplicates the top-of-stack. We begin by storing the user's input in n, and placing negative 1 (_1) on the stack. Macro M increments the top-of-stack by one, duplicates it, and then does the necessary sqrt mod 2 (v2%). dc's precision is zero by default, so doing a square root is, by default, actually the floor of the square root. 0=D compares our v2% to zero, and runs our duplication macro (D) if true. z fetches the stack depth, and then ln!<M compares this to n (our target), continuing to run M until we get to the value we were looking for. Finally, print it.

Scala 3, 52 bytes
Stream.from(0).filter(n=>math.sqrt(n).toInt%2==0)(_)

Attempt This Online!

JavaScript (ES6), 41 40 bytes

f=(n,i=0,j=1)=>n<j?n+i:f(n-j,i-2*~j,j+4)
<input type=number min=0 value=0 oninput=o.textContent=f(this.value)>
0

Edit: Saved 1 byte thanks to @JonathanFrech.

i+j+j+2 <=> i-~j*2.

Vyxal G, 39 bitsv2, 4.875 bytes
≬√⌊₂l

Try it Online!
Bitstring:
111111000101100000001111100000100100000

lol vyncode


text:
Is this a Boggle pad?
Given a list of case-insensitive ASCII letter strings ("words"), output whether the entire list can be found on some four-by-four configuration ("board") of letter squares, in which no square can be used more than once in a word, and in which words are formed by moving from any square to any adjacent square including diagonally.
You do not need to worry that the combination of squares that would allow for the list actually appears in a Boggle game. The words need not be actual words in any language. You should assume that if Q appears on the board, it's on a square of its own (unlike in actual Boggle).
Standard loopholes are banned, standard I/O rules apply, and you're golfing.

In the examples below, a slash signifies a newline.
Truthy examples

auuuuooiiaaoiee, euiaaiueeuua, ooouuueee, eueueuoaoa — All are on the board auii/euoa/ueoa/euio
swiop, byteba, ceropl, qoiz, aeis, lqoep — All are on the board abcb/rety/poiw/lqzs

Falsy examples

swiop, byteba, ceropl, qoiz, aeis, lqoep, wybez — There are fifteen distinct letters (abceilopqrstwyz) and a single word has two bs, so that's the sixteenth square. Thus there's only one e. But the e has nine distinct letters (abcioprtz) adjacent to it, which is impossible.
hskcbnzvgfa, lajdnzvfhgs, kajfbmxvshd, ldgckvbsanx — There are sixteen distinct letters (abcdfghjklmnsvxz). Of those, s is adjacent to all of abghkv, v is adjacent to all of bfgksxz, b is adjacent to all of cfmnsv, a is adjacent to all of fjklns, and f is adjacent to all of abghjv. But on an actual board only four squares are adjacent to more than five squares apiece.

I can understand the challenge clearly and unambiguously. If anyone disagree (and VTC as unclear), consider leaving a comment.

I wonder if it would be better suited for fastest-code or fastest-algorithm. As code-golf, it may lead to brute-force solutions that run forever and never actually return anything.

(Or you may consider adding a time limit if you decide to keep it as code-golf.)

@Arnauld, I don't like fastest-code challenges, personally, and don't know enough compsci to understand or judge fastest-algorithm challenges. That said, I'm considering making a note in the challenge that no brute-force answer will get the checkmark, even if it's shortest in its language.

You'd need to define what brute-force exactly means. But even so, I'm not sure it's a good idea. A very clever answer may still use brute-force in some way.

Besides that, I too think that the challenge is clearly defined. So, people that have VTC really should share their thoughts.

@msh Not accepting any answer is an option.

@Arn Both codegolf and fastestcode are interesting in their own way. You can post fastestcode if you want.

As far as I can see, in general this is a subgraph problem, which is NP complete, so all non-magical answers will need some degree of brute force.

I haven't VTC, but the question didn't make sense to me until I read up on what Boggle was and what its rules were. Perhaps a short description that would make sense to someone who doesn't know Boggle, and better formatting of the board (auii/euoa/ueoa/euio) in 2D, would help clarify the challenge.

Python 3, 215 bytes
def f(w):b=product(*[set("".join(w))]*16);return any(all(any(all(x-y in[1,-1,4,-4]for x,y in zip(q,q[1:]))for q in product(*[[x for x in range(16)if k[x]==c]for c in a]))for a in w)for k in b)
from itertools import*

Try it online!
This is never going to finish, so I can't really debug it or prove it works. I will try to find constant optimizations / test with reduced test cases, but if you spot a reason it would definitely fail, I will take it down / fix it.