# Golf me an ASCII Alphabet

Don't you find that reading simple text isn't appealing enough? Try our

#####  ###   ###  ##### #####       ##### ##### #   # #####   #
#   # #     #   #   #     #           #   #      # #    #     #
#####  ###  #       #     #           #   ####    #     #     #
#   #     # #   #   #     #           #   #      # #    #
#   #  ###   ###  ##### #####         #   ##### #   #   #     #


Much more fancy isn't it? But it's pretty long to write by hand, it would be wonderful if someone did a program that do it for me !

Your task, if you volunteer to help me, will be to write a program or a function that takes a string containing [a-zA-Z\s\n] only, and output (or return) the ascii writing of it!

You must use the following alphabet to format your output:

##### ####   ###  ####  ##### #####  ###  #   # ##### ##### #   # #     #   #
#   # #   # #   # #   # #     #     #     #   #   #     #   #  #  #     ## ##
##### ####  #     #   # ####  ####  #  ## #####   #     #   ###   #     # # #
#   # #   # #   # #   # #     #     #   # #   #   #   # #   # #   #     #   #
#   # ####   ###  ####  ##### #      ###  #   # ##### ###   #  #  ##### #   #

#   #  ###  ####   ###  ####   ###  ##### #   # #   # #   # #   # #   # #####
##  # #   # #   # #   # #   # #       #   #   # #   # #   #  # #   # #     #
# # # #   # ####  #   # ####   ###    #   #   #  # #  # # #   #     #     #
#  ## #   # #     #  ## ##        #   #   #   #  # #  ## ##  # #    #    #
#   #  ###  #      #### # #    ###    #    ###    #   #   # #   #   #   #####


The space:

     |
| it's a 5x5 square of spaces
| but had to pad it with |s to make it appear in this post
|
|


As this is a fixed-width font, the space character is also surrounded by spaces, resulting in a 7-width space between the two letters.

a b
1234567       -- these numbers are just for the example, you don't have to output them
#####       ####
#   #       #   #
#####       ####
#   #       #   #
#   #       ####

a  b
1234567890123
#####             ####
#   #             #   #
#####             ####
#   #             #   #
#   #             ####


When you encounter a newline, as in the input

ascii
text


Just make sure to separate the two blocks of text by at least one empty line

#####  ###   ###  ##### #####
#   # #     #   #   #     #
#####  ###  #       #     #
#   #     # #   #   #     #
#   #  ###   ###  ##### #####

##### ##### #   # #####
#   #      # #    #
#   ####    #     #
#   #      # #    #
#   ##### #   #   #


Also, you are allowed to replace the #s with any other character as long as it is in the printable ASCII range, and is not spaces. You could for instance use As for the letter A, B for the letter B and so on.

As this is (and moreover ) the winning submission will be the one that solve this challenge in the least byte possible, have fun!

• Is the 5-char space also to be surrounded by single-spaces, or is this a variable width font?
May 30 '16 at 7:10
• @Adám you're right, it is supposed to be surrounded by spaces, I'll update regarding this point May 30 '16 at 7:11
• Can we somehow retrieve the pixel alphabet as input or do we have to construct those characters inside our rated code snippet? May 30 '16 at 12:52
• @ByteCommander One (big) part of this challenge is about string compressing, you have to find the best way to compress this alphabet in your code, while still being able to retrieve it and use it :). So yes, it is included in your golfed-code and can't be inputed to your program May 30 '16 at 12:55
• @Katenkyo Aha, okay. Thanks for the clarification. May 30 '16 at 12:56

## Python 3, 375 bytes

f=lambda i:"\n\n".join("\n".join(map(" ".join,zip(*[[x.replace("0"," ")[a*5:a*5+5]for a in range(5)]for x in[["{:025b}".format(int(c,36))for c in'0 JPCFL J2UKE 92Y3Y J2KAM JOMCF JOMC0 92B72 AYP81 JFM3J JFMHO AZC7M AB6ZJ B5I5T B43N5 92YWE J2UJ4 92YY7 J2UQC 926UM JFM2S AYE5Q AY8G4 AYHKH AT6Q9 AT6KK AWU7'.split()][x!=" "and ord(x)-64]for x in j.upper()]])))for j in i.split("\n"))


See this code running on ideone.com.

The same code, but somehow nicely indented, formatted and commented:

f = lambda i: \

