Code Golf Stack Exchange is a question and answer site for programming puzzle enthusiasts and code golfers. It only takes a minute to sign up.
Sign up to join this community
Challenge: Print the entire printable ASCII charset (not just a range!) in order.
!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~
Rules: read closely
No other characters allowed in the output.
Program/function does not accept input.
Try not to hardcode/embed the output.
This is code golf, shortest answer wins.
+[[>++<<+>-]>]<<<++[<.+>++]
+ changes the initial cell to 1. After this step, we enter the following, nested loop.
[ While the current cell is non-zero:
[ While the current cell (C) is non-zero:
>++ Increment the cell to C's right twice.
<<+ Increment the cell to C's left.
>- Decrement C.
]
> Advance to the cell to C's right.
]
This computes consecutive powers of 2 until the the value 256 = 0 (mod 256) is reached. When the outer loop finishes, the tape is in the following state.
v
001 002 004 008 016 032 064 128 000 000 000
<<<++ retrocedes three cells and increments twice, leaving the tape as follows.
v
001 002 004 008 016 032 066 128 000 000 000
Now we're ready to print the actual output. As a stop condition, we increment the cell above twice each time we print and increment the cell to its left. Since 66 + 95 × 2 = 256 = 0 (mod 256), we stop after printing all 95 printable ASCII characters. We achieve this as follows.
[ While the current cell (C) is non-zero:
< Retrocede to the cell to C's left.
.+ Print its content and increment.
>++ Increment C twice.
]
>. Your implementation runs off the tape to the left, which few interpreters support.
\$\endgroup\$
++++[->++++[->++>++++++<<]<]>>>-[-<.+>]
++++[->++++[->++>++++++<<]<]
The nested loops basically mean you multiply the number of plusses together, so 4 × 4 × 2 = 32 in one cell and 4 × 4 × 6 = 96. Here is the tape after running this:
00 00 32 96
^
>>>- moves the pointer to the fourth cell and decrements it. Now we're done with the setup. 32 is the code for space, the first printable ASCII character. 95 is the number of characters we have to print. Here is the tape now:
00 00 32 95
^
[-<.+>] runs until the current cell (the fourth one) is zero. It decrements the counter and prints the character and increments it for the next time.
->(32:126).map((i)->@"i).fuse
Range from 32-126, loop over it and get the string at the given char code @" and the fuse together (join)
32@"126
Unfortunately this is broken as of the current release but I'm sure you can go back some versions where this works
~
{2`
$`
T01`p`_pThe leading linefeed is significant.
Stage 1: Substitution
~We start by replacing the empty (non-existent) input with a single ~.
Stage 2: Substitution
{2`
$`
The regex of this substitution is still empty, since the ` separates configuration from regex and {2 is therefore just the configuration. The { indicates that the remaining two stages should be run in a loop until they stop changing the output. The 2 indicates that this specific stage has a limit of 2, meaning that only the first two matches of the regex will be replaced. Since the regex is empty, that means we get an empty match in front of the string and an empty match after the first character.
This match is replaced with the prefix $` which refers to everything in front of the match. For the first match, there is nothing in front of it, so this doesn't insert anything, but for the second match, there is the leading character in front of it, which therefore gets duplicated.
Stage 3: Transliteration
T01`p`_p
Here, T activates transliteration mode, and 0 and 1 are limits (where 0 just means "don't set this limit"). Together, they mean "transliterate only the first character in the string". The actual transliteration maps from p to _p. Here, p expands to the printable ASCII characters and _ means "remove" this character, so the expanded lists look like this:
!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~
_ !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~
That means spaces get removed and all other characters get decremented by one.
To see how the last two stages act together here is the string after each of the first few and last stages:
~
~~
}~
}}~
|}~
||}~
{|}~
...
"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~
""#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~
!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~
!!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~
!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~
!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~
!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~
Since the state of the string is only checked after every other stage to determine whether to end the loop, and the two stages cancel each other once we reach the leading space (since Stage 2 adds a space and Stage 3 removes it), this terminates the loop and therefore the program.
print''.join(map(chr,range(32,127)))
Simple enough. A full program that prints out the entire ASCII sequence in order.
man ascii|fold -w1|LC_ALL=C sort -u|tr -cd '[:print:]'
I like that this uses the ASCII man page (which contains an ASCII table) to extract the characters.
srd\
r range from
d space
\<del> to the delete character, 0x7F (included literally in the program)
s sum (concatenate all)
for(i=32;i<128;i++)console.log(String.fromCharCode(i))
Wasted quite a few bytes printing it... Also prints each char on a new line.
31, you can save one byte removing i++ and using String.fromCharCode(++i).
\$\endgroup\$
Jul 11, 2016 at 12:29
console.log can become alert if you don't mind clicking through 97 boxes
\$\endgroup\$
v->{for(char i=31;++i<127;)System.out.print(i);}
Explanation:
v->{ // Method with empty unused parameter and no return-type
for(char i=31;++i<127;) // Loop characters from ' ' to '~'
System.out.print(i);} // And print it
f(){for(char i=32;i<128;i++)putchar(i);}
f(){ is not ok?)
\$\endgroup\$
jot -s '' -c 95 32
@Pw
@P is the string that contains the printable ASCII characters so… yeah, not very interesting.
It's not clear whether OP accepts built-ins or not, and since others have posted answers that use built-ins, I'll use the 3 bytes version until OP clarifies this point.
32:126e Get a number between 32 and 126
:"~c"w Format that number to STDOUT as a char code
\ Backtrack
$><<[*' '..?~]*''
or
print *[*' '..?~]
⁴⁷⁷＋＋╷ is the shortest way i could find to make the number 95 (Canvas only has literals for 0-9, and predefined variables for 10, Infinity, 256, 13, 64, 11, 12, 16, and 128.)
\$\endgroup\$
DECLARE @ int=32x:PRINT char(@)SET @+=1IF @<127GOTO x
DECLARE @ char(95)=''WHILE 95>LEN(@)SET @=char(126-LEN(@))+@ PRINT @
SELECT to SET.
\$\endgroup\$
SELECT to SET. If you change both 94s to 95 that seems to fix it.
\$\endgroup\$
IO.puts Enum.uniq 32..?~
Prints a trailing newline. If that's not acceptable, it's +1 byte for write instead of puts.
uniq is the cheapest operation I managed to find for converting range to list. As a bonus, here are 4 different programs that all accomplish the task in 27 bytes:
IO.puts Enum.to_list 32..?~
IO.puts Enum.into 32..?~,[]
IO.puts Enum.take 32..?~,95
IO.puts for n<-32..?~,do: n
-6 bytes, thanks @anna328p
B8 20 0E MOV AX, 0E20H
.LOOP:
CD 10 INT 10H
40 INC AX
3C 7E CMP AL, 7EH
75 F6 JNE .LOOP
B8 4C00 MOV AX, 4C00H
CD 21 INT 21H
Running on DOSBox :
uCAOzRBAPH91+bhMAM0h (base64)
\$\endgroup\$
eval q y print chr length xor s qq q while uc le q q q x length q q truncate tie q x length q q foreach q y for q q q x ord q q q
eval q y
print chr length
xor s qq q
while
# default variable has spaces only; equibalent to $_
uc
# instead of <=126
le q q q
# 126==14*9
x length q q truncate tie q
x length q q foreach q
# just noticed i could golf the word
y for q q q x ord q q q
eval q y print chr length xor s qq q while chr length lt chr length q q length length length length length length length length length length length length length length length length length length q y foreach q q q x ord q q q
Using length of default variable to be accumulator.
eval q y
# print chr($accumulator)
print chr length xor
# increment it
s qq q
while
# instead of <
chr length lt
# 127 is unfortunately a prime; any efficient ideas within the restrictions?
chr length q q length length length length length length length length length length length length length length length length length length q
# $accumulator=32
y foreach q q q x ord q q q
lambda:range(32,127)
Try it online! Returns a range of codepoints.
lambda:range(32,127) # full program
lambda: # return function taking no arguments that returns...
range( , ) # range object of all integers between...
32 # literal...
range( , ) # minus 1 and...
127 # literal
(Microsoft SQL Server 2012+)
declare @ int=32;while(@<127)begin;print char(@);set @+=1;end
GOTO instead of while.
\$\endgroup\$
putStr[' '..'~']
~KS4>
Pyke's printable variable isn't sorted and it contains tabs and newlines etc... :(
f(i){for(i=31;++i<128;putchar(i));}
Call:
int main() {
f();
}
Uses the horrible (Will again if OP confirms that a vertical output is OK).int-as-a-string trick I learnt from Lynn.
putchar(i) is the same length.
\$\endgroup\$
puts there originally, but then I changed it because of the newlines and didn't question it further. Thanks!
\$\endgroup\$
i;f(){for(;++i<96;putchar(i+32));} also works, and saves a byte.
\$\endgroup\$