Imprima um Tabula Recta!

81

Imprima um Tabula Recta!

O Tabula Recta (às vezes chamado de 'Tabela Vigenere'), foi criado por Johannes Trithemius e foi usado em várias cifras, incluindo todas as variantes da cifra Vigenere de Bellaso e da cifra Trithemius. Se parece com isso:

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

Frequentemente preciso disso, mas não consigo encontrá-lo em nenhum lugar da Internet para copiar e colar. Como a tabela quadrada é muito longa e leva muito tempo para digitar, seu código deve ser o mais curto possível.

Regras / Requisitos

  • Cada envio deve ser um programa ou uma função completa. Se for uma função, deve ser executável, bastando adicionar a chamada de função na parte inferior do programa. Qualquer outra coisa (por exemplo, cabeçalhos em C) deve ser incluída.
  • Se possível, forneça um link para um site onde seu programa possa ser testado.
  • Seu programa não deve escrever nada para STDERR.
  • As brechas padrão são proibidas.
  • Seu programa pode produzir em qualquer caso, mas deve ser impresso (não uma matriz ou similar).

Pontuação

Os programas são classificados de acordo com os bytes, em UTF-8, por padrão, ou com um conjunto de caracteres diferente de sua escolha.

Eventualmente, a resposta com o mínimo de bytes vencerá.

Submissões

Para garantir que sua resposta seja exibida, inicie-a com um título, usando o seguinte modelo de remarcação:

# Language Name, N bytes

onde Nestá o tamanho do seu envio. Se você melhorar sua pontuação, poderá manter as pontuações antigas no título, identificando-as. Por exemplo:

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

Se você quiser incluir vários números em seu cabeçalho (por exemplo, porque sua pontuação é a soma de dois arquivos ou deseja listar as penalidades de sinalizador de intérprete separadamente), verifique se a pontuação real é o último número no cabeçalho:

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

Você também pode transformar o nome do idioma em um link que será exibido no snippet da tabela de classificação:

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

Entre os melhores

Aqui está um snippet de pilha para gerar uma classificação regular e uma visão geral dos vencedores por idioma.

George Gibson
fonte
Em relação à regra 1: precisamos incluir cada cabeçalho para cada função que usamos?
Owacoder 30/07/16
Eu quis dizer que se usarmos printf, precisamos incluir stdio.h, se isalphafor usado, ctype.hé necessário etc. Isso está correto?
Owacoder 30/07
3
Você provavelmente deve colocar "minúsculas é permitido" na própria especificação do desafio. Apenas para que as pessoas tenham menos chances de errar se não virem esses comentários.
Sherlock9
2
eu tenho que imprimi-lo ou posso retornar uma string / matriz de char
downrep_nation
1
Obrigado pela pergunta por me fazer ficar acordada a noite toda. (+1)
Anastasiya-Romanova ·

Respostas:

30

05AB1E , 6 5 bytes

Agradecemos ao Downgoat por economizar 1 byte. Código:

ADv=À

Explicação:

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.

Usa a codificação CP-1252 . Experimente online! .

Adnan
fonte
Qual é o objetivo de duplicá-lo?
Esolanging Fruit
1
@ Challenger5 O vcomando consome um valor, iterando sobre ele. Nesse caso, ele consome o alfabeto e itera 26 vezes. Essa também é a quantidade exata de vezes que precisamos repetir a função. As =folhas na pilha intactas e a Àapenas roda a parte superior do elemento 1 da pilha para a esquerda. Isso responde sua pergunta? :)
Adnan
101

Vim, 25 23 bytes

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

Onde está a tecla Return.

: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 da solução

EDIT : minúsculas está ok, então eu posso salvar duas chaves.

Lynn
fonte
23
Isso :h<_<cr>jjYé genial #
Downgoat
3
Wow isso é incrível! OP disse minúsculas foi OK para que você possa removerV~
DJMcMayhem
4
@RobStarling veja: meta.codegolf.stackexchange.com/q/8995/40695
Downgoat
4
Desafio alguém a tentar isso no emacs.
addison 31/07
2
@addison Emacs resposta
TuxCrafting 3/16/16
24

Python 2, 59 57 53 bytes

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

Graças a @xsot por -4 bytes!

