Inspiriert von diesem Beitrag . Für diejenigen, die diese Frage als Duplikat markieren, möchte ich Sie dringend bitten, die Frage tatsächlich zu lesen, um festzustellen, dass meine eine Modifikation der verknüpften ist. Der verknüpfte fragt nicht nach einer Eingabe und soll nur das Alphabet diagonal drucken.

Die Herausforderung

Bei einer Eingabe zwischen einschließlich 1-26 wird das Alphabet diagonal gedruckt, der vertikale Druck beginnt jedoch am Index der angegebenen Eingabe.

Beispiele

Angesichts der Eingabe:

16

Ihr Programm sollte folgendes ausgeben:

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

Eingang:

4

Ausgabe:

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

Eingang:

1

Ausgabe:

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

Eingang:

26

Ausgabe:

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

Wertung

Das ist Code-Golf , also gewinnt die kürzeste Antwort in jeder Sprache.

Viel Glück!

Kohle , 9 Bytes

↘✂β⁰Ｎ↓✂βη

Probieren Sie es online!

Wie es funktioniert

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

Diese Lösung funktioniert in der aktuellen Version von Charcoal nicht mehr (höchstwahrscheinlich aufgrund einer Fehlerbehebung), aber das Problem wurde für 10 Bytes mit behoben ↘✂β⁰Ｎ↓✂βＩθ.

05AB1E , 11 Bytes

AvNI<‚Wysú,

Das erste Mal versucht 05AB1E, also bin ich offen für Tipps.

Probieren Sie es online!

Wenn eine durch Null indizierte Eingabe von 0bis 25zulässig ist, können dies 10 Bytes sein, indem das weggelassen wird <.

JavaScript (ES2017), 73 72 71 66 Bytes

Dank @JustinMariner einige Bytes gespart

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

Python 2, 61 58 57 Bytes

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

-3 Bytes dank Rod

-1 Byte mehr dank Mr. Xcoder

Ruby, 51 46 43 Bytes

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

Gibt eine Liste von Zeichenfolgen zurück.

Sieht so aus, als ob die Python-Typen mit ihren Indizes etwas zu tun hatten. -5 Bytes, indem Sie sich von Mr. Xcoders Verbesserung der ppperry-Lösung inspirieren lassen.

Bisherige Lösung mit rjust(51 Bytes):

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

Python 2 , 62 50 57 Bytes

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

Probieren Sie es online!

Stiehlt schwer von dieser Antwort von Dennis.

R 99 89 Bytes

@MickeyT sparte 10 Bytes

Funktion

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

Demo

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)

Retina , 72 68 Bytes

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

Probieren Sie es online! Die Ausgabe enthält nachgestellte Leerzeichen. Speichern Sie 1 Byte, indem Sie den Speicherplatz löschen, bevor die $Indizierung auf Null zulässig ist. Bearbeiten: 4 Bytes mit dem Alphabet-Generator von @ MartinEnder gespeichert. Erläuterung:

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

Füge das Alphabet ein.

\D
$.`$* $&¶

Diagonalisiere es.

\d+
$* 

Konvertieren Sie die Eingabe in unär als Leerzeichen.

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

Schneiden Sie überlange Linien so ab, dass keine Linie länger als die leere Linie am Ende ist.

Mathematica, 103 Bytes

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

Pyth , 21 17 15 Bytes

Geschehen auf einem Telefon mit 3% Akku.

VlG+*d?>QNNQ@GN

Erläuterung:

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)

Probieren Sie es online!

Jelly , 11 Bytes

26Ḷ«’⁶ẋżØaY

Probieren Sie es online!

Common Lisp, 84 Bytes

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

Probieren Sie es online!

Python , 52 Bytes

Ziemlich überrascht, dass niemand bemerkte, dass der offensichtliche Ansatz auch so kurz war wie die anderen.

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

Probieren Sie es online!

Python , 53 Bytes

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

Probieren Sie es online!

Haskell, 58 54 Bytes

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

Probieren Sie es online!

Wie es funktioniert

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 

Edit: @Lynn hat 4 Bytes gespeichert. Vielen Dank!

Java (OpenJDK 8) , 69 Byte

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

Probieren Sie es online!

Gaia , 12 Bytes

…26⊃§×¦₵a+†ṣ

Probieren Sie es online!

Erläuterung

…             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 Byte

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

Gibt eine Liste von Zeichenfolgen zurück.

Probieren Sie es online!

Mathematica, 67 Bytes

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

Gibt eine SparseArrayder Zeichenfolgen zurück. Zum Visualisieren Grid@vorne anhängen .

Probieren Sie es auf Wolfram Sandbox

Verwendung

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

a
 b
  c
   d
    e
    f
    g

    ⋮

    z 

Python 2 , 52 Bytes

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

Probieren Sie es online!

Ich gehe davon aus, dass eine Liste von Zeichenfolgen in Ordnung ist ...

Kürzeste, die ich mit Rekursion bekommen konnte:

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

SOGL V0.12 , 12 Bytes

z{ē.-.Hχ@*Ot

Probieren Sie es hier aus!

Python 3 , 52 Bytes

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

Probieren Sie es online!

C (gcc) , 50 Bytes

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

Probieren Sie es online!

Proton , 40 Bytes

Vorausgesetzt, eine Liste von Strings ist in Ordnung.

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

Probieren Sie es online!

Proton , 49 Bytes

Stattdessen als ASCII-Kunst:

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

Probieren Sie es online!

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

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

Die Byteanzahl umfasst auch

using System.Linq;

Probieren Sie es online!

Dies gibt eine Sammlung von Zeichenfolgen zurück, eine für jede Zeile. Wenn dies nicht zulässig ist, nimmt die Antwort für string.Concat()und um 17 Byte zu\n innerhalb der Zeichenfolge

Erläuterung:

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 Bytes

26:tiXl2Y2oZ?c

Probieren Sie es bei MATL Online aus

Erläuterung

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 Bytes

j.e+<*kdtQbG

Probieren Sie es hier aus!

Wenn Listen von Strings zulässig sind, kann dies auf 11 Byte verkürzt werden :

.e+<*kdtQbG

Pyth , 12 Bytes

VG+<*dxGNtQN

Probieren Sie es hier aus!

Pyth , 14 Bytes

jm+<*d;tQ@Gd26

Probieren Sie es hier aus.

Wenn Listen von Strings zulässig sind, kann dies auf 13 Byte verkürzt werden :

m+<*d;tQ@Gd26

Wie funktionieren diese?

Im Gegensatz zu den meisten anderen Antworten wird bei allen drei Lösungen das Kleinbuchstaben-Alphabet durchlaufen.

Erklärung # 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.

Erklärung # 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)

Erklärung # 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 Bytes

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

Dies ist eine Funktion, die die Ausgabe als String zurückgibt.

Probieren Sie es online aus.

Japt , 16 13 Bytes

3 Bytes gespart dank @Oliver

;C£RiXiYmUÉ î

Online testen!

q / kdb + 33 31 Bytes

Lösung:

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

Beispiel:

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

Erläuterung:

Erstellen Sie eine Liste von Leerzeichen (26) bis zur Länge des Minimums der Eingabe und des Bereichs von 0..25), fügen Sie jeden Buchstaben des Alphabets hinzu und drucken Sie auf 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 )

Anmerkungen:

• -2 Bytes durch Umstellen der Klammern

Java 1.8 (ohne Lambda), 98 Bytes

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

Die Logik ist einfach. Bietet keine Validierung der Eingabedaten, sehr schlecht!

• Update: Nur Funktion! Vielen Dank an @Olivier Grégoire