Wybierz swojego ulubionego znanego informatyka lub pioniera informatyki, który urodził się w 1942 roku lub wcześniej (ponieważ 1943 oznacza początek stworzenia „pierwszego” komputera ). Powinni mieć stronę w Wikipedii lub inną witrynę, która podaje rok ich urodzenia i pokazuje, w jaki sposób ich osiągnięcia odnoszą się do informatyki. Możesz wybrać to samo co ktoś inny, ale zachęcamy do wybrania kogoś nowego.

Weź nazwę, pod którą są powszechnie znani. Najprawdopodobniej będzie to ich imię i nazwisko, ale może zawierać skróty lub drugie imiona, jeśli jest to bardziej powszechne. Na przykład, dla Tony Hoare zarówno Tony Hoarei C. A. R. Hoarebyłoby do przyjęcia.

Wszystkie znaki w nazwie muszą być drukowalne ASCII . Jeśli nazwa zawiera znaki, których nie można wydrukować w formacie ASCII, dobrze jest, jeśli wybierzesz coś przybliżonego. np. Kurt GodelzamiastKurt Gödel .

Weź zestaw unikalnych znaków w nazwie (np. C. ARHoare) I przesuń je w górę skali ASCII do druku do roku urodzenia swojego naukowca, przechodząc od ~miejsca do miejsca. (Zasadniczo dodaj rok urodzenia modulo 95.) Otrzymasz (najprawdopodobniej) nowy zestaw drukowalnych znaków ASCII.

