Étant donné une lettre de l'alphabet anglais, votre tâche consiste à créer un alphabet semi-diagonal à l'entrée.

Comment construire un alphabet semi-diagonal?

Brève description : Tout d’abord, vous prenez la position de la lettre dans l’alphabet P( Pindexé 1 ici). Ensuite, vous imprimez chaque lettre jusqu'à l'entrée (incluse) sur une ligne, précédée de P-1et répétez cette Pfois fois, entrelacement d'espaces.

Exemples :

• Étant donné que Fvotre programme devrait produire:

  UNE 
   BB 
    CCC 
     DDDD 
      EEEEE 
       FFFFFF 
  

• Étant donné que Kvotre programme devrait produire:

  UNE
   BB 
    CCC 
     DDDD 
      EEEEE 
       FFFFFF 
        GGGGGGG 
         HHHHHHHH 
          IIIIIIIII 
           JJJJJJJJJJ 
            KKKKKKKKKKK 
  

• Étant donné que Avotre programme devrait produire:

  A
  

Règles

• Vous pouvez choisir des caractères minuscules ou majuscules, mais cela devrait être cohérent.

• Vous pouvez avoir des espaces superflus comme suit:

  • Un espace de début cohérent (sur chaque ligne).
  • Une ou plusieurs nouvelles lignes.
  • Espaces de fuite.

• L'entrée et la sortie peuvent être prises avec n'importe quel moyen standard, et des failles par défaut s'appliquent.

• Vous êtes autorisé à générer une liste de lignes à la place, à condition de fournir également la version ascii-art .

• C'est du code-golf , donc le code le plus court en octets gagne!

^{Inspiré par ce défi .}

Python 3 , 59 octets

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

Essayez-le en ligne!

Python 3 , 61 octets

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

Essayez-le en ligne! (lien vers la jolie version imprimée)

Python 2 , 63 61 59 octets

-2 octets grâce à Rod. -2 octets grâce à Felipe Nardi Batista.

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

Essayez-le en ligne!

C, 89 octets

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

Essayez-le en ligne!

PowerShell , 45 42 octets

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

Essayez-le en ligne!

Prend l'entrée sous forme de caractère littéral, puis parcourt les majuscules jusqu'à ce point, chaque itération précédant le nombre d'espaces, puis l'hybride caractère / espace.

3 octets sauvés grâce à TessellatingHeckler.

JavaScript (ES6), 85 octets

Fonctionne en minuscule pour les entrées et les sorties. Sort un espace de début et un espace de fin sur chaque ligne.

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

Démo

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 octets

Invite le caractère scalaire. Imprime la liste des lignes.

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

Essayez-le en ligne! (a la version d'art ASCII à un octet supplémentaire)

⎕ invite pour l'entrée

⎕A⍳ trouver ɩ ndex dans Un alphabet

⍳ d' abord que de nombreux ɩ ntegers

(… )¨ Applique la fonction tacite suivante à chacun:

 ⊃∘⎕A choisissez la lettre lettre argument'th du A lphabet

 ⊢⍴ remodeler cycliquement à la longueur de l'argument

 ' ',¨⍨ ajouter un espace à chacun

 ⍴∘'', ajoute une chaîne de longueur d'argument (complétée d'espaces)

 ∊ ε nlist (aplatir)

La version d'art ASCII a juste un ↑à l'extrême gauche; mélanger la liste des chaînes dans la table des caractères.

Perl 5 , 31 octets

Code de 30 octets + 1 pour -l.

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

Essayez-le en ligne!

Dyalog APL, 38 octets

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

Essayez-le en ligne!

Comment?

⎕A↑⍨ - prendre l'alphabet jusqu'à

⎕A⍳⍵ - le caractère d'entrée

¨ - pour chaque personnage

    ⍵,' ' - prendre le caractère et un espace

    (...)⍴ - remodeler à

    2×y←⎕A⍳⍵ - deux fois l'indice du caractère dans l'alphabet

    (y/' ') - et précéder les espaces d'index de caractères

↑ - puis aplatir

APL (Dyalog Classic) , 26 octets

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

Essayez-le en ligne!

Explication

                      ⍳⎕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 octets (en compétition )

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

Essayez-le en ligne!

Notez que bien que je prévoie d’ajouter certaines fonctionnalités depuis longtemps, c'est ce défi qui m'a convaincu de le faire.

