Golf mir ein ASCII-Alphabet

13

Finden Sie es nicht attraktiv genug, einfachen Text zu lesen? Probier unser

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

Viel ausgefallener, nicht wahr? Aber es ist ziemlich lang, von Hand zu schreiben, es wäre wunderbar, wenn jemand ein Programm machen würde, das es für mich macht!

Wenn Sie mir freiwillig helfen, besteht Ihre Aufgabe darin, ein Programm oder eine Funktion zu schreiben, die [a-zA-Z\s\n]nur eine Zeichenfolge enthält , und die ASCII-Schrift davon auszugeben (oder zurückzugeben)!

Sie müssen das folgende Alphabet verwenden, um Ihre Ausgabe zu formatieren:

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

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

Der Raum:

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

Da es sich um eine Schriftart mit fester Breite handelt, wird das Leerzeichen auch von Leerzeichen umgeben, was zu einem 7-fachen Abstand zwischen den beiden Buchstaben führt.

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

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

Wenn Sie auf eine neue Zeile stoßen, wie in der Eingabe

ascii
text

Stellen Sie einfach sicher, dass die beiden Textblöcke durch mindestens eine Leerzeile voneinander getrennt sind

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

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

Sie können das #s auch durch ein beliebiges anderes Zeichen ersetzen, sofern es sich im druckbaren ASCII-Bereich befindet und keine Leerzeichen enthält. Sie könnten zum Beispiel As für den Buchstaben A, Bfür den Buchstaben B usw. verwenden.

Da es sich um Code-Golf (und darüber hinaus um Kolmogorov-Komplexität ) handelt, ist der Gewinner derjenige, der diese Herausforderung im kleinstmöglichen Byte löst. Viel Spaß!

code-golf ascii-art kolmogorov-complexity Katenkyo
quelle
Soll das 5-Zeichen-Feld auch von einzelnen Leerzeichen umgeben sein, oder handelt es sich um eine Schriftart mit variabler Breite?
Adám
@ Adám du hast recht, es soll von Leerzeichen umgeben sein, ich werde diesbezüglich
updaten
Können wir irgendwie das Pixel-Alphabet als Eingabe abrufen oder müssen wir diese Zeichen in unserem Code-Snippet mit Nennwert konstruieren?
Byte Commander
@ByteCommander Ein (großer) Teil dieser Herausforderung ist das Komprimieren von Zeichenfolgen. Sie müssen den besten Weg finden, um dieses Alphabet in Ihrem Code zu komprimieren, während Sie es dennoch abrufen und verwenden können :). Also ja, es ist in Ihrem Golf-Code enthalten und kann nicht in Ihr Programm
eingegeben werden
@Katenkyo Aha, okay. Danke für die Klarstellung.
Byte Commander

Antworten:

6

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

Sehen Sie sich diesen Code auf ideone.com an.

Derselbe Code, aber irgendwie gut eingerückt, formatiert und kommentiert:

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

Ich habe mich auch für die Base-36- Codierung entschieden, da dies die höchste Basis ist, die Python int()nativ unterstützt. Hier ist ein kurzes Python 3-Skript, das ich geschrieben habe (ungolfed) und das Schriftdefinitionen wie in der Frage in Base 36-Codes umwandelt : Mein Konverter auf ideone.com

Das Ergebnis besteht aus dem Zeichen 1als aktiviertem Pixel und einem Leerzeichen als deaktiviertem Pixel. Hier ist ein einziger Beispiellauf:

Eingabe (Zeilenumbruch als \n):

Hello World
Python rocks

Ausgabe:

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
Byte Commander
quelle
4

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

Jeder Buchstabe in ASCII wird als binäre Zeichenfolge mit # - 1, Leerzeichen - 0 dargestellt. Anschließend wird er in Basis 36 konvertiert, sodass zum Speichern von + ":" nur 5 Zeichen erforderlich sind, damit Clojure weiß, dass er als Symbol behandelt werden soll. Dann wird die Eingabe nach Zeilenumbruchsymbolen aufgeteilt und für jede Zeile wird ein Buchstabe in der Basis 36 zurück in die Binärbasis konvertiert und es werden die ersten [0: 5] Symbole hinzugefügt, die nächsten [5:10] Symbole und so weiter.

