# Print all ASCII alphanumeric characters without using them

## Challenge

Print the following characters:

abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890


The catch is that you may not use any one of them in your code.

You may print them in arbitrary order, with or without a leading or trailing newline, but you may not print any other characters.

## Rules

• You may not use any characters from the set mentioned above
• You may use any other characters
• No cheating
• Standard loopholes banned
• This is , shortest answer wins.

## Clarifications

• If your language uses a different charset, you may not use codepoints in that charset that correspond to alphanumeric characters.
• Returning a string from a function is considered a valid form of output.
• You may return a char array.
• This is somewhat ambiguous. If you mean output those raw bytes without those bytes in your code, then you should specify that you can't use the codepoints of these characters, even if they map to something else in your language's codepage. – FlipTack Jan 5 '17 at 19:57
• So this means that I cannot use any letters or numbers in my source code. Well, that pretty much takes out any non-esoteric languages. – R. Kap Jan 5 '17 at 20:04
• What if the language is just raw bytes (as opcodes) that don't have a representation? Am I free to use any characters? – FlipTack Jan 5 '17 at 22:03
• @briantist it's fine if they're internally represented by ints, but the characters themselves have to be printed. – anna328p Jan 5 '17 at 23:15
• @R.Kap Javascript could work, provided you don't think of it as eso – Destructible Lemon Jan 5 '17 at 23:32

# MarioLANG, 255 233 199 bytes

