Распечатать Tabula Recta!

81

Распечатать Tabula Recta!

Tabula Recta (иногда называемая «таблицей Вигенера») была создана Иоганнесом Тритемиусом и использовалась в нескольких шифрах, включая все варианты шифра Вигенере Белласо и шифра Тритемия. Это выглядит так:

ABCDEFGHIJKLMNOPQRSTUVWXYZ
BCDEFGHIJKLMNOPQRSTUVWXYZA
CDEFGHIJKLMNOPQRSTUVWXYZAB
DEFGHIJKLMNOPQRSTUVWXYZABC
EFGHIJKLMNOPQRSTUVWXYZABCD
FGHIJKLMNOPQRSTUVWXYZABCDE
GHIJKLMNOPQRSTUVWXYZABCDEF
HIJKLMNOPQRSTUVWXYZABCDEFG
IJKLMNOPQRSTUVWXYZABCDEFGH
JKLMNOPQRSTUVWXYZABCDEFGHI
KLMNOPQRSTUVWXYZABCDEFGHIJ
LMNOPQRSTUVWXYZABCDEFGHIJK
MNOPQRSTUVWXYZABCDEFGHIJKL
NOPQRSTUVWXYZABCDEFGHIJKLM
OPQRSTUVWXYZABCDEFGHIJKLMN
PQRSTUVWXYZABCDEFGHIJKLMNO
QRSTUVWXYZABCDEFGHIJKLMNOP
RSTUVWXYZABCDEFGHIJKLMNOPQ
STUVWXYZABCDEFGHIJKLMNOPQR
TUVWXYZABCDEFGHIJKLMNOPQRS
UVWXYZABCDEFGHIJKLMNOPQRST
VWXYZABCDEFGHIJKLMNOPQRSTU
WXYZABCDEFGHIJKLMNOPQRSTUV
XYZABCDEFGHIJKLMNOPQRSTUVW
YZABCDEFGHIJKLMNOPQRSTUVWX
ZABCDEFGHIJKLMNOPQRSTUVWXY

Мне часто это нужно, но я не могу найти его где-нибудь в Интернете, чтобы скопировать и вставить. Поскольку квадратный стол так долго, и принимает чертов возраст ввести ваш код должен быть как можно короче.

Правила / Требования

  • Каждое представление должно быть либо полной программой, либо функцией. Если это функция, ее нужно запустить, для этого нужно всего лишь добавить вызов функции в конец программы. Все остальное (например, заголовки в C), должно быть включено.
  • Если это возможно, предоставьте ссылку на сайт, где ваша программа может быть протестирована.
  • Ваша программа не должна ничего писать STDERR.
  • Стандартные лазейки запрещены.
  • Ваша программа может выводить в любом случае, но она должна быть напечатана (не массив или аналогичный).

счет

Программы оцениваются в соответствии с байтами, в UTF-8 по умолчанию или другой набор символов по вашему выбору.

В конце концов ответ с наименьшим количеством байтов победит.

Материалы

Чтобы убедиться, что ваш ответ обнаружен, начните его с заголовка, используя следующий шаблон уценки:

# Language Name, N bytes

где Nразмер вашего представления. Если вы улучшите свой счет, вы можете сохранить старые результаты в заголовке, вычеркнув их. Например:

# Ruby, <s>104</s> <s>101</s> 96 bytes

Если вы хотите включить в заголовок несколько чисел (например, потому что ваш результат равен сумме двух файлов или вы хотите перечислить штрафы за флаг интерпретатора отдельно), убедитесь, что фактический результат является последним числом в заголовке:

# Perl, 43 + 2 (-p flag) = 45 bytes

Вы также можете сделать название языка ссылкой, которая затем будет отображаться во фрагменте списка лидеров:

# [><>](http://esolangs.org/wiki/Fish), 121 bytes

Leaderboard

Вот фрагмент стека, который генерирует как регулярную таблицу лидеров, так и обзор победителей по языкам.

Джордж Гибсон
источник
Что касается правила 1: нужно ли включать каждый заголовок для каждой функции, которую мы используем?
owacoder
Я имел в виду, если мы используем printf, мы должны включить stdio.h, если isalphaиспользуется, ctype.hнужен и т. Д. Это правильно?
owacoder
3
Возможно, вам следует указать «нижний регистр разрешен» в самой спецификации вызова. Просто люди с меньшей вероятностью пропустят это, если не увидят эти комментарии.
Sherlock9
2
я должен напечатать это или я могу вернуть массив string / char
downrep_nation
1
Спасибо за вопрос, что заставил меня не спать всю ночь. (+1)
Анастасия-Романова

Ответы:

30

05AB1E , 6 5 байт

Спасибо Downgoat за сохранение 1 байта. Код:

ADv=À

Объяснение:

A      # Push the lowercase alphabet.
 D     # Duplicate it.
  v    # For each in the alphabet...
   =   #   Print without popping and with a newline.
    À  #   Rotate 1 to the left.

