গল্ফ আমাকে একটি 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এ বর্ণের Bজন্য, অক্ষর বি এবং আরও ব্যবহার করতে পারেন।

যেহেতু এটি কোড-গল্ফ (এবং আরও কলম্বোগরভ-জটিলতা ) বিজয়ী জমাটি হ'ল এটিই চ্যালেঞ্জটিকে কমপক্ষে বাইটে সমাধান করতে পারে, মজা করুন!

code-golf  ascii-art  kolmogorov-complexity 
— Katenkyo
সূত্র
5-চর স্পেসটিও কি একক-স্পেস দ্বারা বেষ্টিত হবে, বা এটি একটি পরিবর্তনশীল প্রস্থের ফন্ট?
— অ্যাডম
@ আদম আপনি ঠিক বলেছেন, এটি চারপাশে ঘিরে থাকার কথা, আমি এই
— বিষয়টির
আমরা কি কোনওভাবে ইনপুট হিসাবে পিক্সেল বর্ণমালা পুনরুদ্ধার করতে পারি বা আমাদের রেটযুক্ত কোড স্নিপেটের মধ্যে সেই অক্ষরগুলি তৈরি করতে হবে?
— বাইট কমান্ডার
@ বিটকম্যান্ডার এই (চ্যালেঞ্জের একটি) বড় অংশটি স্ট্রিং সংকোচনের বিষয়ে, আপনাকে নিজের কোডটিতে এই বর্ণমালাটি সংকোচন করার সর্বোত্তম উপায় খুঁজে বের করতে হবে, তবুও এটি পুনরুদ্ধার করতে এবং এটি ব্যবহার করতে সক্ষম হয়ে থাকতে :)। সুতরাং হ্যাঁ, এটি আপনার গল্ফড-কোডে অন্তর্ভুক্ত রয়েছে এবং আপনার প্রোগ্রামের সাথে পরিচিত হতে পারে না
— কেটেনকিও
@ ক্যাটেনকিও আহা, ঠিক আছে স্পষ্টির জন্য ধন্যবাদ।
— বাইট কমান্ডার

উত্তর:

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

আদর্শ কোড.কম এ চলমান এই কোডটি দেখুন।

একই কোড, তবে কোনওভাবে সুন্দরভাবে ইন্টেন্টেড, ফর্ম্যাট এবং মন্তব্য করেছে:

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

পাইথনের বিল্ট-ইন দেশীয়ভাবে সমর্থনকারী সর্বোচ্চ বেসটি আমি বেস ৩ enc টি এনকোডিংয়ের জন্যও যাওয়ার সিদ্ধান্ত নিয়েছি int()। এখানে আমি লিখেছিলাম (অজলিত) একটি সংক্ষিপ্ত পাইথন 3 স্ক্রিপ্ট যা ফন্টের সংজ্ঞাগুলি প্রশ্নের মতো করে বেস 36 কোডগুলিতে রূপান্তরিত করে: আইডোন.কম এ আমার রূপান্তরকারী

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, স্পেস - 0 দিয়ে উপস্থাপিত হয় তারপরে এটি বেস 36 এ রূপান্তরিত হয় যাতে ক্লোজারকে এটি প্রতীক হিসাবে গণ্য করা উচিত তা জানতে "+" সংরক্ষণ করতে কেবল 5 টি অক্ষর লাগে। তারপরে ইনপুটটি নিউলাইন প্রতীক দ্বারা বিভক্ত হয় এবং প্রতিটি লাইনের জন্য আমরা 36 টি বেসে একটি অক্ষরকে বাইনারি বেসে ফিরে রূপান্তর করি এবং প্রথমে [0: 5] চিহ্নগুলি নিউলাইন প্রতীক যুক্ত করি, পরবর্তী [5:10] চিহ্নগুলি এবং এই জাতীয় পেতে পারি।

আপনি এটি এখানে চলমান দেখতে পাবেন - https://ideone.com/y99ST5

— cliffroot
সূত্র
1

এসওজিএল , ১৩7 বাইট (প্রতিদ্বন্দ্বী)

 °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
— মাল্টিলাইন
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 টি সারি প্রদর্শন করে The সূচকটিও ফাঁকা লাইনের জন্য যাদু স্ট্রিংয়ের বাইরে চলে যায়। সুতরাং, সারি 6-এ কেবল ফাঁকা স্থান রয়েছে।

আপনি যদি কোনও জায়গার পরিবর্তে অন্য একটি চরিত্র মুদ্রণ করেন তবে এটি সর্বাধিক দেখা যায়। উদাহরণস্বরূপ ·।

#####··###···###··#####·#####·······#####·####··#####·
#···#·#·····#···#···#·····#·········#···#·#···#···#···
#####··###··#·······#·····#·········#####·####····#···
#···#·····#·#···#···#·····#·········#···#·##······#···
#···#··###···###··#####·#####·······#···#·#·#·····#···
······················································
#####·#####·#···#·#####·
··#···#······#·#····#···
··#···####····#·····#···
··#···#······#·#····#···
··#···#####·#···#···#···
························
— mazzy
সূত্র
0

সি (জিসিসি) , 326 বাইট

এটি একটি প্রথম ছুরিকাঘাত। টিআইওতে 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

জাভাস্ক্রিপ্ট (ES6), 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
সূত্র
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.