Data una lettera dell'alfabeto inglese, il tuo compito è costruire un alfabeto semi-diagonale sull'input.

Come costruire un alfabeto semi-diagonale?

Breve descrizione : in primo luogo, prendi la posizione della lettera nell'alfabeto P(qui Pè 1-indicizzato). Quindi, stampi ogni lettera fino all'input (incluso) su una riga, preceduto da P-1e ripeti i Ptempi di quella lettera , interfacciandosi con gli spazi.

Esempi :

• Dato F, il tuo programma dovrebbe produrre:

  UN 
   BB 
    CCC 
     DDDD 
      EEEEE 
       FFFFFF 
  

• Dato K, il tuo programma dovrebbe produrre:

  UN
   BB 
    CCC 
     DDDD 
      EEEEE 
       FFFFFF 
        GGGGGGG 
         HHHHHHHH 
          IIIIIIIII 
           JJJJJJJJJJ 
            kkkkkkkkkkk 
  

• Dato A, il tuo programma dovrebbe produrre:

  A
  

Regole

• Puoi scegliere caratteri minuscoli o maiuscoli, ma ciò dovrebbe essere coerente.

• Potresti avere spazi estranei come segue:

  • Uno spazio iniziale coerente (su ogni riga).
  • Una o più righe nuove o finali.
  • Spazi finali.

• L'input e l'output possono essere presi con qualsiasi media standard e si applicano scappatoie predefinite.

• È consentito invece generare un elenco di righe, purché si fornisca anche la versione ascii-art .

• Questo è code-golf , quindi vince il codice più corto in byte!

^{Ispirato da questa sfida .}

Python 3 , 59 byte

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

Provalo online!

Python 3 , 61 byte

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

Provalo online! (collegamento alla versione piuttosto stampata)

Python 2 , 63 61 59 byte

-2 byte grazie a Rod. -2 byte grazie a Felipe Nardi Batista.

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

Provalo online!

C, 89 byte

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

Provalo online!

PowerShell , 45 42 byte

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

Provalo online!

Prende l'input come carattere letterale, quindi passa attraverso le maiuscole fino a quel punto, ogni iterazione antepone il numero appropriato di spazi e quindi l'ibrido char \ space.

Salvato 3 byte grazie a TessellatingHeckler.

JavaScript (ES6), 85 byte

Funziona in minuscolo sia per input che per output. Emette uno spazio iniziale e uno spazio finale su ciascuna riga.

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

dimostrazione

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 byte

Richiede il carattere scalare. Stampa l'elenco delle righe.

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

Provalo online! (ha la versione di arte ASCII ad un byte aggiuntivo)

⎕ richiesta di input

⎕A⍳ trova de ndex in una lettera

⍳ prima che molti ɩ ntegers

(... )¨ applica la seguente funzione tacita a ciascuno:

 ⊃∘⎕A scegli l'argomentazione lettera dell'alfabeto A

 ⊢⍴ ridisegnare ciclicamente la lunghezza dell'argomento

 ' ',¨⍨ aggiungere uno spazio a ciascuno

 ⍴∘'', anteporre una stringa di lunghezza argomento (riempita con spazi)

 ∊ ϵ nlist (appiattisci)

La versione di arte ASCII ha solo un ↑a sinistra; mescola l'elenco di stringhe in una tabella di caratteri.

Perl 5 , 31 byte

30 byte codice + 1 per -l.

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

Provalo online!

Dyalog APL, 38 byte

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

Provalo online!

Come?

⎕A↑⍨ - prendi l'alfabeto fino al

⎕A⍳⍵ - il carattere di input

¨ - per ogni carattere

    ⍵,' ' - prendi il carattere e uno spazio

    (...)⍴ - rimodella in

    2×y←⎕A⍳⍵ - il doppio dell'indice del carattere nell'alfabeto

    (y/' ') - e anteporre spazi di indice di caratteri

↑ - quindi appiattire

APL (Dyalog Classic) , 26 byte

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

Provalo online!

Spiegazione

                      ⍳⎕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 byte (in competizione )

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

Provalo online!

Nota che, anche se ho intenzione di aggiungere alcune funzionalità per molto tempo, questa sfida è stata ciò che mi ha convinto a farlo finalmente.

L'output contiene uno spazio iniziale su ogni riga e una nuova riga finale.

hexdump:

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

Spiegazione:

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

A¹¡н«ðâƶāú

