Rédiger une feuille de triche formatée en code Morse

24

Défi:

Écrivez un programme qui produit la sortie suivante:

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

Il s'agit d'un tableau formaté des codes Morse des lettres de A à Z. Chaque colonne est séparée par trois espaces.

Il y a quatre emplacements manquants, qui sont utilisés par les jeux de caractères internationaux. Votre programme doit y écrire un espace.

La sortie doit être constituée d'espaces ASCII, de points, de tirets, de lettres majuscules et de nouvelles lignes (LF ou CRLF) uniquement.

Votre programme n'accepte aucune entrée.

Voici un exemple de programme Python qui produit la sortie souhaitée:

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

Il s'agit de , donc la réponse la plus courte en octets l'emporte.

Locoluis
la source
1
peut chaque ligne 3 espaces préfixés?
dzaima
1
Les failles standard interdisent le codage en dur de la solution. Quelle partie du tableau pouvons-nous coder en dur?
Brunner
@Brunner considérant que la table fait environ 450 octets, je doute que le codage en dur soit la solution optimale
Cyoce
@Cyoce Ce n'est certainement pas la version la plus courte ici, mais Joerg Huelsermann l'a réduite à 208 octets dans ses brillantes réponses php.
Brunner
1
Sommes-nous autorisés à avoir des espaces de fin?
2017

Réponses:

5

Gelée , 85 octets

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

Un programme complet d'impression de la feuille de triche.

Essayez-le en ligne!

Comment?

Remarque: je pense qu'il peut y avoir un moyen de réduire cela en formant une liste qui formate correctement en utilisant l'atome de la grille G, mais je ne peux pas tout à fait savoir comment.

Ø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
la source
7

Python 3.6, 201 197 193 187 octets

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

Utilise un peu de formatage, de déballage et de magie A000918 .

Uriel
la source
Soit dit en passant, f'{i//k:0{j}b}'.replace(*'0.').replace(*'1-')est la même longueur que''.join('.-'[int(x)]for x in f'{i//k:0{j}b}')
Uriel
5

Rétine , 125 octets

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

Essayez-le en ligne! Devrait être de 121 octets mais j'étais trop paresseux pour gérer les espaces blancs au début et à la fin. Explication:

[blank line]
. EISHVUF_ARL_WPJ¶- TNDBXKCYMGZQO__

Les lettres dont le code commence par .et -respectivement sont préchargées. (Il est théoriquement possible d'éviter de précharger le .-mais cela économise les octets de cette façon.) Les _s sont utilisés à la place des espaces car ils sont considérés comme des lettres, ce qui les rend plus faciles à faire correspondre ci-dessous.

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

Ici, nous divisons chaque ligne en cinq morceaux:

  • Les lettres des préfixes, le cas échéant
  • Le code Morse actuel
  • La lettre actuelle
  • La première moitié des lettres restantes (leur caractère suivant est .)
  • La seconde moitié des lettres restantes (leur caractère suivant est -)

Les pièces sont ensuite remontées sur deux lignes:

  • Les lettres des préfixes, le code Morse actuel, la lettre actuelle, le code Morse avec un .suffixe, la première moitié des lettres restantes
  • Espaces remplaçant les trois premières pièces, le code Morse par un -suffixe, la seconde moitié des lettres restantes

Les nouvelles lignes suivent le même format que la ligne existante, juste avec un préfixe Morse supplémentaire et la moitié du nombre de lettres restant à traiter. Cette opération est ensuite répétée jusqu'à ce que chaque ligne ne comporte qu'une seule lettre.

_
  [single space]

Les _s sont ensuite reconvertis en espaces.

Neil
la source
3

JavaScript (ES6), 154 147 145 octets

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
la source
Oh dang! J'ai raté celui-ci ... n'aurait pas dérangé autrement! Bravo :-)
Bumpy
2

PHP, 208 octets

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

Essayez-le en ligne!

PHP, 229 octets

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

Essayez-le en ligne!

Jörg Hülsermann
la source
2

Perl 5, 158 156 octets

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

PHP, 184 183 181 octets

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

Courez avec -nrou essayez-le en ligne .

panne

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 octets avec espaces de début: remplacer ltrim("$r\n")par "$r\n"et 28par31 .

171 (= -10) octets avec espaces de fin :

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

ventilation essayer en ligne

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
la source
1
Pas de vraie rupture de ligne cette fois?
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++];devrait économiser 2 octets.
Christoph
1
Il semble que vous ayez trop laissé tomber un espace: dans la dernière ligne ----ne correspond pas au reste. "EISHVUF ARL WPJTNDBXKCYMGZQO "devrait avoir 2 espaces à la fin.
Christoph
2

APL (Dyalog) , 92 octets

Besoins ⎕IO←0par défaut sur de nombreux systèmes.

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

Essayez-le en ligne!

{... }¨'...'  appliquer la fonction anonyme qui suit à chacune des chaînes:

⍪⍵ transformer l'argument en une colonne

' ', ajouter un espace (sur chaque ligne)

'.-'[], Ajoutez la chaîne après son indexation avec:

  ≢⍵ la longueur de l'argument

   les indices de cela (0, 1, 2,…, longueur -1)

  2⊥⍣¯1 anti-base-2 (utilise autant de bits que nécessaire)

   transposer (d'une représentation dans chaque colonne à une dans chaque ligne)

()⍀ Développer par (insérer des lignes vides comme indiqué par des zéros dans):

  ≢⍵ la longueur de l'argument

  16÷ diviser seize par cela

  1↑⍨ (over) prendre à partir d'un (fait une liste d'un suivi de 1 à n zéros)

  16⍴ recycler ce modèle jusqu'à ce qu'il ait seize éléments

