Imprima una Tabula Recta!

La Tabula Recta (a veces llamada 'Mesa Vigenere'), fue creada por Johannes Trithemius, y se ha utilizado en varias cifras, incluidas todas las variantes de la cifra Vigenere de Bellaso y la cifra Trithemius. Se parece a esto:

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

Frecuentemente necesito esto, pero no puedo encontrarlo en ningún lugar de Internet para copiar y pegar. Debido a que la tabla cuadrada es muy larga y requiere una gran cantidad de tiempo para escribir, su código debe ser lo más corto posible.

Reglas / requisitos

Cada presentación debe ser un programa completo o una función. Si es una función, debe ser ejecutable solo necesitando agregar la llamada a la función al final del programa. Se debe incluir cualquier otra cosa (por ejemplo, encabezados en C).
Si es posible, proporcione un enlace a un sitio donde se pueda probar su programa.
Su programa no debe escribirle nada STDERR.
Las lagunas estándar están prohibidas.
Su programa puede generar resultados en cualquier caso, pero debe imprimirse (no una matriz ni similar)

Puntuación

Los programas se puntúan según los bytes, en UTF-8 de forma predeterminada o en un conjunto de caracteres diferente de su elección.

Eventualmente, la respuesta con la menor cantidad de bytes ganará.

Envíos

Para asegurarse de que su respuesta se muestre, comience con un título, utilizando la siguiente plantilla de Markdown:

# Language Name, N bytes

¿Dónde Nestá el tamaño de su envío? Si mejora su puntaje, puede mantener los puntajes antiguos en el título, tachándolos. Por ejemplo:

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

Si desea incluir varios números en su encabezado (por ejemplo, porque su puntaje es la suma de dos archivos o desea enumerar las penalizaciones de la bandera del intérprete por separado), asegúrese de que el puntaje real sea el último número en el encabezado:

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

También puede hacer que el nombre del idioma sea un enlace que luego aparecerá en el fragmento de la tabla de clasificación:

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

Tabla de clasificación

Aquí hay un fragmento de pila para generar una tabla de clasificación regular y una descripción general de los ganadores por idioma.

Mostrar fragmento de código

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

Expand snippet

code-golf string kolmogorov-complexity cryptography alphabet George Gibson
fuente

Con respecto a la regla 1: ¿tenemos que incluir cada encabezado para cada función que usamos?

owacoder

Me refería a que si usamos printf, debemos incluir stdio.h, si isalphase usa, ctype.hse necesita, etc. ¿Es esto correcto?

owacoder

3

Probablemente deberías poner "se permite minúsculas" en la especificación de desafío. Solo así es menos probable que las personas se lo pierdan si no ven estos comentarios.

Sherlock9

2

¿tengo que imprimirlo o puedo devolver una cadena / matriz de caracteres

downrep_nation

1

Gracias por la pregunta por hacerme permanecer despierto toda la noche. (+1)

Anastasiya-Romanova 秀

30

05AB1E , 6 5 bytes

Gracias a Downgoat por guardar 1 byte. Código:

ADv=À

Explicación:

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.

Utiliza la codificación CP-1252 . Pruébalo en línea! .

Adnan
fuente

¿Cuál es el propósito de duplicarlo?

Esolanging Fruit

1

@ Challenger5 El vcomando consume un valor, iterando sobre él. En este caso, consume el alfabeto, por lo que itera 26 veces. Esa es también la cantidad exacta de veces que necesitamos iterar la =Àfunción. Las =hojas de la pila intacto y el Àsólo gira la parte superior del elemento de la pila 1 a la izquierda. ¿Responde esto a tu pregunta? :)

Adnan

101

Vim, 25 23 bytes

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

¿Dónde ↵está la tecla de retorno?

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

EDITAR : minúsculas está bien, así que puedo guardar dos claves.

Lynn
fuente

23

Eso :h<_<cr>jjYes genial

Downgoat

3

¡Guau eso es increible! OP dijo que las minúsculas estaban bien, así que puedes eliminarlasV~

DJMcMayhem

44

@RobStarling ver: meta.codegolf.stackexchange.com/q/8995/40695

Downgoat

44

Reto a alguien a probar esto en emacs.

addison

2

@addison Emacs respuesta

TuxCrafting

24

Python 2, 59 57 53 bytes

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

¡Gracias a @xsot por -4 bytes!

