Dada una letra del alfabeto inglés, su tarea es construir un alfabeto semi-diagonal a la entrada.

¿Cómo construir un alfabeto semi-diagonal?

Descripción breve : Primero, toma la posición de la letra en el alfabeto, P( Pestá indexada aquí 1). Luego, imprime cada letra hasta la entrada (inclusive) en una línea, precedida por P-1y repite esa letra Pveces, intercalando con espacios.

Ejemplos :

• Dado F, su programa debería generar:

  UNA 
   cama y desayuno 
    CCC 
     DDDD 
      EEEEE 
       FFFFFF 
  

• Dado K, su programa debería generar:

  UNA
   cama y desayuno 
    CCC 
     DDDD 
      EEEEE 
       FFFFFF 
        GGGGGGG 
         HHHHHHHH 
          IIIIIIIII 
           JJJJJJJJJJ 
            KKKKKKKKKKK 
  

• Dado A, su programa debería generar:

  A
  

Reglas

• Puede elegir caracteres en minúsculas o mayúsculas, pero eso debería ser coherente.

• Puede tener espacios extraños de la siguiente manera:

  • Un espacio inicial consistente (en cada línea).
  • Una (s) línea (s) nueva o final.
  • Espacios finales.

• La entrada y la salida se pueden tomar por cualquier medio estándar y se aplican las lagunas predeterminadas.

• En su lugar, se le permite generar una lista de líneas, siempre que también proporcione la versión ascii-art .

• Este es el código de golf , por lo que gana el código más corto en bytes.

^{Inspirado en este desafío .}

Python 3 , 59 bytes

lambda l:[' '*i+'%c '%(i+65)*-~i for i in range(ord(l)-64)]

Pruébalo en línea!

Python 3 , 61 bytes

lambda l:[' '*i+-~i*(chr(i+65)+' ')for i in range(ord(l)-64)]

Pruébalo en línea! (enlace a la versión bonita)

Python 2 , 63 61 59 bytes

-2 bytes gracias a Rod. -2 bytes gracias a Felipe Nardi Batista.

i=1
exec"print' '*i+'%c '%(i+64)*i;i+=1;"*(ord(input())-64)

Pruébalo en línea!

C, 89 bytes

i,j;f(l){for(i=64;i++<l&&printf("%*c ",i-64,i);puts(""))for(j=i-65;j--;)printf("%c ",i);}

Pruébalo en línea!

PowerShell , 45 42 bytes

65..$args[0]|%{" "*$i+++"$([char]$_) "*$i}

Pruébalo en línea!

Toma la entrada como un carácter literal, luego recorre las mayúsculas hasta ese punto, cada iteración antepone el número apropiado de espacios y luego el híbrido char \ space.

Guardado 3 bytes gracias a TessellatingHeckler.

JavaScript (ES6), 85 bytes

Funciona en minúsculas para entrada y salida. Emite un espacio inicial y un espacio final en cada línea.

f=(c,k=10,C=k.toString(36),r=s=>`${s} `.repeat(k-9))=>r``+r(C)+(C==c?'':`
`+f(c,k+1))

Manifestación

f=(c,k=10,C=k.toString(36),r=s=>`${s} `.repeat(k-9))=>r``+r(C)+(C==c?'':`
`+f(c,k+1))

O.innerText = f('m')

<pre id=O>

APL (Dyalog) , 26 bytes

Solicita caracteres escalares. Imprime la lista de líneas.

(∊⍴∘'',' ',¨⍨⊢⍴⊃∘⎕A)¨⍳⎕A⍳⎕

Pruébalo en línea! (tiene versión de arte ASCII en un byte adicional)

⎕ solicitud de entrada

⎕A⍳ encontrar ɩ ndex en un alfabeto

⍳ primero que muchos Ɩ ntegers

(… )¨ Aplique la siguiente función tácita a cada uno:

 ⊃∘⎕A elige la letra de la letra del argumento del alfabeto A

 ⊢⍴ cíclicamente darle forma a la longitud del argumento

 ' ',¨⍨ agregar un espacio a cada

 ⍴∘'', anteponer una cadena de longitud de argumento (rellenado con espacios)

 ∊ ϵ nlist (aplanar)

