26

Ispirato da questo post . Per coloro che contrassegnano questa domanda come duplicata, vi esorto a leggere effettivamente la domanda per vedere che la mia è una modifica di quella collegata. Quello collegato non richiede un input ed è semplicemente di stampare l'alfabeto in diagonale.

La sfida

Dato un input compreso tra 1-26 inclusivamente, stampare l'alfabeto in diagonale, ma iniziare a stampare in verticale sull'indice dell'input specificato.

Esempi

Dato l'input:

Il tuo programma dovrebbe produrre:

Ingresso:

Produzione:

a
 b
  c
   d
   e
   f
   g
   h
   i
   j
   k
   l
   m
   n
   o
   p
   q
   r
   s
   t
   v
   w
   x
   y
   z

Ingresso:

Produzione:

a
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

Ingresso:

Produzione:

punteggio

Questo è code-golf , quindi vince la risposta più breve in ogni lingua.

In bocca al lupo!

code-golf ascii-art alphabet

— SpookyGengar
fonte

6

Possiamo scegliere di utilizzare l'indicizzazione 0 o 1?

— notjagan,

È accettabile uno spazio iniziale coerente?

— Giuseppe,

Gli spazi finali sono accettabili?

— Dom Hastings,

Possiamo usare le maiuscole?

— Adám,

Possiamo restituire un elenco di stringhe?

— Adám,

13

Carbone , 9 byte

↘✂β⁰Ｎ↓✂βη

Provalo online!

Come funziona

↘✂β⁰Ｎ↓✂βη
 ✂β⁰Ｎ         the alphabet from position 0 to the input
↘               print diagonally, down and to the right
        ✂βη    the alphabet starting from the position of the input
       ↓        print downwards

Questa soluzione non funziona più nella versione corrente di Charcoal (molto probabilmente a causa di una correzione di bug), ma il problema viene risolto per 10 byte con ↘✂β⁰Ｎ↓✂βＩθ.

— notjagan
fonte

2

Non sono sicuro del perché funzioni; potrebbe essere un bug che è stato introdotto un paio di settimane fa. (Normalmente dovresti usare Ｉθinvece di η.)

— Neil

@Neil Oggi sembra rotto. L'uso di Ｉθ lo risolve.

— JP de la Torre,

Salvare 1 byte utilizzando …βＮinvece di ✂β⁰Ｎ.

— Neil,

7

05AB1E , 11 byte

AvNI<‚Wysú,

Prima volta che provo 05AB1E, quindi sono aperto ai suggerimenti.

Provalo online!

Se è consentito un input con indice zero da 0a 25, questo può essere di 10 byte omettendo il <.

— Justin Mariner
fonte

Niiice! Esattamente quello che ho ottenuto. Ho provato "sollevare" ma non funziona come previsto. Penso che sia abbastanza ottimale :).

— Magic Octopus Urn il

4

JavaScript (ES2017), 73 72 71 66 byte

Alcuni byte salvati grazie a @JustinMariner

f=(n,x=26)=>x?f(n,x-1)+(x+9).toString(36).padStart(x<n?x:n)+`
`:''

— ETHproductions
fonte

1

Questo aggiunge un 10dopo zalla fine a causa di avere ++xprima x.toString(). È stato corretto il bug e golfato a 68 byte usando padStart: TIO

— Justin Mariner il

@JustinMariner Grazie, penso che potrei passare a ES8 per questo ...

— ETHproductions

Puoi salvare qualcosa dal curry? n=>g=(x=26)=>x?f(x-1)+(x+9).toString(36).padStart(x<n?x:n)+'\n':""

— Shaggy,

@Shaggy Forse, non so se sia permesso quel tipo di curry.

— ETHproductions

