text:
Convert to and from Base 94
The challenge
Make 2 programs which convert decimal to and from base 94, or a bidirectional program.
Base 94?
Base 94 is like any other base, but instead of 0 to 9 and letters, it uses ASCII characters 33 to 126. Not 127 because chr(127) is DEL. Not 32 because that's a space.
Examples
0 - ! or empty string
1 - "
93 - ~
94 - "!
2020 - 6O
14233221 - 2-n8

Scoring
For two programs, the score will be the sum of the byte count of both of the programs.
The bidirectional program is simply just the byte count. Consider it like a -50% to the score.

FWIW, base 94 is ok for encoding binary data but somewhat messy (and with a fair few wasted codes). 94^83 ~= 5.883e+163, 256^68 ~= 5.759e+163. Base 85 is neater.

convert decimal to and from ... Wait what?  So the input has to be a decimal string, not a normal int number?  In most programming languages that define a base / internal representation for integer types, it's base 2 / binary.  (For example, C guarantees that the object representation of integral type is binary, which determines how bit-shifts and bitwise booleans work). If you didn't mean base 10 input, perhaps you mean "serialize and deserialize a number to / from a base 94 string" or a less formal equivalent?  Decimal, hex, and base 94 are serialization formats for numbers.

@PeterCordes But most languages who use binary as inner representation of numbers has built-in i/o functions which accept decimal from stdin / print decimal to stdout. So I believe they are still decimals, to end users.

@tsh: These are programming puzzles for programmers, and the rules are talking about the implementation, not end-use.  The default I/O methods allow writing functions that take integer args like C void itoa_b94(char *out, int num), not only terminal read/print.  But the wording in this question would rule that out and restrict you to taking input via stdin instead of a function arg (many more chars), or taking it as a decimal-float, or as some other decimal-based representation, because int has no implication of or association with decimal.

@PeterCordes Data stored in memory only has meanings when you print it. Otherwise, they are only a serial of bytes (in most implementations). There is nothing different to say 841838136 or 2-n8 since they share the same byte sequence with the GCC on TIO. But I don't think output an int 841838136 should be allowed anyway.

@tsh: So you disagree with the top voted answer on the meta Q&A that says functions can "output" via their return value? That's what makes it allowed for e.g. my answer to have an asm implementation of int atoi_b94(char*p, size_t len) instead of internally converting to int and then writing more code to print that with system calls for some OS. I'm not even sure I understand your point. The binary object-representation of an int, e.g. 4 bytes in a register, can represent a number just as well as a string of digits in memory.

@tsh: To put it another way, everyone (except you?) understands that this codegolf challenge is about converting between numbers and base94 strings.  Not necessarily between decimal strings and base 94 strings.  Many of the answers have a base94->number part that return a number in a numeric type like C int, x86 ISA dword, or JavaScript numeric, not print as decimal.  People wrote those answers despite the question being worded to exclude them, if you read it literally.  Related: this one is much more explicit about the number side, counting bytes

@PeterCordes I agree that a submission may be a function not full program. But when you say between "numbers and base94 strings", what do you mean by numbers? base94 number is also a number. May I do nothing at all? I meant that when we say decimal, we are already talking about int. Because int has a default built-in which print / receive decimal, but not base 94.

@tsh: ok, that's a good point, you do need to rule out having the other side of the conversion be base94, making it a no-op.  I understand that some people say decimal or hex to mean int, but those people are not technically accurate; those are serialization formats for numbers.  int is binary.  So we need to be more specific than "number".  Given that it has to work for all I/O methods and languages, we don't want to say "integral type" or something.  Probably "decimal or numeric type" covers it, or "decimal or binary" to allow both of those options but no others.

Or just say "number"; it should be obvious to human readers that a no-op answer would be pointless.  But maybe desirable to exclude bases that are easier to convert, like 94^2 which might be easy in the same way that 8-bit bytes naturally split into 2 hex digits.

Haskell, 42 + 31 = 73 bytes
To base 94: 42 bytes
(l!!)
l="":tail[s++[c]|s<-l,c<-['!'..'~']]

Try it online!
Instead of using modular arithmetic, we generate the list l of all strings in the desired order and index into it.
The recursive definition of l is similar to this one for generating all strings, but modified to output strings in the desired order by appending the new character, and with a tail to prevent the analogue of leading zeroes.
From base 94: 31 bytes
foldl(\n->(94*n-33+).fromEnum)0

Try it online!
Iterates over the characters c of the string, updating the current value n to 94*n-33+fromEnum c.

Python 2, 40 + 45 = 85 bytes
To base 94: 40 bytes
f=lambda n:n*"?"and f(n/94)+chr(n%94+33)

Try it online!
Python 3 would need 1 extra byte for // in place of /.
From base 94: 45 bytes
g=lambda s:s>''and g(s[:-1])*94+ord(s[-1])-33

Try it online!
Both to and from base 94: 86 bytes
h=lambda x:x*'?'and h(x/94)+chr(x%94+33)if x<''else x>''and h(x[:-1])*94+ord(x[-1])-33

Try it online!
A Frankenstein's monster stitched from the two above functions that turns out just barely longer than their byte total. Since this function accepts both numbers and strings, care must be taken not to produce an error caused by an illegal operation by acting on the wrong type.

C (gcc), (34 + 44) = 78 bytes
The 'Decimal to Base94' function prints the Base94 number to STDOUT, whereas the 'Base94 to Decimal' function actually returns the integer.

Decimal to Base94:
f(n){n&&f(n/94)+putchar(n%94+33);}

Try it online!
Base94 to Decimal:
n;f(char*s){for(n=0;*s;n=n*94+*s++-33);n=n;}

Try it online!

Bash + GNU utilities, Score 37 + 70 = 107 bytes

Base 10 to Base 94: 37 bytes
dc<<<94o$1p|sed 's/\b \|$/ 33+P/g'|dc

Try the test suite online!
Input is passed as an argument, and output is on stdout.
This works for inputs from \$0\$ through \$94^{23}-1.\$
This is probably sufficient, since \$94^{23}-1\$ is a huge number (46 decimal digits long — 2409576021839340871044919550282633620681129983 in base 10, or ~~~~~~~~~~~~~~~~~~~~~~~ in base 94), and this is already much larger than most languages can handle.

If you want it to work for arbitrarily large inputs, subject only to memory limitations, use
dc<<<94o$1p|sed 's/\\//g;s/\b \|$/ 33+P/g'|dc
instead (which is 45 bytes long).

