गोल्फ मुझे एक ASCII वर्णमाला

13

क्या आपको नहीं लगता कि साधारण पाठ पढ़ना पर्याप्त अपील नहीं है? कोशिश करिए हमारा

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

बहुत अधिक फैंसी यह नहीं है? लेकिन यह हाथ से लिखने के लिए बहुत लंबा है, यह बहुत अच्छा होगा यदि कोई ऐसा प्रोग्राम करता है जो मेरे लिए करता है!

आपका कार्य , यदि आप मेरी मदद करने के लिए स्वेच्छा से काम करते हैं , तो एक प्रोग्राम या एक फ़ंक्शन लिखना होगा जो [a-zA-Z\s\n]केवल एक स्ट्रिंग लेता है , और आउटपुट (या वापसी) की एएससीआई लेखन!

अपने आउटपुट को प्रारूपित करने के लिए आपको निम्नलिखित वर्णमाला का उपयोग करना होगा:

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

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

अंतरिक्ष:

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

जैसा कि यह एक निश्चित-चौड़ाई वाला फ़ॉन्ट है, अंतरिक्ष वर्ण भी रिक्त स्थान से घिरा हुआ है, जिसके परिणामस्वरूप दो अक्षरों के बीच 7-चौड़ाई का स्थान होता है।

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

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

जब आप एक नई पंक्ति का सामना करते हैं, जैसा कि इनपुट में है

ascii
text

बस कम से कम एक खाली लाइन द्वारा पाठ के दो ब्लॉकों को अलग करना सुनिश्चित करें

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

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

इसके अलावा, आपको #किसी भी अन्य वर्ण के साथ एस को बदलने की अनुमति है जब तक कि यह मुद्रण योग्य एएससीआईआई रेंज में है, और रिक्त स्थान नहीं है। आप उदाहरण Aके लिए अक्षर A, Bअक्षर B और इतने पर के लिए उपयोग कर सकते हैं ।

जैसा कि यह कोड-गोल्फ (और इसके अलावा कोल्मोगोरोव-कॉम्प्लेक्सिटी ) है, विजयी सबमिशन वह होगा जो कम से कम बाइट में इस चुनौती को हल करे, मज़े करे!

code-golf  ascii-art  kolmogorov-complexity 
— Katenkyo
स्रोत
क्या 5-चार स्थान भी सिंगल-स्पेस से घिरा हुआ है, या यह एक चर चौड़ाई फ़ॉन्ट है?
— अड्म
@ आप सही कह रहे हैं, यह रिक्त स्थान से घिरा माना जाता है, मैं इस बिंदु के बारे में अपडेट
— करूंगा
क्या हम किसी तरह से पिक्सेल वर्णमाला को इनपुट के रूप में प्राप्त कर सकते हैं या क्या हमें अपने रेटेड कोड स्निपेट के अंदर उन वर्णों का निर्माण करना होगा?
— बाइट कमांडर
@ByteCommander एक (बड़ा) इस चुनौती का हिस्सा स्ट्रिंग कंप्रेसिंग के बारे में है, आपको अपने कोड में इस वर्णमाला को संपीड़ित करने का सबसे अच्छा तरीका खोजना होगा, जबकि अभी भी इसे पुनर्प्राप्त करने और इसका उपयोग करने में सक्षम है :)। तो हाँ, यह आपके गोल्फ-कोड में शामिल है और इसे आपके कार्यक्रम में शामिल नहीं किया जा सकता है
— काटनेंको
@Katenkyo अहा, ठीक है। स्पष्टीकरण के लिए धन्यवाद।
— बाइट कमांडर

जवाबों:

6

पायथन 3, 375 बाइट्स

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

इस कोड को ideone.com पर देखें।

एक ही कोड, लेकिन किसी तरह अच्छी तरह से इंडेंट, स्वरूपित और टिप्पणी:

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

मैंने बेस 36 एनकोडिंग के लिए भी जाने का फैसला किया है क्योंकि यह उच्चतम बेस पायथन का अंतर्निहित int()मूल समर्थन है। यहाँ एक छोटी पायथन 3 लिपि है जो मैंने लिखी थी (ungolfed) जो फ़ॉन्ट परिभाषाओं को आधार में परिवर्तित करती है जैसे आधार 36 कोड में: ideone.com पर मेरा कन्वर्टर

परिणाम 1में सक्षम पिक्सेल के रूप में चरित्र होता है और अक्षम पिक्सेल के रूप में एक स्थान होता है । यहां एक एकल उदाहरण रन है:

इनपुट (रेखा विराम \n):

Hello World
Python rocks

आउटपुट:

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
— बाइट कमांडर
स्रोत
4

क्लोजर, 552 बाइट्स