dianne
fuente

44

Me gusta este. Por cierto, puedes acortar la última línea a print bytearray(a).

xsot

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

Pruébalo en línea!

Esto fue sorprendentemente no trivial y no tengo idea de si es óptimo.

~~La única forma de jugar un problema como este en /// es extrayendo subcadenas comunes.~~ ( Resulta que estaba equivocado ) . Sin embargo, debido a la naturaleza de la salida, no está claro qué subcadenas deberían extraerse mejor, ya que no se puede extraer todo el alfabeto debido a los saltos de línea. Por lo tanto, deberá extraer algunas subcadenas del alfabeto envuelto, pero luego hay compensaciones en términos de cuánto tiempo hace las subcadenas y cuáles elige.

Así que esto es lo que hice. Este es un script CJam que encuentra todas las subcadenas hasta una longitud de 25 en la cadena dada y para cada una de ellas calcula cuántos bytes ahorraría su extracción. Básicamente, si hay Ncopias de una Msubcadena de longitud , guardaría (N-1)*(M-1) - 5subcadenas, estas subcadenas no contienen barras inclinadas. Además, técnicamente, cuando ya ha extraído 8 subcadenas más o menos, el desplazamiento constante al final se reduce a -4, pero el script no lo considera.

De todos modos, esto es lo que hice con el script:

Ejecute el script contra el código actual (que inicialmente es solo la salida).
De las subcadenas que producen la mejora más grande, elija la más corta. Si hay varias, elija la lexicografía más pequeña (por lo que puedo decir, para la entrada dada esto reduce las superposiciones entre las subcadenas).
Reemplace todas las apariciones de la subcadena elegida en el código con una letra minúscula no utilizada.
Anteponga /x/ABC/al código donde xestá la letra elegida y ABCes la subcadena.
Repita hasta que no queden subcadenas que puedan salvar algo.

Al final, ahorramos unos pocos bytes más al reemplazar el resultado //con |y anteponer /|/\/\//(es por eso que extraer subcadenas solo cuesta 4 en lugar de 5 bytes después de la octava subcadena más o menos).

Como dije, no tengo idea de si esto es óptimo y encuentro el resultado de aspecto bastante irregular bastante interesante. Es posible llegar a una solución más corta eligiendo subcadenas no óptimas (pero más) en algún punto de la línea. Me pregunto cuál es la clase de complejidad de este problema ...

Martin Ender
fuente

Eso ... es ... brillante ...

George Gibson

1

@GeorgeGibson Gracias ... Tuve que comenzar a mitad de camino cuando noté cierto YXen la salida. ;)

Martin Ender

Mi respuesta se fue, fue un engaño de esto (más grande y más tarde). ¡+1 por eso [golf increíble]!

Erik the Outgolfer

Con respecto a la clase de complejidad, ¿no debería ser el problema indecidible ya que /// es Turing completo? El problema es "dada una cadena, busque el programa /// más corto que la genere". Excepto para cadenas pequeñas, existirían /// programas que se repiten indefinidamente (pero no se puede demostrar que se repiten indefinidamente) que no se puede demostrar que no producen la salida deseada sin ejecutarlos para siempre. Prueba formal No estoy seguro todavía, pero intuitivamente, ¿no es posible?

ghosts_in_the_code

16

C, 47 bytes

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

Pruébalo en Ideone

Un solo bucle, imprimiendo el alfabeto cada 26 caracteres pero con cada 27 caracteres reemplazados por una nueva línea.

Anders Kaseorg
fuente

1

¡Maldición! ¡Acabo de escribir exactamente la misma función! :-) Puede guardar el primer punto y coma utilizando f(i)luego simplemente llamar f()sin ningún argumento.

Level River St

@LevelRiverSt Eso dependería de un comportamiento indefinido.

Anders Kaseorg

2

En última instancia, depende de usted, pero PPCG considera que los lenguajes se definen por sus implementaciones, por lo que siempre que mencione en qué compilador funciona, confiar en UB no se considera un problema.

Dennis