# join multiline strings together using an empty line as separator:
"\n\n".join(

# join the string lines of one big output line together:
"\n".join(

# join the corresponding rows of the letters together using " ":
map(" ".join, zip(*

# make a list (output line) of list (output characters)
# of strings (single character's rows):
[

# replace 0s with spaces and split the bit strings into
# chunks of 5 characters - the rows of each letter:
[x.replace("0", " ")[a*5 : a*5+5] for a in range(5)]

for x in [

# split the space separated character codes and
# convert them from base 36 to
# base 2 strings of length 25:
["{:025b}".format(int(c, 36)) for c in

# the encoded font data (reformatted):
'0 JPCFL J2UKE 92Y3Y J2KAM JOMCF JOMC0 92B72 '
'AYP81 JFM3J JFMHO AZC7M AB6ZJ B5I5T B43N5 92YWE '
'J2UJ4 92YY7 J2UQC 926UM JFM2S AYE5Q AY8G4 AYHKH '
'AT6Q9 AT6KK AWU7'.split()]

# select element 0 if we want a space, else find
# out the index from the ASCII code of the letter:
[x != " " and ord(x) - 64]

# repeat for every character in the input line:
for x in j.upper()
]
]
))

# repeat for every line in the input
) for j in i.split("\n")
)


I also decided to go for base 36 encoding as that's the highest base Python's built-in int() natively supports. Here is a short Python 3 script I wrote (ungolfed) that converts font definitions like in the question into base 36 codes: My converter on ideone.com

The result consists of the character 1 as enabled pixel and a space   as disabled pixel. Here's a single example run:

Input (line break as \n):

Hello World
Python rocks


Output:

1   1 11111 1     1      111        1   1  111  1111  1     1111
1   1 1     1     1     1   1       1   1 1   1 1   1 1     1   1
11111 1111  1     1     1   1       1 1 1 1   1 1111  1     1   1
1   1 1     1     1     1   1       11 11 1   1 11    1     1   1
1   1 11111 11111 11111  111        1   1  111  1 1   11111 1111

1111  1   1 11111 1   1  111  1   1       1111   111   111  1   1  111
1   1  1 1    1   1   1 1   1 11  1       1   1 1   1 1   1 1  1  1
1111    1     1   11111 1   1 1 1 1       1111  1   1 1     111    111
1       1     1   1   1 1   1 1  11       11    1   1 1   1 1 1       1
1       1     1   1   1  111  1   1       1 1    111   111  1  1   111


# Clojure, 552 bytes