La versión de arte ASCII solo tiene una ↑a la izquierda; Mezcle la lista de cadenas en la tabla de caracteres.

Perl 5 , 31 bytes

Código de 30 bytes + 1 para -l.

print$"x$-,"$_ "x++$-for A..<>

Pruébalo en línea!

Dyalog APL, 38 bytes

{↑{(y/' '),(2×y←⎕A⍳⍵)⍴⍵,' '}¨⎕A↑⍨⎕A⍳⍵}

Pruébalo en línea!

¿Cómo?

⎕A↑⍨ - toma el alfabeto hasta

⎕A⍳⍵ - el carácter de entrada

¨ - por cada char

    ⍵,' ' - toma el char y un espacio

    (...)⍴ - remodelar a

    2×y←⎕A⍳⍵ - dos veces el índice del carácter en el alfabeto

    (y/' ') - y anteponer espacios de índice de caracteres

↑ - luego aplanar

APL (Dyalog Classic) , 26 bytes

{↑{(≠\⍵<⍳3×⍵)\⍵⊃⎕A}¨⍳⎕A⍳⍵}

Pruébalo en línea!

Explicación

                      ⍳⎕A⍳⍵  generate indexes up to position of right arg ⍵
{                   }¨       on each index apply function
   (≠\⍵<⍳3×⍵)                generate boolean mask for expansion (each line has a length 3 times its index ⍵, starting with ⍵ blanks and then alternating letter blank)
             \⍵⊃⎕A          expand character in position ⍵
 ↑                            mix result into text matrix

V , 28, 26, 25 , 23 bytes ( compitiendo )

