एक स्वरूपित मोर्स कोड धोखा देती लिखें

Question

चुनौती:

एक प्रोग्राम लिखें जो निम्न आउटपुट का उत्पादन करता है:

. E   .. I   ... S   .... H
                     ...- V
             ..- U   ..-. F
                     ..--  
      .- A   .-. R   .-.. L
                     .-.-  
             .-- W   .--. P
                     .--- J
- T   -. N   -.. D   -... B
                     -..- X
             -.- K   -.-. C
                     -.-- Y
      -- M   --. G   --.. Z
                     --.- Q
             --- O   ---.  
                     ----  

यह A से Z तक के अक्षरों के मोर्स कोड की एक स्वरूपित तालिका है। प्रत्येक कॉलम को तीन स्थानों से अलग किया जाता है।

चार लापता स्लॉट हैं, जिनका उपयोग अंतर्राष्ट्रीय चरित्र सेट द्वारा किया जाता है। आपके कार्यक्रम को वहां एक स्थान लिखना होगा।

आउटपुट में ASCII स्पेस, डॉट्स, डैश, अपरकेस अक्षर और नएलाइन (या तो LF या CRLF) शामिल होने चाहिए।

आपका कार्यक्रम कोई इनपुट स्वीकार नहीं करता है।

निम्नलिखित एक नमूना पायथन प्रोग्राम है जो वांछित आउटपुट का उत्पादन करता है:

b = "."
out = []
last = 0
ch = "EISHVUF ARL WPJTNDBXKCYMGZQO  "
cx = 0
while b:
    if last >= len(b):
        print("   ".join(out))
        out = ["   ", "    ", "     ", "      "][0:len(b) - 1]
    out.append(b + " " + ch[cx])
    cx += 1
    last = len(b)
    if len(b) < 4:
        b += "."
    elif b[-1] == ".":
        b = b[0:-1] + "-"
    else:
        i = len(b) - 1
        while b[i] == "-":
            i -= 1
            if i < 0:
                break
        if i < 0:
            break
        b = b[0:i] + "-"
print("   ".join(out))

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

Comments

प्रत्येक पंक्ति 3 स्थान खाली कर सकते हैं?

— dzaima

स्टैंडर्ड लूपहोल्स सॉल्यूशन हार्ड कोडिंग को नापसंद करते हैं। हमें हार्ड कोड की कितनी तालिका की अनुमति है?

— ब्रूनर

@ शराबी मेज पर विचार कर रही है 450 बाइट्स के बारे में, मुझे संदेह है कि कठिन कोडिंग इष्टतम समाधान है

— साइकोस

@Cyoce निश्चित रूप से यहां सबसे छोटा संस्करण नहीं है, लेकिन जोर्ज ह्यूल्सरमन ने अपने शानदार तीखे जवाबों में इसे 208 बाइट्स तक कम कर दिया।

— ब्रूनर

क्या हमें अनुगामी स्थान रखने की अनुमति है?

— एडम

Answer 1

जेली , 85 बाइट्स

ØQj⁶“_ȦeƤbṅỌU@⁼Cq’œ?;⁶$⁺ṁ®L€€¤
4R2ṗ©ị⁾.-;€€⁶ż"¢;€€⁶$⁺W€€j"731Dẋ@⁶¤ZµKFṚ;⁶ẋ³¤ḣ29ṫ3Ṛµ€Y

एक पूरा कार्यक्रम चीटिंग शीट को छापता है।

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

कैसे?

नोट: मुझे लगता है कि एक सूची बनाने के लिए इसे ट्रिम करने का एक तरीका हो सकता है जो ग्रिड एटम के उपयोग से सही तरीके से प्रारूपित करता है G, लेकिन मैं कैसे काम नहीं कर सकता।

ØQj⁶“_ȦeƤbṅỌU@⁼Cq’œ?;⁶$⁺ṁ®L€€¤ - Link 1: get "letters" lists: no arguments
ØQ                             - Qwerty yield = ["QWERTYUIOP","ASDFGHJKL","ZXCVBNM"]
  j⁶                           - join with spaces = "QWERTYUIOP ASDFGHJKL ZXCVBNM"
    “_ȦeƤbṅỌU@⁼Cq’             - base 250 number = 23070726812742121430711954614
                  œ?           - lexicographical permutation at index = "ETIANMSURWDKGOHVF L PJBXCYZQ"
                       ⁺       - do this twice:
                      $        -   last two links as a monad
                    ;⁶         -     concatenate a space              = "ETIANMSURWDKGOHVF L PJBXCYZQ  "
                             ¤ - nilad followed by link(s) as a nilad:
                         ®     -   recall from registry (4R2ṗ from the Main link)
                          L€€  -   length for €ach for €ach = [[1,1],[2,2,2,2],[3,3,3,3,3,3,3,3],[4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4]]
                        ṁ      - mould like = ["ET","IANM","SURWDKGO","HVF L PJBXCYZQ  "]

