गोल्फ द्वारा प्रेरित मुझे एक ASCII वर्णमाला , जिसमें से यह चुनौती (लगभग) एक सीधा उलटा है।

कार्य:

ASCII- कला पाठ की एक स्ट्रिंग लें और नियमित ASCII पाठ के रूप में पाठ की सामग्री का उत्पादन करें।

इनपुट:

ASCII- कला पाठ का स्ट्रिंग।

इनपुट में केवल ASCII वर्ण #, रिक्त स्थान और 4 या 5 न्यूलाइन (एक अनुगामी न्यूलाइन वैकल्पिक है) के उदाहरण होंगे । सभी लाइनों की लंबाई समान है। (अर्थात, अंतिम ASCII- कला पत्र अनुगामी स्थानों के साथ गद्देदार है।) आप #चाहें तो इनपुट के बजाय कुछ अन्य मुद्रण योग्य ASCII वर्ण का उपयोग कर सकते हैं ।

इनपुट में ASCII- कला पत्र A-Zऔर ASCII- कला स्थान (व्हॉट्सएप का 5x5 ब्लॉक) होगा। कोई विराम चिह्न नहीं। ASCII- कला पाठ की केवल एक पंक्ति (5 वास्तविक लाइनें) है। कोई अनुगामी या अग्रणी ASCII- कला स्थान नहीं होंगे, न ही आसन्न ASCII- कला स्थान होंगे।

पत्र का आकार 5x5 अक्षर है। प्रत्येक अक्षर के बीच 1x5 स्थान होता है। शब्दों के बीच का स्थान व्हाट्सएप का 5x5 ब्लॉक (प्रत्येक तरफ + 1x5 स्थान है, क्योंकि यह सिर्फ एक और अक्षर है)। अंत में या शुरुआत में 1x5 स्थान नहीं होगा, केवल ASCII- कला पत्रों के बीच।

आउटपुट:

स्ट्रिंग जिसमें ASCII वर्ण A-Z+ रिक्त स्थान के रूप में पाठ है । आउटपुट लोअरकेस में भी हो सकता है, अगर वह आपके समाधान के लिए किसी तरह आसान हो। मिश्रित मामले की भी अनुमति है।

ASCII- कला पत्र:

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

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

अंतरिक्ष:

     |
     | A 5x5 square of spaces.
     | (Padded with |s to make it appear in this post.)
     |
     |

उदाहरण:

इनपुट:

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

आउटपुट: HELLO WORLD

इनपुट:

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

आउटपुट: ASCII

इनपुट:

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

आउटपुट: PPCG

यह कोड-गोल्फ है , इसलिए बाइट्स में सबसे कम उत्तर जीतता है।

— Steadybox
स्रोत

10

मैं सोच रहा हूँ कि इसका समाधान किसी प्रकार के हैश फ़ंक्शन में शामिल हो सकता है ...

— नील

6

यदि आप एक छवि के लिए इनपुट परिवर्तित करके ऐसा करते हैं और छवि प्रसंस्करण का उपयोग करके इसे हल करते हैं तो मुझसे बाउंटी! (इस घोल को बहुत ही आसानी से बनाया जाना चाहिए)

— स्टीवी ग्रिफिन

3

यदि यह किसी को मदद करने के लिए है: या तो दूसरी पंक्ति, चौथी पंक्ति, या अक्षरों के मध्य स्तंभ को प्रासंगिक जानकारी खोए बिना छोड़ा जा सकता है।

— मार्टिन एंडर

1

@ जुंगहवनमीन हम्म। मुझे नहीं लगता, क्योंकि यह बहुत मानव-पढ़ने योग्य ASCII- कला पाठ नहीं होगा।

— स्टेडीबॉक्स

1

@JonathanAllan मुझे लगता है कि ठीक भी होगा।

— स्टेडीबॉक्स

13

जेली , 50 44 42 बाइट्स

ỴZ;6/UOḂḅ7‘ị“¥ŒƲVĊ⁾|W£⁼³ƭÇuʋụzḢĖ0ḢẆẠØsĠỌỊ»

इसे ऑनलाइन आज़माएं! (ध्यान दें कि तर्क में अग्रणी न्यूलाइन की आवश्यकता नहीं है, लेकिन चूंकि न्यूलाइन्स के अग्रणी और अनुगामी का कोई प्रभाव नहीं है, जिसमें मैंने बहु-स्ट्रिंग स्ट्रिंग को मानव-पठनीय बनाने के लिए शामिल किया है)

