Write the whole of the holed using the unholed

Question

The ASCII characters from decimal code 33 to 126 are:

!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~

Notice that in most fonts, 25 of these characters have "holes" in them: (a genus greater than 0 you might say)

#$%&04689@ABDOPQRabdegopq

The other 68 "unholed" characters are:

!"'()*+,-./12357:;<=>?CEFGHIJKLMNSTUVWXYZ[\]^_`cfhijklmnrstuvwxyz{|}~

Your task is to write the shortest program possible using only the unholed characters that outputs each of the holed characters exactly once in any order.

Since Space, Tab and newlines (Line Feed and/or Carriage Return) are empty space they may appear in your program or its output. They still count towards the number of characters. Other ASCII characters may not be used (and certainly not non-ASCII characters).

Notes

• You do not have to use all of the unholed characters nor only one of each.
• The output may not contain unholed characters.
• The Whitespace language may be used.
• Output should go to stdout or can go to a file. There should be no input.

Bonus: Just for fun, try printing all the unholed characters using the holed characters. I'm skeptical that it can be done in an existing language.

Answer 1

GolfScript, 37 36 characters

[":=<?)-/! YX[]VIHKx{}|~vih"{25^}/]+

Try the code here.

The string contains the forbidden characters xor'ed with 25. Fortunately all characters are mapped to valid ones.

Answer 2

Brainfuck 119

--[------->++<]>-.+.+.+.++++++++++.++++.++.++.+.+++++++.+.+.++.+++++++++++.+.+.+.[------>+<]>--.+.++.+.++.++++++++.+.+.

Answer 3

Bonus - dc, 179 characters

Oh good, another restricted character set challenge where P is allowed.

6A44469PD684P44D4898PDB99P4008D0BP486B48BPA60BPD096P4A68666P460A0D4P690490AP8084088P6B6AB66P6BBB608P80D4BAAPA046PBAD4P60A6668P480DD96P4A040BBP848BP40DD8D0P46840B6P696B48BP48D64BAP

Since dc is apparently obscure enough to require explaining (strange to me considering the weird stuff around here!) here's an overview:

It's primarily an RPN calculator with arbitrary-precision arithmetic. But for this challenge, I'm making use of the P command, which interprets a number as a series of characters in base 256 and prints them. Examples: 65 P prints A (ASCII code 65). 16706 P prints AB (16706=65*256+66).

Aside from that, the only other interesting feature is that it recognizes all of the hexadecimal digits 0-9A-F even when they are not contained in a hexadecimal number. Decimal input is the default, so the input token 999 means 9 hundreds + 9 tens + 9 and ABC means 10 hundreds + 11 tens + 12 making it equivalent to 1122.

