26

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:

Votre programme devrait produire:

Contribution:

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:

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:

Sortie:

Notation

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

Bonne chance!

code-golf ascii-art alphabet

— SpookyGengar
source

6

Pouvons-nous choisir d'utiliser l'indexation 0 ou 1?

— notjagan

Un espace de tête cohérent est-il acceptable?

— Giuseppe

Les espaces de fuite sont-ils acceptables?

— Dom Hastings

Pouvons-nous utiliser des majuscules?

— Adám

Pouvons-nous renvoyer une liste de chaînes?

— Adám

13

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 ↘✂β⁰Ｎ↓✂βＩθ.

— notjagan
source

2

Je ne sais pas pourquoi cela fonctionne; il s'agit peut-être d'un bogue qui a été introduit il y a quelques semaines. (Vous devriez normalement utiliser à la Ｉθplace de η.)

— Neil

@Neil Il semble cassé aujourd'hui. L'utilisation de Ｉθ le résout.

— JP de la Torre

Enregistrez 1 octet en utilisant …βＮau lieu de ✂β⁰Ｎ.

— Neil

7

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

— Justin Mariner
source

Niiice! Exactement ce que j'ai. J'ai essayé "lift" mais ça ne fonctionne pas comme prévu. Je pense que c'est assez optimal :).

— Urne de poulpe magique

4

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)+`
`:''

— ETHproductions
source

1

Cela ajoute un 10après zà la fin en raison de l'avoir ++xavant x.toString(). Correction d'un bug et golfé à 68 octets en utilisant padStart: TIO

— Justin Mariner

@JustinMariner Merci, je pense que je pourrais passer à ES8 pour ça ...

— ETHproductions

Pouvez-vous enregistrer quelque chose en curry? n=>g=(x=26)=>x?f(x-1)+(x+9).toString(36).padStart(x<n?x:n)+'\n':""

— Shaggy

@Shaggy Peut-être, je ne sais pas si ce type de curry est autorisé.

— ETHproductions

Ah, fou, on dirait que votre proposition pour autoriser ce n'est plus un consensus :(

— Shaggy

4

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

— pppery
source

1

même réponse, mais avec entrée / impression pour économiser quelques octets

— Rod

@Pavel Cela ne fonctionnerait pas, car à inputchaque fois la forboucle serait répétée , même s'il n'y a qu'une seule ligne d'entrée.

— notjagan

57 octets utilisant exec

— officialaimm

57 octets en utilisant l'indice.

— M. Xcoder

56 octets

— M. Xcoder

4

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

— m-chrzan
source

3

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.

— Stephen
source

3

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)

— Loris lents
source

1

Quelques petites économies. Plutôt, ifelseessayez min. print.noquotepeut être remplacé par catun '\n'dans la pâte. Il \npeut s'agir d'un retour chariot simple. Les accolades pour le corps de la fonction peuvent être supprimées.

— MickyT

Vous pouvez économiser plus en utilisant writeplutôt que catet paste:write(c(rep(" ",min(x,i)),letters[i]),"",26,,"")

— user2390246

3

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.

— Neil
source

2

Mathematica, 103 octets

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

— J42161217
source

2

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!

— Stan Strum
source

1

@totallyhuman Je viens d'avoir une pizza incroyable à Las Vegas, Nouveau-Mexique

— Stan Strum

J'ai trouvé des approches beaucoup plus courtes et j'ai décidé de poster ma propre réponse .

— M. Xcoder

@ Mr.Xcoder Oui, bon travail là-dessus.

— Stan Strum

2

Gelée , 11 octets

26Ḷ«’⁶ẋżØaY

Essayez-le en ligne!

— Leaky Nun
source

2

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!

— Renzo
source

2

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!

— M. Xcoder
source

2

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!

— nimi
source

Vous pouvez enregistrer quatre octets en utilisant la notation do et ['`'..]!!m.

— Lynn

@Lynn; Merci! J'oublie toujours la notation do pour les listes.

— nimi

2

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!

— Olivier Grégoire
source

2

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

— Chat d'affaires
source

1

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!

— Conor O'Brien
source

Puis-je demander pourquoi node.js? semble être un JS normal valide

— Downgoat

@Downgoat C'est le formatage automatique TIO

— Conor O'Brien

btw vous pouvez enregistrer des octets en utilisant.padStart

— Downgoat

Attendez nvm la façon dont je pensais en fait la réponse de l'ETH

— Downgoat

Basculez vers ES8 et enregistrez un octet avec padEndau lieu de repeat.

— Shaggy

1

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]

— JungHwan Min
source

1

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[]

— totalement humain
source

1

SOGL V0.12 , 12 octets

z{ē.-.Hχ@*Ot

Essayez-le ici!

— dzaima
source

1

Python 3 , 52 octets

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

Essayez-le en ligne!

— Leaky Nun
source

1

C (gcc) , 50 octets

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

Essayez-le en ligne!

— Justin Mariner
source

1

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!

— M. Xcoder
source

1

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
    )

— Grzegorz Puławski
source

1

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

— Suever
source

1

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.

— M. Xcoder
source

1

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.

— Cristian Lupascu
source

1

Japt , 16 13 octets

Enregistré 3 octets grâce à @Oliver

;C£RiXiYmUÉ î

Testez-le en ligne!

— ETHproductions
source

@Oliver Dang, j'étais fatigué ...

— ETHproductions

1

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

— streetster
source

1

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

— Douglas Held
source

1

Pour épargner certains octets, utilisez for(;c++<26;s+=c<i?" ":"")System.out.println(s+(char)o++);également, vous pouvez écrire uniquement une fonction, ou un lambda au lieu d'un programme complet.

— Olivier Grégoire

Si je devais inclure uniquement le corps d'une fonction, alors comment le lecteur saurait-il à quoi il se a[0]réfère? Je pense que les extraits ne sont pas justes s'ils ne sont pas compilés; le défi est tout aussi intéressant avec un langage riche en constructions.

— Douglas tenue

1

Bonjour! J'ai dit une fonction ou un lambda, pas un extrait. ;-) Vous pouvez donc écrire void f(int i){...}(pas de statique nécessaire) ou à la i->{...}place de tout votre programme. Voir tous les conseils Java . Voir ma réponse pour ce même défi , comme exemple. Amusez-vous sur le site! :-)

— Olivier Grégoire

Alphabet diagonal à l'entrée

Fusain , 9 octets

Comment ça marche

05AB1E , 11 octets

JavaScript (ES2017), 73 72 71 66 octets

Python 2, 61 58 57 octets

Rubis, 51 46 43 octets

Python 2 , 62 50 57 octets

R, 99 89 octets

une fonction

démo

Rétine , 72 68 octets

Mathematica, 103 octets

Pyth , 21 17 15 octets

Gelée , 11 octets

Lisp commun, 84 octets

Python , 52 octets

Python , 53 octets

Haskell, 58 54 octets

Java (OpenJDK 8) , 69 octets

Gaia , 12 octets

Explication

JavaScript (Node.js) , 72 octets

Mathematica, 67 octets

Usage

Python 2 , 52 octets

SOGL V0.12 , 12 octets

Python 3 , 52 octets

C (gcc) , 50 octets

Proton , 40 octets

Proton , 49 octets

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

MATL, 14 octets

Pyth , 12 octets

Pyth , 12 octets

Pyth , 14 octets

Comment ça marche?

Explication # 1

Explication # 2

Explication # 3

Haskell, 60 octets

Japt , 16 13 octets

q / kdb +, 33 31 octets

Java 1.8 (sans Lambda), 98 octets