Schreiben Sie ein formatiertes Morsecode-Cheatsheet

24

Herausforderung:

Schreiben Sie ein Programm, das die folgende Ausgabe erzeugt:

. 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   ---.  
                     ----  

Dies ist eine formatierte Tabelle mit den Morsecodes der Buchstaben von A bis Z. Jede Spalte ist durch drei Leerzeichen getrennt.

Es fehlen vier Slots, die von internationalen Zeichensätzen verwendet werden. Ihr Programm muss dort ein Leerzeichen schreiben.

Die Ausgabe darf nur aus ASCII-Leerzeichen, Punkten, Bindestrichen, Großbuchstaben und Zeilenumbrüchen (entweder LF oder CRLF) bestehen.

Ihr Programm akzeptiert keine Eingaben.

Das Folgende ist ein Beispiel-Python-Programm, das die gewünschte Ausgabe erzeugt:

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

Das ist , also gewinnt die kürzeste Antwort in Bytes.

Locoluis
quelle
1
Kann jede Zeile 3 Leerzeichen voranstellen?
Dzaima
1
Standardschlupflöcher verbieten die harte Codierung von Lösungen. Wie viel von der Tabelle dürfen wir hart codieren?
Brunner
@Brunner in Anbetracht der Tabelle ist rund 450 Bytes, ich bezweifle, dass harte Codierung die optimale Lösung ist
Cyoce
@Cyoce Auf jeden Fall nicht die kürzeste Version, aber Jörg Hülsermann hat es in seinen brillanten PHP-Antworten auf 208 Bytes gebracht.
Brunner
1
Dürfen wir abschließende Leerzeichen verwenden?
Adám

Antworten:

5

Jelly , 85 Bytes

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

Ein volles Programm zum Ausdrucken des Spickzettel.

Probieren Sie es online!

Wie?

Hinweis: Ich denke, es gibt eine Möglichkeit, dies zu reduzieren, indem man eine Liste erstellt, die das Rasteratom korrekt formatiert G, aber ich kann nicht genau herausfinden, wie.

Ø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
Jonathan Allan
quelle
7

Python 3.6, 201 197 193 187 Bytes

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

Verwendet etwas Formatierung, Auspacken und A000918- Magie.

Uriel
quelle
Übrigens f'{i//k:0{j}b}'.replace(*'0.').replace(*'1-')ist die gleiche Länge wie''.join('.-'[int(x)]for x in f'{i//k:0{j}b}')
Uriel
5

Netzhaut , 125 Bytes

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

Probieren Sie es online! Sollte 121 Bytes sein, aber ich war zu faul, um mit dem Leerzeichen am Anfang und Ende umzugehen. Erläuterung:

[blank line]
. EISHVUF_ARL_WPJ¶- TNDBXKCYMGZQO__

Die Buchstaben , dessen Code beginnt mit .und -jeweils vorgespannt sind. (Es ist theoretisch möglich, das vorab zu laden .-, spart aber auf diese Weise Bytes.) _S werden anstelle von Leerzeichen verwendet, da sie als Buchstaben betrachtet werden, was die Zuordnung im Folgenden erleichtert.

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

Hier teilen wir jede Zeile in fünf Teile:

  • Die Buchstaben für Präfixe, falls vorhanden
  • Der aktuelle Morsecode
  • Der aktuelle Brief
  • Die erste Hälfte der verbleibenden Buchstaben (ihr nächstes Zeichen ist .)
  • Die zweite Hälfte der verbleibenden Buchstaben (ihr nächstes Zeichen ist -)

Die Teile werden dann in zwei Linien wieder zusammengesetzt:

  • Die Buchstaben für Präfixe, der aktuelle Morsecode, der aktuelle Buchstabe, der Morsecode mit .Suffix, die erste Hälfte der verbleibenden Buchstaben
  • Leerzeichen, die die ersten drei Teile ersetzen, der Morsecode mit einem -Suffix, die zweite Hälfte der verbleibenden Buchstaben

Die neuen Zeilen haben dasselbe Format wie die vorhandene Zeile, nur mit einem zusätzlichen Morse-Präfix und der Hälfte der Buchstaben, die noch verarbeitet werden müssen. Dies wird dann wiederholt, bis jede Zeile nur noch einen Buchstaben enthält.

