Tarea

Su tarea es imprimir este texto exacto:

A
BCD
EFGHI
JKLMNOP
QRSTUVWXY
ZABCDEFGHIJ
KLMNOPQRSTUVW
XYZABCDEFGHIJKL
MNOPQRSTUVWXYZABC
DEFGHIJKLMNOPQRSTUV
WXYZABCDEFGHIJKLMNOPQ
RSTUVWXYZABCDEFGHIJKLMN
OPQRSTUVWXYZABCDEFGHIJKLM
NOPQRSTUVWXYZABCDEFGHIJKLMN
OPQRSTUVWXYZABCDEFGHIJKLMNOPQ
RSTUVWXYZABCDEFGHIJKLMNOPQRSTUV
WXYZABCDEFGHIJKLMNOPQRSTUVWXYZABC
DEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKL
MNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVW
XYZABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJ
KLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXY
ZABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOP
QRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHI
JKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZABCD
EFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZA
BCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZ

Especificaciones

• Puede hacerlo en minúsculas en lugar de mayúsculas.
• Se permiten líneas nuevas al final del triángulo.
• Se permiten espacios finales después de cada línea.
• Debe imprimir en STDOUT en lugar de generar una matriz de cadenas.

Tanteo

Este es el código de golf . Programa con el menor recuento de bytes gana.

Vim, 29 bytes

:h<_↵↵↵y$ZZ26P0qqa↵♥βjllq25@q

Donde ↵representa la tecla Retorno, ♥la tecla Escape y βla tecla Retroceso.

Python 2, 65 bytes

i=1
a=bytearray(range(65,91))*26
while a:print a[:i];a=a[i:];i+=2

Jalea , 10 bytes

26RḤ’RØAṁY

Pruébalo en línea!

Cómo funciona

26RḤ’RØAṁY  Main link. No Arguments.

26          Set the return value to 26.
  R         Range; yield [1, 2, ..., 25, 26].
   Ḥ        Unhalve; yield [2, 4, ..., 50, 52].
    ’       Decrement; yield [1, 3, ..., 49, 51].
     R      Range; yield [[1], [1, 2, 3], ..., [1, ..., 49], [1, ..., 51]].
      ØA    Yield the uppercase alphabet.
        ṁ   Mold the alphabet as the array of ranges. This repeats the uppercase
            letters over an over again, until all integers in the range arrays
            have been replaced with letters.
         Y  Join, separating by linefeeds.

VBA Excel (80 bytes, 1742 bytes)

Excel, 1742 bytes

Inspirado por la respuesta creativa de la ugoren , logré encontrar una fórmula de Excel para crear el patrón como se muestra en el OP.

=MID(REPT("ABCDEFGHIJKLMNOPQRSTUVWXYZ",26),(ROW()-1)^2+1,2*ROW()-1)

Pegue esta fórmula en la celda A1, luego arrastre por todo el rango A1: A26.

La longitud de la fórmula es de 67 bytes, pero debe replicarla 26 veces, por lo que es igual a 67 * 26 = 1742 bytes. Aquí está la salida:

Excel VBA, 80 bytes

Ahora es posible que integremos Excel con VBA para automatizar el proceso y guardar muchos bytes, ya que VBA está integrado en la mayoría de las aplicaciones de Microsoft Office, incluido Excel. Escriba y ejecute el siguiente código en la ventana Inmediato (use las teclas de combinación CTRL+ Gpara mostrarlo en el Editor de Visual Basic):

[A1:A26]="=MID(REPT(""ABCDEFGHIJKLMNOPQRSTUVWXYZ"",26),(ROW()-1)^2+1,2*ROW()-1)"

El programa funciona imprimiendo la fórmula de Excel anterior en el rango A1: A26. Desafortunadamente, tanto Excel como VBA no tienen un alfabeto incorporado.

Haskell, 67 bytes