¬A[/a
lDÓ./& ò
ò-Ûä$Û>

Pruébalo en línea!

Tenga en cuenta que aunque he estado planeando agregar ciertas características durante mucho tiempo, este desafío fue lo que me convenció para finalmente hacerlo.

La salida contiene un espacio inicial en cada línea y una nueva línea final.

Hexdump:

00000000: ac41 5b2f 1261 0a6c 44d3 2e2f 2620 f20a  .A[/.a.lD../& ..
00000010: f22d dbe4 24db 3e                        .-..$.>

Explicación:

¬A[         " Insert 'ABCDEFGHIJKLMNOPQRSTUVWXYZ['
   /        " Search for...
    <C-r>a  "   The input
l           " Move one character to the right
 D          " And delete every character after the cursor
  Ó         " Search for...
   .        "   Any character
    /       " And replace it with...
     & ò    "   That character followed by a space and a newline
ò           " Recursively...
 -          "   Move to the beginning of the next line up
  Ûä$       "   Make *line number* copies of the current line
     Û>     "   And indent this line by *line number* spaces

05AB1E , 10 bytes

A¹¡н«ðâƶāú

Pruébalo en línea!

-2 gracias a Adnan .

Añadir »para que se imprima en líneas separadas.

R, 94 88 bytes

-6 bytes gracias a Giuseppe

function(x,l=LETTERS)for(i in 1:match(x,l))cat(rep(' ',i-1),rep(paste(l[i],' '),i),'\n')}

Sin golf:

f=function(x,l=letters){
  for(i in 1:which(l==x)){
    A=paste(l[i],' ')
    cat(rep(' ',i-1),rep(A,i),'\n')
  }
}

Haskell, 52 44 bytes

f k=[[" ",s:" "]>>=(['A'..s]>>)|s<-['A'..k]]

Devuelve una lista de líneas.

Pruébalo en línea!

f k=                  -- main function is f, input parameter k
  [   |s<-['A'..k]]   -- for each s from ['A'..k]
     >>=              -- map (and collect the results in a single string) the function: 
         (['A'..s]>>) --  replace each element in ['A'..s] with
    [  ,  ]           --  over the list, containing
     " "              --   a single space to get the indent
        s:" "         --   s followed by space to get the letter sequence

Editar: @jferard: guardado tres bytes. ¡Gracias!

JavaScript (ES8), 92 bytes

c=>(g=n=>n>9?[...g(n-1),`${n.toString(36)} `.repeat(n-=9).padStart(n*3)]:[])(parseInt(c,36))

Utiliza letras minúsculas. Las líneas tienen un espacio inicial y uno posterior. Devuelve una matriz de líneas.

Fragmento de prueba

let f=

c=>(g=n=>n>9?[...g(n-1),`${n.toString(36)} `.repeat(n-=9).padStart(n*3)]:[])(parseInt(c,36))

;O.innerText=f("k").join`\n`

<pre id=O></pre>

Casco , 13 bytes

z+ḣ∞øzRNC1…'A

Toma un carácter entre comillas simples como argumento de línea de comando, imprime el resultado en STDOUT. Pruébalo en línea!

Explicación

Estoy explotando la forma en que Husk imprime listas de listas de cadenas: unir listas internas con espacios y listas externas con nuevas líneas.

z+ḣ∞øzRNC1…'A  Implicit input, say 'C'
          …'A  Range from A: "ABC"
        C1     Cut into strings of length 1: ["A","B","C"]
     z N       Zip with positive integers
      R        using repetition: x = [["A"],["B","B"],["C","C","C"]]
   ∞ø          The empty string repeated infinitely: ["","","",...
  ḣ            Prefixes: [[],[""],["",""],["","",""],...
z+             Zip with x using concatenation: [["A"],["","B","B"],["","","C","C","C"]]
               Implicitly join each inner list with spaces, join the resulting strings with newlines and print.

05AB1E , 15 14 13 bytes

Guardado 1 byte gracias a Adnan

A¹¡н«ƶ€S»¶¡āú»

Pruébalo en línea! o la versión de arte Ascii

Explicación

A                # push lowercase alphabet
 ¹¡              # split at input
   н             # get the first part
    «            # append the input
     ƶ           # repeat each a number of times corresponding to its 1-based index
      €S         # split each to a list of chars
        »        # join on spaces and newlines
         ¶¡      # split on newlines
           āú    # prepend spaces to each corresponding to its 1-based index
             »   # join on newlines

APL (Dyalog Unicode) , ^{SBCS de} 22 bytes

⍕⍪⊢∘⊂\2,.↑⍉⍴⍨⌸⎕a↑⍨⎕a⍳⍞

Pruébalo en línea!

Usos ⎕io←1. Imprime un espacio principal, que está permitido.

QBasic, 79 74 72 bytes

Gracias a Taylor Scott por el ahorro de bytes (¡dos veces!)

FOR i=1TO ASC(INPUT$(1))-64
?TAB(i)
FOR j=1TO i
?CHR$(64+i)" ";
NEXT j,i

Utiliza mayúsculas. La entrada es presionando una tecla y no se repite en la pantalla.

Explicación

Hacemos un bucle idesde 1hasta la posición de la letra límite en el alfabeto (basado en 1). Para cada uno i, nos movemos a la columna ide la pantalla usando TAB; luego, iveces, imprimimos la iletra del alfabeto seguida de un espacio.

Japt -R , 24 23 17 15 bytes

Emite una matriz, incluye una nueva línea principal y un espacio inicial y final en cada línea.

IòUc ÏçSiXd¹iYç

Pruébalo

• 1 byte guardado con la ayuda de Oliver y otros 6 gracias a él señalando una mejor manera de generar la matriz inicial.

Carbón , 18 bytes

Ｆ⁺⌕αθ¹«Ｐ×⁺§αι ⁺ι¹↘

Pruébalo en línea!

Braingolf , 65 bytes

a#a-# 7-,-~vc<!?>[$_]:$_|&,(.#a-!?.>[# M]1+>[.M# M]:$_!@|v#
&@R);

Pruébalo en línea!

Minúscula

Contiene 1 espacio final en cada línea y una nueva línea final al final de la salida.

C # (.NET Core) , 103 bytes

n=>{var i='`';var l="";for(;i<n;l+='\n'){l+="".PadLeft(i++-96);for(int s=96;s++<i;)l+=i+" ";}return l;}

Pruébalo en línea!

JavaScript, 102 94 bytes

2 bytes guardados gracias a Neil

f=
a=>[...Array(parseInt(a,36)-9)].map((a,b)=>''.padEnd(b).padEnd(b*3+1,(b+10).toString(36)+' '))

console.log(f('k').join`\n`)

Retina , 51 bytes

^.
$&$&
}T`L`_L`^.
.
$.`$* $&$.`$* ¶
+`(\w) \B
$&$1

Pruébalo en línea! Explicación:

^.
$&$&

Duplicar la (primera) letra.

}T`L`_L`^.

Gírelo de nuevo 1 en el alfabeto o elimínelo si es un duplicado A. Siga duplicando y girando hasta que dupliquemos A, momento en el cual la eliminación deshace la duplicación y el ciclo se completa.

.
$.`$* $&$.`$* ¶

Reemplace cada letra con una línea con la letra acolchada en ambos lados.

+`(\w) \B
$&$1

Inserte letras duplicadas entre todos los pares de espacios de relleno a la derecha de las letras existentes.

Haskell , 57 bytes

x!'@'=x
x!e=([e]:[' ':r++' ':[last r]|r<-x])!pred e
([]!)

Pruébalo en línea!

Carbón de leña , 15 bytes

Ｆ…·AＳ«Ｐ⪫Ｅ…@ιι ↘

Pruébalo en línea! El enlace es a la versión detallada del código. Explicación:

 …·AＳ           Inclusive character range from A to the input
Ｆ    «          Loop over each character
         …@ι    Exclusive range from @ to the current character
        Ｅ   ι   Replace each element with the current character
       ⪫        Join with spaces
      Ｐ         Print without moving the cursor.
              ↘ Move the cursor down and right.

Si el relleno adicional fuera legal, esto funcionaría para 14 bytes:

Ｅ…·?θ⁺× κ⪫× κι

Pruébalo en línea! El enlace es a la versión detallada del código.

Mathematica, 70 bytes

(T=Table)[""<>{" "~T~i,T[Alphabet[][[i]]<>" ",i]},{i,LetterNumber@#}]&

minúsculas

produce una lista

Gracias @ ngenisis para correcciones

Para la versión ascii-art coloque Column@al principio

Excel VBA, 72 bytes

Función de ventana inmediata anónima de VBE que toma entrada de la celda A1y salidas a la ventana inmediata de VBE

For i=1To Asc([A1])-64:[B1]=i:?Space(i-1)[REPT(CHAR(B1+64)&" ",B1)]:Next

Pyth , 17 bytes

.e+*kd*+bdhk<GhxG

Pruébalo aquí (bonita versión impresa).

¿Como funciona esto?

• hxG - Toma el índice de la entrada en minúsculas.

• <G - Recorta todos los caracteres después de la entrada del alfabeto.

• .e- Mapa enumerado. Mapas sobre el alfabeto recortado con los índices como ky las letras como b.

• *kd- Añadir kespacios.

• +bd- b+ un espacio (la letra actual + espacio).

• *...hk- Repite k+1veces.

• +(...)(...) - Concatenar.

C ++ (gcc) , 164 bytes

#include<iostream>
#define f for(int i=0;i<o-'`';i++)
using namespace std;int main(){char c;cin>>c;for(char o='a';o<=c;o++){f cout<<' ';f cout<<o<<' ';cout<<'\n';}}

Mi primer intento después de mucho tiempo al acecho!

Código no oculto a continuación:

#include <iostream>

using namespace std;
#define f for (auto i = 0; i < output - '`'; i++)

int main()
{
  char input;

  cin >> input;

  for (char output = 'a'; output <= input; output++)
  {
    f cout << ' ';

    f cout << output << ' ';

    cout << endl;
  }
}

Pruébalo en línea!