Eine Kanonenkugel wird abgefeuert, so dass sie im ersten Augenglied ihres Fluges von NBaumkronen, im zweiten Augenglied von N-1Baumkronen usw. aufsteigt , bis sie den höchsten Punkt ihrer Flugbahn erreicht. Dann fängt es an, um 1, 2 usw. Baumkronen pro Augenglied zu fallen, bis es den Boden berührt. Gleichzeitig bewegt sich die Kanonenkugel horizontal mit einer konstanten Geschwindigkeit von 1 Baumwipfel / Augenglied.

Ihre Aufgabe ist es, die Flugbahn mit aufeinander folgenden Buchstaben aus dem englischen Alphabet zu zeichnen. Wenn Ihnen die Buchstaben ausgehen, beginnen Sie erneut bei 'A'. Schreiben Sie eine Funktion oder ein Programm. Die Eingabe ist eine Ganzzahl N( 1≤N≤15). Die Ausgabe kann eine Zeichenmatrix in jeder vernünftigen Form sein, beispielsweise eine durch Zeilenumbrüche getrennte Zeichenfolge oder eine Liste von Zeichenfolgen. Buchstaben können alle Kleinbuchstaben oder alle Großbuchstaben sein. Zusätzliche führende und nachfolgende Leerzeichen sind zulässig. Standardlücken sind verboten. Kürzerer Code ist besser.

in:
5
out:
    OP
   N  Q
   M  R
  L    S
  K    T
  J    U
 I      V
 H      W
 G      X
 F      Y
E        Z
D        A
C        B
B        C
A        D

in:
1
out:
AB

05AB1E , 33 32 29 28 Bytes

>*As∍2ä`R)ζRIL£vyε`N·úJ])˜.c

Probieren Sie es online!

Erläuterung

>*                             # push input*(input+1)
  As∍                          # take that many characters from the alphabet (with wrap)
     2ä                        # split in 2 parts
       `R)                     # reverse the second part
          ζ                    # zip (gives a list of pairs)
           R                   # reverse
            IL£                # split into parts of sizes equal to [1,2...]
               vy              # for each (part y, index N)
                 ε             # for each pair in that part
                  `N·úJ        # insert N*2 spaces between the characters
                       ]       # end loops
                        )˜     # wrap in a flattened list
                          .c   # format as lines padded to equal length

Stax , 29 24 Bytes

╦'♫ΓqπL⌂δ@╚n>DI∙Q┴òkεwö╔

Führen Sie es online aus und debuggen Sie es

Dies ist die entsprechende ASCII-Darstellung desselben Programms.