परिणाम मिश्रित मामले हैं (जैसा कि ओपी द्वारा एक टिप्पणी में अनुमति दी गई है )।

कैसे?

नई लाइनों पर विभाजन, स्थानांतरित करता है, और एक साथ छह (उप) के उप-स्लाइस के साथ मिलकर चरित्र निरूपण प्राप्त करता है और प्रत्येक को उलट देता है (लंबाई के अंतिम चरित्र के लिए बाद के आधार रूपांतरण को लंबाई 30 के अन्य सभी 30)। फिर नक्शे '#'और ' 'एक और शून्य क्रमशः इस तथ्य का उपयोग करते हुए कि '#'एक विषम ऑर्डिनल है, जबकि ' 'एक भी है। प्रत्येक को पढ़ता है जैसे कि यह एक आधार संख्या सात थी। प्रभावी रूप से प्रत्येक के modulo 81 लेता है (27 संभावित मामलों के लिए 27 अद्वितीय मान देने के लिए), और अंत में एक "मैजिक स्ट्रिंग" में सही इंडेक्स पर सही वर्णों के साथ अनुक्रमित करता है (modulo इंडेक्सिंग का उपयोग लंबाई 81 के जादुई स्ट्रिंग के साथ बचाने के लिए किया जाता है। 2 बाइट्स)।

यहाँ "मैजिक स्ट्रिंग" है जिसे मैंने एक (केस-इनसेन्सिटिव) रेगेक्स पैटर्न के साथ बनाया है जो इसे मैच करने के लिए आवश्यक है (मैंने इसे लंबाई 81 बनाने के लिए "एड" जोड़ा):

 ' affectedly Azerbaijan rewaxed naganas jiujitsudankly pase UVB freqHaarlemcoacted'
'^ ..f...e.....z......a..r.w.x...n.g......iuj....d..kly.p.s...vb....qh.....m.o.ct.*'