_#53=[]
s#i=take i s:drop i s#(i+2)
mapM putStrLn$cycle['A'..'Z']#1

Una recursión simple a lo largo ide la línea. En cada paso, los siguientes icaracteres se toman de una repetición infinita del alfabeto.

Mathematica, 90 bytes

StringRiffle[Flatten[Alphabet[]&~Array~26]~Internal`PartitionRagged~Range[1,51,2],"
",""]&

Función anónima. No realiza ninguna entrada y devuelve una cadena como salida. Sugerencias de golf bienvenidas. Un ejemplo de lo que Internal`PartitionRaggedhace:

In[1]:= Internal`PartitionRagged[{2, 3, 5, 7, 11, 13}, {2, 3, 1}]               

Out[1]= {{2, 3}, {5, 7, 11}, {13}}

C, 79 bytes

main(i,j){for(i=0,j=1;i<676;i++){putchar(i%26+65);if(j*j==i+1){puts("");j++;}}}

Mi primera respuesta en C \ o /

Las sugerencias de golf son más que bienvenidas.

Brachylog , 37 bytes

26~l<:1aLc~j[@A:I],L~@nw
=:2%1,.#@l?,

Pruébalo en línea!

Explicación

• Predicado principal:

  26~l         Let there be a list of 26 elements
  <            This list is an ascending list of integers
  :1aL         Apply predicate 1 to that list ; the resulting list of strings is L
  c            Concatenate the list of strings into one big string
  ~j[@A:I],    That big string is the result of juxataposing the alphabet I times to itself
  L~@n         Create a string which when splitted on line breaks results in L
  w            Write that string to STDOUT
  

• Predicado 1: se utiliza para generar cadenas variables de longitudes impares.

  =            Assign a value to the Input
  :2%1,        That value must be odd
  .#@l?,       Output is a string of length Input
  

Pyth , 12 bytes

jtc*G26*Rd26

Pruébalo en línea!

JavaScript (ES6), 77 82 88

Se requiere EcmaScript 6 solo para guardar 1 byte usando un literal de cadena de plantilla para nueva línea.

for(i=r=l=o='';l+52;r++||(r=l-=2,o+=`
`))o+=(i++%26+10).toString(36);alert(o)

Menos golf

for(i = r = l = o = '';
    l + 52;
    r++ || (r = l -= 2, o += `\n`))
  o += (i++ % 26 + 10).toString(36);
alert(o);

Prueba

for(i=r=l=o='';l+52;r++||(r=l-=2,o+=`
`))o+=(i++%26+10).toString(36);alert(o)

Perl, 42 41 39 bytes

perl -E '@b=(A..Z)x26;say splice@b,0,$#a+=2for@b'

Solo el código:

@b=(A..Z)x26;say splice@b,0,$#a+=2for@b

Desafortunadamente, una versión obvia más corta desencadena un problema interno de perl (uso del valor liberado en la iteración):

say splice@b,0,$#a+=2for@b=(A..Z)x26

JavaScript, 129 bytes

z=1,i=0,g=a=>{b=0,c="";while(a+a-1>b){c+='ABCDEFGHIJKLMNOPQRSTUVWXYZ'.split``[i>26?i=0:i++];b++}console.log(c)};while(z<26)g(z++)

Pyke, 14 bytes

G26*WDoh<
Ko>D

Pruébalo aquí!

Go, 133 bytes

package main
import S "strings"
func main(){s:=S.Repeat("ABCDEFGHIJKLMNOPQRSTUVXXYZ",26)
for i:=1;s!="";i+=2{println(s[:i]);s=s[i:]}}

MATLAB, 112109 95 79 77 bytes

Esto también funcionará con Octave , puedes probar en línea aquí .

a=['' 65:90 65:90]';j=0;for i=1:2:52;b=circshift(a,j);j=j-i;disp(b(1:i)');end

Entonces, después de algunos cambios importantes, he guardado otros 14 32 bytes. Este se está pareciendo mucho más a la longitud que hubiera esperado de MATLAB. Dejé la versión anterior a continuación, ya que es sustancialmente diferente.

a=['' 65:90 65:90]';        %Create 2 copies of the upper case alphabet
j=0;                        %Initialise cumulative sum
for i=1:2:52;               %For each line length
    b=circshift(a,j);       %Rotate the alphabet string by the cumulative offset
    j=j-i;                  %Update cumulative negative sum of offsets.
    disp(
         b(1:i)'            %Extract first 'line length' characters from rotated alphabet.
               );           %Display next line (disp adds newline automatically)
end

Versión original:

a=['' repmat(65:90,1,26)];c=cumsum(1:2:51);disp(cell2mat(arrayfun(@(s,f)[a(s:f) 10],[1,c(1:25)+1],c,'Un',0)))

Wow, ese terminó siendo más largo de lo que pensaba. Veré si no puedo eliminar algunos bytes.

Una versión no golfista para explicar:

a=['' repmat(65:90,1,26)]; %Create 26 copies of the upper case alphabet
c=cumsum(1:2:51);          %Calculate the end index of each row in the above array, by cumulatively summing the length of each line
disp(
     cell2mat(
              arrayfun(@(s,f)
                             [a(s:f) 10], %Extract the part of the alphabet and insert a new line.
                                         [1,c(1:25)+1],c, %start index is the previous end of line plus 1. End index is as calculated by cumsum.
                       'Un',0 %The returned values are not all the same length
                       )   %Do this for each line
              )            %Convert back to a matrix now new lines inserted
     )                     %And display it

Expresiones de gratitud

• 3 bytes guardados - gracias @LuisMendo

XPath 3.0 (y XQuery 3.0), 84 bytes

codepoints-to-string((0 to 25)!(subsequence(((1 to 26)!(65 to 90)),.*.+1,2*.+1),10))

Explicación:

(1 to 26)!(65 to 90) es el alfabeto 26 veces

(0 to 25)!(subsequence(XX, start, len),10) toma 26 subsecuencias de esto, cada una seguida de nueva línea

subsequence(X, .*.+1, 2*.+1) toma subsecuencias sucesivas con posición de inicio y longitud: (1, 1), (2, 3), (5, 5), (10, 9) etc.

codepoints-to-string() convierte los puntos de código Unicode en caracteres

Ruby, 46 bytes

26.times{|i|puts ([*?A..?Z]*26)[i*i,i*2+1]*""}

Véalo en ideone: http://ideone.com/3hGLB0

05AB1E (alternativo) 15 bytes

A2×52µ¼D¾£,¾¼FÀ

Pruébalo en línea!

Explicación:

A2×              # push a string containing a-za-z
   52µ           # Loop the rest of the program until counter = 52
      ¼          # increment counter (it's 0 initially)
       D         # Duplicate the alpha string on the stack
        ¾£       # Replace alpha with alpha[0..counter]
          ,      # Pop the substring and print it
           ¾¼FÀ  # rotate the alpha string left counter++ times.

R, 120 115 111 bytes

v=c();for(i in 1:26){v=c(v,c(rep(LETTERS,26)[(sum((b=seq(1,51,2))[1:i-1])+1):sum(b[1:i])],"\n"))};cat(v,sep="")

Sin golf:

a=rep(LETTERS,26)
b=seq(1,51,2)
v=vector()

for(i in 1:26)
    {
    v=c(v,c(a[(sum(b[1:i-1])+1):sum(b[1:i])],"\n"))
    }

cat(v,sep="")

Básicamente, bes el vector de los números impares entre 1y 51, dando así la longitud de cada línea. Obviamente, la sumfunción suma los números de este vector y proporciona los índices inicial y final.

-5 bytes gracias a @plannapus!
-4 bytes gracias a @plannapus!

R, 81 73 65 63 bytes

Un forenfoque de bucle simple . Repite el alfabeto 26 veces y recorre un rango de índice deslizante que se calcula usando (i^2-2*i+2):i^2.

for(i in 1:26)cat(rep(LETTERS,26)[(i^2-2*i+2):i^2],"\n",sep="")

Casco , 10 bytes

Cİ1ṠṁK…"AZ

Pruébalo en línea!

Explicación

Cİ1ṠṁK…"AZ
      …"AZ    Get the alphabet
   ṠṁK        Replace each letter with the whole alphabet
C             Cut the resulting string into lines with lengths
 İ1            equal to the list of odd numbers

Lote, 123 bytes

@set s=
@for /l %%i in (1,2,51)do @call set s=%%s%%ABCDEFGHIJKLMNOPQRSTUVWXYZ&call echo %%s:~0,%%i%%&call set s=%%s:~%%i%%

05AB1E , 18 17 bytes

26FA26×N>n£NnF¦},

Explicación

26F                 # for N in range(0, 26) do
   A26×             # the alphabet repeated 26 times
       N>n£         # take (N+1)^2 letters
           NnF¦}    # throw away the first N^2 letters
                ,   # print with newline

Pruébalo en línea!

Rexx 74 72 bytes

i=1;m=1;do 26;say substr(copies(xrange('A','Z'),26),i,m);i=i+m;m=m+2;end

Sin golf:

i=1
m=1
do 26
  say substr(copies(xrange('A','Z'),26),i,m)
  i=i+m
  m=m+2
end

TSQL, 129 bytes

USE MASTER al comienzo de la secuencia de comandos es para garantizar que la consulta se ejecute en la base de datos maestra, que es predeterminada para muchos usuarios (sin contar bytes para eso).

Golfizado:

USE MASTER

SELECT SUBSTRING(REPLICATE('ABCDEFGHIJKLMNOPQRSTUVWXYZ',26),number*number+1,number*2+1)FROM spt_values WHERE number<26and'P'=type

Sin golf:

USE MASTER

SELECT SUBSTRING(REPLICATE('ABCDEFGHIJKLMNOPQRSTUVWXYZ',26),number*number+1,number*2+1)
FROM spt_values
WHERE number<26and'P'=type

Violín

Fiddle para versiones anteriores usando la ruta xml

PowerShell, 68 bytes

$a=-join(65..90|%{[char]$_})*26;26..1|%{$a=$a.Insert($_*$_,"`n")};$a

La sección anterior al primer punto y coma produce una cadena que contiene 26 copias del alfabeto en mayúsculas. La siguiente sección inyecta saltos de línea en el índice de cada número cuadrado (trabajando hacia atrás para no tener que dar cuenta del desplazamiento). Finalmente, $aal final solo inserta esa variable de cadena en el equivalente de PowerShell STDOUT.

Dyalog APL, 18 bytes

↑2{⍺↓⍵⍴⎕a}/×⍨0,⍳26

C, 60 bytes

i;main(j){for(;j<27;j*j^++i||puts("",j++))putchar(i%26+65);}

C ++, 111 bytes

void a(){int c=65,i,j;for(i=0;i<26;i++){for(j=0;j<=2*i;j++){std::cout<<(char)c;c++;if(c==91)c=65;}std::cout<<'\n';}}

Primero intente con uno de estos. Utiliza una int "c" para registrar qué letra necesita imprimir en un momento dado. Una vez que "c" pasa 90 ('Z') se restablece a 65 ('A'). Imprime la pirámide con bucles.

PHP, 76 69 bytes

for(;$i<26&&$a.=join(range(A,Z));)echo substr($a,$i**2,1+2*$i++)."
";

• Cree 26 alfabeto (más que suficiente) y contacte con ellos en $ a
• bucle para i <26
• mostrar $ a subcadena inicio i ^ 2, fin 2 * i + 1