Bana ASCII Alfabesini Golf

13

Basit metin okumanın yeterince çekici olmadığını düşünmüyor musunuz? Deneyin bizim

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

Çok daha süslü değil mi? Ama elle yazmak oldukça uzun, birisi bunu benim için yapan bir program yapsaydı harika olurdu!

Göreviniz , bana yardım etmek için gönüllü olmanız durumunda, [a-zA-Z\s\n]sadece içeren bir dize alan bir program veya işlev yazmak ve bunun ascii yazısını çıktılamak (veya geri döndürmek) olacaktır!

Çıktınızı biçimlendirmek için aşağıdaki alfabeyi kullanmanız gerekir:

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

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

Boşluk:

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

Bu, sabit genişlikli bir yazı tipi olduğundan, boşluk karakteri de boşluklarla çevrelenir ve iki harf arasında 7 genişlikli bir boşluk oluşur.

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

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

Giriş satırında olduğu gibi yeni bir satırla karşılaştığınızda

ascii
text

İki metin bloğunu en az bir boş satırla ayırdığınızdan emin olun.

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

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

Ayrıca, #yazdırılabilir ASCII aralığında olduğu ve boşluk olmadığı sürece s tuşlarını başka bir karakterle değiştirmenize izin verilir . Örneğin AA harfi için s, BB harfi için vb. Kullanabilirsiniz .

Bu kod-golf (ve dahası kolmogorov-karmaşıklık ) olduğu için kazanan başvuru, bu meydan okumayı mümkün olan en az baytta çözen, iyi eğlenceler olacak!

code-golf  ascii-art  kolmogorov-complexity 
— Katenkyo
kaynak
5 karakterlik alan tek boşluklarla mı çevrelenecek yoksa değişken genişlikli bir yazı tipi mi?
— 16'da
@ Haklısın, boşluklarla çevrili olması gerekiyor, bu
— konuyla
Bir şekilde piksel alfabesini giriş olarak alabilir miyiz veya bu karakterleri nominal kod snippet'imizde oluşturmamız gerekir mi?
— Bayt Komutanı
@ByteCommander Bu zorluğun bir (büyük) kısmı dize sıkıştırmayla ilgilidir, yine de almak ve kullanmak için bu alfabeyi kodunuzda sıkıştırmanın en iyi yolunu bulmak zorundasınız :). Bu yüzden evet, golf kodunuza dahildir ve programınıza
— girilemez
@Katenkyo Aha, tamam. Açıklama için teşekkürler.
— Bayt Komutanı

Yanıtlar:

6

Python 3, 375 bayt

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

İdeone.com'da çalışan bu koda bakın.

Aynı kod, ancak bir şekilde güzel girintili, biçimlendirilmiş ve yorumlanmış:

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

Ayrıca Python'un yerleşik doğal olarak desteklediği en yüksek taban olduğu için base 36 kodlamaya gitmeye karar verdim int(). İşte soru gibi yazı tipi tanımlarını temel 36 kodlarına dönüştüren kısa bir Python 3 betiği (ungolfed): ideone.com'daki çeviricim

Sonuç, 1etkin piksel olarak karakterden ve devre dışı piksel olarak bir boşluktan oluşur . İşte tek bir örnek:

Giriş (satır sonu olarak \n):

Hello World
Python rocks

Çıktı:

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
— Bayt Komutanı
kaynak
4

Clojure, 552 bayt

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

ASCII'deki her harf # - 1, boşluk - 0 ile bir ikili dize olarak temsil edilir. Sonra, 36 tabanına dönüştürülür, böylece Clojure'a sembol olarak işlem görmesi gerektiğini bildirmek için + ":" depolamak için yalnızca 5 karakter gerekir. Daha sonra giriş satırsonu sembolü ile bölünür ve her satır için 36 tabandaki bir harfi ikili tabana dönüştürür ve ilk [0: 5] sembolleri satırsonu sembolleri ekler, sıra [5:10] sembolleri vb. Alırız.

Burada çalıştığını görebilirsiniz - https://ideone.com/y99ST5

— cliffroot
kaynak
1

SOGL , 137 bayt (rakip olmayan)

 °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

Açıklama:

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

not: şu anda bu dil gerçekten çok satırlı giriş dizesini kabul edemez, bu yüzden bir sayı istedim ve sonraki x satırlarını giriş olarak okudum.

İlk dize

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

"" ve "-" kullanan özel bir sözlük kullanarak sıkıştırılır (sıkıştırmanın "\ n - | / _" özel bir modu vardır, bu yüzden daha da fazla sıkıştırma kullanılabilir!)
Alfabetik sırayla ascii char başına 25 karakter içerir. yukarıdan aşağıya sonra sağa doğru sıralanırlar.
karakterler şöyle

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

ve bu ┼onları bir diziye ekleyen yöntemle aynıdır .

— dzaima
kaynak
Kesinlikle bunun nasıl ortaya çıktığını kontrol edeceğim! Başka bir girdi gerektirmek yerine, orijinal kurallara yapabileceğiniz en yakın şey foo\nbar, çok satırlı girdiler için formda bir girdi gerektirmek olacaktır
— Katenkyo
1

Powershell, 261253 bayt

$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 komut dosyası:

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

Çıktı:

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

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

Not:

$s|% *per|% t*y kısayol edilir için$s|% toUpper|% toCharArray

Alan hakkında:

Kaynak dizginin her karakteri için, komut dosyası sihirli dizgiden bir sembol (bit maskesi) alır '_ONO__NQ...'. Ancak, dizin bir boşluk için sihirli dizenin ötesine geçer. Bu durumda, bit maskesi $cboşalır. Tüm bitler için sıfır anlamına gelir.

Boş satır hakkında:

Komut dosyası, 5 yerine her sembol için 6 satır görüntüler. Dizin, boş bir satır için de sihirli dizenin ötesine geçer. Dolayısıyla, 6. sıra yalnızca boşluklar içerir.

En iyisi boşluk yerine başka bir karakter basarsanız görülür. Örneğin ·.

#####··###···###··#####·#####·······#####·####··#####·
#···#·#·····#···#···#·····#·········#···#·#···#···#···
#####··###··#·······#·····#·········#####·####····#···
#···#·····#·#···#···#·····#·········#···#·##······#···
#···#··###···###··#####·#####·······#···#·#·#·····#···
······················································
#####·#####·#···#·#####·
··#···#······#·#····#···
··#···####····#·····#···
··#···#······#·#····#···
··#···#####·#···#···#···
························
— şaşımış
kaynak
0

C (gcc) , 326 bayt

İlk bıçak. TIO üzerinde stdio.h ve string.h eklemek zorunda kaldı, ama MinGW ile gerekli değil.

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

Çevrimiçi deneyin!

— gastropner
kaynak
0

JavaScript (ES6), 292 287 278 bayt

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`

`

gösteri

Kod snippet'ini göster

— Arnauld
kaynak
Sitemizi kullandığınızda şunları okuyup anladığınızı kabul etmiş olursunuz: Çerez Politikası ve Gizlilik Politikası.
Licensed under cc by-sa 3.0 with attribution required.