+
+
+
+
+
+
+
+
)
><
+"
+
+(
+(
+(
+(
++
+)
)+
++
++
++
+)
++
++
++
++
++
++
++
+)
()
()
-
[!)+)+)-)--)+++((
=#==============
>((+(+      >((+
"======<    "====<
![-)).).((((![-)).
#===========#=====


Try it online!

The more time Mario spends in the air, the less floor you have to draw and the less characters you use for the solution...

## CJam, 15 bytes

"{[@:/"_:,:^\-


Try it online!

### Explanation

"{[@:/" e# Push this string. Note that these are the characters just above and
e# below the a-z, A-Z and 0-9 ranges, respectively.
_        e# Get a copy of the string.
:,       e# Turn each character into a range, i.e. all characters from the null byte
e# to the the character below the given one. E.g. { is turned into "...xyz".
:^       e# Fold symmetric set difference over the list. Gives us the characters that
e# appear in an odd number of the strings. Those are the letters, the digits
e# as well as , @ and /.
\        e# Pull the other copy of the string on top.
-        e# Remove these characters from the string. That leaves only the alphanumerics.


# 𝔼𝕊𝕄𝕚𝕟, 8 chars / 19 bytes

ᶐ+ᶛ+⩥Ⅹă⬯


Try it here!

ᶐ is the uppercase alphabet, ᶛ is the lowercase alphabet, and ⩥Ⅹă⬯ is range (⩥) from 0 to 10 (Ⅹ, the unicode roman numeral) minus 1, joined by (ă) nothing (⬯).

# Perl 6, 50 bytes

{([~] '/'^..^':')~([~] '@'^..^'[')~[~] ''^..^'{'}


Block that returns the string since I don't think there's any way to print without using alphanumeric characters.

Try it online!

# C (clang), 116 bytes

"Arbitrary order" indeed.

The function _ takes a pointer to target string as an argument. Since that pointer is to int, it is assumed that sizeof(int) == 4.

In the TiO link the result is printed as-is, as well as sorted, for easier ocular inspection.

$;*ö;Å(å,ä){(å+=$)<ä?*ö++=å,Å(å,ä):$;}_(*ä){ö=ä;$='&&&&'^'';Å('?_@','[{\\|');$+=$;Å('/.-,','?>=<');*--ö&=';:';}


Try it online!

# Python 3, 2188 bytes

_=𝓸𝓻𝓭('/')
𝓹𝓻𝓲𝓷𝓽(𝓬𝓱𝓻(𝓸𝓻𝓭('')-_)+𝓬𝓱𝓻(𝓸𝓻𝓭('‘')-_)+𝓬𝓱𝓻(𝓸𝓻𝓭('’')-_)+𝓬𝓱𝓻(𝓸𝓻𝓭('“')-_)+𝓬𝓱𝓻(𝓸𝓻𝓭('”')-_)+𝓬𝓱𝓻(𝓸𝓻𝓭('•')-_)+𝓬𝓱𝓻(𝓸𝓻𝓭('–')-_)+𝓬𝓱𝓻(𝓸𝓻𝓭('—')-_)+𝓬𝓱𝓻(𝓸𝓻𝓭(':')+_)+𝓬𝓱𝓻(𝓸𝓻𝓭(';')+_)+𝓬𝓱𝓻(𝓸𝓻𝓭('<')+_)+𝓬𝓱𝓻(𝓸𝓻𝓭('=')+_)+𝓬𝓱𝓻(𝓸𝓻𝓭('>')+_)+𝓬𝓱𝓻(𝓸𝓻𝓭('?')+_)+𝓬𝓱𝓻(𝓸𝓻𝓭('@')+_)+𝓬𝓱𝓻(𝓸𝓻𝓭('Ÿ')-_)+𝓬𝓱𝓻(𝓸𝓻𝓭(' ')-_)+𝓬𝓱𝓻(𝓸𝓻𝓭('¡')-_)+𝓬𝓱𝓻(𝓸𝓻𝓭('¢')-_)+𝓬𝓱𝓻(𝓸𝓻𝓭('£')-_)+𝓬𝓱𝓻(𝓸𝓻𝓭('¤')-_)+𝓬𝓱𝓻(𝓸𝓻𝓭('¥')-_)+𝓬𝓱𝓻(𝓸𝓻𝓭('¦')-_)+𝓬𝓱𝓻(𝓸𝓻𝓭('§')-_)+𝓬𝓱𝓻(𝓸𝓻𝓭('¨')-_)+𝓬𝓱𝓻(𝓸𝓻𝓭('©')-_)+𝓬𝓱𝓻(𝓸𝓻𝓭('')+_)+𝓬𝓱𝓻(𝓸𝓻𝓭('')+_)+𝓬𝓱𝓻(𝓸𝓻𝓭('')+_)+𝓬𝓱𝓻(𝓸𝓻𝓭('')+_)+𝓬𝓱𝓻(𝓸𝓻𝓭('')+_)+𝓬𝓱𝓻(𝓸𝓻𝓭('')+_)+𝓬𝓱𝓻(𝓸𝓻𝓭('')+_)+𝓬𝓱𝓻(𝓸𝓻𝓭('')+_)+𝓬𝓱𝓻(𝓸𝓻𝓭('')+_)+𝓬𝓱𝓻(𝓸𝓻𝓭('')+_)+𝓬𝓱𝓻(𝓸𝓻𝓭('')+_)+𝓬𝓱𝓻(𝓸𝓻𝓭('')+_)+𝓬𝓱𝓻(𝓸𝓻𝓭('')+_)+𝓬𝓱𝓻(𝓸𝓻𝓭('')+_)+𝓬𝓱𝓻(𝓸𝓻𝓭(' ')+_)+𝓬𝓱𝓻(𝓸𝓻𝓭('!')+_)+𝓬𝓱𝓻(𝓸𝓻𝓭('"')+_)+𝓬𝓱𝓻(𝓸𝓻𝓭('#')+_)+𝓬𝓱𝓻(𝓸𝓻𝓭('$')+_)+𝓬𝓱𝓻(𝓸𝓻𝓭('%')+_)+𝓬𝓱𝓻(𝓸𝓻𝓭('&')+_)+𝓬𝓱𝓻(𝓸𝓻𝓭("'")+_)+𝓬𝓱𝓻(𝓸𝓻𝓭('(')+_)+𝓬𝓱𝓻(𝓸𝓻𝓭(')')+_)+𝓬𝓱𝓻(𝓸𝓻𝓭('*')+_)+𝓬𝓱𝓻(𝓸𝓻𝓭('+')+_)+𝓬𝓱𝓻(𝓸𝓻𝓭('')+_)+𝓬𝓱𝓻(𝓸𝓻𝓭('')+_)+𝓬𝓱𝓻(𝓸𝓻𝓭('')+_)+𝓬𝓱𝓻(𝓸𝓻𝓭('')+_)+𝓬𝓱𝓻(𝓸𝓻𝓭('')+_)+𝓬𝓱𝓻(𝓸𝓻𝓭('')+_)+𝓬𝓱𝓻(𝓸𝓻𝓭('')+_)+𝓬𝓱𝓻(𝓸𝓻𝓭(' ')+_)+𝓬𝓱𝓻(𝓸𝓻𝓭(''' ''')+_)+𝓬𝓱𝓻(𝓸𝓻𝓭('')+_),𝓮𝓷𝓭='')  The code contains some unprintable characters that may not display properly. See the TIO link for the actual code. Try it online! There doesn't seem to be a way to do any sort of looping without access to keywords, so I had to make this monster. Here is an explanation of why this works. ## WSF, 145 bytes Prtty much a direct translation of Dennis's answer. Stack Exchange cannot display the code, so here is a reversible xxd hexdump: 00000000: 2020 2020 2020 2020 2020 2020 2020 2020 00000010: 0a20 200a 2020 200a 2020 2020 2020 2020 . . . 00000020: 2020 2020 200a 2020 2020 2020 2020 200a . . 00000030: 2009 0920 0920 0920 0920 2009 0a09 200a .. . . . ... . 00000040: 2020 2020 0a20 200a 0909 2020 0920 2009 . ... . . 00000050: 0a09 200a 200a 0a20 200a 2020 200a 2020 .. . .. . . 00000060: 2020 200a 2020 2020 2020 0920 0920 0920 . . . . 00000070: 2009 0a09 200a 2020 2020 0a20 200a 2020 ... . . . 00000080: 0909 200a 2020 0909 0920 0920 2009 0a09 .. . ... . ... 00000090: 0a  The interpreter runs it perfectly, producing the following output: 0123456789AaBbCcDdEeFfGgHhIiJjKkLlMmNnOoPpQqRrSsTtUuVvWwXxYyZz  # Stacked, 70 bytes (π²²~~:' '#.-):'='#.'#'#.%+..#:'/'#.(πτ/~_:π²~~+|>)+#:++$∪#/!


Leaves a character array on the top of the stack. This simply uses some character and pi magic. Try it here!

• The link doesn't do anything when I paste your code in there... – Patrick Roberts Jan 7 '17 at 6:51
• @PatrickRoberts yeah, because it's a function. Add put to the end to see the result. – Conor O'Brien Jan 7 '17 at 7:06
• Ah, neat okay. I don't know Stacked obviously ^^; – Patrick Roberts Jan 7 '17 at 7:13

# x86 machine code, 30 bytes

Hexdump:

8b d7 8b f9 2b c9 b1 1a b0 7b 2a c1 aa 2c 20 aa
2c 11 3c 3a 7d 01 aa e2 ef 88 0f 8b fa c3


Represented as if it had Windows 1252 encoding, with control characters using the Control Pictures visualization:

‹×‹ù+É±␚°{*Áª, ª,␑<:}␁ªâïˆ␏‹úÃ


It's 32-bit code (IA-32) using fastcall calling convention - receives the pointer to output in ecx.

Assembly code:

    mov edx, edi;
mov edi, ecx;
sub ecx, ecx;
mov cl, 26;
myloop:
mov al, 'a' + 26;
sub al, cl;
stosb;
sub al, 'a' - 'A';
stosb;
sub al, 'A' - '0';
cmp al, '9'+1;
jge myskip;
stosb;
myskip:
loop myloop;
mov [edi], cl;
mov edi, edx;
ret;


Does 26 iterations (cl = 26 down to 1). At each iteration, calculates and outputs a lowercase letter, an uppercase letter and a number. If the number is out of range, doesn't output it.

The output is written to address in ecx, and null-terminated.

The result:

aA0bB1cC2dD3eE4fF5gG6hH7iI8jJ9kKlLmMnNoOpPqQrRsStTuUvVwWxXyYzZ


• Save-restore of the edi register is usually done by push-pop, but push edi is alphanumeric (W) - so I did it with mov edx, edi and mov edi, edx
• Zeroing a register is usually done by xor, but to avoid an alphanumeric character, I did it with sub; same byte count
• jge is one of only a few conditional jump instructions that are allowed
• I don't quite get it. It's definitely not a DOS code (not a single 66 prefix despite 32-bit instructions). Then what's it? A function? Then what calling convention does it follow? – Ruslan Jan 8 '17 at 16:43
• I've clarified my answer – anatolyg Jan 8 '17 at 16:46

# PHP, 339 bytes (no bitwise string)

Of course not the shortest code, but an alternate method using the Array to string cast.

<?=$_=([]._)[-~-~-~-_],++$_,++$_,++$_,++$_,++$_,++$_,++$_,++$_,++$_,++$_,++$_,++$_,++$_,++$_,++$_,++$_,++$_,++$_,++$_,++$_,++$_,++$_,++$_,++$_,++$_,$_=([]._)[_],++$_,++$_,++$_,++$_,++$_,++$_,++$_,++$_,++$_,++$_,++$_,++$_,++$_,++$_,++$_,++$_,++$_,++$_,++$_,++$_,++$_,++$_,++$_,++$_,++$_,$_=-_,++$_,++$_,++$_,++$_,++$_,++$_,++$_,++$_,++$_;?>


([]._) cast an array to string leading "Array_", then you can take both "A" and "a" and use increment string method.

-~-~-~-_ is giving "3" using multiple minus bitwise not() (maybe this can be improved)

# Pyt, 3 bytes

ɬɳǰ


Explanation:

ɬ           Pushes "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
ɳ          Pushes "0123456789"
ǰ         Joins the strings on the stack with no delimiter
Implicit print


Try it online!

# Stax, 2 bytes

Éè


Run and debug it

This isn't very interesting. Just a built-in constant. I used the packed program encoding to avoid alphanumerics, but normally, this is known as VL.

# Befunge-93, 38 33 bytes

"/*@::":^
,\~+:" "->!#$_::%$\~-:


Try it online!

Uses a different method than this answer. The first line pushes these six numbers: (47, 10 + 32), (64, 26 + 32), (96, 26 + 32), representing the 0-9, A-Z and a-z ranges respectively (lengths are summed with 32 so that they can all be printable non-alphanumeric characters, as well as 32 itself), as well as an extra number that gets consumed shortly after (can be any truthy value). Then, execution jumps to the second line, which loops to print all of these ranges.

# 05AB1E, 34 bytes

žĆт₂·-.$Ð₆₂-£?₂₆₂-->.$Ð₂£?₆ÍÍ.$₂£?  Try it online! žĆт₂·-.$Ð₆₂-£?₂₆₂-->.$Ð₂£?₆ÍÍ.$₂£?  # full program
?                      # output without trailing newline...
£                       # first...
₆                          # 36...
-                        # minus...
₂                         # 26...
£                       # characters of...
žĆ                                  # the 05AB1E code page...
.$# excluding the first... т # 100... - # minus... ₂ # 26... · # times 2... .$                            # characters
?          # output without trailing newline...
£           # first...
₂            # 26...
£           # characters of...
Ð                           # the 05AB1E code page excluding the first 48...
.$# plus... ₂ # 26... - # minus... ₆ # (36... - # minus... ₂ # 26)... > # plus 1... Ð .$              # characters
?  # output without trailing newline...
£   # first...
₂    # 26...
£   # characters of...
Ð             # the 05AB1E code page excluding the first 65...
.$# plus... ₆ # 36... Í # minus 2... Í # minus 2... Ð .$     # characters

• I'm pretty sure D is alphanumeric – anna328p Nov 18 '20 at 1:29

# Jelly, 5 bytes

⁵Ḷ;ØẠ


Try it online!

Outputs 0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz

## How it works

⁵Ḷ;ØẠ - Main link. Takes no arguments
⁵     - 10
Ḷ    - [0, 1, ..., 9]
ØẠ - “ABC...XYZabc...xyz”
;   - Concatenate
Implicitly smash together into a string and print


# Husk, 12 bytes

ṁ?;ȯ→½;□…" ~


Try it online!

This was much more difficult in Husk than I expected - which probably indicates that it isn't an optimal solution!

First creates a list of all printable ASCII characters …" ~, and then ṁaps a function across each of them. The function checks (?) whether each character is alphanumeric (□): if it is, then it returns it as a list; if it isn't it returns an empty list (ȯ→½;), by the complicated method of first creating a one-element list (;), dividing it into two halves (½), and then selecting the second (smaller) half (→).

• @Zgarb @Leo I'd hoped I could use the 'empty list' command (ø) here, but ṁ?;ø□…" ~ doesn't seem to infer, and when I wrap it into a lambda as ṁλ?;ø□⁰)…" ~ it seems to output integers instead of characters... any insight why? – Dominic van Essen Nov 18 '20 at 11:06
• Empty list ø is a constant, and you cannot use a constant in fif . The second one is.. interesting. You may have discovered how to use if2 – Razetime Nov 18 '20 at 12:49

# GW-BASIC, 109 bytes

Hex dump of file:

FE 88 A9 C5 C2 1A 0E BF  11 A2 17 7B DC 10 87 D6
B8 8D A1 F3 E2 F3 A3 18  2B 1C E7 A1 14 7D 8D 3E
15 27 0C 2C 0B 2E F9 F1  C0 7D C4 5D 00 F1 89 C4
82 A5 D8 3C C9 CF 17 F0  D7 89 AF 40 8A AE 9D 03
8B EE A4 91 91 2F 5B DE  D5 AA 18 FE B9 AD C8 3A
5D F7 04 1A F2 1A 7C EC  DF 2C DD 88 D3 94 3B 40
7F EB B9 2C 1A B2 F3 C0  8C D3 95 10 1A


As you can see, none of the forbidden characters (30..39, 41..5A, 61..7A) are used. To run, use LOAD"filename.bas and then RUN.

• Could you include the source, even if that includes the restricted bytes? – MD XF Jun 5 '17 at 3:16

# Charcoal, 10 bytes

βα⪫Ｅ…⁰χＩιω


Try it online!

### Explanation

β            Lowercase alphabet (implicitly printed)
α           Uppercase alphabet (implicitly printed)
⪫        ω Join by ""
Ｅ   Ｉι  Map with cast
…⁰χ     Range from 0 to 10

• βαＦχＩ﹪⊕ιχ works (9 bytes). might change later – ASCII-only Nov 4 '18 at 6:35

# MathGolf, 12 bytes

▄_Äδ☻♥+$♂(Ä└  Try it online! ## Explanation ▄ lowercase alphabet as string _ duplicate TOS Äδ capitalize each letter and push to the stack ☻♥+ push 16+32 = 48$       pop(48), push ord(48) = "0"
♂(     push 10-1 = 9
Ä    start block of length 1
└   push TOS+1 without popping (pushes "1"-"9")


# !@#\$%^&*()_+, 43 bytes

>^^!(!_++^!!@[_^+)!(!_++^!!@{_^+)	(!#_^_)#


Try it online! Outputs ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz9876543210.

Perfect language for the challenge. That long space you see is a tab.

>^^!(!_++^!!@[_^+)


This starts a loop from "A"-1 (">" + 2) and continues printing while incrementing up until "[" ("Z" + 1), printing "A".."Z". Similar for the letters from "a" to "z".

	(!#_^_)#`

The tab has char code 0x09. This is a loop that counts down from 9 to 1, printing them as numbers. Then, 0 is printed, being the last value of the loop iterator.