Canon alphabet

34

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
ngn
la source
7
Étroitement liée .
Dom Hastings
2
Pourquoi O et P sont-ils au même niveau dans l'exemple? Si je lis correctement les spécifications, il semblerait qu'il faille remonter d'une cime pour P et descendre d'un pour Q.
Skyler le
2
@Skyler À chaque tick, l'alphabet va de 1 à droite et de N à la verticale. N diminue également chaque tick. Entre Oet P, la coche va de 1 à droite, mais de 0 en haut ou en bas.
Olivier Grégoire
4
On dirait que les canons d'alphabet sont maintenant des canons.
Carl Witthoft
2
@ngn Hah, je bricolais avec la solution Perl de @ TonHospel et je trouvais un octet en moins, mais elle ne prend en charge que 14 octets !
Dom Hastings

Réponses:

8

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
Emigna
la source
Je me sens Nú»ou quelque chose comme ça pourrait être utilisé pour imprimer au fur et à mesure au lieu de])~.c
Urne Octopus Magique
Tout ce que je peux dire, c’est cette implémentation ici, mais c’est pire de 2 octets.
Urne Magic Octopus
8

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écursif
la source
7

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)

entrez la description de l'image ici

Vlo
la source
153 octets - votre solution a imprimé un espace supplémentaire à l’apex que j’ai fixé, puis j’ai aussi joué au golf. Bonne réponse!
Giuseppe
pouvez-vous utiliser Mapau lieu de mapply?
JDL
@JDL Tu as raison. Je pense toujours que Map est un wrapper pour lapplyau lieu de mapply. Merci pour 150
Vlo
Cela ne cessait de me gêner, car je pensais qu'il devrait exister un moyen d'indexer la matrice par row,columnpaires directement avec [plutôt que de devoir passer par mapply(ou Map), alors j'ai trouvé un moyen de le faire. Je me souviens aussi que writeexiste et peut remplacer catpour 112 octets !
Giuseppe
@Giuseppe Mon commentaire à propos de "" n'a pas fonctionné, mais avec [<-, nous pouvons réussir à tout compresser sur une ligne, ce qui évite d'avoir recours à certaines définitions de variables. 110 octets: tio.run/##K/qfpmCj@z@tNC@5JDM/…
Vlo
6

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!

TFeld
la source
5

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
Luis Mendo
la source
4

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
Olivier Grégoire
la source
3

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);
}
Steadybox
la source
intéressant, je ne peux pas compiler ceci (il n'y a pas de main) mais TIO peut
ngn
1
@ngn C'est juste une fonction , vous devez l'ajouter mainpour la compiler. Sur TIO, le mainest dans la section de pied de page.
Steadybox
3

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.

Josué
la source
Ce n'est pas une réponse car il n'y a apparemment aucune tentative de golf (vous le dites même).
Olivier Grégoire
Ok, c'est beaucoup mieux! ;-)
Olivier Grégoire
3

Charbon de bois , 33 31 octets

≔⁰ηF…±N⊕θ«¿ι→↓F↔ι«P§αη≦⊕η¿›ι⁰↓↑

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.

F…±N⊕θ«

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.

F↔ι«

Boucle pour chaque lettre de la colonne.

P§αη

Imprimer la lettre en cours.

≦⊕η

Incrémenter l'index des lettres.

¿›ι⁰↓↑

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

Neil
la source
On dirait qu'il pourrait y avoir un moyen plus court de faire cela, mais je ne sais pas comment: /
ASCII uniquement
4
31 octets
ASCII uniquement
3

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!

Ton Hospel
la source
Belle amélioration! J'essayais d'obtenir(A..Z)x9 au travail, mais la limite était trop courte! Eu cela pour 91 seulement. :)
Dom Hastings
1
@DomHastings Yours était un bon essai de synergie entre les deux calculs de lettres presque répétés. Cela m'énerve aussi.
Ton Hospel
2

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 .

utilisateur2699
la source
2

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

Matthew Jensen
la source
@JoKing Merci, j'oublie toujours l' ~opérateur!
Matthew Jensen
Vous pouvez également changer n and ... or''à n*' 'and ...pour un autre octet
Jo Roi
2

J , 78 75 octets

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

Essayez-le en ligne!

-3 grâce à ngn

Jonas
la source
1
(,|.)@i.@-->i.@-,i.
NDGN
Merci @ ngn. C’est un de ceux où il a semblé qu’il devrait y avoir une solution en 40-50 octets, mais s’il existe je n’aurais pas pu la voir ...
Jonah
1

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

Mort possum
la source
1

Yabasic , 125 octets

Une solution de 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

Sortie du programme (n = 7)

Taylor Scott
la source
1

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!

Asone Tuhid
la source
1

QBasic 1.1 , 124 octets

Prend des commentaires et tire un canon. En raison des limitations de taille d'écran,n doit être 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
Taylor Scott
la source
1

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.

Koishore Roy
la source
1

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!

griffonner
la source