puede afeitarse 1 byte inicializando i cuando se menciona por primera vez:i=702;f(){for(;i--;)//...

tucuxi el

3

@tucuxi No, porque las respuestas de funciones deben ser reutilizables .

Anders Kaseorg

15

J, 15 bytes

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

Intérprete en línea .

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

Monja permeable
fuente

¡Agradable! Aritmética muy inteligente. ¡El enfoque más simple que utiliza |. (Shift)es 8 bytes más largo! (i.26)(|."0 _)u:65+i.26

Dan Oak

1

@dahnoak Puede acortarlo a 16 bytes, u:65+1&|.^:]i.26ya que los adverbios de poder rastrean resultados anteriores si se les proporciona una lista.

millas

1

@miles Nice, mi enfoque usando |.es de 17 bytes: u:65+|."0 1/~i.26(todavía usando /~)

Leaky Nun

1

@LeakyNun Otro enfoque de 17 bytes es u:65+(|./~,.)i.26. ,.Eliminé el rango usando un gancho y para columnizar el rango, pero terminó en la misma longitud.

millas

¿No sabes si puedo encontrar el código fuente de tryj.tk en alguna parte? No pude encontrar ninguna información ni sobre el 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:

Pruébalo en línea!

Inspirado por la sorprendente respuesta de Jakube al desafío L-phabet, pensé que también probaría mi suerte en la programación real en /// en lugar de solo usarlo para la compresión. Esto fue bastante complicado y necesitaba cuatro intentos, pero al final salió mucho más corto que mi solución basada en compresión .

Explicación

Una introducción rápida en ///: básicamente el intérprete solo lee el código carácter por carácter y hace lo siguiente:

Si no es ni a \ni a /, imprímalo.
Si es un \, imprime el siguiente personaje.
Si es a /, analiza una /x/y/instrucción (con las mismas reglas de escape) y sustituye repetidamente todo xel código restante con y.

Tomando un poco más de inspiración de Jakube, por simplicidad solo explicaré una versión 4x4 de esto:

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

Comenzamos reemplazando aquellos :con las cosas entre el segundo y el tercero /. Esto terminará siendo el código que rota las filas subsiguientes. Obtenemos esto:

/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

Los f, by xson solo shorthands para cadenas comunes, que expandiremos ahora. El fes para barras inclinadas, bes para barras diagonales inversas y xes para lo \//que resulta bastante. La razón por la que estoy usando alias para las subcadenas de un solo carácter /y \es que tendrían que escapar en la primera instrucción de sustitución, por lo que en realidad estoy ahorrando muchos bytes al no necesitar todas esas barras invertidas. Esto es lo que obtenemos después x, fy bse han rellenado:

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

Muy legible

Entonces, la primera línea se imprime textualmente. Luego llegamos a la parte funky que gira todas las filas adicionales. En realidad consta de cuatro instrucciones diferentes. Una cosa a tener en cuenta es que he escapado de todas las ocurrencias Adentro de estas instrucciones. La razón de esto es que me permite distinguir As dentro de las instrucciones de As en las filas restantes, que deben procesarse de manera diferente.

/\/\A/\//

Esto coincide /Ay lo reemplaza con /, eliminando el A. Tenga en cuenta que esta subcadena solo aparece en la parte frontal de cada una ABCD, por lo que se elimina el primer carácter de todas las líneas posteriores:

/
\//\A_\//

Esto coincide con un salto de línea seguido de una barra diagonal y lo reemplaza por A_/. Entonces esto inserta un Aal final de cada línea, completando la rotación y también convierte el salto de línea en un guión bajo.

/_\//
\//

Esto coincide _/y lo reemplaza con un salto de línea seguido de una barra diagonal. La razón por la que necesito hacer este desvío a través del guión bajo es el hecho de que /// aplica cada instrucción repetidamente hasta que la cadena ya no coincida. Eso significa que nunca puede usar una instrucción de la forma /x/axb/donde x, ay bson cadenas arbitrarias, porque después de la sustitución xsiempre coincidirá. En particular, esto significa que no podemos simplemente insertar algo delante de un salto de línea. Necesitamos reemplazar el salto de línea en el proceso y deshacer este reemplazo.

/\\\A/\\B/

Esto coincide \Ay lo reemplaza con \B, de modo que las instrucciones después de las filas restantes procesan el siguiente carácter. Después de que se hayan procesado las cuatro instrucciones, la cadena restante se ve así:

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

Entonces, ahora se imprime la primera fila girada, y luego el siguiente conjunto de instrucciones gira las filas restantes por otra celda y así sucesivamente. Después de la última rotación, tenemos algunas instrucciones más que podemos ignorar y luego terminamos con la instrucción incompleta:

/\\\B/\\

Las instrucciones incompletas al final simplemente se ignoran y el programa finaliza.

Martin Ender
fuente

Buena esa. Ayer experimenté un poco con una idea diferente. Quería sustituir cada personaje en cada línea. Algo así como A->B, B->C... Pero no funcionó del todo. Quitar el primer carácter y agregarlo al final es definitivamente un enfoque mucho mejor.

Jakube

@Jakube Intenté eso también pero no llegué a ninguna parte. También es muy difícil evitar estropear las instrucciones posteriores.

Martin Ender

1

124 bytes: goo.gl/efSLKQ Esta es solo su solución, pero he logrado agregar algunas sustituciones adicionales, por lo que solo necesita escribir el alfabeto una vez. Usé la misma estrategia en un problema similar también.

Jakube

1

122: goo.gl/zRsBbR

Jakube

11

Jalea , 7 bytes

ØAṙJṢj⁷

Pruébalo en línea!

Cómo 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
fuente

11

Emacs, 47 bytes

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

Dónde ^P significa "Control P", etc. Eso es 47 bytes, ya que las teclas F3 y F4 requieren dos bytes ASCII.

Después de ingresar la entrada inicial, define una macro de teclado para duplicar la línea y mover el primer carácter al final. Luego ejecuta la macro otras 24 veces.

MattBlissett
fuente

2

Bienvenido a PPCG, buena respuesta! Es muy raro ver una respuesta de Emacs, ni siquiera sé si ya se ha publicado una respuesta de Emacs.

TuxCrafting

10

JavaScript (ES6), 56 bytes

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

Sí, es cierto, la mitad de mi código es el literal de la cadena del alfabeto. Lo mejor que podría hacer sin el literal es 81 bytes:

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

Si desea un programa en lugar de una función, elimine _=>y envuelva console.log()por un costo de 10 bytes.

Neil
fuente

Woah, bien hecho. Una solución muy elegante. ¿Como funciona?

Polyducks

2

@Polyducks Montones y montones de magia regexp. Naturalmente /./gcoincide con cada letra de la cadena del alfabeto suministrada. En la cadena de reemplazo, $&representa la coincidencia misma, $'la parte de la cadena después de la coincidencia y $`la parte de la cadena antes de la coincidencia. $`$&$'por lo tanto, representaría la cadena original, pero, por supuesto, es trivial mover la parte después del partido al comienzo, proporcionando así el efecto de rotación.

Neil

¡Muy inteligente! ¡Bien hecho @Neil!

Polyducks el

9

Mathematica 68 61 bytes

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

Gracias a...

@MartinEnder (7 bytes)

martín
fuente

Además, Arraypodría ser más corto que el mapeo sobre a Range.

Martin Ender

Acabo de comprobar y de Arrayhecho guarda un byte, pero luego puedes guardar otro evitando Column: Array[{"A"~CharacterRange~"Z"~RotateLeft~#,"\n"}&,26,0]<>""(solo tendrás que reemplazarlo \ncon un salto de línea real).

Martin Ender

77

Espera no incorporado? Imposible

MC ΔT

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

Obtiene el alfabeto con map(chr,range(65,91)), luego aplica manualmente la operación de cambio de cadena.

¡Gracias a @LeakyNun y @TheBikingViking por -4 bytes!

¡Gracias a @xnor por -3 bytes!

Cobre
fuente

2

Al parecer a="ABCDEFGHIJKLMNOPQRSTUVWXYZ"es más corto.

Leaky Nun

1

Puedes hacer en a[1:]lugar de a[1:26].

TheBikingViking

2

Tu ciclo se puede hacer como for x in s:print s;s=s[1:]+x.

xnor

3

Usted puede hacer un byte más corto que codificar el alfabeto: s='%c'*26%tuple(range(65,91)).

xnor

9

C, 88 64 bytes

Llamar f()sin argumentos.

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

Pruébalo con ideone .

owacoder
fuente

9

Piet , 247 bytes / 190 codeles

Pruébalo en línea!

Entonces, esto tomó mucho más tiempo de lo que había anticipado, y tengo algunas ideas sobre otros enfoques más eficientes (más aptos para la pila), pero finalmente conseguí que funcionara el problema (y solucioné un error de interpretación y agregué características IDE a lo largo del proceso). manera), así que aquí está. Apenas el lenguaje más eficiente en bytes, pero muy divertido. Aquí hay una vista más grande y un rastro que muestra el camino tomado. Historia en mi GitHub .

Como lenguaje basado en la pila, es demasiado complicado explicarlo brevemente, pero aquí hay una descripción básica de lo que hacen las diferentes secciones / bucles. Todos los nombres de variables y funciones son solo para explicación, ya que no hay variables o funciones en Piet.

Inicialización (superior izquierda): comienza line_counteren 27, carga '@' como cur_letter, se establece letter_counten 27
Bucle principal (comenzando en púrpura oscuro, centro superior)
- Decrementos letter_counter
- Se ramifica a reset_linecero (bloque cian claro de 2 bloques)
- Rollos cur_lettera la cima de la pila
- Se ramifica a check_doneif cur_letter > 'X'(verde azulado / bloque rojo, lado derecho)
- Aumenta cur_lettery genera (esquina inferior derecha)
- Se ramifica a reset_letterif cur_letter > 'Y'(bloque verde claro, izquierda)
- Rolls `letter_counter_ de regreso a la parte superior de la pila, de regreso a la parte superior del bucle
reset_line rama (gran cuadrado rosa):
- Salida de caracteres de nueva línea
- Restablece letter_counta 27
- Continúa de vuelta al principio del bucle principal
check_done rama (mitad derecha dentro)
- Rollos line_counterhacia arriba
- Ramas para terminar si cero
- Disminuye line_countery regresa al fondo de la pila
- Se reanuda donde lo dejó, imprimiendo la carta
reset_line rama (lado izquierdo, bloque verde):
- Restablece cur_lettera '@'
- Se reanuda donde lo dejó, girando / volviendo a la parte superior del bucle

cincodenada
fuente

8

MATL , 8 bytes

Gracias a @Dennis , quien sugirió que MATL debería incorporar indexación modular, y a @Suever , quien tuvo la idea de operaciones automáticas por pares.

1Y2t&+Q)

Pruébalo en línea!

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
fuente

8

Javascript, 113 96 91 76 bytes

Una versión súper corta para ejecutar en la consola:

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

Expandir fragmento

Javascript / HTML, 140 123 118 105 bytes

Una versión más bonita, con una salida HTML que facilita que OP copie y pegue:

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

Expandir fragmento

(EDITAR: debería haber usado la cadena AZ en lugar de generarla)

(EDITAR 2: Gracias a @Neil y @DanTheMan por sus comentarios (ver comentarios))

Polyducks
fuente

¿No es irrelevante el primer C = 26?

DanTheMan

Oh chasquido Parece que olvidé eliminarlo cuando lo moví a para. ¡Fijo! Gracias @DanTheMan :)

Polyducks

1

l.slice(0,1)es justo l[0], mientras que ,27es innecesario, en cuyo punto puede mover el corte y terminar con l.slice(1)+l[0]. También creo que puede mover el console.logcuerpo del bucle para evitar el arrastre ;.

Neil

Probando esto ahora, ¡gracias @Neil! EDITAR: dulce santo moly. Gracias a los dos, los agregaré al crédito en el comentario.

Polyducks

1

Oh, bien, esa es una forma aún mejor de simplificar el console.log.

Neil

8

PowerShell, 44 bytes

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

Joey
fuente

8

R, 47 42 41 bytes

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

Pruébalo en línea!

Genera 27 alfabetas, elimina las letras 27 e imprime en 26 columnas.

Mejora inspirada en la solución de @Giuseppe .

Robert Hacken
fuente

1

46 bytes

Giuseppe

Wow, pensé que había probado todos los trucos de indexación, ¡ reppero esto fue particularmente inspirado! Muy agradable. Votaría de nuevo si pudiera.

Giuseppe

puedes usar en 1lugar de ""para stdout.

Giuseppe

6

Sesos , 27 25 bytes

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

Pruébalo en línea! Verifique la depuración para ver el código SBIN generado. ^†

Asamblea Sesos

El archivo binario anterior se ha generado al ensamblar el siguiente 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)

Cómo funciona

Comenzamos inicializando la cinta a ABCDEFGHIJKLMNOPQRSTUVWXYZ. Esto es lo siguiente.

Escriba 26 en una celda, dejando la cinta en el siguiente 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

Siempre que la celda debajo del encabezado de datos no sea cero, hacemos lo siguiente.

Copiar el número a las dos celdas a la izquierda y añadir 64 a la copia más a la izquierda.

                                                   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

Mueva la copia más a la izquierda a la ubicación original, luego reste 1 de la copia más a la derecha.

                                                     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

El proceso se detiene después de 26 iteraciones, ya que la copia más a la derecha es 0 para entonces. Movimos una celda a la derecha, por lo que el estado final de la cinta después de la inicialización es el siguiente.

     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

Ahora estamos listos para generar la salida, repitiendo el siguiente proceso hasta que la celda debajo del encabezado de datos sea cero.

Primero, imprimimos el carácter debajo del encabezado de datos y nos movemos hacia la derecha, repitiendo este paso hasta encontrar una celda con valor 0 . Después de imprimir ABCDEFGHIJKLMNOPQRSTUVWXYZ, la cinta se ve de la siguiente manera.

                                                                                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

Ahora movemos el cabezal de datos 27 unidades hacia la izquierda (de vuelta al 0 inicial ) y repetimos la combinación de impresión-movimiento hasta que se encuentre una celda con valor 0 . Esto no imprime nada y deja la cinta de la siguiente manera.

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

Ahora, escribimos 10 en la celda actual, imprimimos el carácter correspondiente (salto de línea) y ponemos a cero la celda con una llamada a una getentrada vacía, dejando la cinta sin cambios.

Después, movemos el contenido de la celda a la derecha a la celda actual, luego movemos el cabezal de datos a las unidades a la derecha.

      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

La siguiente iteración es ligeramente diferente. Se imprime el primer paso de impresión BCDEFGHIJKLMNOPQRSTUVWXYZ, dejando la cinta de la siguiente manera.

                                                                                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

Ahora movemos el cabezal de datos 27 unidades hacia la izquierda.

 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

El siguiente ciclo de impresión imprime Ay deja la cinta de la siguiente manera.

   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

Una vez más, imprimimos un salto de línea, movemos el contenido de la celda a la derecha a la celda actual, luego movemos el cabezal de datos a las unidades a la derecha.

         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

Después de 24 iteraciones más, el paso final de mover el cabezal de datos a la derecha deja la cinta en el siguiente 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

La celda debajo del encabezado de datos ahora es 0 y el programa termina.

^† TIO utiliza una versión más reciente de Sesos, que es compatible con versiones anteriores para SASM, pero genera un código SBIN más corto.

Dennis
fuente

6

Haskell, 56 53 52 Bytes

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

misma longitud: (utilizando una sugerencia de @AndersKaseorg)

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

para hacer cosas modulares, debe importar Data.Char para obtener la función chr, 74 59 58 Bytes fue lo mejor que pude obtener con eso: (gracias a @nimi por sugerir la función toEnum)

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

Esto probablemente podría ser mucho más corto, pero no conozco ningún truco de golf de Haskell.

usó mapM en lugar de mapM_ (vea el comentario de @ Lynn)

KarlKastor
fuente

1

Para −3 bytes, cambie ['A'..x]a ['A'..'Z'], que ahora se usa dos veces, y eleve eso a una definición.

Anders Kaseorg

@AndersKaseorg: ¡Gracias! Sin embargo, tuve otra idea que ahorró el mismo número de bytes mientras lo mantenía en línea. Sin embargo, agregué tu sugerencia a la solución alternativa.

KarlKastor

Si solo necesita chrde Data.Char, puede usar toEnumen su lugar y omitir el import.

nimi

1

Siento que cambiar mapM_a mapMdebería estar bien. Tal vez esto valga una meta publicación ...

Lynn

6

R, 53 bytes

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

Aquí está en un intérprete en línea .

plannapus
fuente

5

Retina, 36 31 bytes

5 bytes gracias a Martin Ender.

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

El avance de línea principal es significativo.

Pruébalo en línea!

Créditos .

Monja permeable
fuente

5

Brain-Flak , 222 bytes

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

Pruébalo en línea!

Soy nuevo en Brain-Flak, así que tal vez esto se pueda jugar mucho, pero al menos es un primer intento. Almacena 27 alfabetos completos en la pila izquierda, luego mueve los alfabetos hacia la derecha y reemplaza cada letra 27 por una nueva línea.

Mi código fuente es un poco confuso, pero lo agregaré de todos modos.

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

dorio
fuente

5

V , 36 , 10 bytes

¬AZ25ñÙx$p

Pruébalo en línea!

Esto usa la codificación "Latin1".

Explicación:

¬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
fuente

Ve y agrégalo entonces;)

Conor O'Brien el

@ CᴏɴᴏʀO'Bʀɪᴇɴ Debería saber a estas alturas que la única forma de hacer algo en este idioma es a paso de tortuga. Probablemente lo tenga en funcionamiento en algún momento del próximo enero. : P

DJMcMayhem

Oh, en las próximas 6-8 semanas?

Conor O'Brien

4

C #, 98 bytes

He tratado de ver si puedo generar las letras más cortas que solo inicializarlas como una cadena, pero en realidad no es posible. Las letras son de 26 bytes y este fragmento solo

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

es de 25 bytes. Creo que inicializarlos y luego agregarlos con a + = a es una buena solución, pero con C # está limitado por el recuento de funciones como Substring()y Console.WriteLine().

Mi intento en 98 bytes:

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

Daniel
fuente

4

Octava, 27 bytes

Estamos agregando una fila y un vector de columna, y Octave expande muy bien las dimensiones del esqueleto, no es necesario bsxfun(como lo haría en Matlab).

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

falla
fuente

4

q, 20 bytes

(til 26)rotate\:.Q.A

skeevey
fuente

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
fuente

Puede eliminar fácilmente algunos bytes más: System.out.printf("%c", ...)-> System.out.write(...), '\n'-> 10, 'A'-> 65. Tenga en cuenta que la sugerencia de caracteres de salto de línea / línea nueva está permitida, pero es un requisito de salida ideone . :)

MH.

@MH. buenos consejos! guardado 9 bytes :)

Master_ex

Sé que ha pasado más de un año desde que respondiste esto, pero aún puedes jugar al golf algunas cosas: el espacio en String[]ase puede quitar; y int s=0;while(s<26){p(s,26);p(0,s++);p(-1,0);}puede 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

Creo un alfabeto completo A, luego imprimo 26 versiones rotadas tomando los caracteres que comienzan en ny agregando las posiciones anteriores n.

Toby Speight
fuente

4

Perl, 42 bytes

Crédito total a @Dom Hastings por esto.

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

O (mismo recuento de bytes):

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

Necesita -M5.010o -Eejecutarse, por ejemplo:

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

Mi vieja respuesta (55 bytes):

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

Necesito -M5.010correr. Entonces corre con:

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

Sin embargo, probablemente sea posible hacerlo más corto, pero no descubrí cómo ... todavía

Dada
fuente

Se las arregló para encontrar un par de soluciones de 42 bytes: @l=A..Z;say@l[$_..25],@l[0..$_-1]for 0..25y $_=join"",A..Z;eval'say;/./;$_=$\'.$&;'x26ambas requieren -E/ -M5.010.

Dom Hastings

Bien hecho. ¡Se ve mucho mejor que mi intento! gracias

Dada

Imprima una Tabula Recta!

Imprima una Tabula Recta!

Reglas / requisitos

Puntuación

Envíos

Tabla de clasificación

Respuestas:

05AB1E , 6 5 bytes

Vim, 25 23 bytes

Python 2, 59 57 53 bytes

/// , 220 bytes

C, 47 bytes

J, 15 bytes

/// , 128 bytes

Explicación

Jalea , 7 bytes

Cómo funciona

Emacs, 47 bytes

JavaScript (ES6), 56 bytes

Mathematica 68 61 bytes

Python 2, 75 65 61 58 bytes

C, 88 64 bytes

Piet , 247 bytes / 190 codeles

MATL , 8 bytes

Javascript, 113 96 91 76 bytes

Javascript / HTML, 140 123 118 105 bytes

PowerShell, 44 bytes

R, 47 42 41 bytes

Sesos , 27 25 bytes

Asamblea Sesos

Cómo funciona

Haskell, 56 53 52 Bytes

R, 53 bytes

Retina, 36 31 bytes

Brain-Flak , 222 bytes

V , 36 , 10 bytes

C #, 98 bytes

Octava, 27 bytes

q, 20 bytes

Java, 190 176 172 163 bytes

Bash, 66 bytes

Perl, 42 bytes