4R2ṗ©ị⁾.-;€€⁶ż"¢;€€⁶$⁺W€€j"731Dẋ@⁶¤ZµKFṚ;⁶ẋ³¤ḣ29ṫ3Ṛµ€Y - Main link: no arguments
4R                                                     - range(4) = [1,2,3,4]
  2ṗ                                                   - Cartesian power with 2 = [[[1],[2]],[[1,1],[1,2],[2,1],[2,2]],...,[...,[2,2,2,2]]]
    ©                                                  - copy to register and yield
      ⁾.-                                              - literal ['.','-']
     ị                                                 - index into (makes all the codes, in four lists by length like reading the output top-bottom, left-right)
         ;€€⁶                                          - concatenate a space to each code
               ¢                                       - call last link (1) as a nilad (get the letters reordered as required)
             ż"                                        - zip left and right with zip dyad
                     ⁺                                 - do this twice:
                    $                                  -   last two links as a monad:
                ;€€⁶                                   -     concatenate a space to each code, letter pair
                      W€€                              - wrap each code, letter pair in a list
                                  ¤                    - nilad follwed by link(s) as a nilad:
                           731                         -   literal 731
                              D                        -   to decimal list = [7,3,1]
                               ẋ@⁶                     -   repeat a space = ["       ","   "," "]
                         j"                            - zip with dyad join
                                   Z                   - transpose
                                    µ              µ€  - for each:
                                     K                 -   join with spaces
                                      F                -   flatten
                                       Ṛ               -   reverse
                                            ¤          -   nilad followed by link(s) as a nilad:
                                         ⁶ẋ³           -     space repeated 100 times
                                        ;              -   concatenate
                                             ḣ29       -   head to 29 (make all "lines" the same length)
                                                ṫ3     -   tail from 3 (trim off two spaces from each line)
                                                  Ṛ    -   reverse
                                                     Y - join with newlines
                                                       - implicit print

Answer 2

पायथन 3.6, 201 197 193 187 बाइट्स

