Inspiré par ce post . Pour ceux qui marquent cette question en double, je vous invite à lire la question pour voir que la mienne est une modification de celle liée. Celui lié ne demande pas d'entrée et doit simplement imprimer l'alphabet en diagonale.

Le défi

Étant donné une entrée comprise entre 1 et 26 inclusivement, imprimez l'alphabet en diagonale, mais commencez à imprimer verticalement à l'index de l'entrée donnée.

Exemples

Compte tenu de l'entrée:

16

Votre programme devrait produire:

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

Contribution:

4

Sortie:

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

Contribution:

1

Sortie:

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

Contribution:

26

Sortie:

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

Notation

C'est le golf de code , donc la réponse la plus courte dans chaque langue l'emporte.

Bonne chance!

Fusain , 9 octets

↘✂β⁰Ｎ↓✂βη

Essayez-le en ligne!

Comment ça marche

↘✂β⁰Ｎ↓✂βη
 ✂β⁰Ｎ         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

Cette solution ne fonctionne plus dans la version actuelle de Charcoal (très probablement en raison d'une correction de bogue), mais le problème est résolu pour 10 octets avec ↘✂β⁰Ｎ↓✂βＩθ.

05AB1E , 11 octets

AvNI<‚Wysú,

J'essaie pour la première fois 05AB1E, donc je suis ouvert aux conseils.

Essayez-le en ligne!

Si une entrée indexée zéro de 0à 25est autorisée, cela peut être de 10 octets en omettant le <.

JavaScript (ES2017), 73 72 71 66 octets

Enregistré quelques octets grâce à @JustinMariner

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

Python 2, 61 58 57 octets

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

-3 octets grâce à Rod

-1 octet de plus grâce à M. Xcoder

Rubis, 51 46 43 octets

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

Renvoie une liste de chaînes.

On dirait que les gars de Python étaient sur quelque chose avec leurs abonnements. -5 octets en s'inspirant de l'amélioration de la solution de Ppperry par M. Xcoder.

Solution précédente avec rjust(51 octets):

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

Python 2 , 62 50 57 octets

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

Essayez-le en ligne!

Vole lourdement de cette réponse de Dennis.

R, 99 89 octets

@MickeyT a sauvé 10 octets

une fonction

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

démo

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)

Rétine , 72 68 octets

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

Essayez-le en ligne! La sortie comprend un espace de fin. Enregistrez 1 octet en supprimant l'espace avant $si l'indexation zéro est autorisée. Edit: enregistré 4 octets en utilisant le générateur d'alphabet de @ MartinEnder. Explication:

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

Insérez l'alphabet.

\D
$.`$* $&¶

Diagonalisez-le.

\d+
$* 

Convertissez l'entrée en unaire sous forme d'espaces.

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

Coupez les lignes trop longues de sorte qu'aucune ligne ne soit plus longue que la ligne vierge à la fin.

Mathematica, 103 octets

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

Pyth , 21 17 15 octets

Fait sur un téléphone avec 3% de batterie.

VlG+*d?>QNNQ@GN

Explication:

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)

Essayez-le en ligne!

Gelée , 11 octets

26Ḷ«’⁶ẋżØaY

Essayez-le en ligne!

Lisp commun, 84 octets

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

Essayez-le en ligne!

Python , 52 octets

Assez surpris, personne n'a remarqué que l'approche évidente était aussi courte que les autres.

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

Essayez-le en ligne!

Python , 53 octets

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

Essayez-le en ligne!

Haskell, 58 54 octets

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

Essayez-le en ligne!

Comment ça marche

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 

Modifier: @Lynn a enregistré 4 octets. Merci!

Java (OpenJDK 8) , 69 octets

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

Essayez-le en ligne!

Gaia , 12 octets

…26⊃§×¦₵a+†ṣ

Essayez-le en ligne!

Explication

…             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

JavaScript (Node.js) , 72 octets

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

Renvoie une liste de chaînes.

Essayez-le en ligne!

Mathematica, 67 octets

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

Renvoie une SparseArraychaîne. Pour visualiser, ajoutez Grid@devant.

Essayez-le sur Wolfram Sandbox

Usage

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

a
 b
  c
   d
    e
    f
    g

    ⋮

    z 

Python 2 , 52 octets

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

Essayez-le en ligne!

Je suppose qu'une liste de chaînes est bien ...

Le plus court possible avec la récursivité:

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

SOGL V0.12 , 12 octets

z{ē.-.Hχ@*Ot

Essayez-le ici!

Python 3 , 52 octets

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

Essayez-le en ligne!

C (gcc) , 50 octets

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

Essayez-le en ligne!

Proton , 40 octets

En supposant qu'une liste de chaînes est bien.

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

Essayez-le en ligne!

Proton , 49 octets

Comme ASCII-art à la place:

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

Essayez-le en ligne!

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

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

Le nombre d'octets comprend également

using System.Linq;

Essayez-le en ligne!

Cela renvoie une collection de chaînes, une pour chaque ligne. Si ce n'est pas autorisé, la réponse augmentera de 17 octets pour string.Concat()et à l' \nintérieur de la chaîne

Explication:

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
    )

MATL, 14 octets

26:tiXl2Y2oZ?c

Essayez-le sur MATL Online

Explication

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

Pyth , 12 octets

j.e+<*kdtQbG

Essayez-le ici!

Si les listes de chaînes sont autorisées, cela peut être raccourci à 11 octets :

.e+<*kdtQbG

Pyth , 12 octets

VG+<*dxGNtQN

Essayez-le ici!

Pyth , 14 octets

jm+<*d;tQ@Gd26

Essayez-le ici.

Si les listes de chaînes sont autorisées, cela peut être raccourci à 13 octets :

m+<*d;tQ@Gd26

Comment ça marche?

Contrairement à la plupart des autres réponses, cette carte / boucle sur l'alphabet en minuscules dans les 3 solutions.

Explication # 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.

Explication # 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)

Explication # 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.

Haskell, 60 octets

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

Il s'agit d'une fonction qui renvoie la sortie sous forme de chaîne.

Essayez-le en ligne.

Japt , 16 13 octets

Enregistré 3 octets grâce à @Oliver

;C£RiXiYmUÉ î

Testez-le en ligne!

q / kdb +, 33 31 octets

Solution:

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

Exemple:

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

Explication:

Créer une liste d'espaces (26) jusqu'à la longueur du minimum de l'entrée et de la plage de 0..25), joindre à chaque lettre de l'alphabet, imprimer sur 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 )

Remarques:

• -2 octets en rétablissant les crochets

Java 1.8 (sans Lambda), 98 octets

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

La logique est simple. Ne fournit aucune validation des données d'entrée, très mauvais!

• Mise à jour: Fonction uniquement! Merci à @Olivier Grégoire