Base 94 to Base 10: 78 70 bytes
n=$1;for((;${#n};)){ r=$[94*r+`printf %d "'$n"`-33];n=${n:1};};echo $r

Try the test suite online!
Input is passed as an argument, and output is on stdout.
This works for inputs up to \$2^{63}-1\$ (bash's maximum integer). That's 9223372036854775807 in base 10, or 1**0#VEx9D in base 94.
If you would like it to work for arbitrarily large inputs (subject to resource limitations), use
o()([ "$1" ]&&(printf %dz "'$1";o ${1:1}))
dc<<<`o $1|sed s/z/\ 33-+94*/g`94/p

(78 bytes long) instead.

It seems you have forgotten to write a program to convert from base 94 back to base 10

@Lyxal It must be too late at night here -- thanks, I somehow missed that.

No worries! I originally missed that myself!

For the first part, rs -T can help put each base-94 "digit" on its own line, which should shorten the sed part. For the second part, xxd with flags and then piping it to sed and then to dc should save some

05AB1E, Score 10 bytes
-4 bytes overall thanks to @KevinCruijssen
05AB1E, 5 bytes
žQ¦Åв

Try it online!
05AB1E, 5 bytes
žQ¦Åβ

Try it online!

-2 bytes in both programs: žQ¦Åв and žQ¦Åβ

Nice @KevinCruijssen I had toyed with žQ¦ but didn't find Åв or its counterpart

You can search for 'custom base' to find them. ;)

I am new here. By what count is this program "žQ¦Åв" 5 bytes long, considering it has non-ascii characters and would be 9 bytes in utf-8? Which Codepage is assumed?

Hi @masterxilo 05AB1E has a custom code page, including unprintable ascii characters. For ease of being able to write it we use the custom code page (although in theory we could create the file with the unprintable characters). See: https://github.com/Adriandmen/05AB1E/blob/master/docs/code-page.md

W, 4 bytes
Encoding/Decoding program, it's bidirectional.
lpQB

Explanation
lp   % All printable characters, including the space.
  Q  % Extract all of the string except for the first item.
   B % Convert the input to/from base 94 using the custom base.

@PkmnQ I guess a bidirectional program is simply the bytecount, right?

Yes. I edited the rules.

Haskell, 44 43 + 32 = 75 bytes
-1 byte thanks to xnor.
Base 10 to base 94:
g 0=""
g n=g(div n 94)++[['!'..]!!mod n 94]

Try it online!
Base 94 to base 10:

foldl(#)0
n#c=n*94+fromEnum c-33

Try it online!

One byte shorter to index into a list of characters for the first one: Try it online!

@xnor thanks a lot. I tried it with ['!'..'~'] but didn't consider using an infinite list of characters.

A cute alternative there is cycle['!'..'~']!!n, but that's unfortunately longer.

Japt, 4 bytes
Base-94 I/O as an array of characters. Output for 0 is an empty array, input for 0 can either be an empty array or ["!"].
;ìEÅ

Try it

C (gcc), 34 + 43 = 77 bytes
Encoder
f(n){n&&f(n/94)|putchar(n%94+33);}

Try it online!
Decoder
r;f(int*s){for(r=0;*s;)r=r*94+*s++-33;s=r;}

Takes a wide string as argument.
Try it online!

Wolfram Language (Mathematica), 80 bytes
{FromCharacterCode[#~IntegerDigits~94+33]&,FromDigits[ToCharacterCode@#-33,94]&}

Try it online!

Charcoal, 11 or 7 bytes
Base 10 to base 94: 5 bytes
⍘Ｎ✂γ¹

Try it online! Link is to verbose version of code. Takes input as a string of decimal digits optionally wrapped in []. Explanation:
 Ｎ      Cast input to number
⍘       Base conversion from custom base
   γ    Printable ASCII (including space)
  ✂ ¹   Slice off the first character
        Implicitly print

Base 94 to base 10: 6 bytes
Ｉ⍘Ｓ✂γ¹

Try it online! Link is to verbose version of code. Note: Due to the way Charcoal parses input, if the input looks like JSON then Charcoal will input it as JSON instead of a literal string. To avoid that, quote the input and wrap it in []s, e.g. to input [0] use ["[0]"]. Explanation:
  Ｓ     Cast input to string
 ⍘      Base conversion from custom base
    γ   Printable ASCII (including space)
   ✂ ¹  Slice off the first character
Ｉ       Cast from integer
        Implicitly print

Bidirectional: 7 bytes
⁺ω⍘Ａ✂γ¹

Try it online! Link is to verbose version of code. Takes input as JSON wrapped in []s. Explanation:
   Ａ    Input JSON element
  ⍘     Base conversion to or from custom base
     γ  Printable ASCII (including space)
    ✂ ¹ Slice off the first character
⁺ω      Concatenate empty string (casts result to string)
        Implicitly print

The bidirectional program is impressive, the 7 bytes is ok. I'm gonna edit the question.

First time I see a golfing language use a descriptive emoji! If only all golfing languages used them, I could actually read those programs without comments. Perhaps.

@ComFreek Indeed, some of the functions do try to use somewhat related Unicode symbols, although I don't think there's a Unicode symbol for e.g. base conversion (I don't know why the developer picked that particular character).

By which codepage is this 5 bytes? Does the language at least have to restrict itself to 256 characters? Is the codepage for the program input & output assumed to be the same as the codepage for the program itself?

@masterxilo This language actually restricts itself to slightly fewer than 256 characters, but it has multibyte sequences that encode arbitrary Unicode characters if you really need them. I don't know what the rules on the code page for program input & output are though.

Python 2, 53 + 46 = 99 bytes
Base 10 to base 94:
n=input();r=''
while n:r=chr(n%94+33)+r;n/=94
print r

Try it online!
Base 94 to base 10:
lambda s:reduce(lambda a,b:a*94+ord(b)-33,s,0)

Try it online!

Python 2, 47 + 51 = 98 40 + 42 = 82 bytes
Saved 12 bytes, inspired by @ovs 's suggestion.
Saved 1 byte by replacing len(s) with s>[], stolen from @xnor's Python answer.
f=lambda n:n*`n`and f(n/94)+chr(n%94+33)
g=lambda s:s>[]and ord(s.pop())-33+g(s)*94

Try it online!
f takes in an integer, and returns the base 94 string. Returns the empty string for 0.
g takes in a list of characters, and returns an integer. If input is a empty list (representing an empty string), False is returned in stead of 0, which is functionally equivalent in Python.
Python 2, 82 bytes
This is the bidirectional function that combines the previous 2 functions, with the same total byte count. Utilize the fact that in Python 2, 0 < positive int < empty list < non-empty list.

f=lambda n:n>[]and ord(n.pop())-33+f(n)*94or n<[]and n*`n`and f(n/94)+chr(n%94+33)

Try it online!
Input/output: If n is a list of characters, return the converted integer. If n is an integer, returns its base 94 string.

You can do f without t: f=lambda n:n*[n]and f(n/94)+[chr(n%94+33)].

Ruby, 33 + 34 = 67 bytes
Encode (33):
f=->n{n>0?f[n/94]+""<<n%94+33:""}

Try it online!
Decode (34):
->s{i=0;s.bytes{|x|i=i*94+x-33};i}

Try it online!
Thanks Value Ink, as usual, for some byte trimming.

i=0;s.bytes{|x|i=i*94+x-33};i is -4 bytes.

Basic recursive function for encode is 36 bytes.

Recursive function dose not work with 0

empty string is now allowed for 0 so it works.

K (ngn/k), 9 + 10 = 19 bytes
To base 94, 9 bytes
`c$33+94\

Try it online!
From base 94, 10 bytes
94/-33+`i$

Try it online!
J, 15 + 13 = 28 bytes
To base 94, 15 bytes
[:u:33+94&#.inv

Try it online!
From base 94, 13 bytes
94#._33+a.i.]

Try it online!

x86 32-bit machine code, 14 + 17 = 31 bytes
atoi: explicit-length string input, pointer and length. Returns uint32_t
itoa: pointer to the end of a buffer, returns pointer to the first digit.  Only works for non-negative int32_t - would cost 1 extra byte to xor edx,edx before div instead of cdq to sign-extend.
objdump -d -Mintel disassembly of both functions with machine code (the actual answer) and the source.  Comments added manually.
    ;; input: char *RDI, size_t RCX
    ;; returns: unsigned EDX
    ;; clobbers: EAX temporary to load digits
08049000 <atoi_b94>:
 8049000:       31 c0                   xor    eax,eax               ; EAX = 0 so lodsb zero-extends to 32-bit
 8049002:       99                      cdq                          ; EDX = 0 = total
08049003 <atoi_b94.loop>:
 8049003:       ac                      lods   al,BYTE PTR ds:[esi]
 8049004:       6b d2 5e                imul   edx,edx,0x5e          ; total *= base
 8049007:       8d 54 02 df             lea    edx,[edx+eax*1-0x21]  ; total += char_to_int(digit)
 804900b:       e2 f6                   loop   8049003 <atoi_b94.loop>
 804900d:       c3                      ret

You could call atoi from C if you declare the return value as a 128-bit integer, or a struct.  itoa uses different calling convention.
    ;; input: unsigned EAX, char *RDI=end_ptr
    ;; result: converts into base94 in printing order in the buffer
    ;; returns: RDI=pointer to the first digit.  Caller knows where the end is because it passed that arg
    ;; clobbers: EDX
0804900e <itoa_end_base94>:
 804900e:       6a 5e                   push   0x5e
 8049010:       59                      pop    ecx      ; ECX = base
08049011 <itoa_end_base94.toascii_digit>:                         ; do{
 8049011:       99                      cdq
 8049012:       f7 f1                   div    ecx                  ; EAX = quotient, EDX = remainder
 8049014:       83 c2 21                add    edx,0x21
 8049017:       4f                      dec    edi
 8049018:       88 17                   mov    BYTE PTR [edi],dl    ; *(--p) = digit
 804901a:       85 c0                   test   eax,eax            ; }while(x)
 804901c:       75 f3                   jne    8049011 <itoa_end_base94.toascii_digit>
 804901e:       c3                      ret

next address is 0x1f, total size = 0x1f - 0 = 31 bytes.
Some of the comments use 64-bit registers; I switched to 32-bit to save 2 bytes in single-byte dec edi vs. dec rdi REX opcode modrm.
Try it online!  with a test harness that converts an assemble-time-constant value to a string and back, prints the result, and checks for integer equality.  Change the assembler command line option to -dTESTVAL=94 or whatever to test other values.  If it prints the right string and exit status is 0, it worked.
I used FASM on TIO so I could make 32-bit code; TIO's will only assemble 64-bit object files with NASM/YASM, but FASM can output an executable directly, no linker involved.

For "normal" asm  atoi and itoa, see my answers on those linked SO questions.  Golfing them was straightforward, with only one significant change: use explicit-length strings for itoa so we can use loop instead of having to check for a terminator before tot = tot*base + digit.  And turning itoa into a function that just does the conversion into the caller's buffer.
I also made the 94 and 33 assemble-time symbolic constants (in the TIO link)
I had hoped we might get some use out of stosb, but we need to go backwards, and I couldn't justify having atoi depend on DF=0 while having itoa use std without cld.  Also, getting the remainder into AL means swapping with EDX, but then we need to swap back for the next div.
;; alternate worse version for after DIV
     std
     xchg   eax, edx
     add    al, ZERODIGIT        ; 2 bytes
     stosb                       ; *p-- = digit.  would also need a scasb or inc edi at the end to fix
     xchg   eax, edx
     cld

That's nearly break-even, IIRC one byte longer, but does *p-- = digit instead of the *--p = digit that we actually want.  (Caller could change to pass a pointer to the last element of the buffer, instead of past the end, but I don't think we can justify returning a pointer to the uninitialized space below the first digit.  So that would cost an extra inc edi after the loop.

Raku (raku -p) 60+42 Bytes = 102 Bytes
# convert base-10 to base-94
$!='';while $_ {$!=(chr $_%94+33)~$!;$_=$_.Int div 94};$_=$!

# convert base-94 to base-10
$!=0;$!=94*$!+$_-33 for $_.comb».ord;$_=$!

Red, 68 + 58 = 126 bytes
To base 94, 68 bytes
f: func[n][head either n > 0[append f n / 94 #"!"+(n % 94)][copy""]]

Try it online!
From base 94, 58 bytes
g: func[s][either""= s[0][(-33 + take/last s)+(94 * g s)]]

Try it online!

Perl 5, 36 32 + 26 23 = 55 bytes
To base 94: (Commandline options: -Minteger -n)
do{print chr$_%94+33}while$_/=94

Try it online!
From base 94: (Commandline Options: -pF)
map$\=$\*94-33+ord,@F}{

Try it online!

PowerShell, 62 + 27 = 89 bytes
To Base 94:
param($a)for(;$a){$a-=$r=$a%94
$a/=94
$n=[char]($r+33)+$n}"$n"

Try it online!
From Base 94:
$args|%{$n=$n*94+$_-33}
+$n

Expects input via splatting.
Try it online!

Julia 1.0, 40+46=86 bytes
To Base 64, 40 bytes
!x=reverse(join('!'.+digits(x,base=94)))

From Base 64, 46 bytes
~x=sum(@. 94^(length(x)-1:-1:0)*((x...,)-'!'))

Try it online!

Your to and from base 94 is better, 40 + 46 = 86.

There is a semicolon or line break needed between the two though, so I thought that still counted

"For two programs, the score will be the sum of the byte count of both of the programs."

Ah, ok. I'll change that then

Python 3, 172 bytes
def t(n):return"0"if n<1 else t(n//94).lstrip("0")+''.join(map(chr,range(33,127)))[n%94]
def f(n):return ord(n)-33 if len(n)<2 else f(n[1:])+(ord(n[0])-33)*(94**(len(n)-1))

Try it online!
Based off this answer on StackOverflow


text:
Triangular code, triangular output
For this challenge, submissions should be a program or function shaped like a right triangle, which produces a right triangle of the same size.
What is a right triangle?
For this challenge, a right triangle consists of 1 or more lines, each containing a number of characters (assume all non-newline characters are the same width) equal to that line number:
.
..
...
....

Trailing newlines are allowed.
The challenge:
Your code should form a right triangle, and output a right triangle with the same height made up of any non-newline characters.
As this is code golf, shortest answer in bytes per language wins.

So, to be clear, 1 byte solutions outputting a single character are valid? Also, for longer solutions, must all characters in the output be the same, as in your example? And why are functions disallowed?

@Shaggy Yes, 1 byte solutions would be valid (though for most golfing languages this is probably trivial anyway), characters do not need to be the same, and I actually think I'll revise the rules to allow functions.

Based on "made up of any non-newline characters", a null byte is allowed, right?

@S.S.Anne Yes, I'd say the only bytes not allowed would be \n and \r (0x0a and 0x0d)

I recommend making sure the output is at least one character different than the source code. Otherwise it would allow quine program submissions.

@petStorm A triangular quine is still pretty non-trivial in most languages

Is trailing whitespace allowed at the end every line of the output?

@petStorm I think that sort of defeats the purpose of the challenge

Does “1 or more lines, each containing a number of characters equal to that line number” imply unique characters. I thought it was asking for repetitious characters with repetition = line number.

@vol7ron No, it just means the length of each line should be the same as the line number. The output can be made up of any character(s).

May we exit the program with an exception? (Assuming of course that we've outputted the required output)

@mathjunkie Sure, why not

I have the feeling this challenge would have been better as a code-bowling challenge tbh :)

@KevinCruijssen I thought about it, but it might be difficult to prevent comments/string literals (since requiring programs to be pristine would make right triangles impossible with more verbose languages)

R, 34 bytes
#
d=
cat
d(9^
(1:7)
,sep="
")#####

Try it online!
Outputs \$9^1\$ to \$9^7\$:
9
81
729
6561
59049
531441
4782969

Nice answer! It appears the decimal representation of 9^n is n digits long up to n=21.

C (gcc), 53 bytes
Fixed error pointed out by @S.S. Anne

\
m\
ain
(n){
9<pr\
intf(\
"%d\n",
n*=9)||\
main(n);}

Try it online!

brainfuck, 1 byte
.

Outputs a single null byte.
Try it online!

The fun thing with brainfuck is you can do this with nothing but dots over any number of lines!

@Hand-E-Food Not quite. You'll need a 10 for the newline, so you can do it with +, <, >, and .

It still won't work without loops, because if you have to print more bytes than you have dots, you will inevitably need to reuse them.

JavaScript (ES7),  43  34 bytes
A triangle of 7 rows, filled with 0's.
f
=(
s=`
`)=>
s[7]?
'':0+s
+f(0+s)

Try it online!
Commented
f   // f is a recursive function
=(   // taking
s=`   // a string s initialized to
`)=>   // a linefeed
s[7]?   // if s has more than 7 characters,
'':0+s   // stop recursion; otherwise append a 0, followed by s,
+f(0+s)   // followed by the result of a recursive call with 0 + s

Different method (still 34 bytes), full program

19 byte quine? Is this valid?

@tsh There's apparently no consensus anymore about that kind of quines.

@Arnauld But this question does not require a proper quine.

@tsh You're right, I did not remember this challenge accurately. Your solution looks valid indeed. I think you should post it as a new answer.

Perl 5, 66 54 53 19 bytes
#
##
use
####
Quine

I am submitting this as a joke because I did not even bother trying to write some optimized code.  Instead, I am using a module from CPAN that causes the program to print itself.
The Quine.pm module can be found on CPAN and was released in January 2001, long before this question was posted here.  So I assume that it is acceptable, as it seems to be the tradition in other Code Golf questions.
Edit 1: Saved 12 bytes by removing the semicolon after the use statement.
Edit 2: Thanks to Arnauld for pointing out that I did not need the final newline character, saving one byte.
Edit 3: Thanks to petStorm who made a great improvement by putting the use statement and the module name on separate lines, reducing the program to only 19 bytes.  This exercise that started as a joke is now a very competitive entry.  It would be difficult to do better in a non-obscure language (insert joke about Perl's readability here).

So, can this work? I tried it and it didn't throw a syntax error.

It does work and it produces the expected output without errors.  Thanks a lot for the suggestion!

Bash, 26 bytes
The dc command turns out to be quite useful in code-golfing.
\
d\
c \
-e{\
5..1\
0}*p \

Try it online!

Python 2, 53 43 bytes
I think we are allowed to output different characters. Because of this, I simply printed \$10^i\$ at every iteration.
#
##
###
i=1;
exec\
"prin\
t i;i*\
=10;"*8\

Try it online!

Haskell, 76 64 53 bytes
u
 =
 (9
 ^)
 <$>[
 1..9]
main=
 mapM_
 print u

Try it online!
This prints the first 9 powers of 9.

43 bytes with the help of explicit layout: Try it online!

Ruby, 34 bytes
(
##
1..
7)##
.map{
|x|p(#
9**x)}#

Try it online!

C# (Visual C# Interactive Compiler), 64 53 43 bytes
;
;;
int
s=1,
i;for
(;i++<
9;Print
(s*=9));

Simply prints the first several powers of 9.
Try it online!

Befunge-98 (FBBI), 34 bytes
Outputs \$ 9^k, 1 \leq k \leq 7 \$.
v
8v
<v1
v< @
> 9*v
.^ >\:
a,:|>1-

Try it online!
The first three lines
v
8v
<v1

push 8 (loop counter) and 1 (\$ 9^0 \$). The main loop can be written in a single line as
9*\1-a,:!#@_\:.
9*               multiply by 9
  \              swap to loop counter
   1-            subtract 1
     a,          output newline
       :!        duplicate and invert loop counter
         #@_     quit if non-zero, continue east otherwise
            \    swap to 9^k
             :.  duplicate and output 9^k

Try it online!

05AB1E, 1 bytes
0

Try it online.
Not much to say I guess..

If this was code-bowling instead, we could do something like this (can be made as arbitrary large as you'd want it to, as long as the last three bytes are ₄*»):
1
11
111
1111
11111
111111
1111111
11111111
111111111
1111111₄*»

Try it online.
Explanation:
1\n11\n111\n...  # Push all these numbers one by one to the stack
111...111        # Push the number of the last line
₄*               # Multiply it by 1000 to increase its size by 3
»                # Join everything on the stack by newlines
                 # (after which it is output implicitly as result)

C (gcc), 53 bytes
;
m\
ain
(n){
9/pr\
intf(\
"%d\n",
n)&&mai\
n(n*10);}

Prints powers of 10.
Try it online!

PHP, 43 bytes
;
1;
for
(;$i
++<8;
)echo(
10**$i-
1)."\n";

Try it online!
Not that bad for PHP.. displays a triangle of "9"

Java 10, 76 bytes (11 rows)
v
->
{//
 var
r="";
long i
=0,s=1;
for(;++i
<12;r+=(s
*=9)+"\n")
;return r;}

Inspired by all the other answers.
Try it online.

I wonder why Java doesn't support backslash line continuers.

@S.S.Anne I'm actually wondering why other languages do support backslash line continues. What's the purpose of it in regular programming, apart from benig able to split long strings to multiple lines without using "\n+"?

C has macros that can't take up multiple lines without them. If you want to have a big macro, it won't be readable unless you use the backslash like continuation. The same applies to line-based languages, too. I guess Java is neither of those, so it doesn't need them.

SQL (Oracle) 88 76 Bytes
;
/*
ABC
DEFG
HIJ*/
SELECT
LPAD(1,
LEVEL,1)
FROM DUAL
CONNECT BY
LEVEL < 12;

Try it out
Output:
1
11
111
1111
11111
111111
1111111
11111111
111111111
1111111111
11111111111

Edit: Thanks @Math Junkie, by following the rules I actually cut off 12 bytes.

This is an interesting post, but unfortunately, it misses the point of the challenge. The triangle formed by the source code should be increasing in size, the same way as the output

@mathjunkie I read the question like 3 times, it doesn't state that it needs to be increasing size, just that the code form a right triangle.  It also doesn't specify that the output be the same direction as the code, only that it be the same height.  The code and output triangles are the same (Just reflected across the X-axis)

In the section of the description describing a right triangle, it mentions that the number of characters on a line should be "equal to that line number"

@mathjunkie You are definitely correct, I missed that.  Shoot and I thought I found a loophole.

@mathjunkie Actually thank you for pointing out my error. When I reformatted, I was actually able to save 1 line and therefore 12 bytes.

SmileBASIC 4, 3 bytes
\
?0

0
OK

Wolfram Language (Mathematica), 43 bytes
\
"\
"<\
>".\
"~Ta\
ble~#\
&/@Ran\
ge [8*1]

Try it online!

I like the backslash making the triangle smoother

Clojure, 103 89 76 bytes
(
;;
;;;
loop
[i 9]
(when(
* i;;;;
99999999
)(println
i)(recur(*
i 9))));;;;

Try it online!
Prints the first 11 powers of 9. Exits with an ArithmeticException: integer overflow when trying to multiply \$9^{12}\$ by \$99999999\$.

Canvas, 1 byte
Boring solution, just like everyone else. :)
\

Try it here!
Canvas, 4 bytes
Non-trivial attempt.
＼
２＼

Try it here!
Explanation
＼    # Draw a diagonal, with nothing on the stack
      # Errors silently
      # Newline: A character not in the code page.
      # It basically does nothing.
２    # 2: Push 2 onto the stack
  ＼  # Draw a diagonal with a length of 2
      # Implicit output

I think the new-line might be equivalent to the pilcrow at byte 10 of the code-page, ¶, try it

Bash + GNU utilities, 43 bytes
\
s\
eq\
 -f\
'seq\
 -s "\
" %f' \
$[+8]|sh

Try it online!
I couldn't quite get this down to 7 rows; I needed to pad it by 4 bytes to fill out the 8-row triangle (that's why I have $[+8] in the code instead of just 8).

BSD Challenge!
If you take the same idea as the GNU solution above but use the BSD utility jot instead of seq, it's just one byte too long for a 7-row solution (which would be 34 bytes):
    \
    j\
    ot\
     -w\
    'jot\
     -s "\
    " ' 7|sh
# This is one byte too long for 7 rows :( .

If someone can see how to shave just 1 byte off this BSD version, that would get it down to a 7-row 34-byte solution.
Here's a TIO link to the BSD version if anybody wants to try their hand at eliminating that one last byte!  This also works under OS X, if you have a Macintosh.
(Obviously this version, like the GNU version in my main answer above, can be padded to be another 8-row 43-byte solution, but that's not as interesting.)

I have a 26-byte solution if you want.

@dingledooper  That's a nice one. It's completely different from mine; go ahead and post it yourself.

Ok thanks, that's what I'll do.

I love the smooth edge on your triangle!

@Hand-E-Food Thank you\

Bash, 64 bytes
\
d\
at\
e +\
d%n%\
m%n%j\
%n%Y%n\
%R%n%:z\
%n%7Y%n%\
T%n%N%n%F\

Try it online!
Not the shortest but kind of fancy. Displays current date in convinient format. Tried to do it locales intependent. Last byte for fancy too.

C (gcc), 53 bytes
\
m\
ain
(n){
for(;
9/n;n=
printf(
"%0*d\n"
,n,0));;}

Try it online!
C (gcc), 53 bytes
\
m\
ain
(n){
9/n&&
main(\
printf(
"%0*d\n"
,n,0));;}

Try it online!

C Preprocessor, 65 bytes (10 lines)
.
..
...
....
.....
......
.......
........
.........
__TIME__//

Process with GCC/Clang with -E and -P options. (Thanks to Calculuswhiz for suggesting the -P option.)
All the dots are ignored. The predefined __TIME__ macro expands to a string of the form "HH:MM:SS", meaning the last line stays the same length.

Try the -P option too.

And just a style thing, but instead of ending with two spaces, how about //?

@Calculuswhiz Thanks for the tip. I didn't know about the -P option. And you're right: the slashes are cleared than the spaces. I made both of the changes you suggested.

No problem! I saw your answer, and I thought that surely there must a way to remove that stuff! After some Google attempts, I finally found an SO answer on it. Incidentally, those extra garbage lines are called "linemarkers".

Although... maybe you want to mention the 1-byte . solution.

I figured that one was obvious :P I was trying to do something a little more imaginative. Originally, I was browsing the list of standard macros and thought that __TIME__ expanded to 8 characters--the same number of characters in __TIME__ itself--, which would have been perfect, but I forgot to account for the quotes :( This solution was a hack on the original idea.

Husk, 13 bytes
₁
¶₂
ΘI₃
↑3İ⁰

Try it online!
No comment characters, so every element does something...
₁       # run function on line 1 (next line)
¶₂      # split output of function on line 2 (next line)
ΘI₃     # prepend zero to identity of function on line 3 (next line)
↑3İ⁰    # first 3 elements of powers of 10

Husk, 1 byte
Trivial (but included for completeness)
1

Try it online!
(there are many more like this... all equally uninteresting...)

PowerShell Core, 4 bytes
Trivial power (up to 19 lines)
1
10

Try it online!

PowerShell Core, 4 bytes
p–n junction (90 variants)
1
-1

Try it online!

PowerShell Core, 26 bytes
Twinkle, twinkle, little star
,
'*
*'*
6|%{
'*' *
++$ko}

Try it online!

PowerShell Core, 26 bytes
The magic number in nuclear physics and the quark soup of 3 quarks $_
,
1+
2..
6|%{
"$_"*
$_};$_

Try it online!

TeX, 188 bytes
Nothing out of the ordinary, but for completeness:
%
%%
%%%
%%%%
%%%%%
%%%%%%
%%%%%%%
%%%%%%%%
\countdef
~=1%%%%%%%
\countdef%%
\i=26\loop%%
\advance~1{%%
\loop\advance%
\i1.\ifnum\i<~%
\repeat\endgraf}
\ifnum~<18\repeat
\bye%%%%%%%%%%%%%%

Factor, 34 26 bytes (7 6 lines)
-8 bytes / 1 line thanks to Bubbler!

10
  6
iota
  n^v
stack.

Try it online!
Output:
1
10
100
1000
10000
100000

I was able to reduce by one line using n^v (TIO). Using stack. is a nice idea.

Wow, thank you @Bubbler !

Pxem, Filename: 103 bytes + Content: 0 bytes = 103 bytes
Filename as follows (if your filesystem doesn't support LF, I'm sorry) (also requires to be ASCII-compatible):
x
.p
x.n
.o.n
.o04x
.-.t.z
.c.zxxx
.a.m.m.w
.sx.oab.-
.s.-.c.a.s
.c.o.c.$.mx
.s.s.+.tao.-
.s.m.a.dxxxxx

Content is empty.
Try it online, with rpxem!
Output
x
10
120
xxxx
xxxxx
xxxxxx
xxxxxxx
xxxxxxxx
xxxxxxxxx
xxxxxxxxxx
xxxxxxxxxxx
xxxxxxxxxxxx
xxxxxxxxxxxxx

With comments
Note that every LF is replaced with '?'.
x?.pXX.z # print'x', LF
.a?x.nXX.z # print LF.ord # two-digits
.a?.oXX.z # print LF
.a.n?.sXX.z
.a04x?.-.tXX.z # i = 4
.a.zXX.z # loop
  .a?.c.zxxx?.aXX.z # essentially nop
  .a.m.m.wXX.z # j = i; while j!=0
    .a?.sx.oXX.z # print'x'
    .aab.-?.s.-.cXX.z # j--
  .a.a.s?.c.oXX.z # end-while; print LF
  .a.c.$.mx?.s.s.+.tXX.z # i++
  .aao.-?.s.mXX.z # break if !(14>i)
.a.a.dxxxxx # end-loop; end program

I will admit, when I saw your username I expected INTERCAL

Knight, 26 bytes
;
=a
0W>
6aO*
'.'=a
+1aQQQ

Try It Online!

dc, 4 bytes
B
1f

Try it online!
Explanation:
B   Push 11 on the stack.
1   Push 1 on the stack.
f   Print the items on the stack, starting at the top, each one with a terminal newline.

Io, 43 bytes
A lot more "content" than my previous submissions.
\
 \
  \
for(
i,1,8
,(9**i
)     \
println)

Try it online!

Readability improvement: Try it online!

@mypronounismonicareinstate Nice modification. However, I'm not going to accept it, because in my opinion, a one-liner in a case like this is much more readable than a line-breaked program.

Erlang (escript), 76 bytes
f
()
->[
%%%%
%%%%%
string
:copies
("!", X)
++"\n"||X
<- lists :
seq(1,11)].

Try it online!

Python 3, 53 bytes
#
##
###
for\
i in\
range(
9):####
 print(#
10**i)###

Try it online! Similar to dingledooper's submission. I was also going to submit:
brainfuck, 1 byte!!
.

Try it online! But S.S.Anne beat me by a couple of hours :)

Jelly, 1 byte
0

Try it online!

The vast majority of atoms can be used for this, printing 0 or 1.  The few exceptions are listed as follows: (incomplete, didn't check past Ẓ in the Atoms page)

³⁴⁵⁹: prints more than one digit
½°: prints 0.0
~: prints -1
⁷: prints \n
⁸IRḶṬẈ: prints nothing
MTZ: errors
Ɠƈɠ: interacts with STDIN

Borderline:

Ọ: prints null character (allowed per S.S. Anne's comment)

The null character is fine. See my brainfuck answer.

HQ9+, 1 byte
Q

Try it online!

dirt, 43 bytes
x
xx
xx|
|'a'
(a*'a
)**{1|
}.*|"11
11111"|x

run with with empty string as input:
>dirt triangle.dirt -i ""
a
aa
aaa
aaaa
aaaaa
aaaaaa
aaaaaaa
aaaaaaaa

Stax, 4 bytes
2
mR

Run and debug it at staxlang.xyz!
Nontrivial solution. Prints "\x01\n\x01\x02", so you won't see any output, but it's there. One byte is easy but boring.
2     Push 2
mR    For n in [1,2], print [1..n] as a string

Another 4-byter that feels like cheating:
0     Do nothing
|?    Source of program, implicit print.

x86 machine code (32-bit), 43 bytes
As symbols in codepage 437:
`
!Q
!j
!Y_j
Q░x≤¬
'YX¬A╢
Ç∙ëq∞Çε
ê7af║█¡├

Hexdump:
600a
21510a
216a010a
21595f6a0a
51b078f3aa0a
275958aa41b60a
80f98971ec80ee0a
88376166badbadc3

A fastcall function which receives the pointer to output buffer in ecx. It fills the buffer with a triangle containing the letter x:
x
xx
xxx
xxxx
xxxxx
xxxxxx
xxxxxxx
xxxxxxxx

Disassembly:
10013FF0 60                   pushad
10013FF1 0A 21                or          ah,byte ptr [ecx]
10013FF3 51                   push        ecx
10013FF4 0A 21                or          ah,byte ptr [ecx]
10013FF6 6A 01                push        1
10013FF8 0A 21                or          ah,byte ptr [ecx]
10013FFA 59                   pop         ecx
10013FFB 5F                   pop         edi
10013FFC 6A 0A                push        0Ah
10013FFE 51                   push        ecx
10013FFF B0 78                mov         al,78h
10014001 F3 AA                rep stos    byte ptr es:[edi]
10014003 0A 27                or          ah,byte ptr [edi]
10014005 59                   pop         ecx
10014006 58                   pop         eax
10014007 AA                   stos        byte ptr es:[edi]
10014008 41                   inc         ecx
10014009 B6 0A                mov         dh,0Ah
1001400B 80 F9 89             cmp         cl,89h
1001400E 71 EC                jno         again (10013FFCh)
10014010 80 EE 0A             sub         dh,0Ah
10014013 88 37                mov         byte ptr [edi],dh
10014015 61                   popad
10014016 66 BA DB AD          mov         dx,0ADDBh
1001401A C3                   ret

I used various instructions to insert a new-line byte 0A into the machine code:
10013FF1 0A 21                or          ah,byte ptr [ecx]
10014009 B6 0A                mov         dh,0Ah
10014010 80 EE 0A             sub         dh,0Ah

At the end of the program, I needed to pad it with 4 bytes. I used a harmless MOV command instead of 4 NOPs so I could have hexadecimal BADBAD in code.

Perl 5, 53 bytes
A triangular quine.
$
_=
q{$
_='$
_='."
q{$_}"
.";eva"
.l;print
###};eval

Try it online!

05AB1E, 1 byte
Any one of 0123456789@NQXY_adg‹›¾ÊËåð will work. They will output one of 0123456789101120000000011  respectively.

PowerShell Core, 103 53 34 bytes
#
##
$n`
=1;`
$n..`
7|%{(`
$n*=9)}

A Powershell port of the R solution by Robin Ryder, thanks!
Try it online!
Previous attempt 2
Previous attempt 1

BRASCA, 1 byte
Yep, it's another one of these.
Pick any one of these:
0123456789oOnNlLeEdDhHK+-*^s}r&|_ABmM?!ST<>=Y

Explanation
TL;DR: Most instructions work because an empty stack consists of infinite zeroes.
0-9       - Pushes the digit, implicit output.
oOnN      - Prints the top/bottom of the stack, which is 0x00 because the stack is empty.
lLeEdDhHK - Pushes 10, 13, 26, 32, 48, 65, 97, 100 and 1000 respectively, implicit output.
+-*^s}    - Operate on zeroes because of an empty stack. (ex. + on an empty stack is 0+0).
r         - Pushes a range between 0 and 0, which is just a single 0.
&|_       - Bitwise operators on zeroes because, once again, of an empty stack.
AB        - Registers are 0 by default.
mM        - Shifting an empty stack pushes a 0.
?         - Pushes a random number between 0 and 0.
!         - Pushes the stack length, which is 0.
S         - Concatenates 0 with 0, creating 0.
T         - Sets implicit output to only output the top of the stack, which is empty, so it's a 0.
<>=Y      - Compares 0 with 0 in a bunch of ways.

Charcoal, 13 bytes
Ｆ
Ｅ⁺
.¦.
×⊕λ.

Try it online! Explanation: In Charcoal, newlines, which I will represent below with ¶, are simply parts of string literals.
Ｆ¶

Loop over the characters in the string literal ¶.
Ｅ⁺¶.¦.¶

Concatenate the string literals ¶. and .¶, loop over the characters, and print each result on its own line.
×⊕λ.

Repeat . by one more than the character index (0-indexed).

Keg, 1 byte
t

Try it online!
Sorry, it's a simple literal answer. But then again, all answers in Keg are going to be simple literal answers. Works because characters auto-push and auto-print.
Here's a script that will generate a triangular source code for any given n.

Red, 53 bytes
;
t:
"*"
loop
( 9)[
print(
(( t)))
insert((
t))1 + 7]

Try it online!
Red, 76 64 bytes
;
s:
{t:
 "*"
 loop
(10)[p
rint(t)
insert(t
)"*"]}do
trim/all s

Try it online!

Python 3, 64 53 bytes
#
##
###
for\
i in\
range\
(1, 9):
 print(\
'.' *i )#

Try it online!
Removed a line by pushing two lines into one last one, saved 11 bytes

Zsh, 34 bytes
:
r\
ep\
eat\
 7 {:
s+=A;:
<<<$s;}

Try it online!
After re-joining lines:
:           # ':' is a no-op, just to fill space more visibly than ' '
repeat 7 {
    :
    s+=A
    :
    <<< $s
}

PowerShell, 1 byte
0

Try it online ->
Very similar to other answers, shocked that no one posted this before.

MAWP 0.1, 1 byte
:

Outputs top of stack, which is predefined as 1

Excel Online, 53
9 lines
=
T(
12*
34)&
REPT(
0,ROW(
OFFSET(
A1,,,9))
)&TEXT(,)

How It Works
Kind of like my Google Sheets answer, but the bottleneck is the REPT() instead.
Sadly, I cannot break the function name from the open paren. Also, Excel Online does not auto-close, so we're stuck with an extra line. However, some nice things that did help were that Excel Online detects Array Formulas automatically, and it displays Array elements as separate rows, so I get a free line break.

Google Sheets, 134
15 lines
=
T(
(--
CODE
("owo
(^_^;)
orz")))
&RIGHT(,
)&LEFT(,)
&MID(,1,)&
IF(LN(2),)&
ARRAYFORMULA
(JOIN(CHAR(10
),,REPT(0,ROW(
OFFSET(A1,,,15)

How It Works
Stall until we have a long enough line for ARRAYFORMULA, then catch up by generating 15 rows of an increasing number of 0's using REPT() and ROW(OFFSET()) and joining them together with JOIN(). Google Sheets will auto-close the missing parens.
Notes

Hey, look! No duplicate literals, no duplicate function calls, and no spaces. I could have strung together a bunch of ""&s, but that would be less entertaining.
The bottleneck here is ArrayFormula, so unless there's a way around that, I think we're stuck.

Java 8, 208 bytes
;
/*
who
they
are*/
public
class//
Main{//h
public //
static//14
void main//
(String[]ar)
{for(int i=0;
i<19;i++){for(
int j=0;j<i+1;j
++)  System.out.
//crucial comment
print('*');System.
out.println();}}}//

Try it online!
A triangular full program.

Excel, 26 bytes
=
7^
(((
ROW(
1:6))
 ))&""

Spreadsheet
Below is 17 bytes but Excel removes the line feeds in the array after I hit enter and the output is right justified.
=
3^
{2;
4;6;
8;10}

batch 63 23 bytes
:
T^
YP^
E==^
;%~f0

Outputs the file content.
Note:

TIO not available, run it from the command line after turning echo off

Vyxal, 1 byte
0

Try it Online!
Any digit works.
More interestingly,
Vyxal j, 4 bytes
2
ʁ↵

Try it Online!
2   # 2
 ʁ  # Range 0-1
  ↵ # 10 ** n (vectorised)
    # (j flag) joined by newlines

Using powers of 10.
And finally,
Vyxal, 8 bytes
3
ɾ×
*⁋,

Try it Online!
3      # 3
 ɾ     # 1...3
  ×*   # That many asterisks, for each
    ⁋  # Joined by newlines
     , # Outputted.

Making an asterisk triangle.

Japt, 1 byte
Q

Try it out here

Pyth, 1 byte
Z

Try it online!
In Pyth, Z is initialized to 0. Output is implicit so 0 will be printed

4 bytes
Z
T;

Try it online!
T is initialized to 10 and implicitly printed. ; is a no-op in this context.

Retina, 1 byte
`

Try it online!
The backtick sets the configuration, which in this case is empty. By default, Retina outputs the number of matches of the regex on the input. In this case that regex is the empty string, so the output is 1

33, 1 byte
o

Try it online!
o prints the value of the accumulator, which defaults to 0.
Bit boring, but what can you do about it.

Deadfish~, 1 byte
o

Outputs
0

This is kind of cheating but I can't think of any other way to do it in Deadfish~.

source: Stack Exchange

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

sort: votes


text:
Is this a rectangle?
The challenge:
Given four coordinates, each in x y form, your job is to find out whether or not the given coordinates form a rectangle, and output a truthy/falsey.
Rules:

For the sake of simplicity, squares, lines (two identical pairs of coordinates) or dots (all four of the coordinates are the same) are all counted as rectangles
Coordinates for rectangles can be given in any order, for example this:

A----B
|    |
D----C

and this:
A---B
|   |
|   |
|   |
C---D

are both rectangles.

Rectangles can be rotated, so they won't always be parallel to x and y axis.
You may take input in any form you like as long as the order for each coordinate is not mixed: [x,x,x,x,y,y,y,y] is not acceptable, where as [x,y,x,y,x,y,x,y] or [(x,y),(x,y),(x,y),(x,y)] is fine.
Complex numbers are a valid form of input
This is codegolf, so lowest byte count wins.

Test cases:
[0,2, 3,2, 3,0, 0,0]      Truthy
[3,5, 2,0, 0,2, 5,3]      Truthy
[6,3, 3,5, 0,2, 3,0]      Falsy
[1,4, 5,2, 4,0, 0,2]      Truthy
[0,0, 0,0, 3,2, 4,0]      Falsy
[1,1, 1,1, 1,1, 1,1]      Truthy
[1,4, 100,1, 100,1, 1,4]  Truthy

I don't understand what is the difference between the two figures you draw. They both use the same coordinates, so they both use the same input.

@Uriel, should have been more clear probably. What i meant was that coordinates should not be treated like the second figure

Is [6,3,3,5,0,2,2,0] really a rectangle?

Some of those Truthy cases still don't look like rectangles, but rather parallelograms: Try it online!

@xnor This is a slightly more accurate rendering, at least with the DejaVu Sans Mono font on my computer. I think only the 3rd test case is wrong, as you've mentioned earlier.

@Arnauld Good point, spacing it better does make the rectnagles clearer. It looks like the second test case actually has the issue that the points are in the wrong order, making a self-crossing shape.

@SurculoseSputum I'm understanding it the other way, that the "Coordinates should not be treated like this figure:" means we should always interpret input points as being in cyclic order, so that the second test case wouldn't be a rectangle. I've VTC'ed as unclear.

What needs to be clarified is this: if ABCD is a rectangle with the points presented, say, clockwise, does ACBD also count as a rectangle?  Should we output truthy or falsey for ACBD?

Do we have to handle complex numbers? That would be difficult for most languages.

@RedwolfPrograms That's just an option. As the OP states, you can input $(x,y)$ coordinates too.

@Noodle9 fully approve of your edit, thank you!

So if the points in a rectangle are presented in the order ACBD, we should output truthy, the same as for ABCD?  I think that should be spelled out in the challenge (or the opposite should be spelled out if ACBD shouldn't count as a rectangle).

@MitchellSpector, yep

Related numberphile video: https://youtu.be/xyVl-tcB8pI

@ChristopheLeBesnerais awesome! great video

Are the coordinates guaranteed to be integer?

Python 3, 88 \$\cdots\$ 54 43 bytes
lambda l:len({abs(sum(l)/4-z)for z in l})<2

Try it online!
How
Calculates the distances from the quadrilateral's centre of mass to all of its vertices and tests if they're equal.
Input The four vertices as a sequence of complex numbers in any order.
Output True/False

Does this really check if the shape is a rectangle? You can draw lots of quadrilateral with corners on a circle.

@xnor But the quadrilateral's centre (of mass with even density is what I'm actually calculating) will only coincide with that of the circle if it's a rectangle.

Oh, I see, that's clever. That should work then in the "in any order" interpretation of the challenge.

A nice solution!

Here's an argument that convinced me only a rectangle passes your test. Consider the circle on which four points lie. Its center must be the points' center of mass. One way to "average" the four points is to take the midpoint between two points and then midpoint between the other two points, and take the midpoint between those midpoints. To get the center of the circle at the end, the two midpoints must be opposite each inside the circle. (cont'd)

(continuing) Draw the segment between the two midpoints. We can obtain the pair of points on the circle producing a midpoint by drawing the perpendicular to that segment and intersecting it with the circle. In fact, this the only such of pair of points on the circle. Doing so for both midpoints, we find that central segment is now perpendicular to two equal-length segments whose endpoints are the four corners, so they form a rectangle. (This was all probably confusing without a drawing...)

Diagram

Jelly, 6 bytes
A port of Noodle9's Python answer with a slight adjustment for golfing purposes.
×4_SAE

A monadic Link accepting a list of four complex numbers which yields 1 if they form a rectangle or 0 if not.
Try it online! Or see the test-suite.
How?
Checks that all four coordinates are equidistant from the centre of mass of the uniform density quadrilateral.
×4_SAE - Link: list of complex numbers, C
 4     - literal four
×      - (C) multiply (4) (vectorises across C)
   S   - sum (of C)
  _    - (C×4) subtract (sum(C)) (vectorises across C×4)
    A  - absolute value (vectorises)
     E - all equal?

Note this still works given an equilateral triangle with a repeated coordinate (it would skew the centre of mass toward the repeated coordinate).

The equivalent change to Noodle9's program would be:
lambda l:len({abs(z*4-sum(l))for z in l})<2

05AB1E, 11 bytes
Port of Noodle9's Python answer. 05AB1E doesn't have complex numbers, so it ends up a bit long.
εIøO4/-}nOË

Try it online!

Python 3, 115 108 107 bytes
This solution finds if any permutation of A,B,C,D results in a rectangle.
Output is correct for all test cases except test case 3 which is not a rectangle due to corners not equal to 90 degrees.
lambda a,b,c,d:g(a,b,c,d)+g(a,c,b,d)+g(a,b,d,c)
g=lambda a,b,c,d:b+d-a-c==((b-a)*(d-a).conjugate()).real==0

Try it online!
Input: 4 complex numbers representing the 4 coordinates.
Output: a positive integer if input is a rectangle, or 0 if input is not.
105 bytes if output can be 0 for rectangle, and non-zero for non-rectangle.

lambda a,b,c,d:g(a,b,c,d)*g(a,c,b,d)*g(a,b,d,c)
g=lambda a,b,c,d:b+d-a-c or((b-a)*(d-a).conjugate()).real

Ruby, 44 bytes
Input is an array of 4 complex numbers, again.
->l{l.map{|z|(l.sum/4.0-z).abs}.uniq.size<2}

Try it online!
Port of @Noodle9's Python answer.

APL2: 33 bytes
Yet another port of Noddle9's answer, this time in APL2.
Prerequisites:

This is code is ⎕IO-dependant since it uses Partition with axis. This example in ⎕IO=0
The list of coordinates is stored in variable C.

D≡⌽D←↑+/(M-+/¨.25×M←⊂[1]⍉4 2⍴C)*2
The result is either 1 for true or 0 for false.
An example
If C is the vector 3,5,2,0,0,2,5,3 or rather 3 5 2 0 0 2 5 3, then the first thing that happens is that 4 2⍴C turns it into a 4x2 matrix:
3 5
2 0
0 2
5 3

Then ⍉ transposes that matrix and ⊂[1] turns it into a vector of 2 vectors (x & y). This is stored as M: ((3 2 0 5)(5 0 2 3)).
Next M is multiplied with 0.25 and summed element-wise: (this is what +/¨ does)
(2.5 2.5).
Now we subtract this from M and square the differences:
(M- ...)*2  (yes, * is "power"). We now have:
(0.25 0.25 6.25 6.25)(6.25 6.25 0.25 0.25).
This is summed by the +/ outside the brackets and we get ((6.5 6.5 6.5 6.5)). Sadly we have a 4-element vector inside another structure so we have to "spend" a character to remove the outer shell: ↑.
The inner vector is assigned to variable D. Finally we use ≡ to compare D to its reverse ⌽D thereby checking if all items are equal.

APL (Dyalog Unicode), 25 bytes
{1=≢∪|⍵-+/⍵÷4}

Try it online!
input: complex numbers.
distances from centre of gravity must match.

Husk, 13 bytes
Λ=mO½´×oΣzo□-

Try it online!
I'm not sure if this is correct.
It takes Euclidean distance between all pairs and checks if the resulting array is symmetric.

Vyxal, 12 bytes
ƛ?ÞTvṁ-²∑√;≈

Try it Online!
ƛ         ;  # Map to...
 ?           # Input
  ÞT         # Transposed
    vṁ       # Take the average of each (center)
      -      # Get the x and y distances to the center
       ²∑√   # Pythagoras to get abs. dist. to center
           ≈ # Are all equal?

Bash + GNU utilities, 77 bytes
cat>t;join -j3 t t|xargs -I% dc -e%sDsClD-d*sqlC-d*lq+p|sort|uniq -c|grep 2\

(There's a space at the end, after the backslash.)
Try it online!
Or try the entire test suite online.
The input is in the form:
x1 y1
x2 y2
x3 y3
x4 y4

(with a newline after each point).
The output is the exit code: 0 for falsey, 1 for truthy.

Here's how it works (there are no complex numbers available in bash):

The join computes all the pairs of points.  There are 4 points, so there are 16 pairs of points.  (This includes each pair in both orders, and it even includes pairs where the two points are the same.)
The xargs command uses dc to compute the square of the distance between each pair of points.  We now have a list of all the squares of the distances between pairs of the points.
Now, sort|uniq -c computes how many times each value appears in the list of squared distances.
The original four points form a rectangle iff no value appears exactly twice in the list.

Wolfram Language (Mathematica), 32 bytes
Equal@@Norm/@(r=#;Mean@r-#&/@r)&

This is a port of Noodle9's Python answer. I start by determining the centroid of the four points, which is their average position in space, by taking the mean of the four vectors corresponding to each. [N.B.: If the points had mass, and their masses were identical, this would give their center of mass.].  I then subtract each point from the centroid, and determine the lengths (norms) of the four resulting vectors.  I then test to see if all four norms are the same.
Try it online!
Alternately, the following is also 32 bytes.  Though this one is non-competing, since the challenge was posted ~May 2020, and this uses new syntax (|-> as a shorthand for \[Function] ) that wasn't introduced until v. 12.2 of Mathematica, which was released in Dec. 2020:
Equal@@Norm/@(r|->Mean@r-#&/@r)&

Interestingly, the above doesn't work in tio.run , because it's using  version 12.0.1 for Linux x86 (64-bit) (October 16, 2019).

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


text:
FizzBuzz: Least unique bytes
Introduction:
Although it seems challenges scored by least unique characters have been attempted, there are few which were well-received. I think it's a potentially interesting scoring criterion, as long as different languages aren't competing with each other (as with code golf).
Challenge:
Create a basic FizzBuzz program or function. The output should be the decimal numbers 1 to 100, inclusive. For multiples of three, print Fizz instead of the number, and for the multiples of five print Buzz. For numbers which are multiples of both three and five, print FizzBuzz.
A trailing newline is allowed, and \n or \r\n can be used to separate the numbers (and Fizzes and Buzzes and FizzBuzzes).
Scoring:
The answer (per language) with the least unique bytes wins. For example,
abbcccdeee

would have a score of 5, as it contains are 5 distinct bytes.

Is this really Fewest (distinct) characters for Turing Completeness. Or are there plausible ways to implement FizzBuzz with fewer than needed to run a general program?

@xnor the equivalent of print("1 2 3 Fizz 4 [...]") for the extra esoteric languages

Possible duplicate of Encode a program with the fewest distinct characters possible,

Unary, score 1 (\$3.065... × 10^{185}\$ bytes)
I couldn't resist ;)
The program consists of 306542480187333548229216501998737670100823810347304444087725506753387994506955599380251625023427643514071322084229755566193943772995081070792874713832316221905650936799216302699728340431 times a single character of your own choosing, which translates to the following brainfuck program:
++>+++++>>>>>++++++++++[>+>>+>>+>+<<<[++++<-<]<,<,-<-<++<++++[<++>++++++>]++>>]>[+[[<<]<[>>]+++<[<.<.<..[>]]<<-[>>>[,>>[<]>[--.++<<]>]]+++++<[+[-----.++++<<]>>+..<-[>]]<[->>,>+>>>->->.>]<<]<[>+<<<,<->>>+]<]

Port of @MitchSchwartz' brainfuck answer for the 1,2,Fizz,4,Buzz challenge, so make sure to upvote him!
Try it online as brainfuck.
The byte-count is generated with this 05AB1E program I wrote.

Is there a programming language whose empty program prints the fizz buzz challenge?

@RGS Not that I'm aware of. I know a program that loops infinitely, a few that print "Hello, World!", one that prints the 99 bottles of bear lyrics, but I haven't seen one (yet) that prints the FizzBuzz sequence.

I think you are winner, then xD

C (gcc), 14 unique bytes (4552 bytes)
The characters I used are: main(){}prtf+&.
a(i){if(++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&printf(&i)){}}n(i){if(++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&printf(&i)){}}f(i){if(++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&printf(&i)){}if(++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&printf(&i)){}if(++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&printf(&i)&printf(&i)){}}t(i){if(++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&printf(&i)){}if(++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&printf(&i)){}if(++i&++i&++i&++i&++i&printf(&i)&printf(&i)){}}r(){}p(i){if(r()&&printf(&i)){}if(++i){}}main(i){if(a(p(i))&n()){}if(a(p(p(i)))&n()){}if(f()&n()){}if(a(p(p(p(p(i)))))&n()){}if(t()&n()){}if(f()&n()){}if(a(p(p(p(p(p(p(p(i))))))))&n()){}if(a(p(p(p(p(p(p(p(p(i)))))))))&n()){}if(f()&n()){}if(t()&n()){}if(a(p(i))&a(p(i))&n()){}if(f()&n()){}if(a(p(i))&a(p(p(p(i))))&n()){}if(a(p(i))&a(p(p(p(p(i)))))&n()){}if(f()&t()&n()){}if(a(p(i))&a(p(p(p(p(p(p(i)))))))&n()){}if(a(p(i))&a(p(p(p(p(p(p(p(i))))))))&n()){}if(f()&n()){}if(a(p(i))&a(p(p(p(p(p(p(p(p(p(i))))))))))&n()){}if(t()&n()){}if(f()&n()){}if(a(p(p(i)))&a(p(p(i)))&n()){}if(a(p(p(i)))&a(p(p(p(i))))&n()){}if(f()&n()){}if(t()&n()){}if(a(p(p(i)))&a(p(p(p(p(p(p(i)))))))&n()){}if(f()&n()){}if(a(p(p(i)))&a(p(p(p(p(p(p(p(p(i)))))))))&n()){}if(a(p(p(i)))&a(p(p(p(p(p(p(p(p(p(i))))))))))&n()){}if(f()&t()&n()){}if(a(p(p(p(i))))&a(p(i))&n()){}if(a(p(p(p(i))))&a(p(p(i)))&n()){}if(f()&n()){}if(a(p(p(p(i))))&a(p(p(p(p(i)))))&n()){}if(t()&n()){}if(f()&n()){}if(a(p(p(p(i))))&a(p(p(p(p(p(p(p(i))))))))&n()){}if(a(p(p(p(i))))&a(p(p(p(p(p(p(p(p(i)))))))))&n()){}if(f()&n()){}if(t()&n()){}if(a(p(p(p(p(i)))))&a(p(i))&n()){}if(f()&n()){}if(a(p(p(p(p(i)))))&a(p(p(p((i)))))&n()){}if(a(p(p(p(p(i)))))&a(p(p(p(p((i))))))&n()){}if(f()&t()&n()){}if(a(p(p(p(p(i)))))&a(p(p(p(p(p(p((i))))))))&n()){}if(a(p(p(p(p(i)))))&a(p(p(p(p(p(p(p((i)))))))))&n()){}if(f()&n()){}if(a(p(p(p(p(i)))))&a(p(p(p(p(p(p(p(p(p((i)))))))))))&n()){}if(t()&n()){}if(f()&n()){}if(a(p(p(p(p(p(i))))))&a(p(p(i)))&n()){}if(a(p(p(p(p(p(i))))))&a(p(p(p(i))))&n()){}if(f()&n()){}if(t()&n()){}if(a(p(p(p(p(p(i))))))&a(p(p(p(p(p(p(i)))))))&n()){}if(f()&n()){}if(a(p(p(p(p(p(i))))))&a(p(p(p(p(p(p(p(p(i)))))))))&n()){}if(a(p(p(p(p(p(i))))))&a(p(p(p(p(p(p(p(p(p(i))))))))))&n()){}if(f()&t()&n()){}if(a(p(p(p(p(p(p(i)))))))&a(p(i))&n()){}if(a(p(p(p(p(p(p(i)))))))&a(p(p(i)))&n()){}if(f()&n()){}if(a(p(p(p(p(p(p(i)))))))&a(p(p(p(p(i)))))&n()){}if(t()&n()){}if(f()&n()){}if(a(p(p(p(p(p(p(i)))))))&a(p(p(p(p(p(p(p(i))))))))&n()){}if(a(p(p(p(p(p(p(i)))))))&a(p(p(p(p(p(p(p(p(i)))))))))&n()){}if(f()&n()){}if(t()&n()){}if(a(p(p(p(p(p(p(p(i))))))))&a(p(i))&n()){}if(f()&n()){}if(a(p(p(p(p(p(p(p(i))))))))&a(p(p(p(i))))&n()){}if(a(p(p(p(p(p(p(p(i))))))))&a(p(p(p(p(i)))))&n()){}if(f()&t()&n()){}if(a(p(p(p(p(p(p(p(i))))))))&a(p(p(p(p(p(p(i)))))))&n()){}if(a(p(p(p(p(p(p(p(i))))))))&a(p(p(p(p(p(p(p(i))))))))&n()){}if(f()&n()){}if(a(p(p(p(p(p(p(p(i))))))))&a(p(p(p(p(p(p(p(p(p(i))))))))))&n()){}if(t()&n()){}if(f()&n()){}if(a(p(p(p(p(p(p(p(p(i)))))))))&a(p(p(i)))&n()){}if(a(p(p(p(p(p(p(p(p(i)))))))))&a(p(p(p(i))))&n()){}if(f()&n()){}if(t()&n()){}if(a(p(p(p(p(p(p(p(p(i)))))))))&a(p(p(p(p(p(p(i)))))))&n()){}if(f()&n()){}if(a(p(p(p(p(p(p(p(p(i)))))))))&a(p(p(p(p(p(p(p(p(i)))))))))&n()){}if(a(p(p(p(p(p(p(p(p(i)))))))))&a(p(p(p(p(p(p(p(p(p(i))))))))))&n()){}if(f()&t()&n()){}if(a(p(p(p(p(p(p(p(p(p(i))))))))))&a(p(i))&n()){}if(a(p(p(p(p(p(p(p(p(p(i))))))))))&a(p(p(i)))&n()){}if(f()&n()){}if(a(p(p(p(p(p(p(p(p(p(i))))))))))&a(p(p(p(p(i)))))&n()){}if(t()&n()){}if(f()&n()){}if(a(p(p(p(p(p(p(p(p(p(i))))))))))&a(p(p(p(p(p(p(p(i))))))))&n()){}if(a(p(p(p(p(p(p(p(p(p(i))))))))))&a(p(p(p(p(p(p(p(p(i)))))))))&n()){}if(f()&n()){}if(t()&n()){}}

Try it online!
There is a lot of code here (so much that I actually had to add the -w flag to prevent exceeded debug output), so I will split the explanation into parts. Simply put, we are printing every character using brute force, since I originally thought that it would cost less bytes, but looking back it might actually have been a lot easier to use a logical method.
Explanation
The first function a(i) takes in a digit i, and outputs that digit. We increment i 48 times, since the ASCII values for numbers are offset by +48, and then use the fact that printf(&i) acts the same as putchar(i) to print to STDOUT.
a(i)
{
if(++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&printf(&i)){}
}

The second function n(i) prints a newline character \n. Later when we call this function, we won't actually input any parameter (it will be called by n()), which causes i to default to 0. Using this fact we essentially do the same thing as in the first function, except we increment by 10, since that is the ASCII value for \n.
n(i)
{
if(++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&printf(&i)){}
}

The third function f(i) prints Fizz. There is not much to say, except we use the same strategy as in the first function, only we need to repeat this 4 times. It also helps that each ASCII value in Fizz is greater than the last, allowing us to simply increment i throughout the whole function, instead of using an extra character like - to decrement.
f(i)
{
if(++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&printf(&i)){}
if(++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&printf(&i)){}
if(++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&printf(&i)&printf(&i)){}
}

The fourth function t(i) essentially does the same thing as f(i), only it prints Buzz instead of Fizz.
t(i)
{
if(++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&printf(&i)){}
if(++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&++i&printf(&i)){}
if(++i&++i&++i&++i&++i&printf(&i)&printf(&i)){}
}

The fifth function p(i) along with a helper function r() returns i+1. I know that my function seems overly complicated for such a task, so let me explain. For some reason on TIO, simply using a function like p(i){if(++i){}} exploiting the return hack does not work. I suspect this is because the compiler optimizes the code by actually deleting it. Therefore the extra code you see is an attempt to trick the compiler into not deleting it.
r(){}
p(i)
{
if(r()&&printf(&i)){}
if(++i){}
}

The final function main() will take all of the functions mentioned previously and combine them to print the FizzBuzz pattern for all 100 lines. Most of it is self-explanatory, except for how to print a number. A number is simply a concatenation of a bunch of digits, so we can use our function a(i) to print it. So if we want to print 12, we can do something like if(a(1)&a(2)){}. The problem is we don't want to use extra characters like 1 or 2, which we can solve by repeatdly using the p(i) function. Since p(i) equals i+1, we know that p(p(...i...)), would equal i plus a constant, which depends on how many p()s we are nesting. So if we want to print 12, we can do if(a(p(i))&a(p(p(i)))){}. The i variable here is declared as a main parameter, which defaults to 0.
main(i)
{
if(a(p(i))&n()){}
if(a(p(p(i)))&n()){}
if(f()&n()){}
if(a(p(p(p(p(i)))))&n()){}
if(t()&n()){}
if(f()&n()){}
if(a(p(p(p(p(p(p(p(i))))))))&n()){}
if(a(p(p(p(p(p(p(p(p(i)))))))))&n()){}
if(f()&n()){}
if(t()&n()){}
if(a(p(i))&a(p(i))&n()){}
if(f()&n()){}
if(a(p(i))&a(p(p(p(i))))&n()){}
if(a(p(i))&a(p(p(p(p(i)))))&n()){}
if(f()&t()&n()){}
if(a(p(i))&a(p(p(p(p(p(p(i)))))))&n()){}
if(a(p(i))&a(p(p(p(p(p(p(p(i))))))))&n()){}
if(f()&n()){}
if(a(p(i))&a(p(p(p(p(p(p(p(p(p(i))))))))))&n()){}
if(t()&n()){}
if(f()&n()){}
if(a(p(p(i)))&a(p(p(i)))&n()){}
if(a(p(p(i)))&a(p(p(p(i))))&n()){}
if(f()&n()){}
if(t()&n()){}
if(a(p(p(i)))&a(p(p(p(p(p(p(i)))))))&n()){}
if(f()&n()){}
if(a(p(p(i)))&a(p(p(p(p(p(p(p(p(i)))))))))&n()){}
if(a(p(p(i)))&a(p(p(p(p(p(p(p(p(p(i))))))))))&n()){}
if(f()&t()&n()){}
if(a(p(p(p(i))))&a(p(i))&n()){}
if(a(p(p(p(i))))&a(p(p(i)))&n()){}
if(f()&n()){}
if(a(p(p(p(i))))&a(p(p(p(p(i)))))&n()){}
if(t()&n()){}
if(f()&n()){}
if(a(p(p(p(i))))&a(p(p(p(p(p(p(p(i))))))))&n()){}
if(a(p(p(p(i))))&a(p(p(p(p(p(p(p(p(i)))))))))&n()){}
if(f()&n()){}
if(t()&n()){}
if(a(p(p(p(p(i)))))&a(p(i))&n()){}
if(f()&n()){}
if(a(p(p(p(p(i)))))&a(p(p(p((i)))))&n()){}
if(a(p(p(p(p(i)))))&a(p(p(p(p((i))))))&n()){}
if(f()&t()&n()){}
if(a(p(p(p(p(i)))))&a(p(p(p(p(p(p((i))))))))&n()){}
if(a(p(p(p(p(i)))))&a(p(p(p(p(p(p(p((i)))))))))&n()){}
if(f()&n()){}
if(a(p(p(p(p(i)))))&a(p(p(p(p(p(p(p(p(p((i)))))))))))&n()){}
if(t()&n()){}
if(f()&n()){}
if(a(p(p(p(p(p(i))))))&a(p(p(i)))&n()){}
if(a(p(p(p(p(p(i))))))&a(p(p(p(i))))&n()){}
if(f()&n()){}
if(t()&n()){}
if(a(p(p(p(p(p(i))))))&a(p(p(p(p(p(p(i)))))))&n()){}
if(f()&n()){}
if(a(p(p(p(p(p(i))))))&a(p(p(p(p(p(p(p(p(i)))))))))&n()){}
if(a(p(p(p(p(p(i))))))&a(p(p(p(p(p(p(p(p(p(i))))))))))&n()){}
if(f()&t()&n()){}
if(a(p(p(p(p(p(p(i)))))))&a(p(i))&n()){}
if(a(p(p(p(p(p(p(i)))))))&a(p(p(i)))&n()){}
if(f()&n()){}
if(a(p(p(p(p(p(p(i)))))))&a(p(p(p(p(i)))))&n()){}
if(t()&n()){}
if(f()&n()){}
if(a(p(p(p(p(p(p(i)))))))&a(p(p(p(p(p(p(p(i))))))))&n()){}
if(a(p(p(p(p(p(p(i)))))))&a(p(p(p(p(p(p(p(p(i)))))))))&n()){}
if(f()&n()){}
if(t()&n()){}
if(a(p(p(p(p(p(p(p(i))))))))&a(p(i))&n()){}
if(f()&n()){}
if(a(p(p(p(p(p(p(p(i))))))))&a(p(p(p(i))))&n()){}
if(a(p(p(p(p(p(p(p(i))))))))&a(p(p(p(p(i)))))&n()){}
if(f()&t()&n()){}
if(a(p(p(p(p(p(p(p(i))))))))&a(p(p(p(p(p(p(i)))))))&n()){}
if(a(p(p(p(p(p(p(p(i))))))))&a(p(p(p(p(p(p(p(i))))))))&n()){}
if(f()&n()){}
if(a(p(p(p(p(p(p(p(i))))))))&a(p(p(p(p(p(p(p(p(p(i))))))))))&n()){}
if(t()&n()){}
if(f()&n()){}
if(a(p(p(p(p(p(p(p(p(i)))))))))&a(p(p(i)))&n()){}
if(a(p(p(p(p(p(p(p(p(i)))))))))&a(p(p(p(i))))&n()){}
if(f()&n()){}
if(t()&n()){}
if(a(p(p(p(p(p(p(p(p(i)))))))))&a(p(p(p(p(p(p(i)))))))&n()){}
if(f()&n()){}
if(a(p(p(p(p(p(p(p(p(i)))))))))&a(p(p(p(p(p(p(p(p(i)))))))))&n()){}
if(a(p(p(p(p(p(p(p(p(i)))))))))&a(p(p(p(p(p(p(p(p(p(i))))))))))&n()){}
if(f()&t()&n()){}
if(a(p(p(p(p(p(p(p(p(p(i))))))))))&a(p(i))&n()){}
if(a(p(p(p(p(p(p(p(p(p(i))))))))))&a(p(p(i)))&n()){}
if(f()&n()){}
if(a(p(p(p(p(p(p(p(p(p(i))))))))))&a(p(p(p(p(i)))))&n()){}
if(t()&n()){}
if(f()&n()){}
if(a(p(p(p(p(p(p(p(p(p(i))))))))))&a(p(p(p(p(p(p(p(i))))))))&n()){}
if(a(p(p(p(p(p(p(p(p(p(i))))))))))&a(p(p(p(p(p(p(p(p(i)))))))))&n()){}
if(f()&n()){}
if(t()&n()){}
}

FYI, you can achieve a score of 10 by doing the same as this and not using - (since there's no limit on source code length).

I've seen that method somewhere before. I think why I chose this method was because it was more conventional (and impressive). Although, it was definitely a bother to code out.

GS2, 1 unique byte
Another 1-byte solution. Unlike the other ones though, this one can actually be written down :P.
f

Try it online!

Wolfram Language (Mathematica), 22 unique bytes
Do[Echo[If[Mod[d,1+1+1+1+1+1+1+1+1+1+1+1+1+1+1]<1,FizzBuzz,If[Mod[d,1+1+1]<1,Fizz,If[Mod[d,1+1+1+1+1]<1,Buzz,d]]]],{d,1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1}]

Try it online!

yes, I know... golfing just started!

@KevinCruijssen d is ok. it's in "Mod"

Python 2, 7 unique bytes
This uses this answer to the "least amount of unique bytes for Turing completeness". I then encoded this well-golfed Python 2 FizzBuzz answer and I got the program that follows.
c="%c%%c%%%%c%%%%%%%%c"
ex=c==c
ee=c==""
exec"e=%x%%x"%ex%ex
exec"e%%%%%%%%=%x%%x%%%%x"%ee%ex%ee
exec"ee=%x%%x"%e%ee
exec"ee%%%%=%x%%x"%ex%e
exec"e=%x%%x"%ee%e
exec"ec=ex%cex"%e
exec"xe=ec%cec"%e
exec"xx=xe%cxe"%e
exec"xc=xx%cxx"%e
exec"ce=xc%cxc"%e
exec"cc=ce%cce"%e
exec"xee=ce%cec"%e
exec"cee=ce%cex%%cxe"%e%e
exec"exe=ce%cex%%cec%%%%cxe"%e%e%e
exec"xxe=ce%cxx"%e
exec"cxe=ce%cex%%cxx"%e%e
exec"ece=ce%cec%%cxx"%e%e
exec"cce=ce%cex%%cxe%%%%cxx"%e%e%e
exec"eex=ce%cec%%cxe%%%%cxx"%e%e%e
exec"xex=ce%cex%%cec%%%%cxe%%%%%%%%cxx"%e%e%e%e
exec"cex=ce%cxc"%e
exec"exx=ce%cex%%cxc"%e%e
exec"xxx=ce%cec%%cxc"%e%e
exec"cxx=ce%cex%%cec%%%%cxc"%e%e%e
exec"ecx=ce%cxe%%cxc"%e%e
exec"xcx=ce%cex%%cxe%%%%cxc"%e%e%e
exec"ccx=ce%cex%%cec%%%%cxx%%%%%%%%cxc"%e%e%e%e
exec"eec=ce%cex%%cxe%%%%cxx%%%%%%%%cxc"%e%e%e%e
exec"xec=cc%cec"%e
exec"cec=cc%cec%%cxe"%e%e
exec"exc=cc%cex%%cce"%e%e
exec"xxc=cc%cex%%cec%%%%cce"%e%e%e
exec"cxc=cc%cex%%cxe%%%%cce"%e%e%e
exec"ecc=cc%cec%%cxe%%%%cce"%e%e%e
exec"xcc=cc%cxx%%cce"%e%e
exec"ccc=cc%cex%%cxx%%%%cce"%e%e%e
exec"eeee=cc%cec%%cxx%%%%cce"%e%e%e
exec"xeee=cc%cxe%%cxx%%%%cce"%e%e%e
exec"ceee=cc%cec%%cxe%%%%cxx%%%%%%%%cce"%e%e%e%e
exec"exee=cc%cex%%cec%%%%cxe%%%%%%%%cxx%%%%%%%%%%%%%%%%cce"%e%e%e%e%e
exec"xxee=cc%cxc%%cce"%e%e
exec"cxee=cc%cec%%cxc%%%%cce"%e%e%e
exec"ecee=cc%cex%%cec%%%%cxc%%%%%%%%cce"%e%e%e%e
exec"xcee=cc%cxe%%cxc%%%%cce"%e%e%e
exec"ccee=cc%cex%%cxe%%%%cxc%%%%%%%%cce"%e%e%e%e
exec"eexe=cc%cec%%cxe%%%%cxc%%%%%%%%cce"%e%e%e%e
exec"xexe=cc%cxx%%cxc%%%%cce"%e%e%e
exec"cexe=cc%cec%%cxx%%%%cxc%%%%%%%%cce"%e%e%e%e
exec"exxe=cc%cec%%cxe%%%%cxx%%%%%%%%cxc%%%%%%%%%%%%%%%%cce"%e%e%e%e%e
exec"""x=""
"""
exec"x%c=c%%cxc%%xexe%%cxc%%xxc"%e
exec"x%c=c%%xee%%xee%%eex%%eeee"%e
exec"x%c=c%%exee%%ccc%%ceee%%xxe"%e
exec"x%c=c%%xxc%%xcc%%cxee%%xxe"%e
exec"x%c=c%%cxc%%eexe%%exc%%xeee"%e
exec"x%c=c%%xxe%%xxc%%cxe%%cxe"%e
exec"x%c=c%%ecc%%exee%%cxee%%ce"%e
exec"x%c=c%%xxc%%ce%%ccc%%ceee"%e
exec"x%c=c%%ce%%xxc%%xexe%%eex"%e
exec"x%c=c%%ecee%%xxee%%xeee%%ccc"%e
exec"x%c=c%%xcee%%xxe%%cxe%%cxe"%e
cx="""ccc
eec
cex
ccx
cxc
xexe
cxc
xxc
xee
xxee
cxee
ccc
ceee
xcee
ce
ccc
cee
cxx
xex
xxx
ece
exe
cec
ccc
cexe
cexe
exe
e
ccc
cee
xcx
xex
ecx
ece
exe
xec
ccee
cexe
cexe
exe
exee
cxee
cce
exxe
ccc
ccx
ccc
e
eec
exx
ccx
xee
ece
exx
cex
cex"""
exec"exec%cx"%ce

Try it online!

Lenguage, 1 distinct character
Now you see, the problem is that my program is so large that I kinda can't find a way to represent the byte count other than binary. So, uh, here is what I calculated my score as, represented in base 2:
[encoded data, 27810 characters]

BF used for conversion, but place a [] at the start of the program -- my browser is already lagging enough without me trying to open the large link again.
In other words, take any random character of your choosing and repeat it n times, where n is the binary number above converted to base 10. I may have accidentally miscalculated the byte count, but I know it's only 1 distinct character.

Maybe I'm wrong, but I thought a brainfuck program converted to Lenguage couldn't start with a +, since it's 000. At the Synthax section of the Lenguage esolangs page it states: "First, the length of the program (in implementation-dependent characters) is calculated. Then, said length is converted to binary, left-padded by zeroes to a multiple of 3, and then evaluated like Binaryfuck." So after you've converted the gigantic integer to binary and left-padded it with zeroes to a multiple of 3, it won't have those leading +/000 anymore..

@KevinCruijssen you're probably right. I couldn't find a proper generator so I tried to make my own, so it's probably flawed.


text:
Minimal Rotate-Right-Double numbers in base n
Task
For a given base \$n \ge 3\$, find the smallest positive integer \$m\$, when written in base \$n\$ and rotated right once, equals \$2m\$. The base-\$n\$ representation of \$m\$ cannot have leading zeroes.
The corresponding OEIS sequence is A087502, and its base-\$n\$ representation is A158877 (this one stops at \$n=11\$ because the answer for \$n=12\$ has a digit higher than 9). The OEIS page has some information about how to calculate the number:

a(n) is the smallest integer of the form x*(n^d-1)/(2n-1) for integer x and d, where 1 < x < n and d > 1. x is the last digit and d is the number of digits of a(n) in base n.
Maple code:
A087502 := proc(n) local d, a; d := 1; a := n; while a>=n do
  d := d+1; a := denom((2^d-1)/(2*n-1)); od;
return(max(2, a)*(n^d-1)/(2*n-1)); end proc;

You may output the result as a single integer or a list of base-10 or base-\$n\$ digits.
Examples and test cases
For \$ n = 3 \$, the answer is \$ m = 32 \$. \$ n = 4 \$ should give \$ m = 18 \$.
$$
m = 32_{10} = 1012_3 \rightarrow 2m = 64_{10} = 2101_3 \\
m = 18_{10} = 102_4 \rightarrow 2m = 36_{10} = 210_4
$$
n = 3
m = 32
m (base n) = 1012 or [1,0,1,2]
------------------------------
n = 4
m = 18
m (base n) = 102 or [1,0,2]
------------------------------
n = 10
m = 105263157894736842
m (base n) = 105263157894736842 or [1,0,5,2,6,3,1,5,7,8,9,4,7,3,6,8,4,2]
------------------------------
n = 33
m = 237184
m (base n) = 6jqd or [6,19,26,13]
------------------------------
n = 72
m = 340355112965862493
m (base n) = [6,39,19,45,58,65,32,52,26,13]

More I/O examples can be found on OEIS.
Scoring and winning criterion
Standard code-golf rules apply. Shortest solution in bytes wins.

Python 2, 77 76 70 bytes
f=lambda n,m=1,i=1:i<m and f(n,m,i*n)or(m+m%n*i)/n-m*2and f(n,m+1)or m

Try it online!
Input: base n
Output: The smallest integer m satisfies the requirement.
Saved 6 bytes thanks to @Bubbler!
This is a brute-force search that starts at m = 1 and works its way up. Will run out of recursion limit if the actual solution is too large.
For each m, i keeps track of the current power of n, which is increased until i>m.

JavaScript (ES7),  90 88 86  85 bytes
A recursive port of the Maple function.
n=>(d=1,x=n,g=(a=2**++d-1,b=q=n+~-n)=>b?g(b,a%b):(x=q/a)<n?(x+!~-x)*(n**d-1)/q:g())()

Try it online! (\$a(3)\$ to \$a(9)\$)
Or, for +5 bytes, a BigInt version:
n=>(d=1n,x=n,g=(a=2n**++d-1n,b=q=n+~-n)=>b?g(b,a%b):(x=q/a)<n?(~-x?x:2n)*~-(n**d)/q:g())()

Try it online! (\$a(3)\$ to \$a(50)\$)

Would it help if d has a known maximum value? (Spoiler: it is $2n-2$ since $ d \le \varphi(2n-1) \le 2n-2 $.)

@Bubbler Well, it may allow some exec"my_loop;"*2*n in Python, but I don't think I can take advantage of it in JS.

05AB1E, 15 11 bytes
∞.ΔxsIвÁIβQ

-4 thanks to @Grimmy
Try it online!
explanation:
∞ get all positive numbers
 .Δ find the first number for which:
   xs the number doubled and itself (e.g. 64, 32)
     Iв convert to base input (e.g. [1, 0, 1, 2])
       Á rotate right (e.g. [2, 1, 0, 1])
        Iβ convert back from base input to a number (e.g. 64)
          Q compare to the number doubled (that's in the stack from xs)

Rotate right is a built-in. ¤s¨sš => Á

Japt, 11 bytes
_Ñ¶ZsU'é}a1

Try it
_Ñ¶ZsU'é}a1     :Implicit input of integer U
_               :Function taking an integer Z as an argument
 Ñ              :  Multiply by 2
  ¶             :  Check for equality with
   ZsU          :  Convert Z to a string in base U
      'é        :    Rotate right (string is converted back to decimal afterwards)
        }       :End function
         a1     :Starting with 1, return the first integer that returns true when passed through that function

The ' trick prevents the é method from being applied to U (sidenote: there is no é method for numbers in Japt), instead applying it to the base-U string, and saves 2 bytes over the alternative ZsU,_éÃ.

Python 2, 78 bytes
Simple direct solution. Increments x and d until we obtain the appropriate answer.
n=input()
j=x=d=2;k=2*n-1
while j%k:j=x*n**d-x;x=[2,x+1][x<n];d+=x<3
print j/k

Try it online!

Bash + bc, 103 bytes
for((m=1;2*m!=p;));do((m++));t=$(bc<<<"obase=$1;$m");p=$(bc<<<"ibase=$1;${t: -1}${t::-1}");done;echo $m

Try it online!

Pyth, 30 bytes
Fdr2Kt*2QVr2hQI!%J*Nt^QdK/JK.q

Try it online!
Uses a similar approach to my Python 2 answer. Note: I also used the upper bound of 2n-2 on d that @Bubbler mentioned in a comment.
(Q)

Implicitly initialize Q to be the input
Kt*2Q

Initialize K to be 2Q-1
Fdr2K

For d in range(2, 2Q-1):
Vr2hQ

- For N in range(2, Q+1):
J*Nt^Qd

--> Set J to N * (Q^d - 1)
I!%JK/JK.q

--> If J%K==0, print J/K and exit the program

Charcoal, 41 bytes
Ｎθ≔⊖⊗θηＩ÷⌊ΦＥ×θη∨‹ι⊗θ∨‹﹪ιθ²×﹪ιθ⊖Ｘθ÷ιθ¬﹪ιηη

Try it online! Link is to verbose version of code. Uses the OEIS quote plus the additional information provided by @Bubbler in a comment whereby d < 2n-1. Explanation:
Ｎθ

Input n.
≔⊖⊗θη

Calculate 2n-1.
Ｅ×θη

Loop nd + x from 0 to n(2n-1).
∨‹ι⊗θ

Ensure d > 1 by returning 1 if it is not, which is never divisible by 2n-1.
∨‹﹪ιθ²

Ensure x > 1 in the same way.
×﹪ιθ⊖Ｘθ÷ιθ

Calculate x(nᵈ-1).
Φ...¬﹪ιη

Keep only those values that are multiples of 2n-1.
Ｉ÷⌊...η

Divide the minimum of those values by 2n-1 and output the result.

Scala, 80 bytes
n=>Stream.iterate(1)(n*_)map(p=>p to p*n-1 find(x=>2*x==x%n*p+x/n))find(_!=None)

Try it online!
Takes an integer n, returns an Option[Option[Int]] (really a Some[Some[Int]]).


text:
Make a Rectangle from a Triangle
You can depict a triangular number, T(N), by writing one 1 on a line, then two 2's on the line below, then three 3's on the line below that, and so on until N N's. You end up with a triangle of T(N) numbers, hence the name.
For example, T(1) through T(5):
1

1
22

1
22
333

1
22
333
4444

1
22
333
4444
55555

To keep things nicely formatted we'll use the last digit of the number for N > 9, so T(11) would be:
1
22
333
4444
55555
666666
7777777
88888888
999999999
0000000000
11111111111

Now pretend like each row of digits in one of these triangles is a 1-by-something polyomino tile that can be moved and rotated. Call that a row-tile.
For all triangles beyond T(2) it is possible to rearrange its row-tiles into a W×H rectangle where W > 1 and H > 1. This is because there are no prime Triangular numbers above N > 2. So, for N > 2, we can make a rectangle from a triangle!
(We're ignoring rectangles with a dimension of 1 on one side since those would be trivial by putting every row on one line.)
Here is a possible rectangle arrangement for each of T(3) through T(11). Notice how the pattern could be continued indefinitely since every odd N (except 3) reuses the layout of N - 1.
N = 3
333
221

N = 4
44441
33322

N = 5
55555
44441
33322

N = 6
6666661
5555522
4444333

N = 7
7777777
6666661
5555522
4444333

N = 8
888888881
777777722
666666333
555554444

N = 9
999999999
888888881
777777722
666666333
555554444

N = 10
00000000001
99999999922
88888888333
77777774444
66666655555

N = 11
11111111111
00000000001
99999999922
88888888333
77777774444
66666655555

However, there are plenty of other ways one could arrange the row-tiles into a rectangle, perhaps with different dimensions or by rotating some row-tiles vertically. For example, these are also perfectly valid:
N = 3
13
23
23

N = 4
33312
44442

N = 5
543
543
543
541
522

N = 7
77777776666661
55555444433322

N = 8
888888881223
666666555553
444477777773

N = 11
50000000000
52266666634
57777777134
58888888834
59999999994
11111111111

Challenge
Your task in this challenge is to take in a positive integer N > 2 and output a rectangle made from the row-tiles of the triangles of T(N), as demonstrated above.
As shown above, remember that:

The area of the rectangle will be T(N).

The width and height of the rectangle must both be greater than 1.

Row-tiles can be rotated horizontally or vertically.

Every row-tile must be depicted using the last digit of the number it represents.

Every row-tile must be fully intact and within the bounds of the rectangle.

The output can be a string, 2D array, or matrix, but the numbers must be just digits from 0 through 9.
The output does not need to be deterministic. It's ok if multiple runs produce multiple, valid rectangles.
The shortest code in bytes wins!

inspired by Gauss?

@J42161217 Nah, was just playing with Triangular numbers.

Python 2, 59 bytes
n=input()
c=~n%2
while c<n:print`n%10`*n+`c%10`*c;n-=1;c+=1

Try it online!
Prints like:
55555
44441
33322

It looks kind-of redundant to update n-=1;c+=1 where sum n+c remains unchanged. I feel like there's a better way, but I haven't seen it so far. Bounty is up for grabs!

60 bytes
n=input()
b=a=n/2
while n-b:b+=1;print`a%10`*a+`b%10`*b;a-=1

Try it online!
Prints like:
22333
14444
55555

Based on ideas by @newbie.

APL (Dyalog), 49 47 34 38 35 bytes
3 bytes saved thanks to @Bubbler!
{10|(⌈⍵÷2)↑↑,/⍴⍨¨⍉↑((⍳⍵)-2|⍵)(⌽⍳⍵)}

Try it online!
                  ⍉↑                    ⍝ concat each pair in
                     ((⍳⍵)     )(⌽⍳⍵)   ⍝ 1..n and n..1 (into 2×n matrix)
                          -2|⍵           ⍝ concats n-1..0 if n is odd
               ⍴⍨¨                       ⍝ repeat each item *itself* times
            ↑,/                          ⍝ flatten
     (⌈⍵÷2)↑                             ⍝ take first n/2 rows
10|                                      ⍝ for each item, take the last digit

0 7      7 7 7 7 7 7 7      7 7 7 7 7 7 7
1 6  =>  1 6 6 6 6 6 6  =>  1 6 6 6 6 6 6
2 5      2 2 5 5 5 5 5      2 2 5 5 5 5 5
3 4      3 3 3 4 4 4 4      3 3 3 4 4 4 4
4 3      4 4 4 4 3 3 3
5 2      5 5 5 5 5 2 2
6 1      6 6 6 6 6 6 1

Why not simply 10|?

05AB1E, 16 15 14 bytes
Ýεθy×}2äí`RøJ»

Try it online!

JavaScript (ES8),  72 71  68 bytes
Returns a string.
n=>(g=k=>k<n?(h=k=>''.padEnd(k,k%10))(k)+h(n--)+`
`+g(k+1):'')(~n&1)

Try it online!

Charcoal, 24 bytes
ＮθＥ…÷θ²θ⭆⟦⊕ι⁻｜θ¹⊕ι⟧⭆λ﹪λχ

Try it online! Link is to verbose version of code. Explanation:
Ｎθ

Input N.
Ｅ…÷θ²θ

Loop rows from N/2 to N. (Due to the increments in the code below, N/2 is excluded and N is included. I could have put the increments here for the same byte count.)
⭆⟦⊕ι⁻｜θ¹⊕ι⟧

Each row contains two row-tiles, one for the row and one for N|1 minus the row. (If N is odd then this last row-tile is empty.)
⭆λ﹪λχ

Each row-tile consists of copies of its last digit.

Java 11, 89 bytes
n->{for(int c=~n&1;c<n;)System.out.println((n%10+"").repeat(n--)+(c%10+"").repeat(c++));}

Port of @xnor's Python answer, so make sure to upvote him!!
Try it online.
Explanation:
n->{                            // Method with integer parameter and no return-type
  for(int c=~n&1;               //  Temp-integer `c`, starting at 0 if the input is odd;
                                //  or 1 if even
      c<n;)                     //  Loop as long as this `c` is smaller than the input `n`:
    System.out.println(         //   Print with trailing newline:
      (n%10                     //     The last digit of `n`
           +"")                 //     converted to String
               .repeat(n        //     repeated `n` amount of times
                        --)     //     After which `n` is decreased by 1 with `n--`
      +                         //    Appended with:
       (c%10                    //     The last digit of `c`
            +"")                //     converted to String
                .repeat(c       //     repeated `c` amount of times
                         ++));} //     After which `c` is increased by 1 with `c++`

J, 41 33 bytes
-8 bytes thanks to Bubbler!
10(|-:@##"1~@{.],.|.)2&|@>:}.i.,]

Try it online!
K (oK), 41 38 32 bytes
-6 bytes thanks to ngn!
{(x%2)#10!{x}#'(a-2!x),'|a:1+!x}

Try it online!

J, 33 bytes.

@Bubbler Thank you for your nice code. I was going to propose you to post it for yourself, but I saw you have posted an even better solution.

{(x-2!#x),'|x}1+!x -> (a-2!x),'|a:1+!x

{,/x#'10!x} -> 10!{x}#

@ngn Thank you! {x} is so obvious, when you showed it (as using a tenp variable). K is a really nice language, I love it!

@ngn In fact I should have remembered the { }# from one of your previous comments

Erlang (escript), 109 bytes
Seems huge in comparison with other answers.
t(A,B)when A<B->"";t(A,B)->[string:copies([X rem 10+48],X)||X<-[A,B]]++"
"++t(A-1,B+1).
t(N)->t(N,1-N rem 2).

Try it online!

Perl 5 -n, 43 bytes
@a=map$_%10x$_,$_&1^1..$_;say$_,pop@a for@a

Try it online!

this solution breaks large polyominos across multiple rows - (I found out when inputing '32' on the online version)

That's not possible because the entire polyomino is stored as a single unit.  I suspect that the fact that the polyomino is being represented only by its last digit may be causing confusion.  For example, you may be seeing the entries for 12 and 22 near each other, but they are distinct polyominos.

yes - that is the case. Sorry for the noise.

C (gcc), 85 82 bytes
Saved 3 bytes thanks to newbie!!!
i;c;f(n){for(c=-n%2;++c<n;--n,puts(""))for(i=0;i<n+c;)putchar((i++<n?n:c)%10+48);}

Try it online!
Port of xnor's Python answer so make sure to upvote him!!!

-3bytes https://tio.run/##HYxBCsIwEEX3OUUIFGaIgVa7ECfFi7gpA9EEHEusq5Czx@jy/cd/7O7MrUViCiBYwisDL06GI1nLXsg5OWyf/Q3GIP5sXEaKXiwT9p0fawaI1nq5yoVxmEY7n5Fqe65RAIv6f2TXaTlR8tPcuwl1UTpAQlJ6y90GMDcxHauq7Qs

@newbie Nice one - thanks! :-)

Ruby, 64 62 bytes
->n{c=1&~n;n,c=n-1,-~c,puts("#{n%10}"*n+"#{c%10}"*c)while c<n}

Try it online!
Based on @xnor's Python answer, thanks!

J, 30 29 bytes
10(|-:@#$]#~@,"0|.)2&|0&,1+i.

Try it online!
J's reshape $ is so weird that it works in place of take {. when the left is positive singleton (regardless of what comes on the right).

J, 30 bytes
10(|-:@#{.]#~@,"0|.)2&|0&,1+i.

Try it online!
Yet another case of repeat-bind (dyadic &) winning over other approaches.
How it works
10(|-:@#{.]#~@,"0|.)2&|0&,1+i.   NB. input=n
                          1+i.   NB. 1..n
                    2&|0&,   NB. prepend 0, but only if n is odd
  (       ]    "0|.)   NB. for each pair (x,y) of the above and above reversed,
           #~@,        NB. concatenate x copies of x and y copies of y
    -:@#{.   NB. take half the rows
10 |         NB. modulo 10 to all elements of the array

Great solution and explanation!

APL (Dyalog Unicode), 42 bytes
10|{⍵=1:1 1⍴1⋄2|⍵:⍵⍪∇⍵-1⋄(⍳∘≢,1+⊢,⊢/)∇⍵-1}

Try it online!
A fresh approach using recursion, though not very short.
How it works
10|{⍵=1:1 1⍴1⋄2|⍵:⍵⍪∇⍵-1⋄(⍳∘≢,1+⊢,⊢/)∇⍵-1}

           ⍝ Input: n
⍵=1:1 1⍴1  ⍝ Base case: If n=1, give a 1x1 matrix of 1

2|⍵:⍵⍪∇⍵-1  ⍝ For odd n, prepend n copies of n on the top

(⍳∘≢,1+⊢,⊢/)∇⍵-1  ⍝ For even n...
       ⊢,⊢/       ⍝ append its own last column to its right
     1+           ⍝ add 1 to all elements
 ⍳∘≢,             ⍝ prepend a column of 1..(number of rows) to its left

10|{...}  ⍝ Apply modulo 10 to all elements

Jelly, 13 bytes
_Ḷ€ZŒHṚ;"¥/%⁵

A monadic Link accepting an integer which yields a list of lists of integers in \$[0,9]\$.
Try it online! (footer just reformats the output list of lists)
I feel there may be shorter.
How?
_Ḷ€ZŒHṚ;"¥/%⁵ - Link: integer, n
  €           - for each (i) in (implicit range [1..n])
 Ḷ            -   lowered range (i) -> [0..i-1]
_             - (n) subtract (vectorised across that) -> [[n],[n,n-1],...,[n,n-1,...,1]]
   Z          - transpose -> [[n]*n,[n-1]*(n-1),...,[1]]
    ŒH        - split into half (first half longer if n is odd)
          /   - reduce (this list of two lists) by:
         ¥    -   last two links as a dyad:
      Ṛ       -     reverse (the first half)
        "     -     zip together applying:
       ;      -       concatenation
            ⁵ - literal ten
           %  - modulo

An alternative first three bytes is rRṚ

Husk, 16 bytes
←½Ṡz+↔↓¬%2¹m´Rŀ→

Try it online!

Wolfram Language (Mathematica), 106 bytes
(r=#+(y=Mod[#+1,2]);""<>{z@#,z[r-#]}&/@Range@r)[[-⌈r/2⌉;;-y-1]]&
z@x_:=""<>ToString/@Table[x~Mod~10,x]

Try it online!

Icon, 76 bytes
procedure f(n)
c:=seq(1-n%2)&write(repl(n%10,n)||repl(c%10,c))&(n-:=1)=c
end

Try it online!
Inspired by xnor's Python solution - don't forget to upvote it!