Provalo online!

-2 grazie ad Adnan .

Aggiungi »per farlo stampare in righe separate.

R, 94 88 byte

-6 byte grazie a Giuseppe

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

Ungolfed:

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 byte

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

Restituisce un elenco di righe.

Provalo online!

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

Modifica: @jferard: salvato tre byte. Grazie!

JavaScript (ES8), 92 byte

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

Usa lettere minuscole. Le linee hanno uno spazio iniziale e uno finale. Restituisce una matrice di linee.

Test dello snippet

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>

Buccia , 13 byte

z+ḣ∞øzRNC1…'A

Prende un carattere tra virgolette singole come argomento della riga di comando, stampa il risultato su STDOUT. Provalo online!

Spiegazione

Sto sfruttando il modo in cui Husk stampa elenchi di elenchi di stringhe: unisce elenchi interni con spazi e elenchi esterni con nuove righe.

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 byte

Salvato 1 byte grazie ad Adnan

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

Provalo online! o la versione artistica di Ascii

Spiegazione

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) , 22 byte ^SBCS

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

Provalo online!

Usi ⎕io←1. Stampa uno spazio iniziale, che è consentito.

QBasic, 79 74 72 byte

Grazie a Taylor Scott per il risparmio di byte (due volte!)

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

Usa lettere maiuscole. L'ingresso avviene premendo il tasto e non viene ripetuto sullo schermo.

Spiegazione

Passiamo idalla 1posizione della lettera limite all'alfabeto (basato su 1). Per ognuno i, ci spostiamo nella colonna idello schermo usando TAB; poi, ivolte, stampiamo la ilettera dell'alfabeto seguita da uno spazio.

Japt -R , 24 23 17 15 byte

Emette un array, include una nuova riga iniziale e uno spazio iniziale e finale su ciascuna riga.

IòUc ÏçSiXd¹iYç

Provalo

• 1 byte salvato con l'aiuto di Oliver e altri 6 grazie a lui che ha indicato un modo migliore per generare l'array iniziale.

Carbone , 18 byte

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

Provalo online!

Braingolf , 65 byte

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

Provalo online!

Minuscolo.

Contiene 1 spazio finale su ogni riga e una riga finale alla fine dell'output.

C # (.NET Core) , 103 byte

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

Provalo online!

JavaScript, 102 94 byte

2 byte salvati grazie 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 byte

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

Provalo online! Spiegazione:

^.
$&$&

Duplica la (prima) lettera.

}T`L`_L`^.

Ruotalo indietro di 1 nell'alfabeto o eliminalo se è un duplicato A. Continua a duplicare e ruotare fino a quando non dupliciamo A, a quel punto la cancellazione annulla la duplicazione e il ciclo si completa.

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

Sostituisci ogni lettera con una linea con la lettera imbottita su entrambi i lati.

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

Inserisci lettere duplicate tra tutte le coppie di spazi di riempimento a destra delle lettere esistenti.

Haskell , 57 byte

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

Provalo online!

Carbone , 15 byte

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

Provalo online! Il collegamento è alla versione dettagliata del codice. Spiegazione:

 …·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.

Se il padding extra fosse legale, questo funzionerebbe per 14 byte:

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

Provalo online! Il collegamento è alla versione dettagliata del codice.

Mathematica, 70 byte

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

minuscolo

genera un elenco

grazie @ngenisis per le correzioni

Per la versione ascii-art , posizionare Column@all'inizio

Excel VBA, 72 byte

Funzione di finestra immediata VBE anonima che accetta input dalla cella A1e output nella finestra immediata di VBE

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

Pyth , 17 byte

.e+*kd*+bdhk<GhxG

Provalo qui (bella versione stampata).

Come funziona?

• hxG - Prende l'indice dell'input nell'alfabeto minuscolo.

• <G - Taglia ogni carattere dopo l'inserimento dell'alfabeto.

• .e- Mappa enumerata. Mappa sopra l'alfabeto ritagliato con gli indici come ke le lettere come b.

• *kd- Aggiungi kspazi.

• +bd- b+ uno spazio (la lettera corrente + spazio).

• *...hk- Ripeti i k+1tempi.

• +(...)(...) - Concatenare.

C ++ (gcc) , 164 byte

#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';}}

Il mio primo tentativo dopo tanto tempo in agguato!

Codice non registrato di seguito:

#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;
  }
}

Provalo online!