Na przykład CAR Hoare urodził się w 1934 roku, więc przeniesienie każdej postaci C. ARHoareo 1934 (34 mod 95) daje ePBctj2$5(.

Ten urywek stosu wykona za Ciebie wszystkie zmiany:

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>

Wyzwanie

Używając tego zestawu i tylko tego zestawu (bez tabulatorów, bez nowych linii) przesuniętych drukowalnych znaków ASCII, napisz program, który drukuje Hello, [name]!na standardowe lub najbliższe alternatywy, gdzie [name]jest taka sama dokładna nazwa, którą wybrałeś powyżej i którą przesunąłeś, aby uzyskać znaki programu. Możesz użyć wielu znaków z zestawu lub w ogóle ich nie używać. Na przykład PetBee($25drukowany jest program teoretyczny Hello, C. A. R. Hoare!.

Punktacja

Twój wynik to rozmiar kodu w bajtach razy liczba unikalnych znaków w wybranej nazwie. Najniższy ból wygrywa.

Bezsenność, 103 99 98 * 8 = 784

George Boole , 1815

Wszystkie 5 poniższych programów ma tę samą długość (98) i to samo wyjście.

oyoooyLyyyyoyLqoyyoyoLL*yyoLqy|oLq*yLyoyyoLqoq*yLyyLoyooLyyy*qL|yqoLq**LoooyoLqy|qLLo*qyLq*oq|L|oL
oyoooyLyyyyoyLqoyyoyoLLy*yyoLq*oqL*LqyyyoyLyooyyoLyyLoyooLyyyL*q|qoL|q*LoooyoLqyq*LLo*qyLq*o|qL|oL
oyoooyLyyyyoyLqoyyoyoLL*yyoLqy|oLq*yLyoyyoLqoq*yLyyLoyooLyyyL*qq|oL|yq*LoooyoLqyq*LLo*qyLq*o|qL|oL
oyoooyLyyyyoyLqoyyoyoLLy*yyoLq*oqL*LqyyyoyLyooyyoLyyLoyooLyyyL*q|qoL|q*LoooyoLqyq*LL|qyyLy*qq*L|oL
oyoooyLyyyyoyLqoyyoyoLL*yyoLq|oLq*yLyoyyoLyq|oLq|yq*LqooLoyyoyLyLoyyoyLoooyoLo|q|LLq|yyLooooyoLqyL

Wydruki Hello, George Boole!

Bezsenność, 103 * 6 = 618 (prawdopodobnie optymalna i unikalna)

Jeśli G Boole( George Boole , 1815) jest akceptowalny ...

ooyoyoLoyyoyoyyLyoyoooLLoyooyyLoyyyoLooyoyoooooLyoyyoLoyoyyyoLooyyyooLoyoyooooLLyyooyoyoLyoyoooLoyooooL

Wydruki Hello, G Boole!

Bezsenność, 94 92 89 85 83 * 10 = 830

Kurt Godel, 1906.

kukuzkzjzkuxkujx{rxjkjxzjukukzj{ukukzjkrxujzujk{rxujjku{jxuukujrxzjuxjk{urxjxukzj{j

Wydruki Hello, Kurt Godel!

Napisałem program do wyszukiwania rozwiązania. Moja druga wersja programu powinna być bliższa optymalnej niż moja pierwsza wersja.

Zgodnie z nitpick @Martin Büttner ( 100 92 88 85 znaków, ten sam zestaw znaków):

kukuzkzjzkuxkujx{rxjkjxzjukukzj{ukukzjkrxujzujk{rxujju{jxuukujrxuxjzxjk{urxjxjxukzj{j

Wydruki Hello, Kurt Goedel!

Interpretator

CJam, 230 117 115 114 113 110 107 106 bajtów * 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

Sprawdź to tutaj.

Wybrałem Edsger Dijkstra, urodzony w 1930 roku, co daje mi c#2&$1>b()* 3(którego tak naprawdę wybrałem, ponieważ był pierwszym, którego znalazłem, którego imię przyniosło użyteczne postacie dla CJam; od tamtej pory sprawdziłem tuzin nazwisk i żadne nie wyglądało tak obiecująco).

Kod zasadzie tylko buduje kodów ASCII za pomocą 1, 2, 3, *, #(potęgowanie) i (, )(ubytek, przyrostu) i konwertuje je do postaci z c. Aby zapisać niektóre znaki, czasami mogę skopiować wcześniejszy znak $( 0$kopiuje element najwyższego stosu,1$ kopiuje od drugiego do górnego itd.).

Oto podział kodu na znaki (można to również uruchomić):

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 -> !";

Cudowny , 83 bajty * 10 = 830

Wybrałem, R Kowalski, 1941co pozwala mi korzystać z:{It9A+6=53

++63
A66333696A5A696A6A69
A5633A..+3+6+3+9++
A56A+I
AA+6
=3
3653666665
+I+I+6+6+A++

Ta jest nieco bardziej złożona niż stara odpowiedź (poniżej), ponieważ wiele kulek przechodzi przez wiele urządzeń, w większości marmurów wystarczy dodać kilka rzeczy przed wydrukowaniem. Ponieważ nie miałem odejmowania ani niskich cyfr, musiałem utworzyć niższe kody ascii poprzez dodanie dwóch marmurów o wysokiej wartości, ponieważ powoduje to dodatkowe modulo. (Użyłem =3jako deflektora, ponieważ popycha każdy marmur nie równy 3 w prawo i wygląda jak słodki kot)

wydajność:

Hello, R Kowalski!

stara odpowiedź:

Marbelous , 113 * 17 = 1921

Marbelous ma się tu dobrze, ponieważ drukowany jest marmur spadający z planszy, ale ze względu na jego charakter 2D potrzebuje kilku cyfr + pewnej arytmetyki, aby borad nie stał się zbyt duży.

Wybrałem, Philip D. Estridge, 1937kto daje u./26EiSj9:8*-+jako dostępny zestaw znaków. Znaki faktycznie używane są.+-245689E

22
6865
4965686866282252686968696E2244666E65686422456E6E6E6964
--..+4+4+9+4-2-2....+4..+2-2..+9..-4+4..-2..+5+6+4

Tablica jest dość prosta, pierwsze 3 rzędy są literałami, zawsze grupa dwóch jest wartością szesnastkową, czwarty rząd to operacje arytmetyczne, aby utworzyć kody ascii, których nie można było napisać wyraźnie z powodu ograniczonych zestawów znaków.

wydajność:

Hello, Philip Donald Estridge!

Możesz to wypróbować tutaj!

_{Poszukam teraz potencjalnie lepszego kandydata, ponieważ wygląda na to, że cudowny może być tutaj konkurencyjny.}

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.

++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.+++++++++++++++++++++++++++++.+++++++..+++.+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.++++++++++++++++++++++++++++++++++++++++++.+++++++++++++++++++++++++++++++++++++.+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.++++++.++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.+++++++++++++++++++++++++++++++++++++++++++++.++++++++++++++++++++++.++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.++++++++++++++++++++++++++++++.+++++++++++++++++.++.++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.+++++++++++++++++.++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.

Output

Hello, John McCarthy!

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

 "John McCarthy" 1927
 ("John McCarthy" "e+*;h~^|.0$5" 12)

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

From Wikipedia:

Niklaus Emil Wirth (born February 15, 1934) is a Swiss computer scientist, best known for designing several programming languages, including Pascal, and for pioneering several classic topics in software engineering. In 1984 he won the Turing Award 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+++++++50p50g8+,50g88885+++++00pg,g7+,g7+,g55++,888866+++++,8888+++,50g68++,g886++5/+,g6+,g7+,50g88755+++++,g88++,g77++,8888+++,50g5+,g8+,g886++5/+,g7+,8888+++,50g887+++,g886++5/+,g85++,g87++,g88+5/+,g5/85++,50g00p

Breakdown:

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

5((e5(((e2(((e2(((e2((e2c525e2e2(e2(((e2(e2((e2(((c525e5(e5(((e2(e2c2(($Be2(e2(((e2(e2e2((e2(e2e2(c2e2e2((e2e2(e2(((e2(e2c2(($((((((((((((B((((($(((((2e2(e2(e2e2((e2(((e2(e2e2((c2$2$((c2$2$525e2(((e2((e2((e2((e2e2(((e2((c2$2$22((((((($22(((((((((($22(((((($((((255((e2((e2(e2((e2(((e2((c22(((($Be2e2(e2(e2((e2(((e2(((e2(((c

Output:

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.

2e2e2((e2e2(((e2(((e2(((e2((e2c2e2e2(((e2e2(e2(((e2(e2((e2(((c2e2e2e2((e2((e2e2(((e2(e2c2e2e2e2((e2((e2e2(((e2(e2c2e2(e2(((e2(e2e2((e2(e2e2(c2e2((e2e2((e2e2(e2(((e2(e2c2e2((e2e2((e2(((e2(((e2((e2e2c2e2((e2(((e2e2(((e2((e2(e2(((e2(c2e2(e2(e2e2((e2(((e2(e2e2((c2e2((e2e2((e2(((e2(((e2((e2e2c2e2((e2(((e2e2(((e2((e2(e2(((e2(((c2e2(e2(e2e2((e2(((e2(e2e2((c2e2((e2e2((e2(((e2(((e2((e2e2c2e2(((e2(((e2((e2((e2((e2e2(((e2((c2e2(e2(e2e2((e2(((e2(e2e2((c2e2((e2e2((e2(((e2(((e2((e2e2c2e2e2((e2e2(((e2(((e2(((e2((e2c2e2(e2(((e2(e2e2((e2(e2e2(c2e2(((e2e2(e2(((e2(e2(((e2(((e2(((c2e2e2e2(((e2((e2(e2((e2(((e2((c2e2e2(((e2e2(e2(((e2(e2((e2(((c2e2(e2e2(e2(e2((e2(((e2(((e2(((c

Output:

Hello, C. A. R. Hoare!

Generator

q{i
[7209 3113 41 41 41 9 1 0]
{
1$3^)4%@1$+@*4/\'(*\
}%W2tW%"e2"*
'c}%

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

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

Displays:

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
              (code-char
               (+ #x20 (mod (- (+ (char-code c) year) #x20) 95)))
              buffer)
          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 .[].

Ruby 1.8 - 250 × 18 = 4500

p''<<24+48<<2+99<<9+99<<9+99<<22+89<<44<<4+28<<24/4+59<<22+88<<2+95<<22+94<<22+89<<9+99<<24/4+99<<24/4+99<<4+28<<24/4+59<<9+99<<2+99<<22+98<<2+99<<2+99<<24+94<<24/4+99<<99<<5+99<<4+28<<84/4+54<<2+95<<22+92<<2+95<<22+94<<84/4+94<<22+95<<98<<2+95<<4+29

Characters available:

'()+./24589:;<>Efp

Output:

"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)

9)99.9-&^99)).9^..)))..)~99-&.99&.99)^999)9/.(((-9-..9(/-.((9^99((.9-9-^.).9-^).)).~--999~9/.9^.((.9^99(.(.9.~-^.))..9-^))](-

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

11111111111111111111111111111111111111111111111111111111111111111111111184111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111118111111188111841111111111111111111111111111111111111111111182222222222228331184222222222222228118111111118483322222841811111111822222828483322284111182222222222222811111111111111822222222222222811111111182222228222222281111111111118418

Corresponding BF:

++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.>+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.+++++++..+++.>++++++++++++++++++++++++++++++++++++++++++++.------------.<<++.>--------------.++.++++++++.>.<<-----.>+.++++++++.-----.-.>.<<---.>++++.-------------.++++++++++++++.--------------.+++++++++.------.-------.++++++++++++.>+.

Outputs:

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:

o')1Ej2:54g8+9.3

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

47*5+:56+7*+:42)+:4+55*66*:++66+6*o:4+::o7+:oo25*+o56+:4*o42*4*o6*7+o:7+7+7+o:o:25*7++o42*:4*o45+*o:45++o:o:6+:5+o6+o:o:25*7++o24*4*o25*7*4+o:o:2+o:27*+o42)+ooooo;

Outputs:

Hello, Ivar Hjalmar Jacobson!

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

)*+24567:;>Gopq

><>, 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.