_
  [single space]

Die _s werden dann wieder in Leerzeichen umgewandelt.

Neil
quelle
3

JavaScript (ES6), 154 147 145 Byte

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>

Arnauld
quelle
Oh Mist! Ich habe das hier verpasst ... hätte mich sonst nicht gestört! Gut gemacht :-)
Holprig
2

PHP, 208 Bytes

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

Probieren Sie es online!

PHP, 229 Bytes

<?=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",". ","- ","..","--"]);

Probieren Sie es online!

Jörg Hülsermann
quelle
2

Perl 5, 158 156 Bytes

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

PHP, 184 183 181 Bytes

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++];

Laufen Sie mit -nroder versuchen Sie es online .

Nervenzusammenbruch

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 Bytes mit führenden Leerzeichen : Ersetzen Sie ltrim("$r\n")mit "$r\n"und 28mit 31.

171 (= -10) Bytes mit nachgestellten Leerzeichen :

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,"-.");

Aufschlüsselung versuchen Sie es online

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,"-.");
Titus
quelle
1
Diesmal kein echter Zeilenumbruch?
Christoph
1
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++];sollte 2 Bytes sparen.
Christoph
1
Es sieht so aus, als hätten Sie ein Leerzeichen zu viel abgelegt: In der letzten Zeile ----stimmt das nicht mit dem Rest überein. "EISHVUF ARL WPJTNDBXKCYMGZQO "sollte am Ende 2 Leerzeichen haben.
Christoph
2

APL (Dyalog) , 92 Bytes

Bedürfnisse, ⎕IO←0die auf vielen Systemen Standard sind.

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

Probieren Sie es online!

{... }¨'...'  wenden Sie die folgende anonyme Funktion an jeden des Strings:

⍪⍵ Machen Sie das Argument in eine Spalte

' ', ein Leerzeichen voranstellen (in jeder Zeile)

'.-'[],  Die Zeichenkette voranstellen, nachdem sie indiziert wurde mit:

  ≢⍵ die Länge des Arguments

   die Indizes dieser (0, 1, 2,…, Länge -1)

  2⊥⍣¯1 Anti-Base-2 (verwendet so viele Bits wie nötig)

   transponieren (von einer Darstellung in jeder Spalte zu einer in jeder Zeile)

()⍀  Erweitern um (Leerzeilen wie durch Nullen in angegeben einfügen):

  ≢⍵ die Länge des Arguments

  16÷ Teilen Sie sechzehn durch das

  1↑⍨ (over) take from one (erstellt eine Liste mit einer Eins, gefolgt von 1 bis n) Nullen)

  16⍴ recyceln Sie das Muster, bis es sechzehn Elemente enthält

' ', ein Leerzeichen voranstellen

 Format (die Liste der Tabellen in einer einzigen Tabelle, wobei jede Tabelle mit einem Leerzeichen auf jeder Seite aufgefüllt wird)

¯1⌽ um einen schritt nach rechts drehen (dadurch den abschließenden raum nach vorne verschieben)

0 3↓ lösche null Zeilen und drei Spalten (entferne so die drei führenden Leerzeichen)

Adam
quelle
Hey, wo 16÷⍨erscheint in deinem Code?
Zacharý
@ ZacharyT Sicher nicht. Schön gesehen, Sir.
Adám
1

SOGL , 106 105 102 Bytes

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

Wenn vorangestellte Leerzeichen zulässig sind, 102 bis 99 Byte

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

141 Bytes, Komprimierung

Π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

wollte nur sehen, wie gut SOGL mit nur Komprimierung umgehen kann (nun, es ist mehr als nur Komprimierung, aber es sind 97% komprimierte Zeichenfolgen)

dzaima
quelle
1

JavaScript (205 Byte)

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

Holperig
quelle
1

Ruby, 144 143 141 Bytes

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.
Level River St
quelle
1

Pyth , 106 Bytes

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

Testen Sie es online!

Erläuterung

Mit ein paar Worten, was ich hier mache, ist, die Tabelle spaltenweise zu generieren und sie dann vor dem Drucken zu transponieren. Wir stellen fest, dass in einer Spalte die Morsecodes für die Buchstaben als binäre Zeichenfolgen dargestellt werden können ( .durch 0und -durch ersetzen)1 ), wenn von Null bis zum Index des letzten Buchstabens in der Spalte gezählt wird.