for i in range(16):print('   '.join(i%k and' '*(2+j)or f'{i//k:0{j}b}'.replace(*'0.').replace(*'1-')+' '+'ETIANMSURWDKGOHVF L PJBXCYZQ  '[2**j-2+i//k]for j,k in zip((1,2,3,4),(8,4,2,1))))

कुछ स्वरूपण, unpacking और A000918 जादू का उपयोग करता है ।

Comments

वैसे, f'{i//k:0{j}b}'.replace(*'0.').replace(*'1-')उतनी ही लंबाई है''.join('.-'[int(x)]for x in f'{i//k:0{j}b}')

— उरेल

Answer 3

रेटिना , 125 बाइट्स

^
. EISHVUF_ARL_WPJ¶- TNDBXKCYMGZQO__
+m`^((.*?)([-.]+) )(\w)((\w)+?)(((?<-6>)\w)+)$
$2$3 $4   $3. $5¶$.1$*     $3- $7
T`\_`p

इसे ऑनलाइन आज़माएं! 121 बाइट होनी चाहिए लेकिन मैं शुरू और अंत में व्हाट्सएप से निपटने के लिए बहुत आलसी था। स्पष्टीकरण:

[blank line]
. EISHVUF_ARL_WPJ¶- TNDBXKCYMGZQO__

वे अक्षर जिनके कोड क्रमशः .और -क्रमशः शुरू होते हैं, प्रीलोडेड होते हैं। (यह सैद्धांतिक रूप से संभव है कि .-यह प्रीलोडिंग से बचने के लिए हो लेकिन यह बाइट्स को इस तरह बचाता है।) _का उपयोग रिक्त स्थान के बजाय किया जाता है क्योंकि उन्हें अक्षर माना जाता है जिससे उन्हें नीचे मिलान करना आसान हो जाता है।

+m`^((.*?)([-.]+) )(\w)((\w)+?)(((?<-6>)\w)+)$
$2$3 $4   $3. $5¶$.1$*     $3- $7

यहाँ हम प्रत्येक पंक्ति को पाँच टुकड़ों में विभाजित करते हैं:

• उपसर्गों के लिए अक्षर, यदि कोई हो
• वर्तमान मोर्स कोड
• वर्तमान पत्र
• शेष पत्रों की पहली छमाही (उनका अगला चरित्र है .)
• शेष पत्रों का दूसरा भाग (उनका अगला चरित्र है -)

टुकड़ों को फिर दो लाइनों पर फिर से जोड़ा गया है:

• उपसर्गों के लिए पत्र, वर्तमान मोर्स कोड, वर्तमान पत्र, एक .प्रत्यय के साथ मोर्स कोड , शेष पत्रों की पहली छमाही
• पहले तीन टुकड़ों की जगह, एक -प्रत्यय के साथ मोर्स कोड , शेष अक्षरों का दूसरा भाग

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

_
  [single space]

_रों तो रिक्त स्थान में वापस बदल रहे हैं।

Answer 4

जावास्क्रिप्ट (ईएस 6), 154 147 145 बाइट्स

f=(n=r='',d=i=k=0)=>(r+=n&&' '.repeat([d++&&3,21,13,6][i-(i=d-k)])+n+' '+'EISHVUF ARL WPJTNDBXKCYMGZQO  '[k++],d<4)?f(n+'.',d)&&f(n+'-',d):r+=`
`

o.innerHTML = f()

<pre id=o>

Comments

ओह डांग! मैं इस एक को याद किया ... अन्यथा परेशान नहीं होता! शाबाश :-)

— बंपी

Answer 5

PHP, 208 बाइट्स

<?=gzinflate(base64_decode("dZDJEQMhDAT/RNEJaHLwfd+38w/EWrRlu6gVnwZpGhWIGSCxqhCXoFgWhpa3jHtpasYtKOaZZwZ9z/OjCnEOim3imX7et2Y8guKYeR5aF+PqB4/tK8Q0KMbDnnWPeZamZmyCYpJ5Pu/V93y7qxCLoHgnXnf5qZnn/iGo9u1/Gf+XDw=="));

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

PHP, 229 बाइट्स

<?=strtr("3E0.3I053S0.53H12 2.54V1254U05-3F12 25-4 1.4A0.-3R0.-.3L12 2.-.4 12.-4W0.63P12 2.64J
4T0-3N0-.3D0-53B12 2-54X12-.4K0-.-3C12 2-.-4Y1-4M063G06.3Z12 26.4Q1264O0-63 12 2-64 ",[$a="   ","
$a$a","$a $a",". ","- ","..","--"]);

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

Answer 6

पर्ल 5, 158 156 बाइट्स

map{$a=sprintf'%04b',$_;map{$a=~/.{$_}/;print(-$'?' 'x$_:$&=~y/01/.-/r,' ',(' EISHVUF ARL WPJTNDBXKCYMGZQO  '=~/./g)[!-$'&&++$i],$_-4?'   ':"\n")}1..4}0..15

Answer 7

PHP, 184 183 181 बाइट्स

for(;$y<16;$y++,print str_pad(ltrim("$r
"),28," ",0))for($r="",$c="03231323"[$y&7];$c++<4;)$r.=strtr(sprintf("   %0${c}b ",$y>>4-$c),10,"-.")."EISHVUF ARL WPJTNDBXKCYMGZQO  "[$i++];

इसे ऑनलाइन चलाएं -nrया इसके लिए प्रयास करें ।

टूट - फूट

for(;$y<16;$y++,                                    # loop through rows
    print str_pad(ltrim("$r\n"),28," ",0)               # 4. pad to 28 chars and print
    )
    for($r="",                                          # 1. result=empty
        $c="03231323"[$y&7];                            # 2. $c=bits in 1st code -1
        $c++<4;)                                        # 3. loop through columns
        $r.=strtr(sprintf("   %0${c}b ",$y>>4-$c),10,"-.")  # append morse code
            ."EISHVUF ARL WPJTNDBXKCYMGZQO  "[$i++];            # append letter

---

प्रमुख स्थानों के साथ -7 बाइट्स : के ltrim("$r\n")साथ "$r\n"और 28साथ बदलें 31।

अनुगामी स्थानों के साथ 171 (= -10) बाइट्स :

for(;$y<16;$y++)for(print str_pad("
",[0,7,14,22][$c="03231323"[$y&7]]);$c++<4;)echo strtr(sprintf("%0${c}b %s   ",$y>>4-$c,"EISHVUF ARL WPJTNDBXKCYMGZQO"[$i++]),10,"-.");

ब्रेकडाउन इसे ऑनलाइन आज़माएं

for(;$y<16;$y++)                                    # loop through rows
    for(
        print str_pad("\n",[0,7,14,22][             # 2. print left padding
            $c="03231323"[$y&7]                     # 1. $c=bits in 1st code -1
        ]); 
        $c++<4;)                                        # 3. loop through columns
        echo                                                # print ...
            strtr(sprintf("%0${c}b %s   ",                  # 3. delimiting spaces
            $y>>4-$c,                                       # 1. morse code
            "EISHVUF ARL WPJTNDBXKCYMGZQO"[$i++]            # 2. letter
        ),10,"-.");

Comments

इस बार कोई सच्ची लाइन नहीं टूटी?

— क्रिस्टोफ

for(;$y<16;$y++,print str_pad(ltrim("$r\n"),28," ",0))for($r="",$c="03231323"[$y&7];$c++<4;)$r.=strtr(sprintf(" %0${c}b ",$y>>4-$c),10,"-.")."EISHVUF ARL WPJTNDBXKCYMGZQO "[$i++];2 बाइट्स बचाना चाहिए।

— क्रिस्टोफ

ऐसा लगता है कि आपने बहुत अधिक स्थान छोड़ दिया है: अंतिम पंक्ति ----बाकी के साथ मेल नहीं खाती है। "EISHVUF ARL WPJTNDBXKCYMGZQO "अंत में 2 रिक्त स्थान होना चाहिए।

— क्रिस्टोफ

Answer 8

APL (Dyalog) , 92 बाइट्स

⎕IO←0कई प्रणालियों पर डिफ़ॉल्ट की आवश्यकता है।

0 3↓¯1⌽⍕{' ',(16⍴1↑⍨16÷≢⍵)⍀'.-'[⍉2⊥⍣¯1⍳≢⍵],' ',⍪⍵}¨'ET' 'IANM' 'SURWDKGO' 'HVF L PJBXCYZQ  '

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

{... }¨'... ' प्रत्येक स्ट्रिंग में निम्नलिखित अनाम फ़ंक्शन लागू करें:

 ⍪⍵ एक कॉलम में तर्क दें

 ' ', एक स्थान पर प्रिपेंड करें (प्रत्येक पंक्ति पर)

 '.-'[… ], स्ट्रिंग को इसके साथ अनुक्रमित करने के बाद प्रीपेंड करें:

  ≢⍵ तर्क की लंबाई

  ⍳ उस के संकेत (0, 1, 2,…, लंबाई -1)

  2⊥⍣¯1 एंटी-बेस -2 (आवश्यकतानुसार कई बिट्स का उपयोग करता है)

  ⍉ पारगमन (प्रत्येक पंक्ति में एक कॉलम में एक प्रतिनिधित्व से)

 (... )⍀ द्वारा विस्तार करें (शून्य पंक्तियों को शून्य द्वारा इंगित के रूप में डालें):

  ≢⍵ तर्क की लंबाई

  16÷ उस से सोलह भाग करें

  1↑⍨ (ओवर) एक से लेते हैं (1- n शून्य के बाद किसी एक की सूची बनाता है )

  16⍴ उस पैटर्न को रीसायकल करें जब तक कि उसमें सोलह तत्व न हों

 ' ', स्थान खाली करना

⍕ प्रारूप (एक ही तालिका में तालिकाओं की सूची, प्रत्येक पक्ष पर एक जगह के साथ प्रत्येक)

¯1⌽ एक कदम दाईं ओर घुमाएँ (इस प्रकार पीछे की ओर पीछे की ओर बढ़ते हुए)

0 3↓ शून्य पंक्तियों और तीन स्तंभों को छोड़ दें (इस प्रकार तीन प्रमुख रिक्त स्थान हटा दें)

Comments

अरे, 16÷⍨आपके कोड‽ में कहाँ दिखाई देता है

— जचार्इ

@ZacharyT यह सुनिश्चित नहीं करता है। अच्छी तरह से देखा, सर।

— आदम

Answer 9

एसओजीएल , 106 105 102 बाइट्स

¹θΞk“r²{r³³a:IA2─l4;- 0*;+Ζ0.ŗΖ1-ŗø4∫BƧ| ⁵±+⁷b<?⁄@*}+;j;@3*+}±kkk≥x}¹±č┐"7ŗ◄∑f^│N≥Χ±⅜g,ιƨΛ.⌡׀¹*ΛβΧκ‘čŗ

यदि रिक्त स्थान की अनुमति है, तो 102 99 बाइट्स

¹θΞk“r²{r³³a:IA2─l4;- 0*;+Ζ0.ŗΖ1-ŗø4∫BƧ| ⁵±+⁷b<?⁄@*}+;j;@3*+}±≥x}¹±č┐"7ŗ◄∑f^│N≥Χ±⅜g,ιƨΛ.⌡׀¹*ΛβΧκ‘čŗ

141 बाइट्स, संपीड़न

Πa≤χ≥∫RωθΩ≡⅛QΨ═Λ9⁶Ul¹&╔²‘č"‼¼⁸Ƨ,9█ω½└╗«ωΤC¡ιΝ/RL⌡⁄1↑οπ∞b∑#⁵ø⁶‘č"⁵ ?∙«Σf⁾ƨ╤P1φ‛╤Β«╚Δ≡ΟNa1\÷╬5ŗķ§⁷D◄tFhžZ@š⁾¡M<╔↓u┌⁽7¡?v¦#DΘø⌡ ⁹x≡ō¦;⁵W-S¬⁴‘' n

बस यह देखना चाहता था कि एसओजीएल केवल संपीड़न के साथ कितना अच्छा कर सकता है (अच्छी तरह से यह सिर्फ संपीड़न से अधिक है, लेकिन यह 97% संकुचित तार है)

Answer 10

जावास्क्रिप्ट (205 बाइट्स)

for(A='EISHVUF ARL WPJTNDBXKCYMGZQO     ',q=0,i=15;30>i++;){for(x=i.toString(2).replace(/(.)/g,a=>1>a?'.':'-'),o='',j=4;j--;)o+=(i%2**j?A.slice(-6+j):x.slice(1,5-j)+' '+A.charAt(q++))+'   ';console.log(o)}

for(A='EISHVUF ARL WPJTNDBXKCYMGZQO     ',q=0,i=15;30>i++;){for(x=i.toString(2).replace(/(.)/g,a=>1>a?'.':'-'),o='',j=4;j--;)o+=(i%2**j?A.slice(-6+j):x.slice(1,5-j)+' '+A.charAt(q++))+'   ';console.log(o)}

Answer 11

रूबी, 144 143 141 बाइट्स

k=0
16.times{|i|4.times{|j|$><<("%0#{j+1}b 9   "%(i>>3-j)).tr('109',(i+8&-i-8)>>3-j>0?'-.'+'  OQZGMYCKXBDNTJPW LRA FUVHSIE'[k-=1]:" ")}
puts}

Ungolfed

k=0                                                     #setup a counter for the letters
16.times{|i|                                            #16 rows    
  4.times{|j|                                           #4 columns
    $><<("%0#{j+1}b 9   "%(i>>3-j)).                    #send to stdout a binary number of j+1 digits, representing i>>3-j, followed by a 9, substituted as follows.
      tr('109',(i+8&-i-8)>>3-j>0?                       #(i&-i) clears all but the least significant 1's bit of i. the 8's ensure a positive result even if i=0.
      '-.'+'  OQZGMYCKXBDNTJPW LRA FUVHSIE'[k-=1]:      #if the expression righshifted appropriately is positive, substitute 1and0 for -and. Substitute 9 for a letter and update counter.
      " ")}                                             #else substiture 1,0 and 9 for spaces.
puts}                                                   #carriage return after each row.

Answer 12

पायथ , 106 बाइट्स

DhNR.n.e+]++.[\.sllN::.Bk\0\.\1\-\ b*]*\ +2sllNt/16lNNjmj*3\ d.t[h"ET"h"IANM"h"SURWDKGO"h"HVF L PJBXCYZQ  

इसे ऑनलाइन टेस्ट करें!

व्याख्या

कुछ शब्दों में, मैं यहाँ क्या कर रहा हूँ तालिका स्तंभ स्तंभ द्वारा उत्पन्न करना और फिर मुद्रण करने से पहले तालिका को स्थानांतरित करना। हम देखते हैं कि एक कॉलम में अक्षरों के लिए मोर्स कोड को बाइनरी स्ट्रिंग्स ( .द्वारा 0और उसके -द्वारा प्रतिस्थापित 1) के रूप में दर्शाया जा सकता है जब कॉलम में अंतिम अक्षर के शून्य से सूचकांक तक गिना जाता है।

एल्गोरिथ्म एक फ़ंक्शन पर निर्भर करता है जिसमें से मैं नीचे (दूसरे कॉलम के लिए) एक उदाहरण देता हूं:

1. Takes "IANM" as input
2. Generates the binary representations of zero up to len("IANM"): ["0", "1", "10", "11"]
3. Replace with dots and hyphens: [".", "-", "-.", "--"]
4. Pad with dots up to floor(log2(len("IANM"))): ["..", ".-", "-.", "--"]
5. Add the corresponding letters: [".. I", ".- A", "-. N", "-- M"]
6. After each element, insert a list of 16 / len("IANM") - 1 (= 3) strings containing only spaces of length floor(log2(len("IANM"))) + 2 (= 4):
    [".. I", ["    ", "    ", "    "], ".- A", ["    ", "    ", "    "], "-. N", ["    ", "    ", "    "], "-- M", ["    ", "    ", "    "]]
7. Flatten that list:
    [".. I", "    ", "    ", "    ", ".- A", "    ", "    ", "    ", "-. N", "    ", "    ", "    ", "-- M", "    ", "    ", "    "]
8. That's it, we have our second column!

कोड स्पष्टीकरण

मैंने दो में कोड काट दिया। पहला भाग ऊपर वर्णित फ़ंक्शन है, दूसरा भाग यह है कि मैं फ़ंक्शन का उपयोग कैसे करूं:

DhNR.n.e+]++.[\.sllN::.Bk\0\.\1\-\ b*]*\ +2sllNt/16lNN

DhNR                                                      # Define a function h taking N returning the rest of the code. N will be a string
      .e                                             N    # For each character b in N, let k be its index
                      .Bk                                 # Convert k to binary
                     :   \0\.                             # Replace zeros with dots (0 -> .)
                    :        \1\-                         # Replace ones with hyphens (1 -> -)
            .[\.sllN                                      # Pad to the left with dots up to floor(log2(len(N))) which is the num of bits required to represent len(N) in binary
          ++                     \ b                      # Append a space and b
         ]                                                # Make a list containing only this string. At this point we have something like [". E"] or [".. I"] or ...
        +                           *]*\ +2sllNt/16lN     # (1) Append as many strings of spaces as there are newlines separating each element vertically in the table
    .n                                                    # At this point the for each is ended. Flatten the resulting list and return it

⁽¹⁾ : मोर्स टेबल में, पहले कॉलम में, प्रत्येक पंक्ति के बाद सात पंक्तियाँ होती हैं जिसमें एक अक्षर ("E" और "T") होता है। दूसरे कॉलम में, यह तीन लाइनें हैं। फिर एक (तीसरा स्तंभ), फिर शून्य (अंतिम कॉलम)। वह वह जगह है 16 / n - 1जहां nकॉलम में अक्षरों की संख्या है (जो Nऊपर दिए गए कोड में है)। कोड ⁽¹⁾ पर कोड क्या करता है :

*]*\ +2sllNt/16lN

       sllN          # Computes the num of bits required to represent len(N) in binary
     +2              # To that, add two. We now have the length of a element of the current column
  *\                 # Make a string of spaces of that length (note the trailing space)
           t/16lN    # Computes 16 / len(N) - 1