Ah, pazzo, sembra che la tua proposta di consentire questo non sia più un consenso :(

— Shaggy

4

Python 2, 61 58 57 byte

n=input()-1
for i in range(26):print(' '*i)[:n]+chr(i+97)

-3 byte grazie a Rod

-1 byte in più grazie a Mr. Xcoder

— pppery
fonte

1

stessa risposta, ma con input / stampa per risparmiare pochi byte

— Rod

@Pavel Che da allora non avrebbe funzionato inputsarebbe chiamato ogni volta che il forciclo scorre, anche se c'è solo una linea di input.

— notjagan,

57 byte usando exec

— officialaimm il

57 byte usando la sottoscrizione.

— Mr. Xcoder,

56 byte

— Mr. Xcoder

4

Rubino, 51 46 43 byte

->n{(0..25).map{|x|(' '*x)[0,n-1]<<(x+97)}}

Restituisce un elenco di stringhe.

Sembra che i ragazzi di Python stessero facendo qualcosa con i loro abbonamenti. -5 byte prendendo ispirazione dal miglioramento della soluzione di Ppperry da parte di Mr. Xcoder.

Soluzione precedente con rjust(51 byte):

->n{i=0;(?a..?z).map{|c|c.rjust i+=n>c.ord-97?1:0}}

— m-Chrzan
fonte

3

Python 2 , 62 50 57 byte

x=input();n=m=1
exec"print'%*c'%(m,n+96);n+=1;m+=x>m;"*26

Provalo online!

Ruba pesantemente da questa risposta di Dennis.

— Stefano
fonte

3

R, 99 89 byte

@MickeyT ha salvato 10 byte

funzione

function(x)for(i in 1:26)cat(paste(c(rep(" ",min(x,i)),letters[i]),collapse=""),sep="\n")

dimostrazione

f <- function(x)for(i in 1:26)cat(paste(c(rep(" ",min(x,i)),letters[i]),collapse=""),sep="\n")
f(1)
f(10)
f(15)
f(26)

— Lento Loris
fonte

1

Un paio di piccoli risparmi. Piuttosto quindi il ifelsetentativo min. print.noquotepuò essere sostituito con catun '\n'a nella pasta. Il \npuò essere un ritorno dritto. Le parentesi graffe per il corpo della funzione possono essere eliminate.

— MickyT

Puoi risparmiare un po 'di più usando writeinvece di cate paste:write(c(rep(" ",min(x,i)),letters[i]),"",26,,"")

— user2390246

3

Retina , 72 68 byte

^
z
{2=`
$`
}T`l`_l`^.
\D
$.`$* $&¶
\d+
$* 
s`( *)( +)(?=.*¶\1 $)
$1

Provalo online! L'output include spazi vuoti finali. Salvare 1 byte eliminando lo spazio prima $che sia consentita l'indicizzazione zero. Modifica: salvato 4 byte utilizzando il generatore alfabetico di @ MartinEnder. Spiegazione:

^
z
{2=`
$`
}T`l`_l`^.

Inserisci l'alfabeto.

\D
$.`$* $&¶

Diagonalizzalo.

\d+
$*

Converti l'input in unario come spazi.

s`( *)( +)(?=.*¶\1 $)
$1

Taglia le linee troppo lunghe in modo che nessuna linea sia più lunga della linea vuota alla fine.

— Neil
fonte

2

Mathematica, 103 byte

(T=Table;a=Alphabet[];c=Column)[c/@{T[""<>{T[" ",i],a[[i]]},{i,#}],T[""<>{T[" ",#],a[[i]]},{i,#,26}]}]&

— J42161217
fonte

2

Pyth , 21 17 15 byte

Fatto su un telefono con batteria al 3%.

VlG+*d?>QNNQ@GN

Spiegazione:

VlG        For each character in the alphabet (G)
+          Concatenate...
 *d        Space (d) times...
   ?>QNNQ  Ternary; if Q (input) is less than N, return N, else Q
 @GN       The Nth character of the alphabet (G)

Provalo online!

— Stan Strum
fonte

1

@totallyhuman Ho appena mangiato una pizza fantastica a Las Vegas, New Mexico

— Stan Strum,

Ho trovato alcuni approcci considerevolmente più brevi e ho deciso di pubblicare la mia risposta .

— Mr. Xcoder,

@ Mr.Xcoder Sì, ottimo lavoro.

— Stan Strum,

2

Gelatina , 11 byte

26Ḷ«’⁶ẋżØaY

Provalo online!

— Perdente Suora
fonte

2

Lisp comune, 84 byte

(lambda(x)(dotimes(i 26)(format t"~v,,,@a~%"(if(< i x)(1+ i)x)(code-char(+ i 97)))))

Provalo online!

— Renzo
fonte

2

Pitone , 52 byte

Abbastanza sorpreso, nessuno notò che l'approccio ovvio era breve come gli altri.

lambda k:[(i*" ")[:k-1]+chr(i+97)for i in range(26)]

Provalo online!

Python , 53 byte

lambda k:[min(k-1,i)*" "+chr(i+97)for i in range(26)]

Provalo online!

— Mr. Xcoder
fonte

2

Haskell, 58 54 byte

f n=do m<-[1..26];([2..min n m]>>" ")++['`'..]!!m:"\n"

Provalo online!

Come funziona

f n=                  -- input number is n
  do m<-[1..26]       -- for each m from [1..26], construct a string and concatenate
                      -- them into a single string. The string is:
   [2..min n m]>>" "  -- min(n,m)-1 spaces,
      ++              -- followed by
   ['`'..]!!m         -- the m-th char after `
      :               -- followed by
   "\n"               -- a newline

Modifica: @Lynn ha salvato 4 byte. Grazie!

— Nome del modello
fonte

È possibile salvare quattro byte usando notazione e ['`'..]!!m.

— Lynn,

@Lynn; Grazie! Mi dimentico sempre di fare notazione per le liste.

— nimi,

2

Java (OpenJDK 8) , 69 byte

n->{for(int a=0;a++<26;)System.out.printf("%"+(a<n?a:n)+"c%n",a+96);}

Provalo online!

— Olivier Grégoire
fonte

2

Gaia , 12 byte

…26⊃§×¦₵a+†ṣ

Provalo online!

Spiegazione

…             Range 0..input-1
 26⊃          Repeat the last number enough times to make it have length 26
    §×¦       Turn each number into a string of that many spaces
       ₵a+†   Add the corresponding letter to each
           ṣ  Join with newlines

— Gatto di affari
fonte

1

JavaScript (Node.js) , 72 byte

n=>[..."abcdefghijklmnopqrstuvwxyz"].map((e,i)=>" ".repeat(i<n?i:n-1)+e)

Restituisce un elenco di stringhe.

Provalo online!

— Conor O'Brien
fonte

Posso chiedere perché node.js? sembra valido normale JS

— Downgoat

@Downgoat È la formattazione automatica TIO

— Conor O'Brien,

tra l'altro puoi salvare byte usando.padStart

— Downgoat

Aspetta NVM nel modo in cui stavo pensando fondamentalmente arriva alla risposta dell'ETH

— Downgoat,

Passa a ES8 e salva un byte con padEndinvece di repeat.

— Shaggy,

1

Mathematica, 67 byte

SparseArray[x=#;{#,#~Min~x}->Alphabet[][[#]]&~Array~26,{26,#}," "]&

Restituisce una SparseArraydi stringhe. Per visualizzare, aggiungere Grid@davanti.

Provalo su Wolfram Sandbox

uso

Grid@SparseArray[x=#;{#,#~Min~x}->Alphabet[][[#]]&~Array~26,{26,#}," "]&[5]

— JungHwan Min
fonte

1

Python 2 , 52 byte

lambda n:['%*c'%(min(i+1,n),i+97)for i in range(26)]

Provalo online!

Suppongo che un elenco di stringhe vada bene ...

Il più breve che potessi ottenere con la ricorsione:

f=lambda n,i=0:i<26and['%*c'%(min(i+1,n),i+97)]+f(n,i+1)or[]

— totallyhuman
fonte

1

SOGL V0.12 , 12 byte

z{ē.-.Hχ@*Ot

Provalo qui!

— dzaima
fonte

1

Python 3 , 52 byte

lambda n:[('%*c'%(i,i+96))[-n:]for i in range(1,27)]

Provalo online!

— Perdente Suora
fonte

1

C (gcc) , 50 byte

i;f(n){for(;i<26;printf("%*c\n",i++<n?i:n,i+97));}

Provalo online!

— Justin Mariner
fonte

1

Proton , 40 byte

Supponendo che un elenco di stringhe vada bene.

k=>[(i*" ")[to~-k]+chr(i+97)for i:0..26]

Provalo online!

Proton , 49 byte

Come ASCII-art invece:

k=>'\n'.join((i*" ")[to~-k]+chr(i+97)for i:0..26)

Provalo online!

— Mr. Xcoder
fonte

1

C # (.NET Core) , 66 + 18 byte

n=>new int[26].Select((x,i)=>$"{(char)(i+97)}".PadLeft(i<n?i+1:n))

Il conteggio dei byte include anche

using System.Linq;

Provalo online!

Ciò restituisce una raccolta di stringhe, una per ogni riga. Se non è consentito, la risposta aumenterà di 17 byte per string.Concat()e\n all'interno della stringa

Spiegazione:

n =>
    new int[26]                      // Create a new collection of size 26
    .Select((x, i) =>                // Replace its members with:
        $"{(char)(i + 97)}"          // String of an alphabet character corresponding to the index
        .PadLeft(i < n ? i + 1 : n)  // Add spaces to the left
    )

— Grzegorz Puławski
fonte

1

MATL, 14 byte

26:tiXl2Y2oZ?c

Provalo su MATL Online

Spiegazione

26      % number literal
:       % range; vector of equally spaced values [1...26]
t       % duplicate
i       % explicitly grab the input
Xl      % clamp the array to have a maximum value of the input
2Y2     % predefined literal: ['a'...'z']
o       % convert to a numeric array
Z?      % create sparse matrix using the first two inputs as the rows/columns 
        % and the letters 'a'...'z' as the values
c       % convert back to character and implicitly display

— Suever
fonte

1

Pyth , 12 byte

j.e+<*kdtQbG

Provalo qui!

Se sono consentiti elenchi di stringhe, questo può essere abbreviato a 11 byte :

.e+<*kdtQbG

Pyth , 12 byte

VG+<*dxGNtQN

Provalo qui!

Pyth , 14 byte

jm+<*d;tQ@Gd26

Provalo qui.

Se sono consentiti elenchi di stringhe, questo può essere ridotto a 13 byte :

m+<*d;tQ@Gd26

Come funzionano questi?

A differenza della maggior parte delle altre risposte, questa mappa / passa sopra l'alfabeto minuscolo in tutte e 3 le soluzioni.

Spiegazione n. 1

j.e+<*kdtQbG - Full program.

 .e        G - Enumerated map over "abcdefghijklmnopqrstuvwxyz", with indexes k and values b.
     *kd     - Repeat a space a number of times equal to the letter's index.
    <   tQ   - Crop the spaces after the input.
   +      b  - Concatenate with the letter.
j            - (Optional): Join by newlines.

Spiegazione n. 2

VG+<*dxGNtQN  - Full program.

VG            - For N in "abcdefghijklmnopqrstuvwxyz".
      xGN     - Index of the letter in the alphabet.
    *d        - Repeat the space a number of times equal to the index above.
   <     tQ   - But crop anything higher than the input.
  +        N  - Append the letter (at the end)

Spiegazione n. 3

jm+<*d;tQ@Gd26 - Full program.

 m          26 - Map over [0...26) with a variable d.
    *d;        - Space repeated d times.
   <   tQ      - Crop anything whose length is higher than the input.
  +      @Gd   - Concatenate with the letter at that index in the alphabet.
j              - (Optional): Join by newlines.

— Mr. Xcoder
fonte

1

Haskell, 60 byte

f n=unlines$scanl(\p c->take(n-1)(p>>" ")++[c])"a"['b'..'z']

Questa è una funzione che restituisce l'output come stringa.

Provalo online.

— Cristian Lupascu
fonte

1

Japt , 16 anni 13 byte

3 byte salvati grazie a @Oliver

;C£RiXiYmUÉ î

Provalo online!

— ETHproductions
fonte

@Oliver Dang, ero stanco ...

— ETHproductions

1

q / kdb +, 33 31 byte

Soluzione:

-1{(&[x-1;til 26]#'" "),'.Q.a};

Esempio:

q)-1{(&[x-1;til 26]#'" "),'.Q.a}16;
a
 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

Spiegazione:

Crea un elenco di spazi (26) fino alla lunghezza del minimo dell'input e dell'intervallo di 0..25), unisciti a ciascuna lettera dell'alfabeto, stampa su stdout.

-1{(&[x-1;til 26]#'" "),'.Q.a}; / solution
-1                            ; / print result to stdout and swallow return
  {                          }  / lambda function
                         .Q.a   / "abcd..xyz"
                       ,'       / concatenate (,) each
   (                  )         / do all this together
    &[   ;      ]               / minimum of each 
      x-1                       / implicit input (e.g. 10) minus 1 (e.g. 9)
          til 26                / 0 1 2 ... 23 24 25
                   '#" "        / take " " each number of times (0 1 2 )

Gli appunti:

-2 byte riagganciando le parentesi

— streetster
fonte

1

Java 1.8 (senza Lambda), 98 byte

void m(int i){int c=0,o=97;String s="";for(;c++<26;s+=c<i?" ":"")System.out.println(s+(char)o++);}

La logica è semplice. Non fornisce convalida dei dati di input, pessimo!

Aggiornamento: solo funzione! Grazie a @Olivier Grégoire

— Douglas Held
fonte

1

Per risparmiare alcuni byte, utilizzare for(;c++<26;s+=c<i?" ":"")System.out.println(s+(char)o++);Inoltre, è possibile scrivere solo una funzione o un lambda anziché un programma completo.

— Olivier Grégoire,

Se dovessi includere solo il corpo di una funzione, come farebbe il lettore a sapere a cosa si a[0]riferisce? Penso che i frammenti non siano giusti se non vengono compilati; la sfida è altrettanto interessante con un linguaggio ricco di costrutti.

— Douglas tenuto il

1

Ciao! Ho detto una funzione o un lambda, non uno snippet. ;-) Quindi puoi scrivere void f(int i){...}(senza staticità) o al i->{...}posto di tutto il tuo programma. Vedi tutti i suggerimenti Java . Vedi la mia risposta per questa stessa sfida , ad esempio. Buon divertimento sul sito! :-)

— Olivier Grégoire il

Alfabeto diagonale all'ingresso

Carbone , 9 byte

Come funziona

05AB1E , 11 byte

JavaScript (ES2017), 73 72 71 66 byte

Python 2, 61 58 57 byte

Rubino, 51 46 43 byte

Python 2 , 62 50 57 byte

R, 99 89 byte

funzione

dimostrazione

Retina , 72 68 byte

Mathematica, 103 byte

Pyth , 21 17 15 byte

Gelatina , 11 byte

Lisp comune, 84 byte

Pitone , 52 byte

Python , 53 byte

Haskell, 58 54 byte

Java (OpenJDK 8) , 69 byte

Gaia , 12 byte

Spiegazione

JavaScript (Node.js) , 72 byte

Mathematica, 67 byte

uso

Python 2 , 52 byte

SOGL V0.12 , 12 byte

Python 3 , 52 byte

C (gcc) , 50 byte

Proton , 40 byte

Proton , 49 byte

C # (.NET Core) , 66 + 18 byte

MATL, 14 byte

Pyth , 12 byte

Pyth , 12 byte

Pyth , 14 byte

Come funzionano questi?

Spiegazione n. 1

Spiegazione n. 2

Spiegazione n. 3

Haskell, 60 byte

Japt , 16 anni 13 byte

q / kdb +, 33 31 byte

Java 1.8 (senza Lambda), 98 byte