Un boulet de canon est tiré de telle sorte que, lors du premier clignement de son vol, il monte par la Ncime des arbres, pendant le deuxième clignement des yeux par la N-1cime des arbres, etc., jusqu'au point le plus élevé de sa trajectoire. Ensuite, il commence à tomber de 1, 2, etc. cime des arbres par oeil jusqu'à ce qu'il touche le sol. Dans le même temps, le boulet de canon se déplace horizontalement avec une vitesse constante de 1 cime d'arbre / oeil.

Votre tâche consiste à dessiner la trajectoire avec des lettres consécutives de l'alphabet anglais. Si vous manquez de lettres, recommencez à partir de 'A'. Écrire une fonction ou un programme. L'entrée est un entier N( 1≤N≤15). La sortie peut être une matrice de caractères sous n'importe quelle forme raisonnable, par exemple une chaîne séparée par une nouvelle ligne ou une liste de chaînes. Les lettres peuvent être toutes en minuscules ou en majuscules. Des espaces de début et de fin supplémentaires sont autorisés. Les échappatoires standard sont interdites. Un code plus court, c'est mieux.

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 octets

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

Essayez-le en ligne!

Explication

>*                             # 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 octets

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

Exécuter et déboguer en ligne

La représentation ascii correspondante du même programme est la suivante.

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 octets

Cette approche remplit une matrice puis l’imprime.

Golfé

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,,"")

Merci @ Giuseppe pour 153.

Merci @JDL pour 150.

Voir le commentaire de @ Giuseppe pour 112, et quelques modifications pour 110 maintenant 109. Extraire le code original.

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="")}

Si vous tracez une sortie valide, alors 73 octets

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 octets

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

Essayez-le en ligne!

MATL , 29 octets

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

Essayez-le en ligne!

Comment ça marche

,        % 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 octets

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

Essayez-le en ligne!

Explication

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 octets

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

Essayez-le en ligne!

Déroulé:

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 octets

(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))))

À un moment donné, je me suis empêtré dans reverse appels et abandonné l'idée de la rendre aussi courte que possible. Je voulais juste avoir une solution de travail. Voici...

Sorte de non-golf

(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))))

Mise à jour

Motivé par le commentaire d'Olivier, j'ai réussi à couper plusieurs reverseappels et à appliquer des astuces générales au golf pour couper des personnages. Aussi je créé des alias pour reverse, map-indexed, concat, repeatetstr parce que je les ai utilisés plusieurs fois chacun.

(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))))))))))

Crée la fonction cqui accepte la valeur n et retourne une liste de lignes.

Charbon de bois , 33 31 octets

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

Essayez-le en ligne! Le lien est vers la version verbeuse du code. Edit: 2 octets enregistrés grâce à @ ASCII uniquement. Explication:

≔⁰η

Initialisez la lettre actuelle sous forme d'index dans l'alphabet majuscule sur 0.

Ｆ…±Ｎ⊕θ«

Faites une boucle de la négation de l'entrée à l'entrée incluse.

¿ι→↓

Normalement, chaque colonne est à droite de la précédente. Cependant, il n'y a pas de colonne pour zéro. Au lieu de cela, une correction est nécessaire pour assurer l'alignement des côtés gauche et droit.

Ｆ↔ι«

Boucle pour chaque lettre de la colonne.

Ｐ§αη

Imprimer la lettre en cours.

≦⊕η

Incrémenter l'index des lettres.

¿›ι⁰↓↑

Montez ou descendez selon le côté de la trajectoire où nous sommes.

Perl 5 , -n 112 92 90 88 octets

Pour une fois le terriblement long printfsemble gagner.

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

Essayez-le en ligne!

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

Cela crée un tableau de taille appropriée, trouve les indices de la trajectoire et leur attribue le caractère approprié. La partie la plus complexe consiste à générer les caractères AZ, qui reposent sur une distribution très fictive de nombres dans un type chaîne. L'objet renvoyé est un tableau unicode.

Edit : 9 octets enregistrés remplaçant le code numpy qui a généré les caractères AZ ( (r_[0:2*N]%26+65).view('U1')[::2]) avec map, comme suggéré ici .

Python 3 , 139 136 octets

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

Essayez-le en ligne!

Génère chaque couche de manière récursive, en fonction de la taille et du décalage.

-3 octets grâce à Jo King

J , ⁷⁸ 75 octets

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

Essayez-le en ligne!

-3 grâce à ngn

Python 2 , 182 octets

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

Essayez-le en ligne!

Renvoie la liste des listes de caractères. Vérification primitive ici

Gelée , 35 octets

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

Essayez-le en ligne!

Yabasic , 125 octets

Une solution de base qui utilise le mode graphique pour imprimer les caractères dans la colonne et la rangée correctes de l'écran.

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

Cette solution utilisant le mode graphique, elle ne peut pas être exécutée sur TIO.

Sortie

Ci-dessous la sortie pour l'entrée 7

Ruby , 106 103 octets

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

Essayez-le en ligne!

QBasic 1.1 , 124 octets

Prend des commentaires et tire un canon. En raison des limitations de taille d'écran,$n$ doit être $\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 octets

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

Essayez-le en ligne!

J'ai fait de mon mieux. Faites-moi savoir si des optimisations sont possibles.

k4, 76 71 octets

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

certains réarrangements + assignations pour économiser 5 octets

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

une demi-heure d'effort avec quelques efforts pour supprimer quelques octets, mais il y a probablement beaucoup plus à faire ici. y reviendrai. défi amusant!