' ', ajouter un espace

 format (la liste des tables en une seule table, en remplissant chacune avec un espace de chaque côté)

¯1⌽ pivoter d'un pas vers la droite (déplaçant ainsi l'espace de fuite vers l'avant)

0 3↓ supprimer zéro lignes et trois colonnes (supprimant ainsi les trois espaces de tête)

Adam
la source
Hé, où 16÷⍨apparaît dans votre code?
Zacharý
@ZacharyT Ce n'est certainement pas le cas. Joliment repéré, monsieur.
Adám
1

SOGL , 106 105 102 octets

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

Si les espaces en avance sont autorisés, 102 99 octets

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

141 octets, compression

Π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

je voulais juste voir à quel point SOGL pouvait faire avec la compression (enfin, il y a plus que la compression, mais c'est 97% de chaînes compressées)

dzaima
la source
1

JavaScript (205 octets)

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

Cahoteux
la source
1

Rubis, 144 143 141 octets

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}

Non golfé

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
la source
1

Pyth , 106 octets

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

Testez-le en ligne!

Explication

En quelques mots, ce que je fais ici, c'est de générer le tableau colonne par colonne puis de transposer le tableau avant de l'imprimer. On remarque que dans une colonne, les codes morse des lettres peuvent être représentés comme des chaînes binaires (à remplacer .par 0et -par 1) lors du comptage de zéro à l'index de la dernière lettre de la colonne.

L'algorithme repose sur une fonction à partir de laquelle je donne un exemple exécuté ci-dessous (pour la deuxième colonne):

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!

Explication du code

J'ai coupé le code en deux. La première partie est la fonction décrite ci-dessus, la deuxième partie est la façon dont j'utilise la fonction:

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) : Dans le tableau morse, dans la première colonne, il y a sept lignes après chaque ligne contenant une lettre ("E" et "T"). Dans la deuxième colonne, c'est trois lignes. Puis un (troisième colonne), puis zéro (dernière colonne). C'est 16 / n - 1nest le nombre de lettres dans la colonne (qui est Ndans le code ci-dessus). C'est quoi le code à la ligne (1) :

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

D'accord, nous avons maintenant une fonction utile hqui génère essentiellement une colonne de tableau à partir d'une séquence de caractères. Utilisons-le (notez les deux espaces de fin dans le code ci-dessous):

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

Le code peut encore être raccourci; peut-être que j'y reviendrai plus tard.

Jim
la source
1

C, 199 195 octets

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

Vivre sur coliru (avec #include pour éviter le message d'avertissement.)

MISE À JOUR : Quatre caractères enregistrés en déplaçant la "déclaration" de l' mextérieur de la fonction, comme suggéré par @zacharyT

Utilise ce qui semble être une stratégie standard: conserver les lettres dans un arbre binaire encodé en tableau, de sorte que les enfants de l'élément isont2*i et 2*i+1. Cet arbre est enraciné à 2 plutôt qu'à 1 parce que l'arithmétique a fonctionné un peu plus court, je pense. Tout le reste est au golf.

Non golfé:

// 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
la source
Pourriez-vous déplacer le int mpour être en m;dehors de la fonction?
Zacharý
Est-ce que cela fonctionne repl.it/Iqma ?
Zacharý
@ZacharyT: Je suppose que cela fonctionnera mais c'est un caractère de plus (la parenthèse ouverte dans le #define) donc il semble peu utile.
rici
J'ai compté 194 octets avec cette version, est-ce que je manque quelque chose?
Zacharý
1

Bubblegum , 133 octets

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

Comprimé en tant que flux LZMA.

Uriel
la source
0

C, 291 octets

Essayez en ligne

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

Comment ça marche

J'ai d'abord analysé la chaîne en C, en comptant les espaces inférieurs à 26, je les ai donc encodés en minuscules a, b, .. zavec ce petit programme

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

Ensuite, j'ai écrit un analyseur pour cet encodage, où /est une nouvelle ligne, et une lettre minuscule représente des t[i] - 'a'espaces

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
la source
263 octets
plafondcat
0

Bash (avec utilitaires), 254 octets

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
la source
0

Dyalog APL, 159 octets (non concurrent)

↑{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
la source
Pourquoi est-ce non concurrentiel?
2017
Je pense que vous pouvez économiser beaucoup en définissant ⎕IO←0(par défaut sur de nombreux systèmes) et en utilisant (commute) .
2017
0

JavaScript (ES7), 242 240 238 octets

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

Essayez-le en ligne!

–2 octets grâce à Zachary .

eush77
la source
Essayez de changer a!='0'poura!=0
Cyoce
Pouvez-vous remplacer .join('')par .join<insert backtick here><insert backtick here>? (en <insert backtick here>cours de remplacement par de vrais coups de pied)
Zacharý
Comme l'a dit Cyoce, essayez de passer a!='0'à a!=0, cela devrait fonctionner.
Zacharý
@ZacharyT Non, ce n'est pas le cas , mais merci encore.
eush77
Désolé, j'ai oublié l' ''affaire.
Zacharý