Использует кодировку CP-1252 . Попробуйте онлайн! ,

Аднан
источник
Какова цель его дублирования?
Esolanging Fruit
1
@ Challenger5 Команда vиспользует значение, перебирая его. В этом случае он потребляет алфавит, поэтому он повторяется 26 раз. Это также точное количество раз, которое нам нужно для итерации функции. Эти =листы стек интактные и Àтолько поворачивают верхнюю часть стека элемента-влево. Отвечает ли это на ваш вопрос? :)
Аднан
101

Vim, 25 23 байта

:h<_↵jjYZZP25@='Ypx$p'↵

Где ключ возврата.

:h<_↵                       Open the help section v_b_<_example.
     jjY                    Copy the "abcdefghijklmnopqrstuvwxyz" line.
        ZZP                 Close this buffer and paste in ours.
           25@='     '↵     Run these commands 25 times:
                Yp          Duplicate line and move to column 1 of new line.
                  x         Cut the first character.
                   $p       Move to the end and paste.

GIF решения

РЕДАКТИРОВАТЬ : строчные в порядке, поэтому я могу сохранить две клавиши.

Линн
источник
23
Это :h<_<cr>jjYгений
Downgoat
3
Вау, это потрясающе! ОП сказал, что строчные буквы были в порядке, так что вы можете удалитьV~
DJMcMayhem
4
@RobStarling, см .: meta.codegolf.stackexchange.com/q/8995/40695
Downgoat
4
Я смею кого-то попробовать это в Emacs.
Аддисон
2
@addison Emacs answer
TuxCrafting
24

Python 2, 59 57 53 байта

a=range(65,91)*27
a[::-27]=[10]*26
print bytearray(a)

Спасибо @xsot за -4 байта!

Дайан
источник
4
Мне нравится этот. Кстати, вы можете сократить последнюю строку до print bytearray(a).
xsot
18

/// , 220 байт

/|/\/\///n/WXY|m/JKL|l/PQRS|k/CDEF|j/ZaNfV|i/MbAeI|h/TUcO|g/GHdB|f/OlTU|e/BkGH|d/ImMbA|c/VnZaN|b/NfVnZ|a/AeImM/ab
ed
kg
DEFgC
EFgCD
FgCDE
gk
HdBkG
de
mi
KLiJ
LiJK
im
ba
fc
lh
QRShP
RShPQ
ShPQR
hl
UcOlT
cf
nj
XYjW
YjWX
jn

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

Это было на удивление нетривиально, и я понятия не имею, является ли это оптимальным.

Единственный способ решить такую ​​проблему в /// - извлечь общие подстроки. ( Оказывается, я ошибался. ) Однако из-за характера вывода не совсем понятно, какие подстроки лучше всего извлекать, поскольку вы не можете фактически извлечь весь алфавит из-за разрывов строк. Таким образом, вам нужно извлечь некоторые подстроки из обернутого алфавита, но тогда есть компромиссы в отношении того, как долго вы создаете подстроки и какие вы выбираете.

Итак, вот что я сделал. Это скрипт CJam, который находит все подстроки длиной до 25 в данной строке и для каждой из них вычисляет, сколько байтов будет сохранено при извлечении. В основном, если есть Nкопии Mподстроки длины , вы должны сохранить (N-1)*(M-1) - 5подстроки, эти подстроки не содержат косые черты. Кроме того, технически, когда вы уже извлекли 8 подстрок или около того, постоянное смещение в конце уменьшается до -4, но скрипт не учитывает это.

Во всяком случае, вот что я сделал со сценарием:

  • Запустите скрипт для текущего кода (который изначально является только выводом).
  • Из подстрок, дающих наибольшее улучшение, выберите самую короткую. Если их несколько, выберите лексикографически наименьшее (из того, что я могу сказать, для данного ввода это уменьшает перекрытия между подстроками).
  • Замените все вхождения выбранной подстроки в коде неиспользованной строчной буквой.
  • Добавьте /x/ABC/к коду, где xнаходится выбранная буква и ABCподстрока.
  • Повторяйте, пока не останется никаких подстрок, которые могли бы что-либо сохранить.

В конце концов, мы спасем еще несколько байт, заменяя полученный //с |и предваряя /|/\/\//(поэтому извлечение подстроки стоит только 4 вместо 5 байт после 8 подстроки или около того ).

Как я уже сказал, я понятия не имею, является ли это оптимальным, и я нахожу довольно нерегулярный результат довольно интересным. Можно было бы найти более короткое решение, выбрав неоптимальные (но более) подстроки где-нибудь внизу строки. Интересно, каков класс сложности этой проблемы ...