इस तरह से इसे संकुचित किया जा सकता है, ग्यारह उप-स्लाइस को जेली के शब्द में शब्दों के रूप में देखा जा सकता है (जिनमें से अधिकांश प्रमुख डिफ़ॉल्ट सिस्टम का उपयोग करते हैं:

' affectedly Azerbaijan rewaxed naganas jiujitsudankly pase UVB freqHaarlemcoacted'
 ^          ^          ^       ^       ^        ^     ^    ^   ^    ^      ^

जिसके परिणामस्वरूप जेली संपीड़ित स्ट्रिंग, “¥ŒƲVĊ⁾|W£⁼³ƭÇuʋụzḢĖ0ḢẆẠØsĠỌỊ»

शेष कोड निम्नानुसार काम करता है:

ỴZ;6/UOḂḅ7‘ị“...» - Main link: multi-line string, s   e.g. HI as the #s and spaces
Ỵ                 - split on new lines                     ["#   # #####","#   #   #  ","#####   #  ","#   #   #  ","#   # #####"] (each is actually a list)
 Z                - transpose                              ["#####","  #  ","  #  ","  #  ","#####","     ","#   #","#   #","#####","#   #","#   #"] (each is actually a list)
   6/             - six-wise reduce by
  ;               -     concatenation                      ["#####  #    #    #  #####     ","#   ##   #######   ##   #"] (each is actually a list)
     U            - upend (reverse each)                   ["     #####  #    #    #  #####","#   ##   #######   ##   #"] (each is actually a list)
                  -     note: all except the last will be length 30 and like "     ...", which will become [0,0,0,0,0,...], while the last will be length 25 without those five leading zeros.
      O           - cast to ordinals ('#' -> 35, ' '-> 32) [[32,32,...],[35,32,...]]
       Ḃ          - modulo 2 ('#' -> 1, ' ' -> 0)          [000001111100100001000010011111, 1000110001111111000110001] (each is actually a list)
        ḅ7        - convert from base 7 (vectorises)       [223498370543967315553, 191672428080864454753] (these are now integers)
          ‘       - increment                              [223498370543967315554, 191672428080864454754]
                  -  (modulo 81 these would be [68, 41])
           ị      - index into (modulo & 1-indexed):                        
            “...» -     the "magic string" described above ' affectedly Azerbaijan rewaxed naganas jiujitsudankly pase UVB freqHaarlemcoacted'
                                                           "Hi"                                   41^                        68^

— जोनाथन एलन
स्रोत

14

पायथन 2 , 405 335 234 182 171 बाइट्स

lambda s,j=''.join:j(' QPVXU_O__FBLK_JMD_CSYZWIENH_AG___TR'[int(j(`ord(y)%2`for y in j(s.split('\n')[x][i:i+5]for x in range(5))),2)%13836%37]for i in range(0,len(s)/5,6))

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

अंत में जेएस से कम

— OVS
स्रोत

मापांक का चतुर उपयोग, लेकिन मैं यह सोचने में मदद नहीं कर सकता कि ऐसा करने का एक तरीका होना चाहिए: [0,2,3,7,...]और ' UBGOTA...इसे विभाजित करें, और कुछ प्रकार के मानचित्रण का उपयोग करें। 0:' ',2:'U',3:'V'...इतनी देर लगती है ,,,, बहुत सारे हैं :'',। (मुझे पता है कि आपके पास मूल पोस्ट में ऐसा ही कुछ था, लेकिन बहुत लंबी संख्या के साथ।

— स्टिव ग्रिफ़िन

1

@StewieGriffin अब बेहतर है

— Ovs

11

जावास्क्रिप्ट (ईएस 6), 204 186 184 182 बाइट्स

बची हुई 18 बाइट्स नील की बदौलत बची
2 बाइट्स

टूट - फूट:

42-बाइट लुकअप टेबल
~~162~~ ~~144~~ ~~142~~ 140 कोड के बाइट्स

s=>(a=s.split`
`)[0].replace(/.{6}/g,(_,n)=>' H_JM__WDCSORLU___QKG_P_AFT_N_EI_XBV____YZ'[[0,1,2,4].reduce((p,r,i)=>p+='0b'+a[r].substr(n,5).replace(/./g,c=>1^1-c)<<i*6,0)%178%69%43])

डेमो

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

let f =

s=>(a=s.split`
`)[0].replace(/.{6}/g,(_,n)=>' H_JM__WDCSORLU___QKG_P_AFT_N_EI_XBV____YZ'[[0,1,2,4].reduce((p,r,i)=>p+='0b'+a[r].substr(n,5).replace(/./g,c=>1^1-c)<<i*6,0)%178%69%43])

console.log(f(
  ' ###   ###   ###  ##### ##### \n'+
  '#   # #     #   #   #     #   \n'+
  '#####  ###  #       #     #   \n'+
  '#   #     # #   #   #     #   \n'+
  '#   #  ###   ###  ##### ##### \n'
));

स्निपेट का विस्तार करें

— Arnauld
स्रोत

1

आप पाठ्यक्रम के (a=s.split`\n`)[0].replace(/......?/g,साथ substr(n,5)और उसके बिना उपयोग करके बाइट्स के एक पूरे गुच्छा को बचा सकते हैं join।

— नील

मुझे लगता है कि आप एक बाइट के साथ बचा सकते हैं c=>0|c>' ', और एक और साथp+='0b'+...

— ETHproductions

जैसा कि चैलेंज के कमेंट सेक्शन में @Steadybox द्वारा बताया गया है, \nइनपुट में लेना अमान्य है। हालांकि, मुझे लगता है कि आप इनपुट के रूप में वास्तविक न्यूलाइन के साथ टेम्पलेट शाब्दिक का उपयोग कर सकते हैं, जैसे आप splitविधि में कर रहे हैं ।

— अर्जुन

1

@ DobbyTheFree-Elf मैं वास्तव में एक टेम्पलेट शाब्दिक का उपयोग कर सकता था - जो संयोग से अग्रणी बोली के कारण पठनीयता को ख़राब कर देगा। लेकिन जिस तरह से इनपुट डेटा है पर एक बाधा जोड़ने स्वरूपित कार्य करने के लिए पारित किया जा रहा से पहले विषय, IMHO (जब तक से बाहर है वास्तविक सामग्री इनपुट के मान्य है)।

— अरनुलद

1

@ DobbyTheFree-Elf मुझे डर है कि मेरी टिप्पणी थोड़ी अस्पष्ट थी, और मैं उस सवाल को थोड़ा गलत समझ सकता था जिसका मैं जवाब दे रहा था। \nकोड में कॉल साइट पर एक स्ट्रिंग शाब्दिक का उपयोग करना ठीक है, क्योंकि फ़ंक्शन के लिए पारित होने वाले वास्तविक स्ट्रिंग में केवल न्यूलाइन वर्ण शामिल हैं, \` and n . Passing a string that contains \ ` दोनों और nअलग-अलग आसन्न वर्ण ठीक नहीं होंगे।

— Steadybox

9

बैश + इमेजमैजिक + टेसरैक्ट , 161 बाइट्स

मैं @ stewie-griffin द्वारा सुझाए गए दृष्टिकोण को आज़माना चाहता था और bash + ImageMagick (एक स्ट्रिंग को एक छवि में बदलने के लिए) और Tesseract (OCR करने के लिए) गया। यहां मेरा कोड है, जो 'हेलो वर्ल्ड' टेस्टकेस के लिए काम करता है, लेकिन अन्य लोगों को विफल करता है। शायद मापदंडों (फ़ॉन्ट, फ़ॉन्ट आकार, कर्लिंग, रिक्ति) के लिए कुछ tweaking मदद करता है।

convert -font Courier-Bold -pointsize 8 -interline-spacing -3 -kerning -3 label:"$(</dev/stdin)" -bordercolor White -border 5%x20% png:- | tesseract stdin stdout

कमांड चलाने के बाद बस एससीआई कला को कमांडलाइन में कॉपी-पेस्ट करें। ^ D दबाकर अपना इनपुट समाप्त करें।

परीक्षण मामलों के लिए वर्तमान उत्पादन:

हेलो वर्ल्ड: हेलो वर्ल्ड
ASCII: H5511
पीपीसीजी: पीपीओजी

— agtoever
स्रोत

6

स्काला, 184 181 बाइट्स

एक जादू स्ट्रिंग + modulo समाधान पर आधारित hashCode:)

(a:String)=>a.split("\n").map(_.grouped(6)map(_.take(5))toArray).transpose.map(l=>"Q__WLUY_XOI_ZN_GEFR_P__JKBMV_S__ __C__D__H_T__A"(Math.abs(l.mkString.hashCode)%106%79%47))mkString

ऑनलाइन प्रयास करें

अधिक पठनीय:

(a:String) => a.split("\n")
                .map(_.grouped(6)map(_.take(5))toArray)
                .transpose
                .map ( l => 
                    "Q__WLUY_XOI_ZN_GEFR_P__JKBMV_S__ __C__D__H_T__A"(
                        Math.abs(l.mkString.hashCode)%106%79%47
                    )
                )mkString

स्पष्टीकरण

प्रारंभिक स्ट्रिंग (ASCII कला) 5 लाइनों (ASCII चरित्र की ऊंचाई) में विभाजित है
प्रत्येक लाइन 6-वर्ण तत्वों (ASCII वर्ण + 1 स्थान की चौड़ाई) में विभाजित है
केवल पहले 5 अक्षर रखे गए हैं (अंत में स्थान बेकार है)
(या तो प्रत्येक ASCII वर्ण, 25 वर्ण (5x5) के एक दृश्य के रूप में प्रस्तुत किया जाता है युक्त लाइनों स्थानांतरित कर रहे हैं '#'या ' ')
प्रत्येक ASCII वर्ण प्रतिनिधित्व (अनुक्रम) स्ट्रिंग में परिवर्तित हो जाता है और एक पूर्ण हैशकोड की गणना उस स्ट्रिंग के लिए की जाती है (अगले मापांक की वजह से पूर्ण आवश्यकता)
3 लगातार मापांक ( % 106 % 79 % 47) [0; 47[प्रत्येक ASCII वर्ण के लिए एक नंबर) को जोड़ने के लिए लागू होते हैं (नीचे स्पष्टीकरण देखें)
इस संख्या का उपयोग मैजिक स्ट्रिंग के सूचकांक के रूप में किया जाता है

मैजिक स्ट्रिंग कैसे प्राप्त करें?

सबसे पहले, मैंने इस तरह सभी पत्रों का प्रतिनिधित्व किया:

case class Letter(letter: Char, ascii: Seq[Char])

फिर, मैंने सभी वर्णों के ASCII अभ्यावेदन युक्त एक वर्णमाला बनाई:

उदाहरण :

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

हो जाता है

Letter('A', " ### #   #######   ##   #") // 25 characters from top-left to bottom-right

प्रत्येक अक्षर के लिए, एक पूर्ण हैशकोड की गणना की गई (सभी हैशकोड अलग हैं):

val codes = alphabet.map { case Letter(l, a) => (l, Math.abs(a.mkString.hashCode)) }
// codes: Seq[(Char, Int)] = List(( ,253243360), (A,380997542), (B,1221679148), (C,1573119535), (D,307929190), (E,858088672), (F,857996320), (G,750155628), (H,897290147), (I,1518088099), (J,928547488), (K,1184149391), (L,519601059), (M,741735953), (N,2139154001), (O,1625960980), (P,1307658950), (Q,92382816), (R,1221771494), (S,1689301359), (T,1515228067), (U,1390718627), (V,386730851), (W,733134481), (X,628338619), (Y,23919695), (Z,2081560145))

फिर मैंने प्रत्येक कोड को कम करने की कोशिश की, लेकिन हमेशा इस तथ्य का सम्मान करते हुए कि प्रत्येक कोड अद्वितीय होना चाहिए (कोड द्वारा सूचीबद्ध सूची में 27 तत्व, प्रत्येक अक्षर के लिए 1 होना चाहिए)। इसलिए मैंने पहले 200 मापांक आजमाए:

val mod = (1 to 200).find(modulo => codes.map { case (a,b) => (a, b % modulo) }.groupBy(_._2).size==27).get

मैंने पाया 106कि लागू होने वाला पहला मॉडुलो:

val codes2 = codes.map { case (l, c) => (l, c%mod) }
val codes = codes2
// codes: Seq[(Char, Int)] = List(( ,32), (A,46), (B,104), (C,35), (D,38), (E,16), (F,96), (G,94), (H,41), (I,89), (J,102), (K,71), (L,83), (M,105), (N,13), (O,56), (P,20), (Q,0), (R,18), (S,29), (T,43), (U,5), (V,27), (W,3), (X,87), (Y,53), (Z,91))

मैंने पिछले चरणों को सबसे छोटे मोडुलो तक दोहराया। मुझे मिला :

79
47
44
42

नोट: अंतिम मोडुलो 47जिसे मैंने चुना ( ) यहां सबसे छोटा नहीं है:

मुझे 44 मिले, लेकिन अगर मैंने 44 को चुना था, तो मैजिक स्ट्रिंग का आकार 44 (47 के बजाय) होगा लेकिन मुझे लिखना होगा %106%79%47%44( %106%79%47= 10 अक्षरों के बजाय 13 अक्षर)। तो बाइट्स में, कोड को उसी आकार का होना चाहिए था जैसा मुझे मिला
42 भी है, लेकिन तब कोड को मेरे पास एक से अधिक बाइट होनी चाहिए थी

इसके बाद, मैंने प्रत्येक अक्षर से संबंधित निश्चित कोड प्राप्त % 79 % 47करने के लिए अंतिम मापांक ( ) अंतिम पर लागू किया codes:

codes: Seq[(Char, Int)] = List(( ,32), (A,46), (B,25), (C,35), (D,38), (E,16), (F,17), (G,15), (H,41), (I,10), (J,23), (K,24), (L,4), (M,26), (N,13), (O,9), (P,20), (Q,0), (R,18), (S,29), (T,43), (U,5), (V,27), (W,3), (X,8), (Y,6), (Z,12))

अंत में, मैजिक स्ट्रिंग बनाने के लिए:

val initialMap = (0 until 47).map(i => (i, '_')).toMap
val codesMap = codes.map(i => (i._2, i._1)).toMap

val magicString = (initialMap ++ codesMap).toSeq.sortBy(_._1).map(_._2).mkString
// magicString: String "Q__WLUY_XOI_ZN_GEFR_P__JKBMV_S__ __C__D__H_T__A"

उदाहरण:A ऊपर का अक्षर 46 ( 380997542 % 106 % 79 % 47) से जुड़ा है , और जादुई स्ट्रिंग का 46 वां तत्व ए :) है

परीक्षण के मामलों

// assign function to f
val f = (a:String)=>a.split("\n").map(_.grouped(6)map(_.take(5))toArray).transpose.map(l=>"Q__WLUY_XOI_ZN_GEFR_P__JKBMV_S__ __C__D__H_T__A"(Math.abs(l.mkString.hashCode)%106%79%47))mkString

नमस्ते दुनिया :

val asciiArt = """|#   # ##### #     #      ###        #   #  ###  ####  #     #### 
                  |#   # #     #     #     #   #       #   # #   # #   # #     #   #
                  |##### ####  #     #     #   #       # # # #   # ####  #     #   #
                  |#   # #     #     #     #   #       ## ## #   # #   # #     #   #
                  |#   # ##### ##### #####  ###        #   #  ###  #   # ##### #### """.stripMargin

f(asciiArt)    // HELLO WORLD

ASCII:

val asciiArt = """| ###   ###   ###  ##### #####
                  |#   # #     #   #   #     #  
                  |#####  ###  #       #     #  
                  |#   #     # #   #   #     #  
                  |#   #  ###   ###  ##### #####""".stripMargin

f(asciiArt)    // ASCII

पीपीसीजी:

val asciiArt = """|####  ####   ###   ### 
                  |#   # #   # #   # #    
                  |####  ####  #     #  ##
                  |#     #     #   # #   #
                  |#     #      ###   ### """.stripMargin

f(asciiArt)    // PPCG

संपादित करता

.पहले हटाकर 3 बाइट्स बचाए map, toArrayऔरmkString

— norbjd
स्रोत

3

PHP, 294 बाइट्स

<?$l=" 00000YE00G0000R000A0Q0000C0BW000K00000000000LT00000J00000000MU0000Z0000DI000000V0000000P00H0000ONF000S00X";preg_match_all("#(.{5})\s#s","$_GET[0] ",$t);for($i=0;$i<$c=count($a=$t[1])/5;$i++)$s.=$l[bindec(strtr($a[$i].$a[$i+$c].$a[$i+2*$c].$a[$i+3*$c].$a[$i+4*$c]," #","01"))%106];echo$s;

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

विस्तारित

$l=" 00000YE00G0000R000A0Q0000C0BW000K00000000000LT00000J00000000MU0000Z0000DI000000V0000000P00H0000ONF000S00X"; # search string mod 106
preg_match_all("#(.{5})\s#s","$_GET[0] ",$t); # Regex take each group of five chars followed by a whitespace
for($i=0;$i<$c=count($a=$t[1])/5;$i++)
  $s.=$l[bindec(strtr($a[$i].$a[$i+$c].$a[$i+2*$c].$a[$i+3*$c].$a[$i+4*$c]," #","01"))%106]; # join each groups make a binaray make a decimal mod 106  
echo$s; # Output

इनपुट को एक छवि प्रारूप में परिवर्तित करना

@Stevie ग्रिफिन एक छवि से इसे प्राप्त करने के लिए एक समाधान खोज। मुझे लगता है कि वह वास्तव में मेरे द्वारा उपयोग किए गए छवि प्रारूप को नहीं चाहते हैं।

echo'<svg xmlns="http://www.w3.org/2000/svg" width="100%"><switch><foreignObject x="0" y="0" width="100%" height="300"><body xmlns="http://www.w3.org/1999/xhtml"><pre>'.$_GET[0].'</pre></body></foreignObject></switch></svg>';

एसवीजी में एचटीएमएल पार्ट्स हो सकते हैं यदि फिर किसी विदेशी ऑबजेक्ट में शामिल किया गया हो। इसलिए मैंने एक एसवीजी में प्री एलिमेंट डाला।

छवि आउटपुट

<svg xmlns="http://www.w3.org/2000/svg" width="100%"><switch><foreignObject x="0" y="0" width="100%" height="300"><body xmlns="http://www.w3.org/1999/xhtml"><pre>#   # ##### #     #      ###        #   #  ###  ####  #     #### 
#   # #     #     #     #   #       #   # #   # #   # #     #   #
##### ####  #     #     #   #       # # # #   # ####  #     #   #
#   # #     #     #     #   #       ## ## #   # #   # #     #   #
#   # ##### ##### #####  ###        #   #  ###  #   # ##### #### </pre></body></foreignObject></switch></svg>

स्निपेट का विस्तार करें

छवि परिवर्तन से समाधान

एसवीजी के रूप में "i.svg" आप केवल की जगह की जरूरत एसवीजी बचाने के बाद मशीन पठनीय तो है $_GET[0]साथ preg_replace("#(^.*e>)(.*)(</p.*$)#s","$2",join(file("i.svg")))सामान्य इनपुट 55 बाइट्स के साथ रास्ते में

— जार्ग हुल्सरमन
स्रोत

2

पॉवर्सशेल, 152 146 बाइट्स

-join$(for($t=$args-split'
';$c-lt$t[0].Length;$c+=6){$s=0;$t|% s*g $c,5|% t*y|%{$s+=$s+$_}
'_ISRJ_BK_HFQPL_MYNCE _TXDAO_VWUZ__G'[$s%578%174%36]})

टेस्ट स्क्रिप्ट:

$f = {

-join$(for($t=$args-split'
';$c-lt$t[0].Length;$c+=6){$s=0;$t|% s*g $c,5|% t*y|%{$s+=$s+$_}
'_ISRJ_BK_HFQPL_MYNCE _TXDAO_VWUZ__G'[$s%578%174%36]})

}

&$f @"
#   # ##### #     #      ###        #   #  ###  ####  #     #### 
#   # #     #     #     #   #       #   # #   # #   # #     #   #
##### ####  #     #     #   #       # # # #   # ####  #     #   #
#   # #     #     #     #   #       ## ## #   # #   # #     #   #
#   # ##### ##### #####  ###        #   #  ###  #   # ##### #### 
"@

&$f @"
 ###   ###   ###  ##### #####
#   # #     #   #   #     #  
#####  ###  #       #     #  
#   #     # #   #   #     #  
#   #  ###   ###  ##### #####
"@

&$f @"
####  ####   ###   ### 
#   # #   # #   # #    
####  ####  #     #  ##
#     #     #   # #   #
#     #      ###   ### 
"@

&$f @"
       ###  ####   ###  ####  ##### #####  ###  #   # ##### ##### #   # #     #   # #   #  ###  ####   ###  ####   ###  ##### #   # #   # #   # #   # #   # #####
      #   # #   # #   # #   # #     #     #     #   #   #     #   #  #  #     ## ## ##  # #   # #   # #   # #   # #       #   #   # #   # #   #  # #   # #     # 
      ##### ####  #     #   # ####  ####  #  ## #####   #     #   ###   #     # # # # # # #   # ####  #   # ####   ###    #   #   #  # #  # # #   #     #     #  
      #   # #   # #   # #   # #     #     #   # #   #   #   # #   #  #  #     #   # #  ## #   # #     #  #  #   #     #   #   #   #  # #  ## ##  # #    #    #   
      #   # ####   ###  ####  ##### #      ###  #   # ##### ###   #   # ##### #   # #   #  ###  #      ## # #   #  ###    #    ###    #   #   # #   #   #   #####
"@

आउटपुट:

HELLO WORLD
ASCII
PPCG
 ABCDEFGHIJKLMNOPQRSTUVWXYZ

ध्यान दें:

$t|% s*g $c,5|% t*y|%{$s+=$s+$_} के लिए शॉर्टकट है $t.substring($c,5).toCharArray()|%{$s+=$s+$_}
("abcd","efgh").substring(1,2) सरणी देता है ("bc","de")
("bc","de").toCharArray() सरणी देता है ('b','c','d','e')

— Mazzy
स्रोत

2

सी, 225 209 बाइट्स

16 बाइट बचाने के लिए @ceilingcat को धन्यवाद!

i,j,k,l,n,m;f(char*s){l=index(s,10)-s+1;for(i=0;i<l/6;++i){for(m=j=0;j<5;m+=n*(exp10(j++)+.1))for(n=k=0;k<5;)n+=(s[i*6+j+k*l]==35)<<k++;for(j=0;"Qi Y$>W);Xa%d^F4K-]7jcMAG="[j++]-32-m%77;);putchar(n?64+j:32);}}

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

— Steadybox
स्रोत

ASCII- कला पाठ पढ़ें

कार्य:

इनपुट:

आउटपुट:

ASCII- कला पत्र:

उदाहरण:

जेली , 50 44 42 बाइट्स

कैसे?

पायथन 2 , 405 335 234 182 171 बाइट्स

जावास्क्रिप्ट (ईएस 6), 204 186 184 182 बाइट्स

डेमो

बैश + इमेजमैजिक + टेसरैक्ट , 161 बाइट्स

स्काला, 184 181 बाइट्स

स्पष्टीकरण

परीक्षण के मामलों

संपादित करता

PHP, 294 बाइट्स

इनपुट को एक छवि प्रारूप में परिवर्तित करना

छवि आउटपुट

छवि परिवर्तन से समाधान

पॉवर्सशेल, 152 146 बाइट्स

सी, 225 209 बाइट्स