(defn t[s](print(reduce #(str %1"\n"%2)(map #(apply str %)(let[a[:jpcfl :j2uke :92y3y :j2kam :jomcf :jomc0 :92b72 :ayp81 :jfm3j :jfmho :azc7m :ab6zj :b5i5t :b43n5 :92ywe :j2uj4 :92yy7 :j2uqc :926um :jfm2s :aye5q :ay8g4 :ayhkh :at6q9 :at6kk :je7mn :0]](map(fn[o](map #(str(.replace %"0"" ")"\n")(map(fn[w](reduce #(str %1(.substring %2 w(+ w 5))"0")""(map #(str(apply str(repeat(- 25(count %))"0"))%)(map #(Integer/toString(Integer/valueOf(name %)36)2)(map a(map #(if(= % \space)26(-(int %)97))(.toLowerCase o)))))))(range 0 25 5))))(.split s"\n")))))))


Each letter in ascii is represented as a binary string with # - 1, space - 0. Then it's converted to base 36 so that it only takes 5 chars to store + ":" to let Clojure know that it should be treated as symbol. Then the input is split by newline symbol and for each line we convert a letter in 36 base back to binary base and get first [0:5] symbols add newline symbols, get next [5:10] symbols and so on.

You can see it running here - https://ideone.com/y99ST5

# Powershell, 261 253 bytes

$args-split' '|%{$s=$_ 0..5|%{$l=$_ -join($s|% *per|% t*y|%{$c='_ONO__NQ__QAQQNONON_QQQQQ?QQQQAAAQDDIA[SQQQQADQQQJJ(_OAQOOY_DDGAUUQOQONDQJUDD$QQQQAAQQDEEAQYQAYCPDQJ[JD"QONO_ANQ_GI_QQNA^ENDNDQQD?'[$l*26+$_-65+222*!($_-32)] 0..5|%{' #'[(+$c-shr$_)%2]}})}}  Test script: $f = {

$args-split' '|%{$s=$_ 0..5|%{$l=$_ -join($s|% *per|% t*y|%{$c='_ONO__NQ__QAQQNONON_QQQQQ?QQQQAAAQDDIA[SQQQQADQQQJJ(_OAQOOY_DDGAUUQOQONDQJUDD$QQQQAAQQDEEAQYQAYCPDQJ[JD"QONO_ANQ_GI_QQNA^ENDNDQQD?'[$l*26+$_-65+222*!($_-32)] 0..5|%{' #'[(+$c-shr$_)%2]}})}} } &$f "ascii art
text"


Output:

#####  ###   ###  ##### #####       ##### ####  #####
#   # #     #   #   #     #         #   # #   #   #
#####  ###  #       #     #         ##### ####    #
#   #     # #   #   #     #         #   # ##      #
#   #  ###   ###  ##### #####       #   # # #     #

##### ##### #   # #####
#   #      # #    #
#   ####    #     #
#   #      # #    #
#   ##### #   #   #


## Note:

$s|% *per|% t*y is shortcut for $s|% toUpper|% toCharArray

For each character of the source string, the script takes a symbol (bit mask) from the magic string '_ONO__NQ...'. However, the index goes beyond the magic string for a space. In this case, the bit mask $c becomes empty. It means zero for all bits. ## About blank line: The script displays 6 rows for each symbol instead of 5. The index goes beyond the magic string for a blank line too. So, the row 6 contains spaces only. It is best seen if you print another character instead of a space. For example ·. #####··###···###··#####·#####·······#####·####··#####· #···#·#·····#···#···#·····#·········#···#·#···#···#··· #####··###··#·······#·····#·········#####·####····#··· #···#·····#·#···#···#·····#·········#···#·##······#··· #···#··###···###··#####·#####·······#···#·#·#·····#··· ······················································ #####·#####·#···#·#####· ··#···#······#·#····#··· ··#···####····#·····#··· ··#···#······#·#····#··· ··#···#####·#···#···#··· ························  # C (gcc), 326322321 317 bytes -8 bytes thanks to ceilingcat #define X!!putchar char*p,*q;i,j;f(int*s){for(;p=strtok(p?0:strdup(s),"\n");X(10))for(i=0;i<5;i+=X(10))for(q=p;*q;q+=X(32))for(j=0;j<5;)X((*q-32?"OAOAA?A?A?>A1A>?AAA?O1?1OO1?11>1IA>AAOAAO444OO4457A97591111OAKEAAACCIA>AAA>?A?11>AAIN?A?35>1>@>O4444AAAA>AA::4AAEKAA:4:AA:444O842O"[(*q&~32)*5-325+i]-48:0)>>j++&1?35:32);}  Try it online! # SOGL, 137 bytes  °f7-π⅛χ%sΤ↕ņLRΕ⅓9׀b∫rr(¶æKGTΧ3;■ΦΤg¼⁰¡Νg‽}○eΧ²Y∫Οαν⌡l′}¾(8╔ <%╤∙i.d↔ū∫Æo┌jyŗ▲δ⁶=╗$↑yōΛ3h¼╔◄┼)‘’«n.{5{ø}¹,uR{8+:Ahwha’#=?X’«@*}┼L@*┼}pøO


Explanation:

...‘’«n.{5{ø}¹,uR{8+:Ahwha’#=?X’«@*}┼L@*┼}pøO
...‘                                           push a string with the letter data                            ["..."]
’«n                                        split in lengths of 25                                        [[".", ".", ".",...]]
.{                                      repeat input times                                            [[".", ".", ".",...]]
5{ø}                                  push 5 empty strings                                          [[".", ".", ".",...], "", "", "", "", ""]
¹                                 wrap those in an array                                        [[".", ".", ".",...], ["", "", "", "", ""]]
,                                get a string input                                            [[".", ".", ".",...], ["", "", "", "", ""], "Hello World"]
u                               lowercase it                                                  [[".", ".", ".",...], ["", "", "", "", ""], "hello world"]
R{                       }     itirate over the ordinals of the string                       [[".", ".", ".",...], ["", "", "", "", ""], 104]
8+                           add 8 to the ordinal                                          [[".", ".", ".",...], ["", "", "", "", ""], 112]
:A                         save on variable A                                            [[".", ".", ".",...], ["", "", "", "", ""], 112]
h                        swap 2 items one below the stack                              [["", "", "", "", ""], [".", ".", ".",...], 112]
w                       get the ord+8th item of the letter data array (modulo length) [["", "", "", "", ""], [".", ".", ".",...], "-----  -    -    -  -----"]
h                      swap 2 items one below the stack                              [[".", ".", ".",...], ["", "", "", "", ""], "-----  -    -    -  -----"]
a                     load the variable A                                           [[".", ".", ".",...], ["", "", "", "", ""], "-----  -    -    -  -----", 112]
’#=?     }           if equals to 40 then                                          [[".", ".", ".",...], ["", "", "", "", ""], "----- -     -     - -----"] (temporalily switching to space case; it incorrectly picks "N" for space)
X                delete the string                                             [[".", ".", ".",...], ["", "", "", "", ""]]
’«@*            push a string with 25 spaces                                  [[".", ".", ".",...], ["", "", "", "", ""], "                         "]
┼          add the string vertically-then-horizontally to the array      [[".", ".", ".",...], ["", "", "", "", ""], ["-   -", "-   -", "-----", "-   -", "-   -"]] (back to "H")
L@*       push a string with 10 spaces                                  [[".", ".", ".",...], ["", "", "", "", ""], ["-   -", "-   -", "-----", "-   -", "-   -"], "          "]
┼      add the string vertically-then-horizontally to the array      [[".", ".", ".",...], ["", "", "", "", ""], ["-   -  ", "-   -  ", "-----  ", "-   -  ", "-   -  "]]
p    output the resulted line                                      [[".", ".", ".",...], ["", "", "", "", ""]]
øO  append to output an empty line


note: currently this language can't really accept multiline input string so I've made it ask for a number and read the next x lines as the input.

The first string is

"------ -  - -  - -  ----------- - -- - -- - - - -  --- -   --   --   - - - ------   --   --   - --- ------ - -- - -- - --   ------- -  - -  - -  -     --- -   --   -- - -  -- -----  -    -    -  ------   --   -------   --   --  ---   -------    -    -----  -    --  -  --    -----    -    -    -    ------ -     -   -   ---------- -     -     - ----- --- -   --   --   - --- ------ -  - -  - -   -    --- -   --   --  -- ---------- -- - - -- -   -    -   - - -- - -- - -   - -    -    ------    -    ----     -    -    ----- --     --     -  -- --   -----   -   -     - ------   - - -   -   - - -   --     -     --- -   -    -   --  --- - ---  --   -"


compressed using a custom dictionary that uses " " and "-" (the compression has a special mode with "\n -|/_" available so even more compression!)
It contains 25 chars per ascii char in the order of the alphabet. they are ordered top-down then right.
the chars go like

16b
27c
38d . . .
49e
5af


and that's the same way that ┼ adds them to an array.

• I'm definitly going to check how this turns out ! Instead of requiring an other input, the closest thing you could do to the original rules would be to require an input in the form foo\nbar for multiline inputs Apr 4 '17 at 17:39

# JavaScript (ES6), 292287 278 bytes

s=>s.split
.map(s=>vfefvvehvvh1hhefefevhhhhhv
hhhh111h4491rjhhhh14hhhaa8
vf1hffpv4471llhfhfe4hal444
hhhh11hh4551hph1p3g4hara42
hfefv1ehv79vhhe1u5e4e4hh4v.replace(/.{26}/g,S=>s.replace(/./g,c=>'012345'.replace(/./g,x=>' #'[(P=parseInt)(S[P(c,36)-10]||0,36)>>x&1])))).join




### Demo

let f =

s=>s.split
.map(s=>vfefvvehvvh1hhefefevhhhhhv
hhhh111h4491rjhhhh14hhhaa8
vf1hffpv4471llhfhfe4hal444
hhhh11hh4551hph1p3g4hara42
hfefv1ehv79vhhe1u5e4e4hh4v.replace(/.{26}/g,S=>s.replace(/./g,c=>'012345'.replace(/./g,x=>' #'[(P=parseInt)(S[P(c,36)-10]||0,36)>>x&1])))).join



O.innerText = f('HELLO WORLD\nTHIS IS A TEST')
<pre id=O></pre>`