Bir top mermisi, uçağının ilk gözbağında, Nağaç tepelerinden, ikinci gözbağında, N-1ağaç tepelerinden, vs. yörüngesinin en yüksek noktasına ulaşana kadar yükselir . Daha sonra göze düşen ağaç başına 1, 2, vb. Düşmeye başlar. Aynı zamanda top mermisi yatay olarak 1 ağaç tepesi / göz bağı hızıyla hareket ediyor.

Senin görevin yörüngeyi, İngiliz alfabesinden ardışık harfler ile çizmek. Harflerin tükenmesi durumunda, yeniden başla 'A'. Bir işlev veya program yazın. Giriş bir tamsayıdır N( 1≤N≤15). Çıktı, herhangi bir makul biçimde bir karakter matrisi olabilir; örneğin, yeni satırlarla ayrılmış bir dize veya bir dize listesi. Harflerin tümü küçük veya tümü büyük olabilir. Ekstra lider ve sondaki boşluklara izin verilir. Standart boşluklar yasaktır. Kısa kod daha iyi.

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 bayt

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

Çevrimiçi deneyin!

açıklama

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

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

Çevrimiçi çalıştırın ve hata ayıklayın

Aynı programın karşılık gelen ascii gösterimi budur.

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 bayt

Bu yaklaşım bir matrisi doldurur ve ardından matrisi yazdırır.

golfed

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

153 için @Giuseppe teşekkürler.

150 için @JDL teşekkürler.

@ Giuseppe'nin 112 için yaptığı yorumları ve şu anda 110 için bazı düzenlemeleri görün 109. Orijinal kodu kopyala.

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

Geçerli bir çıktı çiziyorsa 73 bayt

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 bayt

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

Çevrimiçi deneyin!

MATL , 29 bayt

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

Çevrimiçi deneyin!

Nasıl çalışır

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

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

Çevrimiçi deneyin!

açıklama

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 bayt

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

Çevrimiçi deneyin!

unrolled:

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 bayt

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

Bir noktada reversegörüşmelere dolaştım ve mümkün olduğunca kısa hale getirme fikrinden vazgeçtim. Sadece çalışan bir çözüm istiyorum. Hadi bakalım...

Ungolfed çeşitleri

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

Güncelleştirme

Olivier'in yorumuyla motive ettiğimde, birden fazla reversegörüşmeyi kestim ve karakterleri kesmek için bazı genel golf oyunları yaptım . Ayrıca ben için diğer adlar yarattı reverse, map-indexed, concat, repeatve stronlara birden çok kez her kullanılan çünkü.

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

cN değerini kabul eden ve bir satırlar listesi döndüren işlevi oluşturur .

Kömür , 33 31 bayt

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

Çevrimiçi deneyin! Bağlantı, kodun ayrıntılı bir versiyonudur. Düzenleme: Yalnızca @ ASCII-sayesinde 2 bayt kaydedildi. Açıklama:

≔⁰η

Geçerli harfi büyük harfle bir indeks olarak 0'a başlat.

Ｆ…±Ｎ⊕θ«

Giriþin olumsuzlamasýný giriþten giriþe kadar bir döngü yapýn.

¿ι→↓

Normalde her sütun bir öncekinin sağındadır. Ancak, sıfır için sütun yok. Bunun yerine, sol ve sağ tarafların hizalanmasını sağlamak için bir düzeltme yapılması gerekir.

Ｆ↔ι«

Sütundaki her harf için döngü.

Ｐ§αη

Geçerli mektubu yazdırın.

≦⊕η

Harf endeksini artırın.

¿›ι⁰↓↑

Yörüngenin hangi tarafına bağlı olduğumuza bağlı olarak yukarı veya aşağı hareket edin.

Perl 5 , -n 112 92 90 88 bayt

Bir kere olsun korkunç uzun printfkazanıyor gibi görünüyor.

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

Çevrimiçi deneyin!

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

Bu uygun büyüklükte bir dizi oluşturur, yörünge için endeksleri bulur ve onlara uygun karakteri atar. En karmaşık kısım, bir dize türüne çok kesik sayı dökümüne dayanan AZ karakterlerini üretmektir. Döndürülen nesne bir unicode dizisidir.

Düzenleme : Burada önerildiği gibi, AZ ( (r_[0:2*N]%26+65).view('U1')[::2]) karakterlerini üreten numpy kodunu değiştirerek 9 bayt kaydedildi .map

Python 3 , 139 136 bayt

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

Çevrimiçi deneyin!

Boyut ve ofset verilen, her katmanı tekrarlı olarak oluşturur.

Jo King sayesinde -3 bayt

J , ⁷⁸ 75 bayt

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

Çevrimiçi deneyin!

-3 ngn sayesinde

Python 2,182 bayt

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

Çevrimiçi deneyin!

Karakter listelerinin listesini döndürür. Burada ilkel doğrulama

Jöle , 35 bayt

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

Çevrimiçi deneyin!

Yabasic , 125 bayt

Bir temel grafik modunu kullanır çözüm ekranının doğru sütuna ve satırdaki karakterleri yazdırmak için.

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

Bu çözüm grafik modunu kullandığından, TIO'da çalıştırılamaz.

Çıktı

Aşağıda giriş için çıktı 7

Ruby , 106 103 bayt

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

Çevrimiçi deneyin!

QBasic 1.1 , 124 bayt

$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 bayt

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

Çevrimiçi deneyin!

Elimden geleni yaptım. Herhangi bir optimizasyon mümkün ise bana bildirin.

k4, 76 71 bayt

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

5 bayttan tasarruf etmek için bazı yeniden düzenleme

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

yarım saatlik çaba, biraz bayt'ı tıraş etme çabasıyla, ancak burada yapılabilecek daha çok şey var. geri döneceğim. eğlenceli bir meydan okuma!