Sie können es hier sehen - https://ideone.com/y99ST5

Cliffroot
quelle
1

SOGL , 137 Bytes (nicht konkurrierend)

 °f`7-π⅛χ%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

Erläuterung:

...‘’«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

Hinweis: Derzeit kann diese Sprache keine mehrzeiligen Eingabezeichenfolgen akzeptieren. Daher habe ich sie nach einer Zahl fragen lassen und die nächsten x Zeilen als Eingabe gelesen.

Die erste Zeichenfolge ist

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

komprimiert mit einem benutzerdefinierten Wörterbuch, das "" und "-" verwendet (die Komprimierung verfügt über einen speziellen Modus mit "\ n - | / _", sodass noch mehr Komprimierung möglich ist!).
Es enthält 25 Zeichen pro ASCII-Zeichen in der Reihenfolge des Alphabets. Sie sind von oben nach unten und dann rechts angeordnet.
Die Zeichen gehen wie

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

und das ist der gleiche Weg, ┼der sie zu einem Array hinzufügt.

dzaima
quelle
Ich werde auf jeden Fall überprüfen, wie sich das herausstellt! Anstatt eine andere Eingabe zu erfordern, können Sie den ursprünglichen Regeln am nächsten kommen, indem Sie eine Eingabe in der Form foo\nbarfür mehrzeilige Eingaben
anfordern
1

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]}})}}

Testskript:

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

Ausgabe:

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

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

Hinweis:

$s|% *per|% t*y ist eine Abkürzung für$s|% toUpper|% toCharArray

Über den Weltraum:

Für jedes Zeichen der Quellzeichenfolge entnimmt das Skript ein Symbol (Bitmaske) aus der magischen Zeichenfolge '_ONO__NQ...'. Der Index geht jedoch über die magische Zeichenfolge für ein Leerzeichen hinaus. In diesem Fall die Bitmaske$c leer. Es bedeutet Null für alle Bits.

Über Leerzeile:

Das Skript zeigt für jedes Symbol 6 statt 5 Zeilen an. Der Index geht auch für eine Leerzeile über die magische Zeichenfolge hinaus. Die Zeile 6 enthält also nur Leerzeichen.

Am besten ist es, wenn Sie anstelle eines Leerzeichens ein anderes Zeichen drucken. Zum Beispiel ·.

#####··###···###··#####·#####·······#####·####··#####·
#···#·#·····#···#···#·····#·········#···#·#···#···#···
#####··###··#·······#·····#·········#####·####····#···
#···#·····#·#···#···#·····#·········#···#·##······#···
#···#··###···###··#####·#####·······#···#·#·#·····#···
······················································
#####·#####·#···#·#####·
··#···#······#·#····#···
··#···####····#·····#···
··#···#······#·#····#···
··#···#####·#···#···#···
························
mazzy
quelle
0

C (gcc) , 326 Bytes

Ein erster Versuch. Musste stdio.h und string.h in TIO einbinden, wird aber bei MinGW nicht benötigt.

char*p=0,*q;(*X)()=putchar;i,j;f(char*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;j++)X(((*q==32?0:"OAOAA?A?A?>A1A>?AAA?O1?1OO1?11>1IA>AAOAAO444OO4457A97591111OAKEAAACCIA>AAA>?A?11>AAIN?A?35>1>@>O4444AAAA>AA::4AAEKAA:4:AA:444O842O"[(toupper(*q)-65)*5+i]-48)>>j)&1?35:32);}

Probieren Sie es online!

Gastropner
quelle
0

JavaScript (ES6), 292 287 278 Byte

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

Code-Snippet anzeigen

Arnauld
quelle