वर्णमाला तोप

Question

एक तोप को निकाल दिया जाता है ताकि उसकी उड़ान के पहले नेत्रगोलक में यह Ntreetops द्वारा चढ़ता है , दूसरी eyeblink द्वारा N-1treetops, आदि के दौरान जब तक यह अपने प्रक्षेपवक्र के उच्चतम बिंदु तक नहीं पहुंचता है। फिर यह जमीन से टकराने तक प्रति भौंहों पर 1, 2, आदि ट्रीटॉप्स गिरने लगता है। एक ही समय में तोप का गोला क्षैतिज रूप से 1 treetop / eyeblink के निरंतर वेग के साथ आगे बढ़ रहा है।

आपका काम अंग्रेजी वर्णमाला के लगातार अक्षरों के साथ प्रक्षेपवक्र आकर्षित करना है। यदि आप पत्रों से बाहर निकलते हैं, तो फिर से शुरू करें 'A'। एक समारोह या एक कार्यक्रम लिखें। इनपुट एक पूर्णांक N( 1≤N≤15) है। आउटपुट किसी भी उचित रूप में एक चरित्र मैट्रिक्स हो सकता है, उदाहरण के लिए एक नईलाइन-अलग स्ट्रिंग या स्ट्रिंग की सूची। पत्र सभी लोअरकेस या सभी अपरकेस हो सकते हैं। अतिरिक्त अग्रणी और अनुगामी रिक्त स्थान की अनुमति है। मानक खामियों को मना किया जाता है। कम कोड बेहतर है।

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

Comments

बारीकी से संबंधित ।

— डोम हेस्टिंग्स

उदाहरण में O और P समान स्तर पर क्यों हैं? अगर मैं युक्ति को सही ढंग से पढ़ूं, तो ऐसा लगता है कि इसे P के लिए एक treetop ऊपर जाना चाहिए और Q के लिए एक से उतरना चाहिए।

— Skyler

@ स्टाइलर हर टिक पर, वर्णमाला 1 दाईं ओर और N लंबवत रूप से जाती है। N हर टिक को घटाता है। बीच Oऔर P, टिक सही करने के लिए 1 जाता है, लेकिन 0 ऊपर या नीचे वार्ड।

— ओलिवियर ग्रेजायर

ऐसा लगता है कि वर्णमाला के तोप अब कैनन हैं।

— कार्ल विटथॉफ्ट

@ हैनह , मैं @ टोनहोसल के पर्ल समाधान के साथ छेड़छाड़ कर रहा था और 1 बाइट कम के साथ आया था, लेकिन यह केवल 14 तक का समर्थन करता है !

— डोम हेस्टिंग्स

Answer 1

05AB1E , 33 32 29 28 बाइट्स

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

इसे ऑनलाइन आज़माएं!

व्याख्या

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

Comments

मुझे ऐसा लगता है Nú»या ऐसा कुछ इस्तेमाल किया जा सकता है जिसे आप प्रिंट करने के लिए इस्तेमाल कर सकते हैं])~.c

— मैजिक ऑक्टोपस Urn

मैं यह सब यहाँ लागू कर सकता हूँ लेकिन यह 2 बाइट्स से भी बदतर है।

— मैजिक ऑक्टोपस Urn

Answer 2

स्टेक्स , 29 24 बाइट्स

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

इसे ऑनलाइन चलाएं और डीबग करें

इसी कार्यक्रम का संबंधित एएससीआई प्रतिनिधित्व है।

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

Answer 3

आर, 169 163 161 153 150 110 109 बाइट्स

यह दृष्टिकोण एक मैट्रिक्स में भरता है और फिर मैट्रिक्स को प्रिंट करता है।

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 के लिए @Giuseppe धन्यवाद।

धन्यवाद @JDL 150 के लिए।

112 के लिए @ Giuseppe की टिप्पणी देखें, और 110 के लिए कुछ संपादन अब 109। रिप मूल कोड।

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

यदि एक वैध आउटपुट की साजिश रचते हैं तो 73 बाइट्स

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

Comments

153 बाइट्स - आपके समाधान ने शीर्ष पर एक अतिरिक्त स्थान मुद्रित किया, जिसे मैंने तय किया, और फिर मैंने कुछ चीजों को नीचे कर दिया। अच्छा जवाब!

— Giuseppe

के Mapबजाय आप का उपयोग कर सकते हैं mapply?

— JDL