Мартин Эндер
источник
Это ... это ... блестяще ...
Джордж Гибсон
1
@ GeorgeGibson Спасибо ... Мне пришлось начинать сначала, когда я заметил кое-что YXв выводе. ;)
Мартин Эндер
Мой ответ ушел, это было обманом (больше и позже). +1 за это [невероятный гольф]!
Эрик Outgolfer
Что касается класса сложности, разве проблема не должна быть неразрешимой, поскольку /// Тьюринг завершен? Проблема в том, что «задана строка, найдите самую короткую /// программу, которая ее выводит». Если бы не маленькие строки, существовали бы программы ///, которые зацикливаются бесконечно (но не может быть доказано, что они зацикливаются бесконечно), которые не могут показывать, что они не производят желаемый результат, не выполняя их вечно. Формальное доказательство я сам еще не уверен, но интуитивно не возможно ли это?
ghosts_in_the_code
16

C, 47 байтов

i;f(){for(i=702;i--;)putchar(i%27?90-i%26:10);}

Попробуйте это на Ideone

Один цикл печати алфавита каждые 26 символов, но каждый 27-й символ заменяется новой строкой.

Андерс Касеорг
источник
1
Черт! Я просто написал точно такую ​​же функцию! :-) Вы можете сохранить первую точку с запятой, используя f(i)затем просто вызов f()без каких-либо аргументов.
Уровень Река St
@LevelRiverSt Это будет зависеть от неопределенного поведения.
Андерс Касеорг
2
В конечном счете, это зависит от вас, но PPCG считает, что языки определяются их реализациями, поэтому, пока вы упоминаете, в каком компиляторе он работает, полагаться на UB не считается проблемой.
Деннис
Вы можете побрить 1 байт, инициализируя i, когда впервые упоминается:i=702;f(){for(;i--;)//...
tucuxi
3
@tucuxi Нет, потому что ответы функций должны быть многоразовыми .
Андерс Касеорг
15

J 15 байт

u:65+26|+/~i.26

Онлайн переводчик .

u:65+26|+/~i.26
           i.26  creates vector [0 1 2 ... 25]
        +/~      builds an addition table with itself
     26|         modulo 26 to every element
  65+            add 65 to every element
u:               convert every element from codepoint to character
Дрянная Монахиня
источник
Приятно! Очень умная арифметика. Самый простой подход, который использует |. (Shift)на 8 байтов больше! (i.26)(|."0 _)u:65+i.26
Дэн Оук
1
@dahnoak Вы можете сократить его до 16 байт, u:65+1&|.^:]i.26поскольку наречие власти отслеживают предыдущие результаты, если дан список.
миль
1
@miles Хорошо, мой подход использует |.17 байтов: u:65+|."0 1/~i.26(все еще использую /~)
Leaky Nun
1
@LeakyNun Еще один 17-байтовый подход u:65+(|./~,.)i.26. Я избавился от ранга, используя крюк и ,.колонку, но она оказалась такой же длины.
миль
Разве вы не знаете, могу ли я где-нибудь найти исходный код tryj.tk? Я не мог найти информацию ни об этом, ни об авторе (f211)
Дэн Оук
15

/// , 128 байт

/:/fABCDEFGHIJKLMNOPQRSTUVWXYZ
fbfbAfxf
xbA_xf_x
xfbbbAfbb//x/bff//f/\///b/\\:B:C:D:E:F:G:H:I:J:K:L:M:N:O:P:Q:R:S:T:U:V:W:X:Y:Z:

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

Вдохновленный удивительным ответом Якуба на вызов L-phabet, я решил попробовать свои силы и в реальном программировании на ///, а не просто использовать его для сжатия. Это было довольно сложно, и мне понадобилось четыре попытки, но в итоге получилось намного короче, чем мое решение на основе сжатия .

объяснение

Быстрый учебник по ///: в основном интерпретатор просто читает символ за символом и делает следующее:

  • Если это ни то, \ни другое /, распечатайте его.
  • Если это \, напечатайте следующий символ.
  • Если это /, проанализируйте /x/y/инструкцию (с теми же правилами экранирования) и несколько раз замените все xв оставшемся коде на y.

Взяв немного больше вдохновения от Якуба, для простоты я просто объясню версию 4x4:

/:/fABCD
fbfbAfxf
xbA_xf_x
xfbbbAfbb//x/bff//f/\///b/\\:B:C:D:

Начнем с того, что заменим их :на вещи между вторым и третьим /. В результате код будет вращать последующие строки. Мы получаем это:

/x/bff//f/\///b/\\fABCD
fbfbAfxf
xbA_xf_x
xfbbbAfbbBfABCD
fbfbAfxf
xbA_xf_x
xfbbbAfbbCfABCD
fbfbAfxf
xbA_xf_x
xfbbbAfbbDfABCD
fbfbAfxf
xbA_xf_x
xfbbbAfbb

Символы f, bи xявляются просто сокращенными для обычных строк, которые мы сейчас расширим. Для fслэшей, bдля слэшей и xдля \//которых случается довольно много. Причина, по которой я использую псевдонимы для односимвольных подстрок /и \заключается в том, что они должны быть экранированы в первой инструкции подстановки, поэтому я на самом деле экономлю довольно много байтов, не требуя всех этих обратных косых черт. Вот то, что мы получаем после x, fи bбыли заполнены:

ABCD
/\/\A/\///
\//\A_\///_\//
\///\\\A/\\B/ABCD
/\/\A/\///
\//\A_\///_\//
\///\\\A/\\C/ABCD
/\/\A/\///
\//\A_\///_\//
\///\\\A/\\D/ABCD
/\/\A/\///
\//\A_\///_\//
\///\\\A/\\

Очень читабельно

Итак, первая строка просто дословно напечатана. Затем мы попадаем в интересную часть, которая вращает все дальнейшие ряды. На самом деле он состоит из четырех разных инструкций. Стоит заметить, что я избежал всех случаев, описанных Aв этих инструкциях. Причина этого в том, что это позволяет мне отличать As в инструкциях от As в оставшихся строках, которые должны обрабатываться по-разному.

/\/\A/\//

Это соответствует /Aи заменяет его /, удаляя A. Обратите внимание, что эта подстрока появляется только ABCDв начале каждого , поэтому при этом удаляется первый символ всех последующих строк:

/
\//\A_\//

Это соответствует переводу строки после косой черты и заменяет его на A_/. Таким образом, это вставляет Aв конце каждой строки, завершая вращение, а также превращает перевод строки в подчеркивание.

/_\//
\//

Это соответствует _/и заменяет его переводом строки с последующей косой чертой. Причина, по которой мне нужно сделать этот обход через подчеркивание, заключается в том, что /// применяет каждую инструкцию несколько раз, пока строка больше не совпадает. Это означает , что вы никогда не можете использовать инструкцию вида , /x/axb/где x, aи bпроизвольные строки, потому что после замены xвсегда будет по- прежнему совпадают. В частности, это означает, что мы не можем просто вставить что-то перед переводом строки. Нам нужно заменить перевод строки в процессе и отменить эту замену.

/\\\A/\\B/

Это соответствует \Aи заменяет его \Bтак, чтобы инструкции после оставшихся строк обрабатывали следующий символ. После обработки всех четырех инструкций оставшаяся строка выглядит следующим образом:

BCDA
/\/\B/\///
\//\B_\///_\//
\///\\\B/\\C/BCDA
/\/\B/\///
\//\B_\///_\//
\///\\\B/\\D/BCDA
/\/\B/\///
\//\B_\///_\//
\///\\\B/\\

Теперь печатается первая повернутая строка, а затем следующий набор инструкций поворачивает оставшиеся строки на другую ячейку и так далее. После последнего поворота у нас есть еще несколько инструкций, которые мы можем игнорировать, а затем мы заканчиваем неполной инструкцией:

/\\\B/\\

Неполные инструкции в конце просто игнорируются, и программа завершается.

Мартин Эндер
источник
Хороший. Вчера я немного поэкспериментировал с другой идеей. Я хотел заменить каждый символ в каждой строке. Что-то вроде A->B, B->C... Но это не совсем сработало. Удаление первого символа и добавление его в конце, безусловно, намного лучший подход.
Якуб
@Jakube Я тоже это попробовал, но ничего не получалось. Слишком трудно избежать путаницы в последующих инструкциях.
Мартин Эндер
1
124 байта: goo.gl/efSLKQ Это только ваше решение, но мне удалось добавить несколько дополнительных замен, так что вам нужно записать алфавит только один раз. Использовал ту же стратегию и для аналогичной проблемы.
Jakube
1
122: goo.gl/zRsBbR
Якуб
11

Желе , 7 байт

ØAṙJṢj⁷

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

Как это устроено

ØAṙJṢj⁷  Main link. No arguments.

ØA       Set argument and return value to "ABCDEFGHIJKLMNOPQRSTUVWXYZ".
   J     Yield the indices of the argument, i.e., [1, ..., 26].
  ṙ      Rotate the alphabet 1, ..., 26 units to the left.
         This generates all rotations, but not in the correct order.
    Ṣ    Sort the rotated alphabets.
     j⁷  Join, separating by linefeeds.
Деннис
источник
11

Emacs, 47 байт

abcdefghijklmnopqrstuvwxyz^M
^P
<F3>
^K ^K ^Y ^Y
^P
^<space> ^F ^W ^E ^Y ^A
<F4>
^U 2 4 F4

Где ^Pозначает «Control P» и т. Д. Это 47 байтов, поскольку для клавиш F3 и F4 требуется два байта ASCII.

После ввода начального ввода он определяет макрос клавиатуры для дублирования строки и перемещения первого символа в конец. Затем он запускает макрос еще 24 раза.

MattBlissett
источник
2
Добро пожаловать в PPCG, хороший ответ! Очень редко можно увидеть ответ Emacs, я даже не знаю, был ли ответ Emacs уже опубликован.
TuxCrafting
10

JavaScript (ES6), 56 байт

_=>"ABCDEFGHIJKLMNOPQRSTUVWXYZ".replace(/./g,"$&$'$`\n")

Да, верно, половина моего кода - буквенный строковый литерал. Лучшее, что я мог сделать без литерала - это 81 байт:

_=>[...Array(26)].map((_,i,a)=>a.map(_=>(i++%26+10).toString(36)).join``).join`
`

Если вам нужна программа, а не функция, удалите _=>и оберните console.log()ее стоимостью 10 байт.

Нил
источник
Вау, молодец. Очень элегантное решение. Как это работает?
Полидукс
2
@Polyducks Много и много магии регулярных выражений. Естественно /./gсоответствует каждой букве предоставленной строки алфавита. В строке замены $&представляет само совпадение, $'часть строки после совпадения и $`часть строки перед совпадением. $`$&$'поэтому будет представлять исходную строку, но, конечно, тривиально переместить деталь после совпадения в начало, тем самым обеспечивая эффект вращения.
Нил
Супер умный! Молодец @ Нил!
Полидукс
9

Mathematica 68 61 байт

Column[""<>RotateLeft["A"~CharacterRange~"Z",#]&/@0~Range~25]

Благодаря...

@MartinEnder (7 байт)

Мартин
источник
Кроме того, Arrayможет быть короче, чем отображение над Range.
Мартин Эндер
Я только что проверил и Arrayдействительно сохраняет байт, но затем вы можете сохранить другой, избегая Column: Array[{"A"~CharacterRange~"Z"~RotateLeft~#,"\n"}&,26,0]<>""(вам просто нужно заменить \nреальный перевод строки).
Мартин Эндер
7
Ждать не встроенный? Невозможно
MC ΔT
1
Print@@@NestList[RotateLeft,"A"~CharacterRange~"Z",25]
alephalpha
Grid@Array[FromCharacterCode[Mod[+##-2,26]+65]&,{26,26}]
Мате
9

Python 2, 75 65 61 58 байт

a='%c'*26%tuple(range(65,91))
for x in a:print a;a=a[1:]+x

Получает алфавит с помощью map(chr,range(65,91)), затем вручную применяет операцию сдвига строки.

Спасибо @LeakyNun и @TheBikingViking за -4 байта!

Спасибо @xnor за -3 байта!

медь
источник
2
Видимо a="ABCDEFGHIJKLMNOPQRSTUVWXYZ"короче.
Лаки Монахиня
1
Вы можете сделать a[1:]вместо a[1:26].
TheBikingViking
2
Ваш цикл может быть сделан как for x in s:print s;s=s[1:]+x.
xnor
3
Вы можете сделать один байт короче , чем жестко прописывать алфавита: s='%c'*26%tuple(range(65,91)).
xnor
9

Piet , 247 байт / 190 кодов

Tabula Recta in Piet

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

Таким образом, это заняло гораздо больше времени, чем я ожидал, и у меня есть несколько идей относительно некоторых других более эффективных (более стековых) подходов, но я наконец-то заработал чертовски полезную вещь ( исправил ошибку интерпретатора и добавил функции IDE вдоль кстати), так вот оно и есть. Вряд ли самый эффективный язык, но чертовски весело. Вот увеличенный вид и след, показывающий пройденный путь. История на моем GitHub .

Tabula Recta in Piet, большая версия

След трассы Tabula Recta

Как язык, основанный на стеке, он слишком запутан, чтобы кратко объяснять, но вот основной обзор того, что делают различные секции / циклы. Все имена переменных и функций приведены только для пояснения, поскольку в Piet нет переменных или функций.

  • Инициализация (слева вверху): начинается line_counterс 27, загружается как @ cur_letter, устанавливаетletter_count на 27
  • Основной цикл (начиная с темно-фиолетового, по центру)
    • Декрементирует letter_counter
    • Филиалы в reset_line если ноль (светло-голубой 2-блок)
    • Рулоны cur_letter на вершину стека
    • Филиалы к check_doneеслиcur_letter > 'X' (чирок / красный блок, правая сторона)
    • Надбавки cur_letter и выводит его (нижний правый угол)
    • Филиалы к reset_letterеслиcur_letter > 'Y' (светло-зеленый блок, слева)
    • Откатывает `letter_counter_ к началу стека, к началу цикла
  • reset_line ветка (большой розовый квадрат):
    • Вывод символа новой строки
    • Сбрасывает letter_countдо 27
    • Продолжает вернуться к началу основного цикла
  • check_done ветвь (правая половина внутри)
    • Rolls line_counterto top
    • Ветви заканчиваются, если ноль
    • Уменьшение line_counterи откат к основанию стека
    • Возобновляет, где он остановился, печать письма
  • reset_line ветвь (левая сторона, зеленый блок):
    • Сбрасывает cur_letterна «@»
    • Возобновляет, где это остановилось, катится / возвращаясь к вершине петли
cincodenada
источник
8

MATL , 8 байт

Благодаря @Dennis , который предложил, чтобы MATL включал модульное индексирование, и @Suever , у которого была идея автоматических парных операций.

1Y2t&+Q)

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

1Y2    % Predefined literal: string 'AB...Z'
t      % Push another copy of it
&+     % 2D array with all pairwise additions of ASCII code points from that string.
       % Gives the 26×26 array [130 131... 155; 131 132... 146; ...; 155 156... 180] 
Q      % Add 1 to each element. First entry is now 131, etc
)      % Index into string 'AB...Z'. Since it has length 26 and MATL uses modular
       % indexing, 131 is the first entry (character 'A'), etc. Implicitly display
Луис Мендо
источник
8

Javascript, 113 96 91 76 байт

Супер-короткая версия для запуска в консоли:

l="ZABCDEFGHIJKLMNOPQRSTUVWXY";for(C=26;C--;console.log(l=l.slice(1)+l[0]));

Javascript / HTML, 140 123 118 105 байт

Более симпатичная версия с выводом HTML, которая упрощает копирование и вставку OP:

<script>l="ABCDEFGHIJKLMNOPQRSTUVWXYZ";for(C=26;C--;document.write(l+"<br>"),l=l.slice(1)+l[0]);</script>

(РЕДАКТИРОВАТЬ: я должен был просто использовать строку AZ вместо генерации)

(РЕДАКТИРОВАТЬ 2: Спасибо @Neil и @DanTheMan за их вклад (см. Комментарии))

Polyducks
источник
Разве первый C = 26 не имеет значения?
DanTheMan
О, хватит. Похоже, я забыл удалить его, когда переместил в. Исправлена! Спасибо @DanTheMan :)
Полидукс
1
l.slice(0,1)просто l[0], в то время ,27как ненужно, в этот момент вы можете переместить срез и в конечном итоге l.slice(1)+l[0]. Кроме того, я думаю, что вы можете переместить console.logв тело цикла, таким образом избегая трейлинга ;.
Нил
Тестирую это сейчас, спасибо @Neil! РЕДАКТИРОВАТЬ: Сладкий святой моли. Благодаря вам обоим, я добавлю вас в кредит в комментарии.
Полидукс
1
О, хорошо, это еще лучший способ упростить console.log.
Нил
8

PowerShell, 44 байта

-1..24|%{-join[char[]](65..90)[($_-25)..$_]}
детеныш
источник
8

R, 47 42 41 байт

write(rep(LETTERS,27)[-27*1:26],1,26,,'') 

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

Генерирует 27 альфа-диабета, удаляет 27-е буквы и печатает в 26 столбцах.

Улучшение вдохновленный @Giuseppe «s решение .

Роберт Хакен
источник
1
46 байтов
Джузеппе
Ух ты, я думал, что перепробовал каждый трюк с индексированием, repно это особенно вдохновило! Очень хорошо. Я бы снова проголосовал, если бы мог.
Джузеппе
Вы можете использовать 1вместо ""для stdout.
Джузеппе
6

Sesos , 27 25 байт

0000000: 685902 ae7b33 764992 c45d9b 397360 8fef1f 7bca72  hY..{3vI..].9s`...{.r
0000015: 3adc33 07

Попробуйте онлайн! Проверьте Debug, чтобы увидеть сгенерированный код SBIN.

Сесос сборка

Двоичный файл выше был сгенерирован путем сборки следующего кода SASM.

add 26
jmp
    jmp
        rwd 1, add 1, rwd 1, add 1, fwd 2, sub 1
    jnz
    rwd 2, add 64
    jmp
        fwd 2, add 1, rwd 2, sub 1
    jnz
    fwd 1, sub 1
jnz
fwd 1
jmp
    jmp
        put, fwd 1
    jnz
    rwd 27
    jmp
        put, fwd 1
    jnz
    add 10, put, get, fwd 1
    jmp
        rwd 1, add 1, fwd 1, sub 1
    jnz
    fwd 1
; jnz (implicit)

Как это устроено

Мы начнем с инициализации ленты ABCDEFGHIJKLMNOPQRSTUVWXYZ. Это следующим образом.

Запишите 26 в ячейку, оставив ленту в следующем состоянии.

                                                     v
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 26 0

Пока ячейка под заголовком данных не равна нулю, мы делаем следующее.

Скопируйте число в две ячейки слева и добавьте 64 в крайнюю левую копию.

                                                   v
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 90 26 0 0

Переместите крайнюю левую копию в исходное положение, затем вычтите 1 из крайней правой копии.

                                                     v
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 25 90 0

Процесс останавливается после 26 итераций, так как самая правая копия 0 . Мы перемещаем ячейку вправо, поэтому конечное состояние ленты после инициализации следующее.

     v
0 0 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 0

Теперь мы готовы сгенерировать вывод, повторяя следующий процесс, пока ячейка под заголовком данных не станет равной нулю.

Сначала мы печатаем символ под заголовком данных и перемещаемся вправо, повторяя этот шаг, пока не будет найдена ячейка со значением 0 . После печатиABCDEFGHIJKLMNOPQRSTUVWXYZ лента выглядит следующим образом.

                                                                                v
0 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 0

Теперь мы перемещаем головку данных на 27 единиц влево (назад к ведущему 0 ) и повторяем комбинацию «печать-перемещение», пока не будет найдена ячейка со значением 0 . Это ничего не печатает и оставляет ленту следующим образом.

v
0 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 0

Теперь мы пишем 10 в текущую ячейку, печатаем соответствующий символ (перевод строки) и обнуляем ячейку при вызове getпустого ввода, оставляя ленту без изменений.

После этого мы перемещаем содержимое ячейки вправо к текущей ячейке, затем перемещаем заголовок данных в единицах вправо.

      v
65 0 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 0

Следующая итерация немного отличается. Первый шаг печати печатаетBCDEFGHIJKLMNOPQRSTUVWXYZ , оставляя ленту следующим образом.

                                                                                v
65 0 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 0

Теперь мы перемещаем головку данных на 27 единиц влево.

 v
65 0 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 0

Последующая петля печати печатает Aи оставляет ленту следующим образом.

   v
65 0 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 0

Еще раз, мы печатаем перевод строки, перемещаем содержимое ячейки вправо к текущей ячейке, затем перемещаем заголовок данных на единицы вправо.

         v
65 66 0 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 0

После еще 24 итераций последний шаг перемещения головки данных вправо оставляет ленту в следующем состоянии.

                                                                                v
65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 0 0

Ячейка под заголовком данных теперь равна 0, и программа завершается.


TIO использует более новую версию Sesos, которая обратно совместима с SASM, но генерирует более короткий код SBIN.

Деннис
источник
6

Haskell, 56 53 52 байта

mapM(\x->putStrLn$init$[x..'Z']++['A'..x])['A'..'Z']

той же длины: (используя предложение @AndersKaseorg)

a=['A'..'Z']
mapM putStrLn[take 26$[x..'Z']++a|x<-a]

чтобы делать модульные вещи, вы должны импортировать Data.Char, чтобы получить функцию chr, 74 59 58 байт было лучшим, что я мог получить с этим: (спасибо @nimi за предложение функции toEnum)

a=[0..25]
mapM(\x->putStrLn[toEnum$65+(x+y)`mod`26|y<-a])a

Вероятно, это может быть намного короче, но я не знаю никаких уловок игры в гольф на Haskell.

использовал mapM вместо mapM_ (см. комментарий @ Lynn)

KarlKastor
источник
1
Для -3 байтов измените ['A'..x]на ['A'..'Z'], который теперь используется дважды, и поднимите его до определения.
Андерс Касеорг
@AndersKaseorg: Спасибо! Тем не менее, у меня появилась другая идея, которая позволила сохранить то же количество байтов, сохранив при этом единственное значение. Я добавил ваше предложение к альтернативному решению.
КарлКастор
Если вам нужно только chrот Data.Char, вы можете использовать toEnumвместо и опустить import.
Ними
1
Я чувствую , как меняется mapM_к mapMдолжно быть в порядке. Может быть, это стоит мета пост ...
Линн
5

Brain-Flak , 222 байта

(((()()()()){})<(((({}){}){}){})>)((((([[]]{}){}()){}))<>()){<>({}<>)<>{({}<(({}()))>[()])}{}<>([({})]<>{})<>(({}<>))<>({}[()])}{}<>(({}<>))<>{}{}{}<>{({}<(({}())[()]<{({}<<>({}<>)>[()])}{}{}((()()()()()){})>)>[()])}{}{}{}

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

Я новичок в Brain-Flak, так что, возможно, это может быть много в гольфе, но, по крайней мере, это первая попытка. Он хранит 27 полных алфавитов в левом стеке, затем перемещает алфавиты вправо и заменяет каждую 27-ю букву новой строкой.

Мой исходный код немного сбивает с толку, но я все же добавлю его.

(((()()()()){})
    park 8 in third
    <(((({}){}){}){})> push 64
)
((((([[]]{}){}()){}))<>()) push 26 twice on left and 27 on right
left stack: 64 letter, 26 letter count, 26 constant
right stack: 27 alphabet count
{ while alphabet count
    <>
    ({}<>)<> push 26 back to right
    { while counter
        (
            {} park counter in third
                <(({}()))> add next letter to stack
            [()] decrement counter
        )
    }
    {} pop 0 counter
    <>([({})]<>{}) set Z back to A-1
    <>(({}<>)) move 26 twice from right to left
    <> go to right stack
    ({}[()]) decrement counter
}
{} pop 0
<>(({}<>)) push 26 twice on right stack
<>{}{}{} pop counter, @ and Z from left stack
<> go to right stack
{ while alphabet count
    (
        {} save alphabet count on third stack
        <(
            ({}())[()] save constant on third stack and push lettercount 26 + 1 for lf
            <
                {   while lettercount
                    (
                        {} save lettercount on third stack
                        <
                            <>({}<>) pull letter from left to right
                        > 
                        [()] decrement lettercount
                    )
                }
                {} pop 0
                {} pop last letter
                ((()()()()()){}) push lf
            >
        )>
        [()] decrement alphabet count
    )
}
{}{}{} pop alphabet count, constant and lf
Дориан
источник
5

V , 36 , 10 байтов

¬AZ25ñÙx$p

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

При этом используется кодировка «Latin1».

Объяснение:

¬AZ         " Insert the alphabet
   25ñ      " 25 times...
      Ù     "   Duplicate this line
       x    "   Cut the first character
        $p  "   Move to the end of the line and past the character we just cut
DJMcMayhem
источник
Иди и добавь это потом;)
Конор О'Брайен
@ CᴏɴᴏʀO'Bʀɪᴇɴ К настоящему времени вы должны знать, что единственный способ что-либо сделать на этом языке - это шаг улитки. Я, вероятно, запустю это в следующем январе. : P
DJMcMayhem
Ох, в ближайшие 6-8 недель?
Конор О'Брайен,
4

C #, 98 байт

Я пытался понять, смогу ли я сгенерировать буквы короче, чем просто инициализировать их как строку, но на самом деле это невозможно. Буквы 26 байтов, и только этот фрагмент

for(char a='A';a<'[';a++)

составляет 25 байт. Я думаю, что инициализация их, а затем добавление их с + = a является хорошим решением, но с C # вы ограничены количеством функций, таких как Substring()и Console.WriteLine().

Моя попытка 98 байтов:

var a="ABCDEFGHIJKLMNOPQRSTUVWXYZ";a+=a;for(int i=0;i<26;i++)Console.WriteLine(a.Substring(i,26));
Даниил
источник
4

Октава, 27 байт

Мы добавляем строку и вектор столбца, и Octave приятно расширяет размеры сиглета, в этом нет необходимости bsxfun(как вам потребуется в Matlab).

[mod((v=0:25)+v',26)+65,'']
flawr
источник
4

q, 20 байтов

(til 26)rotate\:.Q.A
skeevey
источник
14 байтов -1_'26 27#.Q.A
стритстлер
4

Java, 190 176 172 163 байта

class C{public static void main(String[] a){int s=0;while(s<26){p(s,26);p(0,s++);p(-1,0);}}static void p(int s,int e){for(;s<e;s++)System.out.write(s<0?10:65+s);}}
Master_ex
источник
Вы можете легко сбрить еще несколько байтов: System.out.printf("%c", ...)-> System.out.write(...), '\n'-> 10, 'A'-> 65. Обратите внимание, что предложение символа новой строки / перевода строки разрешено, но требуется идеальное выходное значение . :)
МХ.
@MH. отличные советы! сохранено 9 байт :)
Master_ex
Я знаю, что прошло уже больше года с тех пор, как вы ответили на это, но вы все еще можете сыграть в гольф несколько вещей: пространство String[]aможно удалить; и int s=0;while(s<26){p(s,26);p(0,s++);p(-1,0);}может быть for(int s=0;s<26;p(0,s++),p(0,s++))p(s,26);.
Кевин Круйссен
4

Баш, 66 байт

A=`printf %c {A..Z}`
for i in {0..25};do echo ${A:$i}${A::$i};done

Я создаю полный алфавит в A , затем печатаю 26 повернутых версий, беря символы, начинающиеся с nи добавляя предшествующую позицию n.

Тоби Спейт
источник
4

Perl, 42 байта

Полная заслуга @Dom Hastings за это.

@l=A..Z;say@l[$_..25],@l[0..$_-1]for 0..25  

Или (тот же счетчик байтов):

$_=join"",A..Z;eval'say;/./;$_=$\'.$&;'x26

Нужно -M5.010или -Eзапустить, например:

perl -E '@l=A..Z;say@l[$_..25],@l[0..$_-1]for 0..25'



Мой старый ответ (55 байт):

@t=A..Z;for$i(0..25){print$t[($_+$i)%26]for 0..25;say}

Нужно -M5.010бежать. Так что бегите с:

perl -M5.010 -e '@t=A..Z;for$i(0..25){print$t[($_+$i)%26]for 0..25;say}'  

Возможно, возможно сделать короче, но я не выяснил, как ... пока

папа
источник
Удалось придумать пару 42-байтовых решений: @l=A..Z;say@l[$_..25],@l[0..$_-1]for 0..25и $_=join"",A..Z;eval'say;/./;$_=$\'.$&;'x26оба требуют -E/ -M5.010.
Дом Гастингс
Красиво сделано. Выглядит намного лучше, чем моя попытка! спасибо
Дада