Der Algorithmus basiert auf einer Funktion, von der ich im Folgenden ein Beispiel gebe (für die zweite Spalte):

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!

Code Erklärung

Ich habe den Code in zwei Teile geteilt. Der erste Teil ist die oben beschriebene Funktion, der zweite Teil ist, wie ich die Funktion benutze:

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

(1) : In der Morse-Tabelle stehen in der ersten Spalte nach jeder Zeile sieben Zeilen mit einem Buchstaben ("E" und "T"). In der zweiten Spalte sind es drei Zeilen. Dann eins (dritte Spalte), dann null (letzte Spalte). Das heißt , 16 / n - 1wo ndie Anzahl der Buchstaben in der Spalte (die Nin dem obigen Code). So sieht der Code in Zeile (1) aus :

*]*\ +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 ["    ", "    ", ...])

Okay, jetzt haben wir eine nette hilfreiche Funktion, hdie im Grunde eine Tabellenspalte aus einer Folge von Zeichen generiert. Lass es uns benutzen (beachte die beiden nachgestellten Leerzeichen im Code unten):

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

Der Code kann noch gekürzt werden; Vielleicht komme ich später darauf zurück.

Jim
quelle
1

C 199 195 Bytes

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

Live on coliru (mit #include, um die Warnmeldung zu vermeiden.)

UPDATE : Durch Verschieben der "Deklaration" von wurden vier Zeichen gespeichertm außerhalb der Funktion wurden gespeichert, wie von @zacharyT vorgeschlagen

Verwendet , was eine Standard - Strategie zu sein scheint: halten Sie die Buchstaben in einem Array-codierten binären Baum, so dass die Kinder des Elements isind 2*iund2*i+1 . Dieser Baum wurzelt eher bei 2 als bei 1, weil die Arithmetik meiner Meinung nach etwas kürzer war. Der Rest ist Golfen.

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);
}
rici
quelle
Könntest du das bewegen int m, um m;außerhalb der Funktion zu sein?
Zacharý
Funktionierts repl.it/Iqma ?
Zacharý
@ ZacharyT: Ich nehme an, es wird funktionieren, aber es ist ein Zeichen länger (die offene Klammer in der #Definition), so dass es wenig Sinn macht.
rici
Ich habe mit dieser Version 194 Bytes gezählt. Fehlt mir etwas?
Zacharý
1

Bubblegum , 133 Bytes

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..

Komprimiert als LZMA-Stream.

Uriel
quelle
0

C 291 Bytes

Versuchen Sie es online

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

Wie es funktioniert

Zuerst habe ich die Zeichenfolge in C analysiert und dabei Leerzeichen gezählt, die kleiner als 26 sind. Deshalb habe ich sie a, b, .. zmit diesem kleinen Programm in Kleinbuchstaben codiert

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

Dann habe ich einen Parser für diese Kodierung geschrieben, wobei /eine neue Zeile und ein Kleinbuchstabe t[i] - 'a'Leerzeichen darstellen

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);
}
Khaled.K
quelle
263 Bytes
Ceilingcat
0

Bash (mit Dienstprogrammen), 254 Bytes

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
Sigvaldm
quelle
0

Dyalog APL, 159 Bytes (nicht konkurrierend)

↑{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
Locoluis
quelle
Warum ist das nicht konkurrierend?
Adám
Ich denke, Sie können viel sparen, indem Sie einstellen ⎕IO←0(Standardeinstellung auf vielen Systemen) und verwenden (pendeln) .
Adám
0

JavaScript (ES7), 242 240 238 Byte

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

Probieren Sie es online!

–2 Bytes dank Zachary .

eush77
quelle
Versuchen Sie , a!='0'zua!=0
Cyoce
Können Sie ersetzen .join('')mit .join<insert backtick here><insert backtick here>? ( <insert backtick here>wird durch aktuelle Backticks ersetzt)
Zacharý
Wie Cyoce sagte, versuchen Wechsel a!='0'zu a!=0, dass funktionieren sollte.
Zacharý
@ ZacharyT Nein, tut es nicht , aber nochmals vielen Dank.
Eush77
Entschuldigung, habe den ''Fall vergessen .
Zacharý