@JDL आप सही हैं। मैं हमेशा सोचता हूं कि मैप एक रैपर की lapplyजगह है mapply। 150 के लिए धन्यवाद

— व्लो

यह मुझे परेशान करता रहा, क्योंकि मुझे लगा कि row,columnजोड़े के [माध्यम से सीधे mapply(या Map) जाने के बजाय जोड़े द्वारा मैट्रिक्स को अनुक्रमित करने का एक तरीका होना चाहिए , इसलिए मुझे ऐसा करने का एक तरीका मिला। मैं भी याद आया कि writeमौजूद है और जगह ले सकता है catके लिए 112 बाइट्स !

— ग्यूसेप

@Giuseppe के बारे में मेरी टिप्पणी "" काम नहीं करती थी, लेकिन [<- के साथ, हम कुछ चर परिभाषाओं की आवश्यकता को समाप्त करते हुए, एक पंक्ति में सब कुछ निचोड़ने का प्रबंधन कर सकते हैं। 110 बाइट्स: tio.run/##K/qfpmCj@z@tNC@5JDM/…

— Vlo

Answer 4

पायथन 2 , 140 135 133 बाइट्स

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

इसे ऑनलाइन आज़माएं!

Answer 5

MATL , 29 बाइट्स

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

इसे ऑनलाइन आज़माएं!

यह काम किस प्रकार करता है

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

Answer 6

जावा (ओपनजेडके 8) , 121 बाइट्स

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

इसे ऑनलाइन आज़माएं!

व्याख्या

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

Answer 7

सी, 184 बाइट्स

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

इसे ऑनलाइन आज़माएं!

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

Comments

दिलचस्प है, मैं इसे संकलित नहीं कर सकता (कोई मुख्य नहीं है) लेकिन TIO can

— ngn

@ng यह सिर्फ एक फ़ंक्शन है , आपको mainइसे संकलित करने के लिए जोड़ने की आवश्यकता है। TIO पर, mainपाद लेख अनुभाग में है।

— स्टेडीबॉक्स

Answer 8

क्लोजर, 417 319 बाइट्स

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

कुछ बिंदु पर मैं उलझ गया reverse कॉल और इसे यथासंभव छोटा करने के विचार पर छोड़ दिया। मैं सिर्फ काम करने का हल चाहता था। हेयर यू गो...

छंटनी की गई

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

अद्यतन करें

ओलिवियर की टिप्पणी से प्रेरित होकर, मैंने कई reverseकॉल काटने और पात्रों को काटने के लिए कुछ सामान्य गोल्फिंग गुर लगाने में कामयाब रहा । इसके अलावा, मैं कल्पित नामों बनाया reverse, map-indexed, concat, repeatऔर strक्योंकि मैं उन्हें कई बार प्रत्येक इस्तेमाल किया।

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

फ़ंक्शन को बनाता है cजो मान n स्वीकार करता है और लाइनों की एक सूची देता है।

Comments

यह कोई जवाब नहीं है क्योंकि जाहिरा तौर पर गोल्फ के लिए कोई प्रयास नहीं है (आप भी ऐसा कहते हैं)।

— ओलिवियर ग्राएगोइरे

ठीक है, यह बहुत बेहतर है! ;-)

— ओलिवियर ग्रेगोइरे

Answer 9

चारकोल , 33 31 बाइट्स

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

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। संपादित करें: @ ASCII- केवल के लिए 2 बाइट्स सहेजे गए। स्पष्टीकरण:

≔⁰η

वर्तमान अक्षर को अपरकेस वर्णमाला में 0 में एक सूचकांक के रूप में प्रारंभ करें।

Ｆ…±Ｎ⊕θ«

इनपुट के नकार से इनपुट में समावेशी एक लूप बनाएं।

¿ι→↓

आम तौर पर प्रत्येक स्तंभ पिछले के दाईं ओर होता है। हालाँकि, शून्य के लिए कोई कॉलम नहीं है। इसके बजाय, यह सुनिश्चित करने के लिए एक सुधार की आवश्यकता है कि बाएँ और दाएँ पक्ष संरेखित करें।

Ｆ↔ι«

कॉलम में प्रत्येक अक्षर के लिए लूप।

Ｐ§αη

वर्तमान पत्र मुद्रित करें।

≦⊕η

पत्र सूचकांक में वृद्धि।

¿›ι⁰↓↑

हम जिस प्रक्षेप पथ पर हैं, उसके आधार पर ऊपर या नीचे जाएं।

Comments

ऐसा लगता है कि ऐसा करने का एक छोटा तरीका हो सकता है लेकिन यह सुनिश्चित नहीं है कि कैसे: /

— केवल

31 बाइट्स

— केवल

Answer 10

पर्ल 5 , -एन 112 92 90 88 बाइट्स

एक बार के लिए बहुत लंबे समय printfसे जीतने के लिए लगता है।

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

इसे ऑनलाइन आज़माएं!

Comments

अच्छा सुधार! मैं (A..Z)x9काम करने की कोशिश कर रहा था , लेकिन यह सीमा से बहुत कम था! केवल 91 के लिए था। :)

