Choose your favorite famous computer scientist or computer science pioneer who was born in 1942 or earlier (as 1943 marks the start of the creation of the 'first' computer). They should have a Wikipedia page or other site that lists their birth year and tells how their accomplishments relate to computer science. You may choose the same as someone else but choosing someone new is encouraged.

Take a name they are commonly known by. This will most likely be their first and last name but it might include abbreviations or middle names if that is more common. For example, for Tony Hoare both Tony Hoare and C. A. R. Hoare would be acceptable.

All the characters in the name must be printable ASCII. If the name contains characters that aren't printable ASCII it's fine if you choose something approximate. e.g. Kurt Godel instead of Kurt Gödel.

Take the set of unique characters in the name (e.g. C. ARHoare) and shift them up the printable ASCII scale by the birth year of your scientist, looping around from ~ to space. (Basically add the birth year modulo 95.) This will give you a (most likely) new set of printable ASCII characters.

For example, C. A. R. Hoare was born in 1934, so shifting every character in C. ARHoare by 1934 (34 mod 95) characters gives ePBctj2$5(.

This Stack Snippet will do all the shifting for you:

function go() {var name = document.getElementById("name").value;var year = parseInt(document.getElementById("year").value);var unique = {};for (var i = 0; i < name.length; i++) { unique[name.charAt(i)] = true; } var result = ''; for (var char in unique) { result += String.fromCharCode((char.charCodeAt(0) - 32 + year) % 95 + 32); } document.getElementById("result").value = result; }
Name: <input type="text" id="name" value="C. A. R. Hoare"><br>
Birth Year: <input type="text" id="year" value="1934"><br>
<button type="button" onclick="go()">Ok</button><br>
Result: <input type="text" id="result" readonly>


Using this set and only this set (no tabs, no newlines) of shifted printable ASCII characters, write a program that prints Hello, [name]! to stdout or closest alternative, where [name] is the same exact name you chose above and shifted to get your program characters. You may use multiple characters from the set or not use some at all. For example, the theoretical program PetBee($25 prints Hello, C. A. R. Hoare!.


Your score is your code size in bytes times the number of unique characters in the name you choose. The lowest sore wins.

  • 6
    \$\begingroup\$ Were I to pick, for example, Muḥammad ibn Mūsā al-Khwārizmī, and use a reasonable ASCII-fication of their name, for instance Muhammad ibn Musa al-Khwarizmi, would that be acceptable? \$\endgroup\$
    – ymbirtt
    Commented Nov 21, 2014 at 14:11
  • 3
    \$\begingroup\$ Rear Admiral Grace Murray Hopper, United States Navy, (Retired), Doctor of Philosophy. Born 1906. Would that be OK? \$\endgroup\$ Commented Nov 21, 2014 at 15:17
  • 2
    \$\begingroup\$ @BillWoodger I think that's a bit of a stretch. I'd be OK with Rear Admiral Grace Murray Hopper though. Remember that your code size is multiplied by the number of unique characters in the name so a longer name is not necessarily better. \$\endgroup\$ Commented Nov 21, 2014 at 19:17
  • 5
    \$\begingroup\$ @Calvin'sHobbies Oh oops. Thought that was grit on my screen. \$\endgroup\$
    – Justin
    Commented Nov 22, 2014 at 6:58
  • 4
    \$\begingroup\$ What about C. A. R. Hoare's brother, C. D. R. Hoare? \$\endgroup\$ Commented Nov 22, 2014 at 8:59

12 Answers 12


CJam, 230 117 115 114 113 110 107 106 bytes * 13 = 1378

23)3*c11(2#)c111(((c3*))))22 2*c32c23 3*c3))$(113))c1$)))2$)2$(32c3)))$(3)$))1($)1($)3))$)1($)1$(12$(((33c

Test it here.

I chose Edsger Dijkstra, born 1930, which gives me c#2&$1>b()* 3 (whom I really just chose because he was the first one I found whose name yielded useful characters for CJam; I've checked a dozen names since and none looked as promising).

The code basically just builds the ASCII codes using 1, 2, 3, *, # (exponentiation) and (, ) (decrement, increment) and converts them to a character with c. To save some characters I can sometimes copy an earlier character with $ (0$ copies the top stack element, 1$ copies the second-to-top stack element and so on).

Here is the breakdown of the code into characters (this is also runnable):

23)3*c    "(23+1)*3 -> 72 -> H";
11(2#)c   "(11-1)^2+1 -> 101 -> e";
111(((c   "111-3 -> 108 -> l";
3*)       "Turn l into string lll and split off the third l.";
)))       "l+3 -> o";
22 2*c    "22*2 -> 44 -> ,";
32c       "32 -> Space";
23 3*c    "23*3 -> 69 -> E";
3))$(     "e-1 -> d";
113))c    "113+2 -> 115 -> s";
1$)))     "d+3 -> g";
2$)       "d+1 -> e";
2$(       "s+1 -> r";
32c       "32 -> Space";
3)))$(    "E-1 -> D";
3)$))     "g+2 -> i";
1($)      "i+1 -> j";
1($)      "j+1 -> k";
3))$)     "r+1 -> s";
1($)      "s+1 -> t";
1$(       "s-1 -> r";
12$(((    "d-3 -> a";
33c       "33 -> !";

Marbelous, 83 bytes * 10 = 830

I've chosen R Kowalski, 1941 which allows me to use: {It9A+6=53


This one is a bit more complex than the old answer (below) since many marbles go through multiple devices, all in all most marble just have a few things added to them before being printed though. Because I didn't have subtraction or low numerals, the lower ascii codes had to be formed by adding by merging two high value marbles, since this results in addition modulo. (I've used =3 as a deflector since it pushes every marble not equal to 3 to the right and looks like a cute cat)


Hello, R Kowalski!

old answer:

Marbelous, 113 * 17 = 1921

Marbelous does okay here, since ever marble that falls off the board gets printed, because of its 2D nature though, it needs a few numerals + some arithmetic to not let the borad get too huge.

I've chosen Philip D. Estridge, 1937 who yields u./26EiSj9:8*-+ as the available character set. The characters actually used are .+-245689E


The board is pretty simple, the first 3 rows are literals, ever group of two is a hexadecimal value, the fourth row are arithmetic operations to form the ascii codes that could not be written explicitly because of the limited character sets.


Hello, Philip Donald Estridge!

You can try it out here!

I'll now look for a possible better candidate, since it looks like marbelous might actually be competitive here.

  • \$\begingroup\$ Not sure whether shortening the name considered acceptable. \$\endgroup\$ Commented Nov 26, 2014 at 14:59
  • \$\begingroup\$ @n̴̖̋h̷͉̃a̷̭̿h̸̡̅ẗ̵̨́d̷̰̀ĥ̷̳ I'm using the initial rather than the full first name, seems justified. \$\endgroup\$
    – overactor
    Commented Nov 26, 2014 at 15:06
  • \$\begingroup\$ I can do G Boole with 105 characters * 6 - I think there should be a limit on how much the name can be shortened. \$\endgroup\$ Commented Nov 26, 2014 at 15:14
  • 3
    \$\begingroup\$ Your program doesn't seem to work without new line. The question explicitly disallow the use of new line character Using this set and only this set (no tabs, no newlines) of shifted printable ASCII characters \$\endgroup\$ Commented Dec 1, 2014 at 5:35

Insomnia, 103 99 98 * 8 = 784

George Boole, 1815

All 5 programs below have the same length (98) and same output.


Prints Hello, George Boole!

Insomnia, 103 * 6 = 618 (probably optimal and unique)

If G Boole (George Boole, 1815) is acceptable...


Prints Hello, G Boole!

Insomnia, 94 92 89 85 83 * 10 = 830

Kurt Godel, 1906.


Prints Hello, Kurt Godel!

I wrote a program to search for the solution. My second version of the program should be closer to optimal than my first version.

As per @Martin Büttner's nitpick (100 92 88 85 characters, same set of characters):


Prints Hello, Kurt Goedel!


  • \$\begingroup\$ You can include it in your answer itself and hide it by default. \$\endgroup\$
    – Optimizer
    Commented Nov 25, 2014 at 14:16
  • 2
    \$\begingroup\$ Nitpick: the correct transliteration of Gödel using only the Latin alphabet is Goedel. ;) \$\endgroup\$ Commented Nov 25, 2014 at 14:17
  • \$\begingroup\$ @Optimizer: I have another answer also using Insomnia, so I put it on the other thread. \$\endgroup\$ Commented Nov 25, 2014 at 14:57
  • 1
    \$\begingroup\$ I know, but it will occupy just as much space as the link to the interpreter and you can keep including the snippet in any answer you like. That is the purpose of snippets! :) \$\endgroup\$
    – Optimizer
    Commented Nov 25, 2014 at 15:01

Brainfuck,1846*12 = 22152

Just to have a language other than CJam. Requires original spec Brainfuck with byte datatype, that overflows at 256.

Only uses 2 characters: + to increment the current cell, and . to output the current cell.



Hello, John McCarthy!

Credit goes to Coredump for revealing the following in his answer:

 "John McCarthy" 1927
 ("John McCarthy" "e+*;h~^|.0$5" 12)
  • \$\begingroup\$ The output appears to be missing an exclamation mark! \$\endgroup\$ Commented Nov 22, 2014 at 11:46
  • 1
    \$\begingroup\$ @githubphagocyte Thanks, it's fixed now! \$\endgroup\$ Commented Nov 22, 2014 at 12:10
  • \$\begingroup\$ I'am glad it helped. \$\endgroup\$
    – coredump
    Commented Nov 23, 2014 at 0:11

"Hello, Niklaus Emil Wirth!" (Befunge-98, 222×14=3108)

From Wikipedia:

Niklaus Emil Wirth (15 February 1934 – 1 January 2024) was a Swiss computer scientist. He designed several programming languages, including Pascal, and pioneered several classic topics in software engineering. In 1984, he won the Turing Award, generally recognized as the highest distinction in computer science, “for developing a sequence of innovative computer languages”.

With a shift of 34, Niklaus Emil Wirth (18 characters, 14 unique) ends up as p,./$86Bg0,/By,57+.

Code (try it out here):



88888888+++++++ # Put eight '8's on the stack and add them together (ASCII 64 = `@`)
50p             # Save this value in row 0, column 5 (where the 6th '8' was)
50g8+,          # Fetch the value we just saved, add 8 and print it (ASCII 72 = `H`)
50g88885+++++   # Fetch it again and add 37 (4×8+5) (ASCII 101 = `e`)
00p             # Save this value in row 0, column 0 (the very first character)
g,              # Fetch & print this value (stack is empty, so coordinates will be zero)
g7+,g7+,        # Fetch it again, add 7 (ASCII 108 = `l`) and print. Repeat.
g55++,          # Print `o`
888866+++++,    # Print `,` (4×8+2×6=44)
8888+++,50g68++,g886++5/+,g6+,g7+,50g88755+++++,g  # Continue in a similar fashion,
88++,g77++,8888+++,50g5+,g8+,g886++5/+,g7+,8888++  # using integer division (`/`) in
+,50g887+++,g886++5/+,g85++,g87++,g88+5/+,g5/85++, # a few places
50g00p          # Fetch the `@` character and put it in cell (0,0)

The last line places a HALT character (@) at the beginning of the line. When the control wraps around back to this point, the program will stop. This shouldn't actually be necessary, because the @ character at (5,0) is still there and nothing should be output before it is reached. However, the only online Befunge interpreter that will run this monstrosity won't work properly without it.

It is actually possible to make a working solution with just Niklaus Wirth (12 unique chars, p,./$86By,57+), but the code is much, much longer.

(Tagged as Befunge-98 because Befunge-93 is limited to a width of 80 characters.)


CJam, 323 bytes * 10 = 3230



Hello, C. A. R. Hoare!

CJam, 662 bytes * 10 = 6620 8700

Not to win but just because it looks possible. It used only 2e(c.



Hello, C. A. R. Hoare!


[7209 3113 41 41 41 9 1 0]

The trivial answer 222(((((((((((c (generated by q{i222_@-'(*'c}%) has 3420 bytes.

  • \$\begingroup\$ Wow I didn't know you could use e_ outside number literals. \$\endgroup\$ Commented Nov 21, 2014 at 14:36
  • \$\begingroup\$ Have you checked how low you can get by using repetitions of 2? Or by using the other (useful) characters B, 5 and $? (E.g. you can get second to fourth space and the second and third period with 2$, as well as the A with 2$((.) \$\endgroup\$ Commented Nov 21, 2014 at 15:23
  • \$\begingroup\$ @MartinBüttner Tried to golf down a bit by hand. But it seemed too complicated. Maybe I'll write a program to do that later. But this will not win anyway. \$\endgroup\$
    – jimmy23013
    Commented Nov 21, 2014 at 16:41

CJam, 16 * 307 288 = 4912 4608

B(7*2+cB(B(*2(+cB(B*((cB(B*((cBB*7-(((c5 8*5(+c8 2*2*cBB*2/5+cBB*7-cBB*5-cBB*Bm5-(cBB*4-cBB*7-c8 2*2*cB7*(((cBB*7-(((cBB*Bm5-(cBB*B-c8 2*2*c8B*2+8-cBB*7-(((c7 2+B*(cBB*8 2*-cBB*B-c8 2*2*cB(7*2(+cBB*7-(((cBB*7-cB(B(*2(+cB(B*((cB(B*((c8 2*2*cB7*cBB*8 2*-cB(B*((cBB*B-cB(B(*2(+cBB*7-c5(8*1+c


Hello, Arthur John Robin Gorell Milner!

This is my first answer using CJam, so surely this can better golfed (any hint is welcome).

Here is some utility code I used. Since I computed the character set for some other names, this may be useful for someone who better knows CJam (or maybe for another language).

  • Find the character set, along with the number of unique characters
(defun character-set (name year)
  (let* ((uniques (remove-duplicates name))
         (size (length uniques))
         (buffer (make-array size 
                             :element-type 'character
                             :fill-pointer 0)))
    (loop for c across uniques
          do (vector-push
               (+ #x20 (mod (- (+ (char-code c) year) #x20) 95)))
          finally (return (values buffer size)))))
  • Define a list of well-known figures
(defparameter *masters*  
  '("Grace Murray Hopper" 1906
    "Augusta Ada King, Countess of Lovelace" 1815
    "Augusta Ada Byron" 1815
    "Ada Lovelace" 1815
    "John von Neumann" 1903
    "Neumann Janos Lajos" 1903
    "Charles Babbage" 1791
    "John McCarthy" 1927
    "Wilhelm Ackermann" 1896
    "George Boole" 1815
    "Kurt Godel" 1906
    "Andrei Nikolaievitch Kolmogorov" 1903
    "Bertrand Arthur William Russell, 3rd Earl Russell" 1872
    "Arthur John Robin Gorell Milner" 1934))
  • Compute the allowed printable character sets, sort by size of set
(sort (loop for (n y) on *masters* by #'cddr
            collect (cons n (multiple-value-list (character-set n y))))
      #'< :key #'caddr)

(("George Boole" "Q|q*Lyvo" 8) 
 ("Ada Lovelace" "Kn*Vy!vkmo" 10)
 ("Kurt Godel" "Q{xz&Mujkr" 10) 
 ("John von Neumann" "Mkyr#Qhxpdq" 11)
 ("Charles Babbage" "5Zd^eq4TSYW" 11)
 ("Grace Murray Hopper" "MiS{g &Nuvkx" 12)
 ("Neumann Janos Lajos" "QhxpMq#Odmrv" 12)
 ("John McCarthy" "e+*;h~^|.0$5" 12)
 ("Augusta Ada Byron" "q }~Knk*L$|yx" 13)
 ("Wilhelm Ackermann" "Sedh{=_gani]j" 13)
 ("Arthur John Robin Gorell Milner" "c78l+t%i2Bo,/1(5" 16)
 ("Andrei Nikolaievitch Kolmogorov" "DqgQndhlwfk#Nopjury" 19)
 ("Augusta Ada King, Countess of Lovelace" "KnUsq6M x~}p*Vy!vkmo" 20)
 ("Bertrand Arthur William Russell, 3rd Earl Russell" "&R%XL;MQovH)EVc6YWIP" 20))

Brainf_ck - 723 * 12 = 8676

I did a crawl from Wikipedia's List of computer scientists and collected the birthyears and longest names of all the people listed there. I wrote a program to run over all these and find any I could possibly do in a common language. Sadly, I was unable to find any names that could support echo;, alert(), console.log() (I can hope), print, or main.

I mainly wanted to share my raw crawl data in case anyone wanted to similarly search for other languages (note: may be inaccurate and incomplete): Crawl Data.

EDIT: New crawl paste with about 40 new names from List of computing people and List of pioneers in computer science.

EDIT: Manually cleaned up the list.

I did find that Jean David Ichbiah (1940), chief designer of Ada, provides +-. (the shortest of three people to do so). I generated this BF code for him.


Alexander Keewatin Dewdney provided the most usable BF characters (+.<>), but came in slightly above my answer. No one I found provided .[].

  • 1
    \$\begingroup\$ Some of that crawl data is definitely wrong. I met Sir Maurice Wilkes: he was old, but not 900 years old. \$\endgroup\$ Commented Nov 25, 2014 at 0:07
  • \$\begingroup\$ I took a manual pass through and fixed some of those, and also found a lot of dates that the bot didn't pick up on at all. Didn't bring up any new results for me, though. \$\endgroup\$
    – BMac
    Commented Nov 25, 2014 at 5:44

Ruby 1.8 - 250 × 18 = 4500


Characters available:



"Hello, Anatolii Alexeevich Karatsuba!"

Anatolii Karatsuba, born 1937, is most well known for his contributions to the field of analytic number theory (a field I personally enjoy), including the Karatsuba Algorithm, a method for fast multiplication of arbitrary precision operands.

This is the first and only name I tried.


GolfScript (125 * 14 = 1750)


Online demo

Douglas Engelbart (1925 - 2013) is perhaps most famous for the "Mother of All Demos". His name and year of birth give characters !&(),-./9]^z{~, of which this solution uses &()-./9]^~

The basic structure of the code is build list of numbers](- which puts a lot of numbers in an array with the empty string that starts on the stack, then pulls out that string and uses it with the type promotion of - to turn the array of numbers into a string.

Since there's no access to elements below the top of the stack I wrote a C# program to find short snippets that take a given integer on the top of the stack and add the next integer required. This created one small problem, when the snippet for 69 (E) ended with - and the snippet for 110 (n) started with 9: it cost one char to use a longer snippet for 110.


CaneCode, 458 410 * 16 = 7328 6560


Corresponding BF:



Hello, Jack Elton Bresenham!

CaneCode is just a direct symbol substitution of Brainfuck, where 12348 correspond to +-><. respectively. I spent about 2 hours trying to look for a short name which gave +-. for normal Brainfuck, with no success.

Jack Elton Bresenham, inventor of Bresenham's line algorithm and born 1937, gives the following characters:


Unfortunately, while 5 ([) is available, the lack of 6 (]) means that the code still had to increment up the 100-ish area (for lowercase chars) the slow way.


><> (Fish), 163 * 15 = 2445



Hello, Ivar Hjalmar Jacobson!

Ivar Hjalmar Jacobson, born 1939, was found thanks to BMac's crawl data. He provides the chars


><>, like Befunge, is a 2D stack-based language. The useful ><> commands are:

  • *+24567 for arithmetic (note that 47 pushes a 4 and a 7 on the stack, not 47)
  • ) for greater than (useful for getting 1)
  • : for duplicating the top of the stack
  • o for output
  • ; for program termination

p is also good for reflection, but I was unable to think of a good use for it. > is another ><> command, directing program flow rightwards, but since the program already executes in that direction it was not needed.


Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Not the answer you're looking for? Browse other questions tagged or ask your own question.