VA*xRr:m|/xH({rix/|1*_%:T)mMm

VA*                             repeat alphabet input times
   xRr:m                        [x ... 1, 1 ... x] where x=input
        |/xH(                   get consecutive substrings of specified sizes
             {           m      map substrings using block
              ix<|1*            reverse string if index<x
                    _%:T)       left-pad to appropriate triangular number
                          Mm    transpose and output

R, 169 163 161 153 150 110 109 Bytes

Dieser Ansatz füllt eine Matrix aus und druckt dann die Matrix.

Golf gespielt

function(n)write(`[<-`(matrix(" ",M<-2*n,k<-sum(1:n)),cbind(rep(1:M,c(n:1,1:n)),c(k:1,1:k)),LETTERS),1,M,,"")

Danke @ Giuseppe für 153.

Danke @JDL für 150.

Siehe @ Giuseppes Kommentar zu 112 und einige Änderungen zu 110. 109. Rippen Sie den Originalcode.

function(n){a=matrix(" ",M<-2*n,k<-sum(1:n))
Map(function(x,y,z)a[x,y]<<-z,rep(1:M,c(n:1,1:n)),c(k:1,1:k),head(LETTERS,2*k))
cat(rbind(a,"
"),sep="")}

Wenn Sie eine gültige Ausgabe zeichnen, dann 73 Bytes

function(n,k=sum(1:n))plot(rep(1:(2*n),c(n:1,1:n)),c(1:k,k:1),pc=LETTERS)

Python 2 , 140 135 133 Bytes

lambda n:[' '*(n-j)+chr(~-i%26+65)+'  '*j+chr((n*-~n-i)%26+65)for i,j in zip(range(n*-~n/2,0,-1),sum([-~i*[i]for i in range(n)],[]))]

Probieren Sie es online!

MATL , 29 Bytes

,G:tPY"tf1Y2y@?tn+P])Z?]Pv1X!

Probieren Sie es online!

Wie es funktioniert

,        % Do twice
  G:     %   Push [1 2 ... n], where n is the input
  tP     %   Duplicate, flip: pushes [n n-1 ... 1]
  Y"     %   Run-length decoding: gives vector with n ones, n-1 twos ... (*)
  tf     %   Duplicate, find: gives [1 2 3 ... n*(n-1)/2] (**)
  1Y2    %   Push string 'ABC...Z'
  y      %   Duplicate from below: pushes [1 2 3 ... n*(n-1)/2]  again
  @?     %   If we are in the second iteration
    tn   %     Duplicate, length: pushes n*(n-1)/2
    +    %     Add: gives [n*(n-1)/2+1 n*(n-1)/2+2 ... n*(n-1)*2] 
    P    %     Flip: gives [n*(n-1)/2 n*(n-1)/2-1 ... n*(n-1)/2+1]
  ]      %   End if
  )      %   Index (1-based, modular) into the string. Gives a substring
         %   with the letters of one half of the parabola (***)
  Z?     %   Sparse: creates a char matrix with the substring (***) written
         %   at specified row (*) and column (**) positions. The remaining
         %   positions contain char(0), which will be displayed as space
]        % End do twice. We now have the two halves of the parabola, but
         % oriented horizontally instead of vertically
P        % Flip the second half of the parabola vertically, so that the
         % vertex matches in the two halves
v        % Concatenate the two halves vertically
1X!      % Rotate 90 degrees, so that the parabola is oriented vertically.
         % Implicitly display

Java (OpenJDK 8) , 121 Byte

n->{for(int l=n*++n/2,r=l,i=1,j=0;l>0;j=j-->0?j:i++)System.out.printf("%"+(n-i)+"c%"+(2*i-1)+"c%n",--l%26+65,r++%26+65);}

Probieren Sie es online!

Erläuterung

n->{                             // int-accepting consumer
 for(                            //  loop
   int l=n*++n/2,                //    declare l (left) is the first character to print.
                                 //              Oh, and n is increased to reduce byte count later.
       r=l,                      //            r (right) is the second character to print.
       i=1,                      //            i is the "outer-loop" index
       j=0;                      //            j is the "inner-loop" index
   l>0;                          //    while there are characters to print        
   j=j-->0?j:i++)                //    simulate two loops in one,
                                 //      where j starts from 0 and always decreases until it reaches 0
                                 //      at which point j is reset to i and i is increased
  System.out.printf(             //   Print...
   "%"+(n-i)+"c%"+(2*i-1)+"c%n", //    2 characters
                                 //    - the first with n-i-1 whitespaces (remember, n was increased)
                                 //    - the second characters with 2*i-2 whitespaces
   --l%26+65,                    //    the first character to print is the left one, we decrease it.
   r++%26+65                     //    the second character to print is the right one, we increase it.
  );                             //   
                                 //  end loop
}                                // end consumer

C 184 Bytes

i,j,k,l,m,h,o;f(n){char L[o=n*n][n*3];for(i=o;i--;)for(L[i][j=n*2]=h=k=0;j--;)L[i][j]=32;for(m=n;!h|~i;m-=1-h*2)for(h+(l=m)?++j:++h;l--;)L[h?i--:++i][j]=65+k++%26;for(;o--;)puts(L+o);}

Probieren Sie es online!

Abgerollt:

i, j, k, l, m, h, o;
f(n)
{
    char L[o=n*n][n*3];

    for (i=o; i--;)
        for (L[i][j=n*2]=h=k=0; j--;)
            L[i][j] = 32;

    for (m=n; !h|~i; m-=1-h*2)
        for (h+(l=m)?++j:++h; l--;)
            L[h?i--:++i][j] = 65 + k++%26;

    for (; o--;)
        puts(L+o);
}

Clojure, 417 319 Bytes

(defn cannon[n](let[a(map #(char(+ 65 %))(iterate #(if(> % 24)0(inc %))0))m1(reverse(reduce #(concat %(repeat %2(- n %2)))[](range 0(inc n))))p1(map-indexed #(str(apply str(repeat %2 " "))(nth a %))m1)m2(reverse(reduce #(concat %(repeat %2(-(* 2 %2)2)))[](reverse(range 0(inc n)))))p2(reverse(map-indexed #(str(apply str (repeat %2 " "))(nth a(+(count p1)%)))m2))](doseq[x(reverse(map #(str % %2)p1 p2))](println x))))

Irgendwann verwickelte ich mich in reverseAnrufe und gab die Idee auf, sie so kurz wie möglich zu halten. Ich wollte nur eine funktionierende Lösung haben. Bitte schön...

Irgendwie ungolfed

(defn cannon [n]
  (let [a (map #(char (+ 65 %)) (iterate #(if (> % 24) 0 (inc %)) 0))
        m1 (reverse (reduce #(concat % (repeat %2 (- n %2))) [] (range 0 (inc n))))
        p1 (map-indexed #(str (apply str (repeat %2 " ")) (nth a %)) m1)
        m2 (reverse (reduce #(concat % (repeat %2 (- (* 2 %2) 2))) [] (reverse (range 0 (inc n)))))
        p2 (reverse (map-indexed #(str (apply str (repeat %2 " ")) (nth a (+ (count p1) %))) m2))]
    (doseq [x (reverse (map #(str % %2) p1 p2))] (println x))))

Aktualisieren

Motiviert durch Oliviers Kommentar gelang es mir, mehrere reverseAnrufe zu unterbrechen und einige allgemeine Golf-Tricks anzuwenden, um Charaktere zu schneiden. Auch habe ich Aliase für reverse, map-indexed, concat, repeatund strda habe ich sie mehrfach jeder.

(defn c[n](let[a(map #(char(+ 65 %))(iterate #(if(> % 24)0(inc %))0))k #(reduce %[](range 0(inc n)))r #(apply str(repeat % " "))rv reverse m map-indexed c concat t repeat s str p(m #(s(r %2)(nth a %))(rv(k #(c %(t %2(- n %2))))))](rv(map #(s % %2)p(rv(m #(s(r %2)(nth a(+(count p)%)))(k #(c %(t %2(-(* 2 %2)2))))))))))

Ungolfed

(defn c [n]
  (let [a (map
           #(char (+ 65 %))
           (iterate
            #(if (> % 24) 0 (inc %))
            0))
        k #(reduce
            %
            []
            (range 0 (inc n)))
        r #(apply str (repeat % " "))
        rv reverse
        m map-indexed
        c concat
        t repeat
        s str
        p (m
           #(s
             (r %2)
             (nth a %))
           (rv (k #(c % (t %2 (- n %2))))))]
    (rv
     (map
      #(s % %2)
      p
      (rv
       (m
        #(s
          (r %2)
          (nth a (+ (count p) %)))
        (k #(c % (t %2 (- (* 2 %2) 2))))))))))

Erstellt die Funktion, cdie den Wert n akzeptiert und eine Liste von Zeilen zurückgibt.

Holzkohle , 33 31 Bytes

≔⁰ηＦ…±Ｎ⊕θ«¿ι→↓Ｆ↔ι«Ｐ§αη≦⊕η¿›ι⁰↓↑

Probieren Sie es online! Link ist eine ausführliche Version des Codes. Bearbeiten: 2 Bytes dank nur @ ASCII gespeichert. Erläuterung:

≔⁰η

Initialisieren Sie den aktuellen Buchstaben als Index in Großbuchstaben auf 0.

Ｆ…±Ｎ⊕θ«

Machen Sie eine Schleife von der Negation der Eingabe zur Eingabe einschließlich.

¿ι→↓

Normalerweise befindet sich jede Spalte rechts von der vorherigen. Es gibt jedoch keine Spalte für Null. Stattdessen ist eine Korrektur erforderlich, um sicherzustellen, dass die linke und die rechte Seite ausgerichtet sind.

Ｆ↔ι«

Schleife für jeden Buchstaben in der Spalte.

Ｐ§αη

Den aktuellen Brief drucken.

≦⊕η

Erhöhen Sie den Buchstabenindex.

¿›ι⁰↓↑

Bewegen Sie sich nach oben oder unten, je nachdem, auf welcher Seite der Flugbahn wir uns befinden.

Perl 5 , -n 112 92 90 88 Bytes

Ausnahmsweise printfscheint die furchtbar lange Zeit zu gewinnen.

#!/usr/bin/perl -n
$p=$q=$_*($%=$_+1)/2;map{printf"%$%c%$.c
",--$p%26+65,$q++%26+65for--$%..$';$.+=2}//..$_

Probieren Sie es online!

Python3 + numpy, 124 115

from pylab import*
def i(N):
 x=zeros((N,2*N),'U');x[r_[N-1:-1:-1,0:N],r_[:2*N]]=map(chr,r_[0:2*N]%26+65)
 return x

Dadurch wird ein Array mit entsprechender Größe erstellt, die Indizes für die Flugbahn ermittelt und ihnen das entsprechende Zeichen zugewiesen. Der komplexeste Teil ist die Generierung der Zeichen AZ, die sich auf eine sehr hackige Zahlenfolge für einen Zeichenfolgentyp stützt. Das zurückgegebene Objekt ist ein Unicode-Array.

Bearbeiten : 9 Bytes gespeichert, die den Zahlencode ersetzen, durch den die Zeichen AZ ( (r_[0:2*N]%26+65).view('U1')[::2]) generiert wurden map, wie hier vorgeschlagen .

Python 3 , 139 136 Bytes

f=lambda n,o=0:n and'\n'.join([f(n-1,o+n).replace('\n','\n ')]+[chr(65+(n+o+~i)%26)+'  '*~-n+chr(65+(n*n+o+i)%26)for i in range(n)])or''

Probieren Sie es online!

Generiert jede Ebene rekursiv unter Berücksichtigung der Größe und des Versatzes.

-3 Bytes dank Jo King

J , ⁷⁸ 75 Bytes

(26{.65|.a.)($~#)`(;/@])`(' '$~1+{:@])}i.@+:(,.~(|.,])@i.@-:@#)@#~1+i.@-,i.

Probieren Sie es online!

-3 danke an ngn

Python 2 , 182 Bytes

I=input()
S=list('ZYXWVUTSRQPONMLKJIHGFEDCBA'*I)
R=range
print zip(*[(' '*(sum(R(abs(i))))+eval('S.pop()+'*abs(i)+"''")[::[-1,1][i>0]]).ljust(sum(range(I+1)))for i in R(-I,I+1)if i])

Probieren Sie es online!

Gibt eine Liste von Zeichenlisten zurück. Primitive Verifikation hier

Gelee , 35 Bytes

ṪṚṭ
r1m0RØAṁs⁸U2¦Ç⁶ṁ$;¥\€ÇzZ¥€⁶ẎUZY

Probieren Sie es online!

Yabasic , 125 Bytes

Eine grundlegende Lösung, die den Grafikmodus verwendet, um die Zeichen in der richtigen Spalte und Zeile des Bildschirms zu drucken.

Input""n
Clear Screen
For i=-n To n
For j=1To Abs(i)
k=i>0
?@(i+n-k,(i^2-i)/2+j-2*j^(!k)+k)Chr$(c+65)
c=Mod(c+1,26)
Next
Next

Da diese Lösung den Grafikmodus verwendet, kann sie nicht mit TIO ausgeführt werden.

Ausgabe

Unten ist die Ausgabe für die Eingabe 7

Rubin , 106 103 Bytes

->n,f=2*s=-~n*n/2-1{l=*?A..?Z;(1..n).map{|i|i.times{puts' '*(n-i)+l[(f-s)%26]+' '*~-i*2+l[(s+=1)%26]}}}

Probieren Sie es online!

QBasic 1.1 , 124 Bytes

$n$$\leq 6$

INPUT n
CLS
FOR i=-n TO n
FOR j=1TO ABS(i)
k=i>0
LOCATE(i^2-i)/2+j-2*j^-(k=0)-k+1,i+n+k+1
?CHR$(c+65)
c=(c+1)MOD 26
NEXT j,i

Python 3 , 190 Bytes

j,r,c,s=int(input()),range,[],[];a=(j+1)*j;b=a//2
for i in r(j):k=i+1;c.extend([j-k]*k)
for i in r(a):s+=chr(ord('A')+(i%26))
for i in r(b):print(' '*c[i]+s[b-i-1]+' '*(2*(j-c[i]-1))+s[b+i])

Probieren Sie es online!

Ich versuchte mein Bestes. Lassen Sie mich wissen, ob Optimierungen möglich sind.

k4, 76 71 Bytes

{+|:'p$(-k,|k:+\l)$(x#b),|:'x_b:(i:-1_0,+\l,|l)_a:(2*p:+/l:|1+!x)#.Q.a}

Einige Neuanordnungen + Zuweisungen, um 5 Bytes zu sparen

{+|:'(+/l)$(-k,|k:+\l)$(x#i_a),|:'((-x)#i:-1_0,+\l,|l)_a:(2*+/l:|1+!x)#.Q.a}

halbstündiger Aufwand mit etwas Aufwand, um ein paar Bytes zu entfernen, aber hier kann wahrscheinlich noch viel mehr getan werden. werde darauf zurückkommen. lustige Herausforderung!