(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 के प्रत्येक अक्षर को # - 1, space - 0. के साथ एक बाइनरी स्ट्रिंग के रूप में दर्शाया गया है, फिर इसे बेस 36 में बदल दिया जाता है, ताकि यह केवल 5 चार्ट्स को स्टोर करने के लिए + ":" ले जाए, ताकि क्लोजर को यह पता चल सके कि इसे प्रतीक के रूप में माना जाना चाहिए। फिर इनपुट को न्यूलाइन प्रतीक द्वारा विभाजित किया जाता है और प्रत्येक पंक्ति के लिए हम 36 बेस में एक अक्षर को बाइनरी बेस में परिवर्तित करते हैं और पहले प्राप्त करते हैं [0: 5] प्रतीकों में न्यूलाइन प्रतीकों को जोड़ते हैं, अगले [5:10] प्रतीक और इतने पर मिलते हैं।

आप इसे यहाँ देख सकते हैं - https://ideone.com/y99ST5

— cliffroot
स्रोत
1

एसओजीएल , 137 बाइट्स (गैर-प्रतिस्पर्धात्मक)

 °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

स्पष्टीकरण:

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

ध्यान दें: वर्तमान में यह भाषा वास्तव में मल्टीलाइन इनपुट स्ट्रिंग को स्वीकार नहीं कर सकती है इसलिए मैंने इसे एक नंबर के लिए कहा है और इनपुट के रूप में अगली एक्स लाइनें पढ़ी है।

पहला तार है

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

"" और "-" का उपयोग करने वाले कस्टम शब्दकोश का उपयोग करके संपीड़ित किया जाता है (संपीड़न में "\ n - / / _" के साथ एक विशेष मोड उपलब्ध है इसलिए और भी अधिक संपीड़न उपलब्ध है!)
इसमें वर्णमाला के क्रम में 25 चार्ट प्रति असिसी चार शामिल हैं। उन्हें ऊपर-नीचे करने का आदेश दिया जाता है, फिर सही।
आकर्षण की तरह चलते हैं

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

और यह उसी तरह है जो ┼उन्हें एक सरणी में जोड़ता है।

— dzaima
स्रोत
मैं निश्चित रूप से जाँच करने जा रहा हूँ कि यह कैसे निकला! एक अन्य इनपुट आवश्यक बनाने के बजाय, निकटतम बात आप मूल नियमों के कर सकता है के रूप में एक इनपुट की आवश्यकता होगी foo\nbarबहु इनपुट के लिए
— Katenkyo
1

पॉवर्सशेल, 261 253 बाइट्स

$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 = {

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

आउटपुट:

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

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

ध्यान दें:

$s|% *per|% t*y के लिए शॉर्टकट है$s|% toUpper|% toCharArray

अंतरिक्ष के बारे में:

स्रोत स्ट्रिंग के प्रत्येक वर्ण के लिए, स्क्रिप्ट जादुई स्ट्रिंग से प्रतीक (बिट मास्क) लेती है '_ONO__NQ...'। हालांकि, सूचकांक एक स्थान के लिए जादू स्ट्रिंग से आगे निकल जाता है। इस स्थिति में, बिट मास्क $cखाली हो जाता है। इसका मतलब है कि सभी बिट्स के लिए शून्य।

रिक्त पंक्ति के बारे में:

स्क्रिप्ट 5. के बजाय प्रत्येक प्रतीक के लिए 6 पंक्तियों को प्रदर्शित करती है। सूचकांक एक खाली लाइन के लिए भी जादुई स्ट्रिंग से परे जाता है। तो, पंक्ति 6 ​​में केवल रिक्त स्थान होते हैं।

यह सबसे अच्छा देखा जाता है यदि आप एक स्थान के बजाय किसी अन्य वर्ण को प्रिंट करते हैं। उदाहरण के लिए ·।

#####··###···###··#####·#####·······#####·####··#####·
#···#·#·····#···#···#·····#·········#···#·#···#···#···
#####··###··#·······#·····#·········#####·####····#···
#···#·····#·#···#···#·····#·········#···#·##······#···
#···#··###···###··#####·#####·······#···#·#·#·····#···
······················································
#####·#####·#···#·#####·
··#···#······#·#····#···
··#···####····#·····#···
··#···#······#·#····#···
··#···#####·#···#···#···
························
— Mazzy
स्रोत
0

सी (जीसीसी) , 326 बाइट्स

इस पर पहला छुरा। TIO पर stdio.h और string.h को शामिल करना था, लेकिन MinGW के साथ इसकी आवश्यकता नहीं थी।

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

इसे ऑनलाइन आज़माएं!

— gastropner
स्रोत
0

जावास्क्रिप्ट (ईएस 6), 292 287 278 बाइट्स

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`

`

डेमो

कोड स्निपेट दिखाएं

— Arnauld
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.