La sortie contient un espace de début sur chaque ligne et un retour à la fin.

Hexdump:

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

Explication:

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

A¹¡н«ðâƶāú

Essayez-le en ligne!

-2 grâce à Adnan .

Ajoutez »pour le faire imprimer sur des lignes séparées.

R, 94 88 octets

-6 octets grâce à 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 octets

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

Retourne une liste de lignes.

Essayez-le en ligne!

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

Edit: @jferard: trois octets sauvegardés. Merci!

JavaScript (ES8), 92 octets

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

Utilise des lettres minuscules. Les lignes ont un espace de début et un espace de fuite. Retourne un tableau de lignes.

Test 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>

Husk , 13 octets

z+ḣ∞øzRNC1…'A

Prend un caractère entre guillemets comme argument de ligne de commande, imprime le résultat dans STDOUT. Essayez-le en ligne!

Explication

J'exploite la façon dont Husk imprime les listes de listes de chaînes: joignez les listes internes avec des espaces et les listes externes avec des lignes.

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 octets

Sauvé 1 octet grâce à Adnan

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

Essayez-le en ligne! ou la version d'art Ascii

Explication

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 22 octets

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

Essayez-le en ligne!

Utilisations ⎕io←1. Imprime un espace de début, ce qui est autorisé.

QBasic, 79 74 72 octets

Merci à Taylor Scott pour les économies d’octets (deux fois!)

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

Utilise les majuscules. La saisie se fait par pression de touche et n’est pas renvoyée à l’écran.

Explication

Nous passons en boucle ide la 1position de la lettre limite dans l'alphabet (base 1). Pour chacun i, nous passons à la colonne ide l'écran en utilisant TAB; puis, iparfois, nous imprimons la iième lettre de l'alphabet suivie d'un espace.

Japt -R , 24 23 17 15 octets

Sort un tableau, inclut une nouvelle ligne principale et un espace de début et de fin sur chaque ligne.

IòUc ÏçSiXd¹iYç

Essaye-le

• 1 octet enregistré avec l'aide d' Oliver et 6 autres grâce à une meilleure façon de générer le tableau initial.

Charbon de bois , 18 octets

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

Essayez-le en ligne!

Braingolf , 65 octets

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

Essayez-le en ligne!

Minuscule.

Contient 1 espace de fin sur chaque ligne et une nouvelle ligne à la fin de la sortie.

C # (.NET Core) , 103 octets

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

Essayez-le en ligne!

JavaScript, 102 94 octets

2 octets économisés grâce à 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 octets

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

Essayez-le en ligne! Explication:

^.
$&$&

Dupliquer la (première) lettre.

}T`L`_L`^.

Faites-le pivoter de 1 dans l'alphabet ou supprimez-le s'il s'agit d'un doublon A. Continuez à dupliquer et à faire pivoter jusqu’à ce que nous ayons dupliqué A. À ce stade, la suppression annule la duplication et la boucle est terminée.

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

Remplacez chaque lettre par une ligne avec la lettre rembourrée des deux côtés.

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

Insérez des lettres en double entre toutes les paires d'espaces de remplissage à la droite des lettres existantes.

Haskell , 57 octets

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

Essayez-le en ligne!

Charbon de bois , 15 octets

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

Essayez-le en ligne! Le lien est vers la version verbeuse du code. Explication:

 …·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 un remplissage supplémentaire était légal, cela fonctionnerait pour 14 octets:

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

Essayez-le en ligne! Le lien est vers la version verbeuse du code.

Mathematica, 70 octets

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

minuscule

affiche une liste

thanx @ ngenisis pour les corrections

For ascii-art version place Column@ at the beginning

Excel VBA, 72 Bytes

Anonymous VBE immediate window function that takes input from cell A1 and outputs to the VBE immediate window

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

Pyth, 17 bytes

.e+*kd*+bdhk<GhxG

Try it here (pretty print version).

How does this work?

• hxG - Takes the index of the input in the lowercase alphabet.

• <G - Trims every character after the input from the alphabet.

• .e - Enumerated Map. Maps over the trimmed alphabet with the indexes as k and the letters as b.

• *kd - Append k spaces.

• +bd - b + a space (the current letter + space).

• *...hk - Repeat k+1 times.

• +(...)(...) - Concatenate.

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

My first attempt after a long time lurking!

Ungolfed code below:

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

Try it online!