The ability to use the digits ABD in decimal partially makes up for the inability to use 12357, and the choice of ordering and grouping does the rest. (If I need some numbers x,y,z and they aren't representable with allowed digits, then I try representing x*256*256+y*256+z instead.)

The program can probably be made slightly shorter by using larger groups. I didn't go past 3 bytes per number.

Answer 4

Pyth, 43 35 characters

tTFk"*+,-7;=?GHIKVWXYhiklnvwx"C-Ck7

Try it here.

Prints the characters in order except that 9 is at the beginning, newline separated.

String contains all characters 7 greater than the ones needed, except that 9 would become @, so it is special cased. Algorithm thanks to @Howard.

Explanation:

tT                print(10-1)                T=10, t(x)=x-1 if x is an int.
Fk"<string>"      for k in "<string>":
C-Ck7             print(chr(ord(k)-7))       Note that C is overloaded as ord and chr.

Answer 5

Bash+coreutils, 56 bytes

tr \(-y \!-r<<<'*+,-7;=?GHIKVWXYhiklnvwx'
tr C-F 7-:<<<E

As luck would have it, adding 7 to the ascii value of the holed characters yields all unholed characters (with the exception of "9"). So we just do this transformation in reverse, then a similar transformation (subtract 12 from "E") to get the "9".

Output:

#$%&0468@ABDOPQRabdegopq
9

Answer 6

Perl - 47 Bytes (thanks @Dom Hastings for the update!)
Perl - 49 Bytes

Edit, 47 bytes:

symlink".",':=<?)-/! YX[]VIHKx{}|~vih'^(F^_)x25

Original, 49 bytes:

symlink".",':=<?)-/! YX[]VIHKx{}|~vih'^chr(25)x25

This is pretty much a Perl version of Howard's solution. XORing the string with 25. The output is a file with the name #$%&04689@ABDOPQRabdegopq. I got the idea to use symlink and the file name as the output format because everything else is banned.

Here's another Perl solution I came up with. It can probably be improved a lot and it is pretty long, so I'm leaving in a readable format for now.

until(y/1/1/>32){s//1/}
until(y/1/1/>125+1){
    if(chr(y/1/1/)!~/[!"'()*+,-.\/12357:;<=>?CEFGHIJKLMNSTUVWXYZ[\\\]^_`cfhijklmnrstuvwxyz{|}~]/) {
        symlink".",chr y/1/1/;
    }
    s/^/1/
}

This one outputs many files, the name of each one is one of the characters. I couldn't figure out how to append strings without using a forbidden character.

for, while, map, say, print, eval, s///e, and any variable name cannot be used (variables start with @ or $ in Perl) which made this difficult.

Hopefully file names are okay as an output format because I'm pretty sure every other way to output information uses one of the banned characters.

Answer 7

MATLAB, 36 bytes

SO CLOSE.... Only 1 byte more than the current winner (isaacg)! Which, on further inspection, already did what I set out to do too. Well, no harm in reinventing the wheel...

I know this is an old challenge, but I only realized that after I got interested in it.

['*+,-7;=?GHIKVWXYhiklnvwx'-7,57,'']

If only I could get MATLAB to understand that I want a string without a separate ''... suggestions, anyone?

Answer 8

Brainfuck 303 275

++++++++[>+>++>+++>++++>+++++>++++++>+++++++>++++++++>+++++++++>++++++++++>+++++++++++>++++++++++++>+++++++++++++>++++++++++++++>+++++++++++++++>++++++++++++++++<<<<<<<<<<<<<<<<-]>>>>+++.--->----.+.+.++>.>----.++.++.+.->.+.+.-->----.++++>-.+.+.+.-->>+.+.-->----.+.++.+>-.+.+.

Brainfuck, the ultimate unholed esoteric language (apart from Whitespace) ;)

Answer 9

JS - 196 - try it

h=(c=!1+[])[1];i=c[2*2];j=(f=[]+{})[1];this[i+'v'+h+'l'](h+'l'+i+'rt('+h+'t'+j+f[2]+'("Iy\x51lJj\\x'+2*2+'1\\x3'+~-1+'Nj\\x'+2*3+'75\x51EFC\x52E\\x3'+3*3+'\x51UVJhYm\x52lZ2\\x3'+3*3+'wc\x51=="))')

Answer 10

GolfScript, 89 characters

71 22+,{33+}/]''+'!"\'()*+,-./12357:;<=>?CEFGHIJKLMNSTUVWXYZ[\]^_`cfhijklmnrstuvwxyz{|}'-

Simply builds an array of all ASCII characters and subtracts the non-"holed" characters from them.

71 22+,  # Builds array of 0..93
{33+}/]  # Converts to 33..126
''+      # Convert ASCII codes to string
'stuff'- # Subtracts "stuff" (the non-holed characters) from the string

Answer 11

Befunge 98 - 69 bytes

"()+ijWI=*">:5j2 ,-5_"157:h">:5j2 ,-1_"=>?LMN^_lmn">:5j2 ,+3_"?"1+s <

Does it in 3 parts. One where unholed character values differ from holed character by 5. Then the ones that differ by 1, and finally a list of unholed characters that differ by 3 from holed ones. The terminate program instruction in Befunge is "@" (char value 64), so at the end I load "?" (char value 63) add 1 then put that in the code with the instruction 's'.

I could maybe golf it more by consolidating the three

>:5j2 ,(differ value)_

section, but probably not by much.

Answer 12

Main - Insomnia, 50

FFy~~jF~y<={*n<<ztf>={.f=(tHL~k<yf={*n>Lj(FunLn<j~

It outputs:

abdegopq04689@ABDOPQR#$%&

Bonus - Insomnia, 268

ogeeoddp@poe@ggep@oe@opge@gee@%d@p@gqeo@p@ge@e9de49ed9e4dppe@%e@geee@ge@p%ee@%e@dp@%ep@%ee@%d@%eeee@%e@%ee@%e@geee@%e@gee@ggopop@peo@ggep@p@ge@ggeep@ge@gee@%e@geee@ge@gee@ge@ppoep@%ee@%edep@gepe@ge@%ee@%e@geee@ge@%ee@%%eeoe@ge@pep@%gep@p@%e@%%eep@%e@gee@e%e@oe@%gep@p@

It outputs:

!"'()*+,-./12357:;<=>?CEFGHIJKLMNSTUVWXYZ[\]^_`cfhijklmnrstuvwxyz{|}~

I think it should be possible to reduce the length of the program if the output is rearranged, but I need to modify my search program to do this.

Just to show case another language which is capable of operate with a restricted number of characters. By the way, it can write just about any output with only 3 unique characters in the source.

Currently, this is the only language that can do both the main challenge and the bonus among all the existing answers.

Insomnia Interpreter.

Answer 13

Befunge 98 - 46 bytes

Befunge-ified version of isaacg's Pyth entry:

"xwvnlkihYXWVKIHG?=;7-,+*">:5j2 ,-7_"?"1+:,s <

Answer 14

JavaScript 240 228

Initial submission:

z=(!1+"")[1];y=(!!1+"")[3];x={}+"";w=x[1];v=x[2];u=z+"t"+w+v;1[_="c\157nstruct\157r"][_](z+'l'+y+'rt('+u+'("Iy\x51lJj"+'+(t=u+'("\x51\x51==")')+'+'+u+'("M"+'+t+'+"==")+"Nj"+'+u+'("Zw==")+"5\x51EFC\x52E\71\x51UVJhYm\x52lZ2\71wc\x51=="))')()

Now, this is a great start, here's how it breaks down...

z=(!1+"")[1];        // assigns "a" to z, !1+"" === "false"
y=(!!1+"")[3];       // assigns "e" to y, !!1 === "true"
x={}+"";             // assigns "[object Object]" to x
w=x[1];v=x[2]        // assigns "o" to w, and "b" to v
u=z+"t"+w+v;         // creates the mystical "atob" command, yes, I'm gonna use it!
1[_="c\157nstruct\157r"][_] // sets up the primitive to a number object... this acts similar to the "window" primitive object so that I can play off functions...
z+'l'+y+'rt(         // starts creating an alert call
'+u+'("Iy\x51lJj"+'+(t=u+'("\x51\x51==")')+'+'+u+'("M"+'+t+'+"==")+"Nj"+'+u+'("Zw==")+"5\x51EFC\x52E\71\x51UVJhYm\x52lZ2\71wc\x51=="))')()
// Above line abuses atob command with a couple of nested instances of the command, also using hex and octal equivalents of characters

And then I thought... "There must be a simpler way..." and there is...

Revised submission: z=(!1+"")[1];y=(!!1+"")[3];x={}+"";w=x[1];v=x[2];u=z+"t"+w+v;this[y+"v"+z+"l"](z+'l'+y+'rt('+u+'("Iy\x51lJj"+'+(t=u+'("\x51\x51==")')+'+'+u+'("M"+'+t+'+"==")+"Nj"+'+u+'("Zw==")+"5\x51EFC\x52E\71\x51UVJhYm\x52lZ2\71wc\x51=="))')

Seeing I can use eval (by piecing it together, inspiration from @bebe; which is a lot quicker than using the constructor of a constructor of a number... ) I drilled it down to 228... I know it may not win this particular Golf Challenge, but this is just my way of showing how much you can abuse JavaScript, and still get the desired result...

Answer 15

Japt, 33 bytes

7+2+"*+,-7;=?GHIKVWXYhiklnvwx"c-7

Try it online!

Same algorithm as isaacg's Pyth submission, just happens to be shorter in Japt.

How it works

7+2+"*+,-7;=?GHIKVWXYhiklnvwx"c-7

7+2           Obviously the number 9
    "..."c-7  Apply -7 on each char's charcode of this string
   +          String concatenation

Yes, it's JS, which is one of the most abusable languages, just shorter (and you don't need alert or console.log here).

Answer 16

Vyxal s, 33 bytes

`*+,-7;=?GHIKVWXYhiklnvwx`C7-57JC

Try it Online! Uses the same (independently discovered) trick of subtracting 7 and putting a 9 on the end.

Answer 17

PHP, 59 bytes

<?='MMMMMMMMMM:::::::::::::::'^"nihk}y{ut\r{x~ujkh[X^_]UJK";

Try it online!

Explanation

Utilises the string-XOR operator (^) to build the desired string from non-holed letters, output via <?=.

Verification for 59 bytes.

Answer 18

Perl 5, 72 bytes

*_=*~;("*,*E'syswrit\LE"^icx)->(uc,':=<?)-/! YX[]VIHKx{}|~vih'^(F^_)x25)

Try it online!

Explanation

I know this is longer than the existing Perl answer, but this outputs using STDOUT, rather than a filename.

*_=*~ aliases the ~ variables (@, %, and $) into _, meaning that $* (which is STDOUT by default) is now in $_, which we can access using uc (which returns $_ by default if no arguments are passed). Next the string CORE::syswrite is built from a combination of the stringwise-XOR of the two strings and the in-line lowercase modifier (\L) of E, which is then called as a function ->(...) with the arguments STDOUT (from uc) and the desired string, also built via stringwise-XOR (copied from @hmatt1's answer and amended to to save bytes using more stringwise-XOR).

Answer 19

PICO-8, 196 bytes

c=77+2?"\35\37\52\57\111\112\113\71"..chr(33+3)..chr(31+7)..chr(32*2)..chr(72-7)..chr(71-5)..chr(71-3)..chr(71-2)..chr(c)..chr(c+1)..chr(c+2)..chr(75+22)..chr(75+23)..chr(c+21)..chr(57*2)..2*13*31

More variables like c might reduce size, not in the mood to try more at the moment.