dianne
fonte
4
Eu gosto deste. A propósito, você pode encurtar a última linha para print bytearray(a).
xsot 31/07
18

/// , 220 bytes

/|/\/\///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

Experimente online!

Isso foi surpreendentemente não trivial e não tenho idéia se é ideal.

A única maneira de resolver um problema como esse em /// é extrair substrings comuns. ( Acontece que eu estava errado. ) No entanto, devido à natureza da saída, não está claro quais substrings devem ser melhor extraídos, pois você não pode extrair o alfabeto inteiro devido às quebras de linha. Portanto, você precisará extrair algumas substrings do alfabeto empacotado, mas existem trocas em termos de quanto tempo você cria os substrings e quais você escolhe.

Então aqui está o que eu fiz. Este é um script CJam que localiza todas as subseqüências até o comprimento 25 na sequência especificada e, para cada uma delas, calcula quantos bytes sua extração salvaria. Basicamente, se houver Ncópias de uma Msubstring de comprimento , você salvaria (N-1)*(M-1) - 5substrings, esses substrings não contêm barras. Além disso, tecnicamente, quando você já extrai 8 substrings, o deslocamento constante no final reduz para -4, mas o script não considera isso.

Enfim, aqui está o que eu fiz com o script:

  • Execute o script no código atual (que inicialmente é apenas a saída).
  • Das substrings que produzem a maior melhoria, escolha a menor. Se houver vários, escolha o menor lexicograficamente (pelo que posso dizer, para a entrada fornecida isso reduz as sobreposições entre substrings).
  • Substitua todas as ocorrências da substring escolhida no código por uma letra minúscula não usada.
  • Anexar /x/ABC/ao código onde xestá a letra escolhida e ABCa substring.
  • Repita até que não haja substrings que salvariam algo.

No final, economizamos mais alguns bytes substituindo o resultado //por |e acrescentando /|/\/\//(é por isso que a extração de substrings custa apenas 4 em vez de 5 bytes após o 8º substring).

Como eu disse, não tenho idéia se isso é ótimo e acho o resultado de aparência irregular bastante interessante. Pode ser possível chegar a uma solução mais curta escolhendo substrings não ideais (mas mais) em algum lugar abaixo da linha. Gostaria de saber qual é a classe de complexidade deste problema ...

Martin Ender
fonte
Isso ... é ... brilhante ...
George Gibson
1
@GeorgeGibson Obrigado ... Eu tive que começar do meio do caminho quando percebi uma certa YXsaída. ;)
Martin Ender
Minha resposta se foi, foi um engano disso (maior e mais tarde). +1 para isso [golfe incrível]!
Erik the Outgolfer
Em relação à classe de complexidade, o problema não deve ser indecidível, pois /// Turing está completo? O problema é "dada uma string, encontre o programa /// mais curto que a produz". Exceto para cadeias pequenas, existiriam /// programas que fazem loop indefinidamente (mas não se pode provar que fazem loop indefinidamente) que não podem ser mostrados para não produzir a saída desejada sem executá-los para sempre. Prova formal Ainda não tenho certeza, mas intuitivamente não é possível?
ghosts_in_the_code
16

C, 47 bytes

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

Experimente no Ideone

Um único loop, imprimindo o alfabeto a cada 26 caracteres, mas a cada 27 caracteres substituídos por uma nova linha.

