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 N
está 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.
/* Configuration */
var QUESTION_ID = 86986; // Obtain this from the url
// It will be like https://XYZ.stackexchange.com/questions/QUESTION_ID/... on any question page
var ANSWER_FILTER = "!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe";
var COMMENT_FILTER = "!)Q2B_A2kjfAiU78X(md6BoYk";
var OVERRIDE_USER = 53406; // This should be the user ID of the challenge author.
/* App */
var answers = [], answers_hash, answer_ids, answer_page = 1, more_answers = true, comment_page;
function answersUrl(index) {
return "https://api.stackexchange.com/2.2/questions/" + QUESTION_ID + "/answers?page=" + index + "&pagesize=100&order=desc&sort=creation&site=codegolf&filter=" + ANSWER_FILTER;
}
function commentUrl(index, answers) {
return "https://api.stackexchange.com/2.2/answers/" + answers.join(';') + "/comments?page=" + index + "&pagesize=100&order=desc&sort=creation&site=codegolf&filter=" + COMMENT_FILTER;
}
function getAnswers() {
jQuery.ajax({
url: answersUrl(answer_page++),
method: "get",
dataType: "jsonp",
crossDomain: true,
success: function (data) {
answers.push.apply(answers, data.items);
answers_hash = [];
answer_ids = [];
data.items.forEach(function(a) {
a.comments = [];
var id = +a.share_link.match(/\d+/);
answer_ids.push(id);
answers_hash[id] = a;
});
if (!data.has_more) more_answers = false;
comment_page = 1;
getComments();
}
});
}
function getComments() {
jQuery.ajax({
url: commentUrl(comment_page++, answer_ids),
method: "get",
dataType: "jsonp",
crossDomain: true,
success: function (data) {
data.items.forEach(function(c) {
if (c.owner.user_id === OVERRIDE_USER)
answers_hash[c.post_id].comments.push(c);
});
if (data.has_more) getComments();
else if (more_answers) getAnswers();
else process();
}
});
}
getAnswers();
var SCORE_REG = /<h\d>\s*([^\n,]*[^\s,]),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/;
var OVERRIDE_REG = /^Override\s*header:\s*/i;
function getAuthorName(a) {
return a.owner.display_name;
}
function process() {
var valid = [];
answers.forEach(function(a) {
var body = a.body;
a.comments.forEach(function(c) {
if(OVERRIDE_REG.test(c.body))
body = '<h1>' + c.body.replace(OVERRIDE_REG, '') + '</h1>';
});
var match = body.match(SCORE_REG);
if (match)
valid.push({
user: getAuthorName(a),
size: +match[2],
language: match[1],
link: a.share_link,
});
});
valid.sort(function (a, b) {
var aB = a.size,
bB = b.size;
return aB - bB
});
var languages = {};
var place = 1;
var lastSize = null;
var lastPlace = 1;
valid.forEach(function (a) {
if (a.size != lastSize)
lastPlace = place;
lastSize = a.size;
++place;
var answer = jQuery("#answer-template").html();
answer = answer.replace("{{PLACE}}", lastPlace + ".")
.replace("{{NAME}}", a.user)
.replace("{{LANGUAGE}}", a.language)
.replace("{{SIZE}}", a.size)
.replace("{{LINK}}", a.link);
answer = jQuery(answer);
jQuery("#answers").append(answer);
var lang = a.language;
if (/<a/.test(lang)) lang = jQuery(lang).text();
languages[lang] = languages[lang] || {lang: a.language, user: a.user, size: a.size, link: a.link};
});
var langs = [];
for (var lang in languages)
if (languages.hasOwnProperty(lang))
langs.push(languages[lang]);
langs.sort(function (a, b) {
if (a.lang > b.lang) return 1;
if (a.lang < b.lang) return -1;
return 0;
});
for (var i = 0; i < langs.length; ++i)
{
var language = jQuery("#language-template").html();
var lang = langs[i];
language = language.replace("{{LANGUAGE}}", lang.lang)
.replace("{{NAME}}", lang.user)
.replace("{{SIZE}}", lang.size)
.replace("{{LINK}}", lang.link);
language = jQuery(language);
jQuery("#languages").append(language);
}
}
body { text-align: left !important}
#answer-list {
padding: 10px;
width: 290px;
float: left;
}
#language-list {
padding: 10px;
width: 290px;
float: left;
}
table thead {
font-weight: bold;
}
table td {
padding: 5px;
}
<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script>
<link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b">
<div id="answer-list">
<h2>Leaderboard</h2>
<table class="answer-list">
<thead>
<tr><td></td><td>Author</td><td>Language</td><td>Size</td></tr>
</thead>
<tbody id="answers">
</tbody>
</table>
</div>
<div id="language-list">
<h2>Winners by Language</h2>
<table class="language-list">
<thead>
<tr><td>Language</td><td>User</td><td>Score</td></tr>
</thead>
<tbody id="languages">
</tbody>
</table>
</div>
<table style="display: none">
<tbody id="answer-template">
<tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr>
</tbody>
</table>
<table style="display: none">
<tbody id="language-template">
<tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr>
</tbody>
</table>
printf
, precisamos incluirstdio.h
, seisalpha
for usado,ctype.h
é necessário etc. Isso está correto?Respostas:
05AB1E ,
65 bytesAgradecemos ao Downgoat por economizar 1 byte. Código:
Explicação:
Usa a codificação CP-1252 . Experimente online! .
fonte
v
comando 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? :)Vim,
2523 bytesOnde
↵
está a tecla Return.EDIT : minúsculas está ok, então eu posso salvar duas chaves.
fonte
:h<_<cr>jjY
é genial #V~
Python 2,
595753 bytesGraças a @xsot por -4 bytes!
fonte
print bytearray(a)
./// , 220 bytes
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
N
cópias de umaM
substring de comprimento , você salvaria(N-1)*(M-1) - 5
substrings, 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:
/x/ABC/
ao código ondex
está a letra escolhida eABC
a substring.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 ...
fonte
YX
saída. ;)C, 47 bytes
Experimente no Ideone
Um único loop, imprimindo o alfabeto a cada 26 caracteres, mas a cada 27 caracteres substituídos por uma nova linha.
fonte
f(i)
apenas chamarf()
sem argumentos.i=702;f(){for(;i--;)//...
J, 15 bytes
Intérprete online .
fonte
|. (Shift)
é de 8 bytes mais!(i.26)(|."0 _)u:65+i.26
u:65+1&|.^:]i.26
pois os advérbios de poder rastreiam resultados anteriores, se houver uma lista.|.
é de 17 bytes:u:65+|."0 1/~i.26
(ainda usam/~
)u:65+(|./~,.)i.26
. Eu me livrei da classificação usando um gancho e,.
colunizei o intervalo, mas acabou no mesmo comprimento./// , 128 bytes
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:
\
nem um/
, imprima-o.\
, imprima o próximo caractere./
, analise uma/x/y/
instrução (com as mesmas regras de escape) e substitua repetidamente tudox
no código restante pory
.Inspirando-me um pouco mais em Jakube, para simplificar, explicarei uma versão 4x4 disso:
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:O
f
,b
ex
são apenas atalhos para sequências comuns, que expandiremos agora. Of
é para barras, ob
é para barras invertidas e ox
é 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 depoisx
,f
eb
foram preenchidos: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
A
dentro destas instruções. A razão para isso é que me permite distinguirA
s nas instruções deA
s nas linhas restantes, que precisam ser processadas de maneira diferente.Isso corresponde
/A
e o substitui por/
, removendo oA
. Observe que essa subcadeia aparece apenas na frente de cada umaABCD
, portanto, elimina o primeiro caractere de todas as linhas subseqüentes:Isso corresponde a um avanço de linha seguido por uma barra e o substitui por
A_/
. Portanto, isso insere umA
no 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/
ondex
,a
eb
são seqüências arbitrárias, porque após a substituiçãox
sempre 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.Isso corresponde
\A
e 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: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:
Instruções incompletas no final são simplesmente ignoradas e o programa termina.
fonte
A->B
,B->C
... Mas não funcionou. Remover o primeiro caractere e anexá-lo no final é definitivamente uma abordagem muito melhor.Geléia , 7 bytes
Experimente online!
Como funciona
fonte
Emacs, 47 bytes
Onde
^P
significa "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.
fonte
JavaScript (ES6), 56 bytes
Sim, isso mesmo, metade do meu código é a literal do alfabeto. O melhor que eu poderia fazer sem o literal é 81 bytes:
Se você deseja um programa em vez de uma função, remova
_=>
e envolvaconsole.log()
por um custo de 10 bytes.fonte
/./g
cada 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.Mathematica
6861 bytesGraças a...
@MartinEnder (7 bytes)
fonte
Array
pode ser mais curto que o mapeamento sobre aRange
.Array
realmente salvar um byte, mas você pode salvar outro evitandoColumn
:Array[{"A"~CharacterRange~"Z"~RotateLeft~#,"\n"}&,26,0]<>""
(você só precisará substituir o\n
por um avanço de linha real).Print@@@NestList[RotateLeft,"A"~CharacterRange~"Z",25]
Grid@Array[FromCharacterCode[Mod[+##-2,26]+65]&,{26,26}]
Python 2,
75656158 bytesObté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!
fonte
a="ABCDEFGHIJKLMNOPQRSTUVWXYZ"
é mais curto.a[1:]
vez dea[1:26]
.for x in s:print s;s=s[1:]+x
.s='%c'*26%tuple(range(65,91))
.C,
8864 bytesLigue
f()
sem argumentos.Experimente em ideone .
fonte
Piet , 247 bytes / 190 codéis
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 .
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.
line_counter
em 27, carrega '@' comocur_letter
, defineletter_count
como 27letter_counter
reset_line
se zero (ciano claro 2 blocos)cur_letter
para o topo da pilhacheck_done
ifcur_letter > 'X'
(cerceta / bloco vermelho, lado direito)cur_letter
e gera (canto inferior direito)reset_letter
ifcur_letter > 'Y'
(bloco verde claro, à esquerda)reset_line
ramo (grande quadrado rosa):letter_count
para 27check_done
ramo (metade direita dentro)line_counter
para o topoline_counter
e rola de volta para o final da pilhareset_line
ramo (lado esquerdo, bloco verde):cur_letter
para '@'fonte
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.
Experimente online!
fonte
Javascript,
113969176 bytesUma versão super curta para execução no console:
Javascript / HTML,
140123118105 bytesUma versão mais bonita, com uma saída HTML que facilita ao OP copiar e colar:
(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))
fonte
l.slice(0,1)
é apenasl[0]
, enquanto o,27
é desnecessário; nesse ponto, você pode mover a fatia e terminar coml.slice(1)+l[0]
. Também acho que você pode mover oconsole.log
para o corpo do loop, evitando a fuga;
.console.log
.PowerShell, 44 bytes
fonte
R,
474241 bytesExperimente online!
Gera 27 alfabetos, remove 27ª letras e imprime em 26 colunas.
Melhoria inspirado por @Giuseppe da solução .
fonte
rep
mas isso foi particularmente inspirado! Muito agradável. Eu votaria novamente se pudesse.1
vez de""
parastdout
.Sesos ,
2725 bytesExperimente 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.
Como funciona
Começamos inicializando a fita para
ABCDEFGHIJKLMNOPQRSTUVWXYZ
. Isto é o seguinte.Escreva 26 em uma célula, deixando a fita no seguinte estado.
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.
Mova a cópia mais à esquerda para o local original e subtraia 1 da cópia mais à direita.
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.
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.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.
Agora, escrevemos 10 na célula atual, imprimimos o caractere correspondente (avanço de linha) e zeramos a célula com uma chamada
get
na 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.
A próxima iteração é um pouco diferente. A primeira etapa de impressão é impressa
BCDEFGHIJKLMNOPQRSTUVWXYZ
, deixando a fita da seguinte maneira.Agora, movemos a cabeça de dados 27 unidades para a esquerda.
O loop de impressão subsequente imprime
A
e sai da fita da seguinte maneira.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.
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.
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.
fonte
Haskell,
565352 Bytesmesmo comprimento: (usando uma sugestão de @AndersKaseorg)
Para fazer coisas modulares, é necessário importar o Data.Char para obter a função chr,
745958 bytes foi o melhor que consegui com isso: (obrigado a @nimi por sugerir a função toEnum)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)
fonte
['A'..x]
para['A'..'Z']
, que agora é usado duas vezes, e levante-o para uma definição.chr
deData.Char
, poderá usartoEnum
e omitir oimport
.mapM_
paramapM
deve ficar bem. Talvez isso valha a pena uma meta post ...R, 53 bytes
Aqui está em um intérprete online .
fonte
Retina,
3631 bytes5 bytes graças a Martin Ender.
O avanço de linha principal é significativo.
Experimente online!
Créditos .
fonte
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.
fonte
V ,
36, 10 bytesExperimente online!
Isso usa a codificação "Latin1".
Explicação:
fonte
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
é 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()
eConsole.WriteLine()
.Minha tentativa de 98 bytes:
fonte
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).fonte
q, 20 bytes
fonte
-1_'26 27#.Q.A
Java,
190176172163 bytesfonte
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 . :)String[]a
pode ser removido; eint s=0;while(s<26){p(s,26);p(0,s++);p(-1,0);}
pode serfor(int s=0;s<26;p(0,s++),p(0,s++))p(s,26);
.Bash, 66 bytes
Crio um alfabeto completo e
A
, em seguida, imprimo 26 versões rotacionadas, pegando os caracteres que começam emn
e anexando as posições anterioresn
.fonte
Perl, 42 bytes
Crédito total para @Dom Hastings por isso.
Ou (mesma contagem de bytes):
Precisa
-M5.010
ou-E
é executado, por exemplo:Minha resposta antiga (55 bytes):
Precisa
-M5.010
correr. Então corra com:Provavelmente é possível fazer mais curto, mas eu não descobri como ... ainda
fonte
@l=A..Z;say@l[$_..25],@l[0..$_-1]for 0..25
e$_=join"",A..Z;eval'say;/./;$_=$\'.$&;'x26
ambas requerem-E
/-M5.010
.