*]                   # Make a list of that length with the string of spaces (something like ["    ", "    ", ...])

ठीक है, अब हमारे पास एक अच्छा सहायक फ़ंक्शन है hजो मूल रूप से वर्णों के अनुक्रम से तालिका के स्तंभ को उत्पन्न करता है। चलो इसका उपयोग करते हैं (नीचे दिए गए कोड में दो अनुगामी रिक्त स्थान पर ध्यान दें):

jmj*3\ d.t[h"ET"h"IANM"h"SURWDKGO"h"HVF L PJBXCYZQ  

           h"ET"                                        # Generate the first column
                h"IANM"                                 # Generate the second column
                       h"SURWDKGO"                      # Generate the third column
                                  h"HVF L PJBXCYZQ      # Generate the last column (note the two trailing spaces)
          [                                             # Make a list out of those columns
        .t                                              # Transpose, because we can print line by line, but not column by column
 mj*3\ d                                                # For each line, join the elements in that line on "   " (that is, concatenate the elements of the lines but insert "   " between each one)
j                                                       # Join all lines on newline

कोड अभी भी छोटा किया जा सकता है; हो सकता है कि मैं बाद में उस पर वापस आ जाऊं।

Answer 13

सी, 199 195 बाइट्स

#define P putchar
m;p(i,v){printf("%*s",i&1|!v?v*(v+11)/2:3,"");for(m=1<<v;m;m/=2)P(45+!(i&m));P(32);P("  ETIANMSURWDKGOHVF L PJBXCYZQ  "[i]);v<3?p(2*i,v+1):P(10);++i&1&&p(i,v);}main(){p(2,0);}

कोलीरू पर लाइव (चेतावनी संदेश से बचने के लिए #include के साथ)।

अद्यतन : m@zacharyT द्वारा सुझाए गए फ़ंक्शन के बाहर "घोषणा" को स्थानांतरित करके चार वर्णों को सहेजा गया

उपयोग क्या एक मानक रणनीति हो रहा है:, एक सरणी एन्कोड की गई बाइनरी पेड़ में पत्र रखें ताकि तत्व के बच्चों के iहैं 2*iऔर 2*i+1। यह पेड़ 1 के बजाय 2 पर निहित है क्योंकि अंकगणित थोड़ा कम काम करता है, मुझे लगता है। बाकी सभी गोल्फ है।

Ungolfed:

// Golfed version omits the include
#include <stdio.h>
// Golfed version uses the string rather than a variable.
char* tree = "  ETIANMSURWDKGOHVF L PJBXCYZQ  ";
/* i is the index into tree; v is the number of bits to print (-1) */
void p(int i, int v) {
  /* Golfed version omits all types, so the return type is int.
   * Nothing is returned, but on most architectures that still works although
   * it's UB.
   */
  printf("%*s", i&1 || !v ? v*(v+11)/2 : 3, "");
  /* v*(v+11)/2 is v*(v+1)/2 + 3*v, which is the number of spaces before the odd
   * element at level v. For even elements, we just print the three spaces which
   * separate adjacent elements. (If v is zero, we're at the margin so we
   * suppress the three spaces; with v == 0, the indent will be 0, too.
   *
   * Golfed version uses | instead of || since it makes no semantic difference.
   */

  /* Iterate over the useful bits at this level */
  for (int m=1<<v; m; m/=2) {
    /* Ascii '-' is 45 and '.' is 46, so we invert the tested bit to create the
     * correct ascii code.
     */
    putchar('-' + !(i&m));
  }
  /* Output the character */
  putchar(' ');
  putchar(tree[i]);
  /* Either recurse to finish the line or print a newline */
  if (v<3)
    p(2*i,v+1);
  else
    putchar('\n');
  /* For nodes which have a sibling, recurse to print the sibling */
  if (!(i&1))
    p(i+1, v);
}

int main(void) {
  p(2,0);
}

Comments

क्या आप फंक्शन से बाहर int mहो सकते हैं m;?

— ज़ाचरी

क्या यह कार्य उत्तर देता है ।

— ज़ाचारि

@ZacharyT: मुझे लगता है कि यह काम करेगा, लेकिन यह एक वर्ण लंबा है (#define में खुला कोष्ठक) इसलिए थोड़ा बिंदु लगता है।

— रिसी

मैंने उस संस्करण के साथ 194 बाइट्स गिना, क्या मुझे कुछ याद आ रहा है?

— ज़ाचरी

Answer 14

बबलगम , 133 बाइट्स

000000: e0 01 be 00   7d 5d 00 17   08 05 23 e4   96 22 00 5d │ à.¾.}]....#ä.".]
000010: e5 e9 94 d3   78 24 16 ec   c1 c4 ad d8   6e 4d 41 e8 │ åé.Óx$.ìÁÄ.ØnMAè
000020: a3 a1 82 e6   f4 88 d9 85   6f ae 6b 93   aa 44 c8 e3 │ £¡.æô.Ù.o®k.ªDÈã
000030: 29 6f df 65   aa 4a f8 06   f5 63 1a 73   a7 e4 4d 19 │ )oßeªJø.õc.s§äM.
000040: 03 2c 87 59   7b df 27 41   4b b6 12 dd   7c e5 78 27 │ .,.Y{ß'AK¶.Ý|åx'
000050: 9c 9f 99 db   f6 8e 42 fd   43 68 48 46   37 da d7 21 │ ...Ûö.BýChHF7Ú×!
000060: a9 ca ea be   f4 57 e0 da   c1 16 97 ef   7a 0c e9 3c │ ©Êê¾ôWàÚÁ..ïz.é<
000070: 8e c2 b6 22   ca e4 e5 53   57 f0 f4 fb   a4 fb c0 a7 │ .¶"ÊäåSWðôû¤ûÀ§
000080: ec cd 6e 00   00                                      │ ìÍn..

एक LZMA धारा के रूप में संपीड़ित।

Answer 15

सी, 291 बाइट्स

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

char*i,*t=".aEc..aIc...aSc....aH/u...-aV/m..-aUc..-.aF/u..--/f.-aAc.-.aRc.-..aL/u.-.-/m.--aWc.--.aP/u.---aJ/-aTc-.aNc-..aDc-...aB/u-..-aX/m-.-aKc-.-.aC/u-.--aY/f--aMc--.aGc--..aZ/u--.-aQ/m---aOc---./u----";
s(n){while(n--)putchar(32);}f(){for(i=t;*i;i++)*i<97?putchar(*i-'/'?*i:10):s(*i-96);}

यह काम किस प्रकार करता है

पहले मैंने सी में स्ट्रिंग को पार्स किया, गिनती के स्थान जो 26 से कम हैं इसलिए मैंने उन्हें इस मामले के a, b, .. zसाथ छोटे मामलों के पत्रों में एन्कोड किया

for(char*i=t; *i; i++)
{
    if(*i == ' ') c++;
    else c = 0;

    if(i[1] != ' ' && c > 0) putchar('a'+c-1);
    else if(*i =='\n') putchar('/');
    else if(*i != ' ') putchar(*i);
}

फिर मैंने उस एन्कोडिंग के लिए एक पार्सर लिखा, जहां /एक नई लाइन है, और एक छोटी सी स्थिति पत्र t[i] - 'a'रिक्त स्थान का प्रतिनिधित्व करता है

int s(int n)
{
    while(n--) putchar(32);
}

f()
{
    for(char*i=t; *i; i++)
        if(*i < 'a')
            if(*i == '/') putchar('\n');
            else putchar(*i);
        else s(*i-'a'+1);
}

Comments

263 बाइट्स

— सीलिंगकैट

Answer 16

बैश (उपयोगिताओं के साथ), 254 बाइट्स

tail -n+2 $0|uudecode|bzip2 -d;exit
begin 644 -
M0EIH.3%!6293631+'LX``&UV`%`P(`!``S____`@`(@:2!H#:@!ZFU'H@T](
MJ>H`'J``;4L>\%)R2H9TS-4WY[M(`"`@=((AJ")8HR^QFK?8RQO2B+W47&@`
M!"@$(!%Q,$'X:#+&>BI<RAC5.J53,S(%FFB!%A-*SM9TY&I8RFZJ9<D0H_B[
)DBG"A(&B6/9P
`
end

Answer 17

डायलॉग एपीएल, 159 बाइट्स (गैर-प्रतिस्पर्धात्मक)

↑{X←⍵-1⋄Y←2*⍳4⋄R←Y+(Y÷16)×⍵-1⋄3↓∊{C←R[⍵]⋄'   ',(⍵⍴(1+0=1|C)⊃'    '({⍵⊃'.-'}¨1+(4⍴2)⊤X)),' ',((1+0=1|C)⊃' '((C-1|C)⊃' ETIANMSURWDKGOHVF L PJBXCYZQ  '))}¨⍳4}¨⍳16

Comments

यह गैर-प्रतिस्पर्धा क्यों है?

— आदम

मुझे लगता है कि आप सेटिंग ⎕IO←0(कई प्रणालियों पर डिफ़ॉल्ट) और उपयोग ⍨(आवागमन) द्वारा बहुत बचत कर सकते हैं ।

— एडम

Answer 18

जावास्क्रिप्ट (ईएस 7), 242 240 238 बाइट्स

console.log([...'EISH000V00UF000 0ARL000 00WP000JTNDB000X00KC000Y0MGZ000Q00O 000 '].map((a,k)=>(n=>(a!='0'?(2**n+(k>>2)/2**(4-n)).toString(2).slice(-n).replace(/./g,c=>'.-'[c])+' '+a:'      '.slice(-n-2))+(n<4?'   ':'\n'))(k%4+1)).join``)

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

-2 के लिए धन्यवाद बाइट्स जाकारी ।

Comments

बदलने का प्रयास करें a!='0'करने के लिएa!=0

— Cyoce

आप के .join('')साथ बदल सकते हैं .join<insert backtick here><insert backtick here>? ( <insert backtick here>वास्तविक

— बैकटिक्स के

के रूप में Cyoce कहा, बदलने का प्रयास a!='0'करने के लिए a!=0, कि काम करना चाहिए।

— ज़ाचारि

@ZacharyT नहीं, यह नहीं है , लेकिन फिर से धन्यवाद।

— eush77

क्षमा करें, ''मामले के बारे में भूल गया ।

— ज़ाचारि