Anders Kaseorg
fonte
1
Droga! Acabei de escrever exatamente a mesma função! :-) Você pode salvar o primeiro ponto e vírgula usando f(i)apenas chamar f()sem argumentos.
Level River St
@LevelRiverSt Isso dependeria de um comportamento indefinido.
Anders Kaseorg 31/07
2
Em última análise, cabe a você, mas o PPCG considera as linguagens a serem definidas por suas implementações, desde que você mencione em qual compilador ele funciona, depender do UB não é considerado um problema.
Dennis
você pode raspar 1 byte por inicializar i quando mencionado pela primeira vez:i=702;f(){for(;i--;)//...
tucuxi
3
@ tucuxi Não, porque as respostas das funções precisam ser reutilizáveis .
Anders Kaseorg
15

J, 15 bytes

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

Intérprete online .

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
Freira Furada
fonte
Agradável! Aritmética muito inteligente. A abordagem mais simples que usa |. (Shift)é de 8 bytes mais! (i.26)(|."0 _)u:65+i.26
Dan Oak
1
@dahnoak Você pode reduzi-lo para 16 bytes, u:65+1&|.^:]i.26pois os advérbios de poder rastreiam resultados anteriores, se houver uma lista.
miles
1
@miles agradável, a minha abordagem usando |.é de 17 bytes: u:65+|."0 1/~i.26(ainda usam /~)
Leaky freira
1
@LeakyNun Outra abordagem de 17 bytes é u:65+(|./~,.)i.26. Eu me livrei da classificação usando um gancho e ,.colunizei o intervalo, mas acabou no mesmo comprimento.
miles
você não sabe se eu posso encontrar o código fonte do tryj.tk em algum lugar? Eu não poderia encontrar qualquer informação nem sobre isso nem sobre o autor (F211)
Dan Oak
15

/// , 128 bytes

/:/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:

Experimente online!

Inspirado pela incrível resposta de Jakube ao desafio do alfabeto L, pensei em tentar a minha mão também na programação real em ///, em vez de apenas usá-la para compactação. Isso foi bastante complicado e eu precisei de quatro tentativas, mas no final saiu muito mais curto que minha solução baseada em compactação .

Explicação

Um iniciador rápido em ///: basicamente o intérprete apenas lê o caractere de código por caractere e faz o seguinte:

  • Se não for \nem um /, imprima-o.
  • Se for um \, imprima o próximo caractere.
  • Se for um /, analise uma /x/y/instrução (com as mesmas regras de escape) e substitua repetidamente tudo xno código restante por y.

Inspirando-me um pouco mais em Jakube, para simplificar, explicarei uma versão 4x4 disso:

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

Começamos substituindo aqueles :com o material entre o segundo e o terceiro /. Isso acabará sendo o código que gira as linhas subseqüentes. Temos isso:

/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

O f, be xsão apenas atalhos para sequências comuns, que expandiremos agora. O fé para barras, o bé para barras invertidas e o xé o \//que acontece bastante. A razão pela qual estou usando aliases para as substrings de caractere único /e \é que elas precisam ser escapadas na primeira instrução de substituição, então estou economizando bastante bytes por não precisar de todas as barras invertidas. Aqui está o que nós temos depois x, fe bforam preenchidos:

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

Muito legível.

Portanto, a primeira linha é impressa literalmente. Então chegamos à parte descolada que gira todas as outras linhas. Na verdade, consiste em quatro instruções diferentes. Uma coisa a notar é que eu escapei de todas as ocorrências Adentro destas instruções. A razão para isso é que me permite distinguir As nas instruções de As nas linhas restantes, que precisam ser processadas de maneira diferente.

/\/\A/\//

Isso corresponde /Ae o substitui por /, removendo o A. Observe que essa subcadeia aparece apenas na frente de cada uma ABCD, portanto, elimina o primeiro caractere de todas as linhas subseqüentes:

/
\//\A_\//

Isso corresponde a um avanço de linha seguido por uma barra e o substitui por A_/. Portanto, isso insere um Ano final de cada linha, completando a rotação e também transforma o avanço de linha em um sublinhado.

/_\//
\//

Isso corresponde _/e o substitui por um avanço de linha seguido por uma barra. A razão pela qual eu preciso fazer esse desvio através do sublinhado é o fato de que /// aplica cada instrução repetidamente até que a string não corresponda mais. Isso significa que você nunca pode usar uma instrução da forma /x/axb/onde x, ae bsão seqüências arbitrárias, porque após a substituição xsempre sempre corresponderá. Em particular, isso significa que não podemos simplesmente inserir algo na frente de um avanço de linha. Precisamos substituir o avanço de linha no processo e desfazer essa substituição.

/\\\A/\\B/

Isso corresponde \Ae o substitui por \B, para que as instruções após as linhas restantes processem o próximo caractere. Após todas as quatro instruções terem sido processadas, a sequência restante fica assim:

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

Portanto, agora a primeira linha girada é impressa e o próximo conjunto de instruções gira as linhas restantes por outra célula e assim por diante. Após a última rotação, temos mais algumas instruções que podemos ignorar e terminamos com a instrução incompleta:

/\\\B/\\

Instruções incompletas no final são simplesmente ignoradas e o programa termina.

Martin Ender
fonte
Agradável. Ontem experimentei um pouco com uma ideia diferente. Eu queria substituir cada caractere em cada linha. Algo como A->B, B->C... Mas não funcionou. Remover o primeiro caractere e anexá-lo no final é definitivamente uma abordagem muito melhor.
Jakube 2/08/16
@Jakube Eu tentei isso também, mas não estava chegando a lugar nenhum. É muito difícil evitar estragar as instruções subseqüentes também.
Martin Ender
1
124 bytes: goo.gl/efSLKQ Esta é apenas a sua solução, mas consegui adicionar algumas substituições adicionais, para que você só precise escrever o alfabeto uma vez. Utilizou a mesma estratégia em problemas semelhantes também.
Jakube 10/09
1
122: goo.gl/zRsBbR
Jakube
11

Geléia , 7 bytes

ØAṙJṢj⁷

Experimente online!

Como funciona

Ø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.
Dennis
fonte
11

Emacs, 47 bytes

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

Onde ^Psignifica "Control P", etc. São 47 bytes, pois as teclas F3 e F4 requerem dois bytes ASCII.

Depois de inserir a entrada inicial, define uma macro do teclado para duplicar a linha e mover o primeiro caractere para o final. Em seguida, executa a macro mais 24 vezes.

MattBlissett
fonte
2
Bem-vindo ao PPCG, boa resposta! É muito raro ver uma resposta do Emacs, nem sei se uma resposta do Emacs já foi publicada.
TuxCrafting 03/08/19
10

JavaScript (ES6), 56 bytes

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

Sim, isso mesmo, metade do meu código é a literal do alfabeto. O melhor que eu poderia fazer sem o literal é 81 bytes:

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

Se você deseja um programa em vez de uma função, remova _=>e envolva console.log()por um custo de 10 bytes.

Neil
fonte
Woah, muito bem. Uma solução muito elegante. Como funciona?
precisa saber é o seguinte
2
@ Polyducks Muita e muita magia regexp. Corresponde naturalmente a /./gcada letra da sequência do alfabeto fornecida. Na sequência de substituição, $&representa a correspondência em si, $'a parte da sequência após a partida e $`a parte da sequência antes da partida. $`$&$'portanto, representaria a sequência original, mas é claro que é trivial mover a parte após a partida para o início, fornecendo o efeito de rotação.
Neil
Super inteligente! Bem feito @Neil!
Polyducks
9

Mathematica 68 61 bytes

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

Graças a...

@MartinEnder (7 bytes)

Martin
fonte
Além disso, Arraypode ser mais curto que o mapeamento sobre a Range.
Martin Ender
Acabei de verificar e Arrayrealmente salvar um byte, mas você pode salvar outro evitando Column: Array[{"A"~CharacterRange~"Z"~RotateLeft~#,"\n"}&,26,0]<>""(você só precisará substituir o \npor um avanço de linha real).
Martin Ender
7
Não espera nenhum built-in? Impossível
MC ΔT 31/07
1
Print@@@NestList[RotateLeft,"A"~CharacterRange~"Z",25]
Alephalpha
Grid@Array[FromCharacterCode[Mod[+##-2,26]+65]&,{26,26}]
mathe
9

Python 2, 75 65 61 58 bytes

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

Obtém o alfabeto map(chr,range(65,91))e aplica manualmente a operação de deslocamento de string.

Obrigado a @LeakyNun e @TheBikingViking por -4 bytes!

Obrigado a @xnor por -3 bytes!

Cobre
fonte
2
Aparentemente a="ABCDEFGHIJKLMNOPQRSTUVWXYZ"é mais curto.
Freira vazando
1
Você pode fazer em a[1:]vez de a[1:26].
TheBikingViking
2
Seu loop pode ser feito como for x in s:print s;s=s[1:]+x.
xnor
3
Você pode executar um byte menor que o código do alfabeto:: s='%c'*26%tuple(range(65,91)).
Xnor
9

C, 88 64 bytes

Ligue f()sem argumentos.

f(i,j){for(i=j=0;i<26;putchar(j==26?j=0,i++,10:65+(i+j++)%26));}

Experimente em ideone .

owacoder
fonte
9

Piet , 247 bytes / 190 codéis

Tabula Recta em Piet

Experimente Online!

Portanto, isso levou muito mais tempo do que eu havia previsto, e tenho algumas idéias sobre outras abordagens mais eficientes (mais compatíveis com a pilha), mas finalmente consegui resolver o problema ( corrigi um erro de intérprete e adicionei recursos de IDE ao longo do caminho), então aqui está. Dificilmente a linguagem mais eficiente em bytes, mas muito divertida. Aqui está uma visão ampliada e um rastreamento mostrando o caminho percorrido. História no meu GitHub .

Tabula Recta em Piet, versão grande

Rastreio de execução Tabula Recta

Como uma linguagem baseada em pilha, é complicado demais para explicar brevemente, mas aqui está uma visão geral básica do que as várias seções / loops fazem. Todos os nomes de variáveis ​​e funções são apenas para explicação, pois não existem variáveis ​​ou funções no Piet.

  • Inicialização (canto superior esquerdo): começa line_counterem 27, carrega '@' como cur_letter, define letter_countcomo 27
  • Laço principal (começando em roxo escuro, no centro)
    • Decrementos letter_counter
    • Ramifica para reset_linese zero (ciano claro 2 blocos)
    • Rola cur_letterpara o topo da pilha
    • Ramos para check_doneif cur_letter > 'X'(cerceta / bloco vermelho, lado direito)
    • Incrementa cur_lettere gera (canto inferior direito)
    • Ramifica para reset_letterif cur_letter > 'Y'(bloco verde claro, à esquerda)
    • Rola `letter_counter_ de volta ao topo da pilha, de volta ao topo do loop
  • reset_line ramo (grande quadrado rosa):
    • Gera caractere de nova linha
    • Redefine letter_countpara 27
    • Continua de volta ao topo do loop principal
  • check_done ramo (metade direita dentro)
    • Rola line_counterpara o topo
    • Ramificações para terminar se zero
    • Decrementa line_countere rola de volta para o final da pilha
    • Continua onde parou, imprimindo carta
  • reset_line ramo (lado esquerdo, bloco verde):
    • Redefine cur_letterpara '@'
    • Continua onde parou, rolando / retornando ao topo do loop
cincodenada
fonte
8

MATL , 8 bytes

Agradecemos a @Dennis , que sugeriu que o MATL incorporasse a indexação modular, e a @Suever , que teve a idéia de operações automáticas em pares.

1Y2t&+Q)

Experimente online!

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
Luis Mendo
fonte
8

Javascript, 113 96 91 76 bytes

Uma versão super curta para execução no console:

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

Javascript / HTML, 140 123 118 105 bytes

Uma versão mais bonita, com uma saída HTML que facilita ao OP copiar e colar:

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

(Edição: Eu deveria ter usado apenas a string AZ em vez de gerá-la)

(EDIT 2: Obrigado a @Neil e @DanTheMan por suas contribuições (ver comentários))

Polyducks
fonte
O primeiro C = 26 não é irrelevante?
DanTheMan
Oh snap. Parece que esqueci de excluí-lo quando o mudei para o for. Fixo! Obrigado @DanTheMan :)
Polyducks
1
l.slice(0,1)é apenas l[0], enquanto o ,27é desnecessário; nesse ponto, você pode mover a fatia e terminar com l.slice(1)+l[0]. Também acho que você pode mover o console.logpara o corpo do loop, evitando a fuga ;.
Neil
Testando isso agora, obrigado @Neil! Edição: Doce Santo Moly. Graças a vocês dois, adicionarei você ao crédito no comentário.
22416 Polyducks
1
Oh, legal, essa é uma maneira ainda melhor de simplificar o console.log.
Neil
8

PowerShell, 44 bytes

-1..24|%{-join[char[]](65..90)[($_-25)..$_]}
Joey
fonte
8

R, 47 42 41 bytes

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

Experimente online!

Gera 27 alfabetos, remove 27ª letras e imprime em 26 colunas.

Melhoria inspirado por @Giuseppe da solução .

Robert Hacken
fonte
1
46 bytes
Giuseppe
Uau, eu pensei que tinha tentado todos os truques de indexação para usar, repmas isso foi particularmente inspirado! Muito agradável. Eu votaria novamente se pudesse.
Giuseppe
você pode usar em 1vez de ""para stdout.
Giuseppe
6

Sesos , 27 25 bytes

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

Experimente online! Marque Debug para ver o código SBIN gerado.

Montagem Sesos

O arquivo binário acima foi gerado montando o seguinte código 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)

Como funciona

Começamos inicializando a fita para ABCDEFGHIJKLMNOPQRSTUVWXYZ. Isto é o seguinte.

Escreva 26 em uma célula, deixando a fita no seguinte estado.

                                                     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

Desde que a célula sob o cabeçalho de dados seja diferente de zero, fazemos o seguinte.

Copie o número para as duas células à esquerda e adicione 64 à cópia mais à esquerda.

                                                   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

Mova a cópia mais à esquerda para o local original e subtraia 1 da cópia mais à direita.

                                                     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

O processo para após 26 iterações, pois a cópia mais à direita é 0 até então. Movemos uma célula para a direita, para que o estado final da fita após a inicialização seja o seguinte.

     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

Agora estamos prontos para gerar a saída, repetindo o processo a seguir até que a célula sob o cabeçalho de dados seja zero.

Primeiro, imprimimos o caractere sob o cabeçalho de dados e movemos para a direita, repetindo esta etapa até que uma célula com o valor 0 seja encontrada. Após a impressão ABCDEFGHIJKLMNOPQRSTUVWXYZ, a fita fica da seguinte maneira.

                                                                                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

Agora, movemos a cabeça de dados 27 unidades para a esquerda (de volta ao 0 inicial ) e repetimos a combinação de impressão e movimentação até que uma célula com o valor 0 seja encontrada. Isso não imprime nada e deixa a fita da seguinte maneira.

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

Agora, escrevemos 10 na célula atual, imprimimos o caractere correspondente (avanço de linha) e zeramos a célula com uma chamada getna entrada vazia, deixando a fita inalterada.

Depois, movemos o conteúdo da célula da direita para a célula atual e, em seguida, movemos o cabeçalho dos dados para as unidades da direita.

      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 próxima iteração é um pouco diferente. A primeira etapa de impressão é impressa BCDEFGHIJKLMNOPQRSTUVWXYZ, deixando a fita da seguinte maneira.

                                                                                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

Agora, movemos a cabeça de dados 27 unidades para a esquerda.

 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

O loop de impressão subsequente imprime Ae sai da fita da seguinte maneira.

   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

Mais uma vez, imprimimos um avanço de linha, movemos o conteúdo da célula da direita para a célula atual e, em seguida, movemos o cabeçalho dos dados para as unidades da direita.

         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

Após mais 24 iterações, a etapa final de mover a cabeça de dados para a direita deixa a fita no seguinte estado.

                                                                                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

A célula sob o cabeçalho de dados agora é 0 e o programa termina.


† O TIO usa uma versão mais recente do Sesos, compatível com versões anteriores do SASM, mas gera um código SBIN mais curto.

Dennis
fonte
6

Haskell, 56 53 52 Bytes

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

mesmo comprimento: (usando uma sugestão de @AndersKaseorg)

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

Para fazer coisas modulares, é necessário importar o Data.Char para obter a função chr, 74 59 58 bytes foi o melhor que consegui com isso: (obrigado a @nimi por sugerir a função toEnum)

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

Provavelmente poderia ser muito mais curto, mas não conheço nenhum truque de golfe de Haskell.

usou mapM em vez de mapM_ (consulte o comentário de @ Lynn)

KarlKastor
fonte
1
Para -3 bytes, mude ['A'..x]para ['A'..'Z'], que agora é usado duas vezes, e levante-o para uma definição.
Anders Kaseorg 30/07
@AndersKaseorg: Obrigado! No entanto, tive outra ideia que salvou o mesmo número de bytes, mantendo-o como um delineador. Eu adicionei sua sugestão à solução alternativa, no entanto.
30916 Karl Karlastast
Se você precisar apenas chrde Data.Char, poderá usar toEnume omitir o import.
nimi
1
Eu sinto que mudar mapM_para mapMdeve ficar bem. Talvez isso valha a pena uma meta post ...
Lynn
6

R, 53 bytes

for(i in 1:26)cat(LETTERS[c(i:26,1:i-1)],"\n",sep="")

Aqui está em um intérprete online .

plannapus
fonte
5

Retina, 36 31 bytes

5 bytes graças a Martin Ender.

Z
{2`
$ `
} T01`L`_L
\ `.
$ & $ '$ `¶

O avanço de linha principal é significativo.

Experimente online!

Créditos .

Freira Furada
fonte
5

Flak cerebral , 222 bytes

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

Experimente online!

Eu sou novo no Brain-Flak, então talvez isso possa ser muito praticado, mas pelo menos é uma primeira tentativa. Ele armazena 27 alfabetos completos na pilha esquerda, depois move os alfabetos para a direita e substitui cada 27ª letra por uma nova linha.

Meu código fonte é um pouco confuso, mas vou adicioná-lo.

(((()()()()){})
    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
Dorian
fonte
5

V , 36 , 10 bytes

¬AZ25ñÙx$p

Experimente online!

Isso usa a codificação "Latin1".

Explicação:

¬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
fonte
Vá e adicione-o então;)
Conor O'Brien
@ CᴏɴᴏʀO'Bʀɪᴇɴ Você já deve saber que a única maneira de fazer qualquer coisa nesse idioma é no ritmo dos caracóis. Provavelmente terei isso em funcionamento em janeiro próximo. : P
DJMcMayhem
Oh, nas próximas 6-8 semanas?
Conor O'Brien
4

C #, 98 bytes

Tentei ver se consigo gerar as letras mais curtas do que apenas inicializá-las como uma string, mas não é realmente possível. As letras são 26 bytes e somente este trecho

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

é de 25 bytes. Eu acho que inicializá-los e depois anexá-los com um + = a é uma boa solução, mas com o C # você é limitado pelo número de bytes de funções como Substring()e Console.WriteLine().

Minha tentativa de 98 bytes:

var a="ABCDEFGHIJKLMNOPQRSTUVWXYZ";a+=a;for(int i=0;i<26;i++)Console.WriteLine(a.Substring(i,26));
Daniel
fonte
4

Oitava, 27 bytes

Estamos adicionando uma linha e um vetor de coluna, e o Octave expande muito bem as dimensões sigleton, sem necessidade bsxfun(como você precisaria no Matlab).

[mod((v=0:25)+v',26)+65,'']
flawr
fonte
4

q, 20 bytes

(til 26)rotate\:.Q.A
skeevey
fonte
14 bytes -1_'26 27#.Q.A
streetster
4

Java, 190 176 172 163 bytes

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
fonte
Você pode facilmente remover mais alguns bytes: System.out.printf("%c", ...)-> System.out.write(...), '\n'-> 10, 'A'-> 65. Observe que a sugestão de char de nova linha / linha é permitida, mas requer requisitos de saída de ideona . :)
MH.
@MH. ótimas dicas! salvou 9 bytes :)
Master_ex 31/07
Sei que já faz mais de um ano que você respondeu isso, mas ainda pode jogar algumas coisas: O espaço em String[]apode ser removido; e int s=0;while(s<26){p(s,26);p(0,s++);p(-1,0);}pode ser for(int s=0;s<26;p(0,s++),p(0,s++))p(s,26);.
Kevin Cruijssen
4

Bash, 66 bytes

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

Crio um alfabeto completo e A, em seguida, imprimo 26 versões rotacionadas, pegando os caracteres que começam em ne anexando as posições anteriores n.

Toby Speight
fonte
4

Perl, 42 bytes

Crédito total para @Dom Hastings por isso.

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

Ou (mesma contagem de bytes):

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

Precisa -M5.010ou -Eé executado, por exemplo:

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



Minha resposta antiga (55 bytes):

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

Precisa -M5.010correr. Então corra com:

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

Provavelmente é possível fazer mais curto, mas eu não descobri como ... ainda

dada
fonte
Conseguiu criar algumas soluções de 42 bytes: @l=A..Z;say@l[$_..25],@l[0..$_-1]for 0..25e $_=join"",A..Z;eval'say;/./;$_=$\'.$&;'x26ambas requerem -E/ -M5.010.
Dom Hastings
Bem feito. Parece muito melhor do que a minha tentativa! obrigado
Dada