Написать отформатированный азбуку Морзе

24

Вызов:

Напишите программу, которая производит следующий вывод:

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

Это отформатированная таблица азбуки Морзе для букв от А до Я. Каждый столбец разделен тремя пробелами.

Есть четыре пропущенных слота, которые используются международными наборами символов. Ваша программа должна написать там пробел.

Выходные данные должны состоять только из пробелов ASCII, точек, тире, букв верхнего регистра и новых строк (либо LF, либо CRLF).

Ваша программа не принимает ввод.

Ниже приведен пример программы на Python, который выдает желаемый результат:

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

Это , поэтому выигрывает самый короткий ответ в байтах.

Locoluis
источник
1
может в каждой строке 3 предшествующих пробела?
Дзайма
1
Стандартные лазейки не допускают жесткого кодирования решения. Какую часть таблицы мы можем жестко кодировать?
Бруннер
@ Бруннер, учитывая, что размер таблицы составляет около 450 байт, я сомневаюсь, что жесткое кодирование является оптимальным решением
Cyoce
@Cyoce Определенно, не самая короткая версия здесь, но Йорг Хельзерманн получил его до 208 байт в своих блестящих php-ответах.
Бруннер
1
Разрешено ли нам иметь конечные пробелы?
Адам

Ответы:

5

Желе , 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
Джонатан Аллан
источник
7

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

Использует некоторое форматирование, распаковку и магию A000918 .

Уриэль
источник
Кстати, f'{i//k:0{j}b}'.replace(*'0.').replace(*'1-')такой же длины, как и''.join('.-'[int(x)]for x in f'{i//k:0{j}b}')
Уриэль
5

Сетчатка , 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__

Буквы, код которых начинается с .и -соответственно предварительно загружены. (Теоретически возможно избежать предварительной загрузки, .-но это сохраняет байты таким образом.) _Вместо пробелов используются символы s, поскольку они считаются буквами, что облегчает их сопоставление ниже.

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

Здесь мы разбили каждую строку на пять частей:

  • Буквы для префиксов, если есть
  • Текущий азбука Морзе
  • Текущее письмо
  • Первая половина оставшихся букв (их следующий символ .)
  • Вторая половина оставшихся букв (их следующий символ -)

Затем кусочки собираются в две строки:

  • Буквы для префиксов, текущий код Морзе, текущая буква, код Морзе с .суффиксом, первая половина оставшихся букв
  • Пробелы, заменяющие первые три части, азбуку Морзе с -суффиксом, вторую половину оставшихся букв

Новые строки следуют тому же формату, что и существующая, только с дополнительным префиксом Морзе и вдвое меньшим количеством букв, оставшихся для обработки. Это повторяется до тех пор, пока в каждой строке не будет только одной буквы.

_
  [single space]

Затем _s возвращаются в пробелы.

Нил
источник
3

JavaScript (ES6), 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>

Arnauld
источник
О черт! Я скучал по этому ... иначе бы не беспокоился! Молодцы :-)
ухабистая
2

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

Попробуйте онлайн!

Йорг Хюльсерманн
источник
2

Perl 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
faubi
источник
2

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,"-.");
Titus
источник
1
На этот раз нет разрыва строки?
Кристоф
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++];должен сохранить 2 байта.
Кристоф
1
Кажется, вы слишком много пропустили: последняя строка ----не совпадает с остальной. "EISHVUF ARL WPJTNDBXKCYMGZQO "должно быть 2 пробела в конце.
Кристоф
2

APL (Dyalog) , 92 байта

Требуется ⎕IO←0по умолчанию во многих системах.

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

Попробуйте онлайн!

{... }¨'... ' применять следующую анонимную функцию к каждой из строк:

⍪⍵ сделать аргумент в столбце

' ', добавить пробел (в каждом ряду)

'.-'[], Добавить строку после того, как она была проиндексирована с помощью:

  ≢⍵ длина аргумента

   индексы этого (0, 1, 2,…, длина -1)

  2⊥⍣¯1 anti-base-2 (использует столько битов, сколько необходимо)

   транспонировать (от одного представления в каждом столбце до одного в каждой строке)

()⍀ Развернуть (вставить пустые строки, как указано нулями в):

  ≢⍵ длина аргумента

  16÷ разделите шестнадцать на это

  1↑⍨ (более) взять от одного (делает список из одного, за которым следуют 1- н ноль)

  16⍴ перерабатывать этот шаблон, пока не будет шестнадцать элементов

' ', ставить пробел

 формат (список таблиц в одну таблицу, дополняющий каждую пробелом с каждой стороны)

¯1⌽ поверните на один шаг вправо (таким образом, перемещая заднее пространство вперед)

0 3↓ отбросить ноль строк и три столбца (удалив три ведущих пробела)

Адам
источник
Эй, где 16÷⍨появляется в вашем коде?
Zacharý
@ZacharyT Конечно, нет. Приятно заметили, сэр.
Адам
1

СОГЛ , 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

просто хотел посмотреть, насколько хорошо SOGL может справиться с простым сжатием (ну, у него больше, чем просто сжатие, но это 97% сжатых строк)

dzaima
источник
1

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

неровный
источник
1

Рубин, 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.
Уровень реки St
источник
1

Pyth , 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

(1) : В таблице Морзе, в первом столбце, есть семь строк после каждой строки, содержащей буквы («E» и «T»). Во втором столбце это три строки. Затем один (третий столбец), затем ноль (последний столбец). Вот 16 / n - 1где nнаходится количество букв в столбце (что Nв коде выше). Вот что делает код в строке (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 ["    ", "    ", ...])

Хорошо, теперь у нас есть хорошая полезная функция, 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

Код все еще может быть сокращен; возможно я вернусь к этому позже.

Джим
источник
1

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

Жить на coliru (с #include, чтобы избежать предупреждения.)

ОБНОВЛЕНИЕ : сохранены четыре символа, перемещая «объявление» за mпределы функции, как предложено @zacharyT

Использует то, что кажется стандартной стратегией: храните буквы в двоичном дереве с кодировкой массива, чтобы потомки элемента iбыли 2*iи 2*i+1. Это дерево имеет корни в 2, а не в 1, потому что арифметика проработана немного короче, я думаю. Все остальное - игра в гольф.

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
источник
Не могли бы вы переместить, int mчтобы быть m;вне функции?
Захари
Это работает repl.it/Iqma ?
Захари
@ZacharyT: Я полагаю, что это будет работать, но это на один символ длиннее (открытая скобка в #define), так что, кажется, мало смысла.
Ричи
С этой версией я насчитал 194 байта, я что-то упустил?
Захари
1

Жевательная резинка , 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.

Уриэль
источник
0

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

Как это работает

Сначала я проанализировал строку в C, считая пробелы, которые меньше 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);
}
Khaled.K
источник
263 байта
ceilingcat
0

Bash (с утилитами), 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
sigvaldm
источник
0

Dyalog APL, 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
Locoluis
источник
Почему это не конкурирует?
Адам
Я думаю, что вы можете сэкономить, установив ⎕IO←0(по умолчанию на многих системах) и используя (коммутировать) .
Адам
0

JavaScript (ES7), 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 байта благодаря Захари .

eush77
источник
Попробуйте перейти a!='0'наa!=0
Cyoce
Вы можете заменить .join('')на .join<insert backtick here><insert backtick here>? ( <insert backtick here>заменяется реальными
кавычками
Как сказала Сайос, попробуйте поменять a!='0'на то a!=0, что должно сработать.
Захари
@ZacharyT Нет, это не так , но еще раз спасибо.
eush77
Извините, забыл о ''деле.
Захари