— डोम हेस्टिंग्स

@DomHastings तुम्हारा दो लगभग दोहराया अक्षर गणना के बीच तालमेल पर एक अच्छा प्रयास था। वह मुझे भी परेशान करता है।

— टन हास्पेल

Answer 11

पायथन 3 + सुन्न, 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

यह एक उचित आकार का सरणी बनाता है, प्रक्षेपवक्र के लिए सूचक ढूंढता है और उन्हें उपयुक्त वर्ण प्रदान करता है। सबसे जटिल हिस्सा अक्षर AZ उत्पन्न कर रहा है, जो एक स्ट्रिंग प्रकार की संख्या के बहुत हैकिश कलाकारों पर निर्भर करता है। लौटी हुई वस्तु एक यूनिकोड सरणी है।

संपादित करें : सहेजा गया 9 बाइट्स जो कि AZ ( (r_[0:2*N]%26+65).view('U1')[::2]) के साथ वर्णात्मक कोड उत्पन्न करता है map, जैसा कि यहां सुझाया गया है ।

Answer 12

पायथन 3 , 139 136 बाइट्स

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

इसे ऑनलाइन आज़माएं!

आकार और ऑफसेट को देखते हुए, प्रत्येक परत को पुन: उत्पन्न करता है।

-3 बाइट्स जो किंग की बदौलत

Comments

@JoKing धन्यवाद, मैं हमेशा ~ऑपरेटर के बारे में भूल जाता हूँ !

— मैथ्यू जेन्सेन

तुम भी बदल सकते हैं n and ... or''करने के लिए n*' 'and ...के लिए एक और बाइट

— जो राजा

Answer 13

जे , ⁷⁸ 75 बाइट्स

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

इसे ऑनलाइन आज़माएं!

-3 ngn के लिए धन्यवाद

Comments

(,|.)@i.@-->i.@-,i.

— ngn

धन्यवाद @ngn यह उन लोगों में से एक है जहां ऐसा महसूस हुआ कि 40-50 बाइट्स में एक समाधान होना चाहिए, लेकिन अगर मैं वहां नहीं देख पा रहा हूं ....

— जोनाह

Answer 14

पायथन 2 , 182 बाइट्स

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

इसे ऑनलाइन आज़माएं!

चरों की सूचियों की सूची लौटाता है। यहां आदिम सत्यापन

Answer 15

जेली , 35 बाइट्स

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

इसे ऑनलाइन आज़माएं!

Answer 16

याबेसिक , 125 बाइट्स

एक मूल समाधान जो स्क्रीन के सही कॉलम और पंक्ति में वर्णों को प्रिंट करने के लिए ग्राफिक्स मोड का उपयोग करता है।

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

क्योंकि यह समाधान ग्राफिक्स मोड का उपयोग करता है, इसलिए इसे TIO पर निष्पादित नहीं किया जा सकता है।

उत्पादन

नीचे इनपुट के लिए आउटपुट है 7

Answer 17

रूबी , 106 103 बाइट्स

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

इसे ऑनलाइन आज़माएं!

Answer 18

QBasic 1.1 , 124 बाइट्स

इनपुट लेता है और एक तोप को गोली मारता है। स्क्रीन आकार सीमाओं के कारण,$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

Answer 19

पायथन 3 , 190 बाइट्स

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

इसे ऑनलाइन आज़माएं!

मैंने अपना श्रेष्ठ प्रयास किया। मुझे पता है कि क्या कोई अनुकूलन संभव है।

Answer 20

k4, 76 71 बाइट्स

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

5 बाइट्स को बचाने के लिए कुछ पुनर्व्यवस्थापन + असाइनमेंट

---

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

कुछ बाइट्स को शेव करने के प्रयास के साथ आधे घंटे का प्रयास, लेकिन शायद बहुत अधिक है जो यहां किया जा सकता है। वापस आ जाएगा। मज़ा चुनौती!