एक गेंद का चाप खींचना

35

एक फेंकी गई गेंद की परवलयिक रेखा खींचना।

इनपुट गेंद का शुरुआती उर्ध्व वेग, धनात्मक पूर्णांक है v। हर सेकंड, गेंद 1सही दिशा में चलती है और अंतरिक्ष vलंबवत चलती है , और फिर गुरुत्वाकर्षण के कारण vकम हो जाती है 1। तो, ऊपर की ओर वेग अंत में नीचे से कुछ ही कदम vके लिए 0और करने के लिए नीचे -v, अंत में वापस अपने प्रारंभिक ऊंचाई तक नीचे गिरने।

गेंद की स्थिति एक परवलय का पता लगाती है। क्षैतिज स्थिति में x, इसकी ऊँचाई y=x*(2*v+1-x)/2, (0,0)नीचे बाईं ओर गेंद की प्रारंभिक स्थिति के साथ है।

Oनिर्देशांक के साथ गेंद के प्रक्षेपवक्र की आउटपुट एएससीआईआई कला यह कभी भी कब्जे में लेती है। आउटपुट पाठ का एक एकल बहु-पंक्ति वाला टुकड़ा होना चाहिए, समय के साथ पथ का एनीमेशन नहीं।

आउटपुट में कोई अग्रणी न्यूलाइन नहीं होना चाहिए और अधिकतम एक अनुगामी न्यूलाइन होना चाहिए। नीचे की रेखा स्क्रीन के बाएं किनारे के साथ फ्लश होनी चाहिए, अर्थात इसमें कोई अतिरिक्त अग्रणी स्थान नहीं है। ट्रेलिंग रिक्त स्थान ठीक हैं। आप मान सकते हैं कि आउटपुट लाइन की चौड़ाई आउटपुट टर्मिनल में फिट होती है।

v = 1

 OO 
O  O

v = 2

  OO  
 O  O 

O    O

v = 3

   OO   
  O  O  

 O    O 


O      O

v = 4

    OO    
   O  O   

  O    O  


 O      O 



O        O

v = 10

          OO          
         O  O         

        O    O        


       O      O       



      O        O      




     O          O     





    O            O    






   O              O   







  O                O  








 O                  O 









O                    O

संबंधित: शेख़ी गेंद सिमुलेशन

लीडरबोर्ड:

कोड स्निपेट दिखाएं

code-golf  ascii-art  physics 
— XNOR
स्रोत
हम लाइनों की एक सूची ouput कर सकते हैं?
— R
@ रायर नोप, स्ट्रिंग विथ न्यूलाइन्स।
— xnor
शिथिल रूप से संबंधित: codegolf.stackexchange.com/q/110410
— टाइटस
क्या मुझे केवल V> 0 के लिए खाते की आवश्यकता है?
— nmjcman101
हां, v सकारात्मक होगा।
— xnor

जवाबों:

17

चारकोल , 18 16 13 बाइट्स

-3 बाइट्स @Neil को धन्यवाद !

Ｆ⊕Ｎ«←OＭ⊕ι↓»‖Ｃ

व्याख्या

Ｆ⊕Ｎ«        »    For ι (implicitly from 0) to (1 + input as number)
       ←O          Print O, with print direction rotated 180 degrees
         Ｍ⊕ι↓     Move 1+ ι units down

                ‖Ｃ Reflect (in the default direction, right), leaving original intact

इसे ऑनलाइन आज़माएं! लिंक वर्बोज कोड है।

— ASCII-केवल
स्रोत
मुझे यह बहुत पसंद है, +1; साथ ही ओपी का आउटपुट अपरकेस "O" का उपयोग करता है। (ऐसा नहीं है कि यह सभी मामलों में मायने रखता है)
— अल्बर्ट रेनशॉ
यदि आप उपयोग करते हैं ↘Oतो आप 0 से N समावेशी के बजाय लूप कर सकते हैं जो आपको तुरंत दो बाइट्स बचाता है।
— नील
@ नील धन्यवाद! इसके अलावा, यह एक बहुत पुरानी पोस्ट है: पी (और मुझे आश्चर्य है कि क्या मुझे नई सुविधाओं का उपयोग करना चाहिए। शायद नहीं?)
— ASCII-only
कड़ाई से बोलते हुए मैंने केवल 1 बाइट बचाई है, जबकि अन्य दो बाइट्स आप के ⁺¹साथ बदल रहे हैं ⊕। हालाँकि अब जब आप इससे ←दूर चले गए हैं, ‖Ｃतो Oआप एक और बाइट को लिखकर बचा सकते हैं ↙OＭι↓, इसलिए मैं फिर से दो बाइट बचा सकता हूं।
— नील
इसके अलावा आप अपना TIO लिंक अपडेट करना भूल गए। और तकनीकी रूप से मेरा मानना ​​है कि अब हम नई सुविधाओं की अनुमति देते हैं, लेकिन मैं उन बाइट्स के लिए क्रेडिट का दावा नहीं कर सकता।
— नील
6

सी, 93 92

(ध्यान दें, टिप्पणियों में किसी को 87 मिले)

y,n;f(s){for(y=0;y<=s;){printf("%*c%*c",s-y+1,79,y*2+1,79);for(n=++y;s+1-n&&n--;)puts("");}}

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

पठनीय: 

y,n;f(s){
    for(y=0;y<=s;){
        printf("%*c%*c",s-y+1,79,y*2+1,79);
        for(n=++y;s+1-n&&n--;)puts("");
    }
}

टिप्पणियाँ:

मैं लूप के लिए दोनों को केवल एक में लूप के लिए ध्वस्त कर सकता हूं, कुल आउटपुट लाइनों की पुनरावृत्ति करके, जो सूत्र द्वारा दिया गया है: n*-~n/2+1

y,n,r;f(s){
    for(r=s,y=n=0;r<s*-~s/2+1;)
        y==n?printf("%*c%*c",s-y+1,79,y*2+1,79),y=0,++n:r++,y++,puts("");
}

लेकिन यह दो सेपरेट-लूप का उपयोग करने की तुलना में और भी अधिक बाइट करता है

— अल्बर्ट रेनशॉ
स्रोत
आप sशुरुआत में वृद्धि करके एक बाइट बचा सकते हैं , इस तरह से:y,n;f(s){++s;for(y=0;y<s;){printf("%*c%*c",s-y,79,y*2+1,79);for(n=++y;s-n&&n--;)puts("");}}
— Steadybox
@Steadybox मेरे लिए संकलन नहीं करेगा। इसके अलावा जब मुझे गिना गया तो मुझे 90 बाइट्स मिलीं (व्हॉट्सएप के पात्रों को हटाने के बाद)
— अल्बर्ट रेनशॉ
सभी मैं जोड़ने की थी गया था ++s;शुरुआत में और फिर बदल रहा है y<=sकरने के लिए y<sऔर s-y+1करने के लिए s-yऔर s+1-nकरने के लिए s-n, तो यह संकलन चाहिए (और 91 बाइट्स होना चाहिए)।
— स्टीडबॉक्स
ऐसा लगता है कि मेरी टिप्पणी में कोड ब्लॉक के एन्कोडिंग के साथ कुछ गड़बड़ है। टिप्पणी से कोड कॉपी करना और चिपकाना मेरे लिए या तो संकलन नहीं होगा।
— स्टेडीबॉक्स
1
— सीलिंगकैट
5

GNU sed, 41

  • स्कोर में -rझंडे से लेकर sed तक +1 शामिल हैं ।
s/$/OO/
:
s/(\s*) O( *)O$/&\n\1O \2 O/
t

इनपुट अनारी में है, रिक्त स्थान की एक स्ट्रिंग के रूप में - स्ट्रिंग की लंबाई इनपुट है।

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

— डिजिटल आघात
स्रोत
4

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

x=input()
for i in range(x):print' '*(x-i),'O'+' '*i*2+'O'+'\n'*(i-x+1and i)

बहुत साधारण। i-x+1and iअनुगामी नई-पंक्तियों का एक समूह को रोकने के लिए है।

— HyperNeutrino
स्रोत
नई शुरुआत को प्रिंट की शुरुआत की तरह, '\n'*(i-1)अनुगामी न्यूलाइन्स से बचने के दौरान 7 बाइट्स बचाता है।
— एमिग्ना
4

MATL , 19 17 बाइट्स

Q:tqYsQ79Z?PtPv!c

MATL ऑनलाइन पर यह कोशिश करो ! या सभी परीक्षण मामलों को सत्यापित करें ।

व्याख्या

Q        % Implicitly input v. Add 1
:        % Push [1 2 ... v+1]
tq       % Duplicate and subtract 1: pushes [0 1 ... v]]
Ys       % Cumulative sum: gives [0 1 3 6 ...]
Q        % Add 1: gives [1 2 4 7 ...]
79       % Push 79 (ASCII for 'O')
Z?       % Create sparse matrix from column indices [1 2 3 4 ...],
         % row indices [1 2 4 7 ...], and data 79
P        % Flip vertically
tP       % Duplicate, flip vertically
v        % Concatenate the two matrices vertically
!        % Transpose
c        % Convert to char. Implicitly display. Char 0 is shown as space
— लुइस मेंडो
स्रोत
4

05AB1E , 18 14 बाइट्स

अदनान की बदौलत 4 बाइट बच गईं

ƒ¶N×'ONúRÂJ}.c

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

व्याख्या

ƒ                   # for N in [0 ... input]
 ¶N×                # push N newlines
    'O              # push "O"
      Nú            # pad with N spaces in front
        RÂ          # reverese and create a reversed copy
          J         # join everything to a string
           }        # end loop
            .c      # pad lines until centered
— Emigna
स्रोत
14 बाइट्स के लिए: ƒ¶N×'ONúRÂJ}.c:)
— अदनान
@ अदनान धन्यवाद! मैंने .cएक अलग संस्करण के साथ कोशिश की , लेकिन यह तब अच्छी तरह से काम नहीं करता था। इसे इस एक के साथ ú
— आजमाना
निश्चित रूप से मेरे द्वारा चुने गए ज़िप विधि से बेहतर है, दिलचस्प दृष्टिकोण लंबवत।
— मैजिक ऑक्टोपस Urn
4

जावास्क्रिप्ट (ईएस 6), 98 92 89 84 78 बाइट्स

(-20 बाइट्स अरनॉल्ड के लिए धन्यवाद!)

f=(v,i=0)=>i>v?"":" "[r="repeat"](v-i)+0+" "[r](2*i)+0+`
`[r](i++<v&&i)+f(v,i)

एक पुनरावर्ती समाधान। यह भी मेरी पहली है कभी जावास्क्रिप्ट में जवाब है, तो कोमल हो कृपया! मैं अभी भी यह सब सीख रहा हूं क्योंकि इस साफ-सुथरी भाषा को प्रस्तुत करना है, इसलिए गोल्फ टिप्स की बहुत सराहना की जाती है। :)

टेस्ट स्निपेट

आपको संपूर्ण आउटपुट देखने के लिए स्क्रॉल करने की आवश्यकता हो सकती है।

f=(v,i=0)=>i>v?"":" "[r="repeat"](v-i)+0+" "[r](2*i)+0+`
`[r](i++<v&&i)+f(v,i)
<input id=i min=1 type=number><button onclick=alert(f(document.getElementById("i").value))>Submit</button>
स्निपेट का विस्तार करें

— आर। कप
स्रोत
इसके अलावा, बैकटिक स्ट्रिंग्स के अंदर वैरिएबल सहित, ${}केवल बाइट्स को बचाता है जब वैरिएबल हिस्सा स्थिर भागों से घिरा होता है। जैसे, इन तारों को हमेशा स्थिर भागों के साथ शुरू और समाप्त होना चाहिए।
— ल्यूक
@ अर्नुलद सभी सुझावों के लिए धन्यवाद! मैं वास्तव में इसकी प्रशंसा करता हूँ! :)
— आर। काप
@ सलाह के लिए धन्यवाद। वह काम आएगा। :)
— आर। काप
आप 0इसके बजाय सुरक्षित रूप से उपयोग कर सकते हैं "0"। वे तार के लिए मजबूर किया जाएगा। और दूसरे विचार पर: i++<v&&iवास्तव में एक बाइट से कम है (i<v)*++i।
— Arnauld
@Arnauld एक बार फिर धन्यवाद! :)
— आर। काप
3

RProgN 2 , 37 बाइट्स

x=0xR{y@xy-` *`o` y2**`o...2y{[` };};

मेरी तरह की गोल्फ भाषा के साथ उचित गोल्फ लैंगगेज में कूदने से पहले।

व्याख्या की

x=              # Set 'x' to the input
0xR{            # For everything between the input and 0
    y@          # Set the iteration value to y, for this function only.
    xy-` *      # Subtract y from x, repeat the string " " that many times.
    `o          # Push an "o" to the stack.
    ` y2**      # Push 2*y " "'s to the stack
    `o          # Push another "o" to the stack
    ...         # Concatenate the parts of this string together, giving us the two balls.
    2y{[` };    # For all numbers between 2 and y, add a newline.
};              #

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

— Ataco
स्रोत
3

रेटिना, 29 19 बाइट्स

 ?
$.`$*¶$&$'O$`$`O

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

रिक्त स्थान के एक भाग के रूप में एकरी में इनपुट लेता है। मेरे जावास्क्रिप्ट उत्तर का पोर्ट। संपादित करें: @ मार्टिनएंडर to के लिए धन्यवाद 10 बाइट्स सहेजे गए।

— नील
स्रोत
मैं केवल किसी के लिए रेटिना स्पिन के साथ आने की प्रतीक्षा कर रहा हूं जिसे रेट्सिना कहा जाता है।
— टाइटस
3

बैश , 76 बाइट्स

for((n=$1+1;--n;));{
yes ''|head -$n
r=$r›${n}AO
t=›${n}BO$t
}
echo O${r}O$t

केवल टर्मिनल में काम करता है क्योंकि यह एएनएसआई से बच दृश्यों का उपयोग करता है । ›सीएसआई बाइट ( 0x9 बी ) का प्रतिनिधित्व करता है ।

परीक्षण चालन

$ # The terminal's encoding must be set to ISO-8859-1.
$
$ xxd -g 1 arc.sh
0000000: 66 6f 72 28 28 6e 3d 24 31 2b 31 3b 2d 2d 6e 3b  for((n=$1+1;--n;
0000010: 29 29 3b 7b 0a 79 65 73 20 27 27 7c 68 65 61 64  ));{.yes ''|head
0000020: 20 2d 24 6e 0a 72 3d 24 72 9b 24 7b 6e 7d 41 4f   -$n.r=$r.${n}AO
0000030: 0a 74 3d 9b 24 7b 6e 7d 42 4f 24 74 0a 7d 0a 65  .t=.${n}BO$t.}.e
0000040: 63 68 6f 20 4f 24 7b 72 7d 4f 24 74              cho O${r}O$t
$
$ bash arc.sh 1
 OO
O  O
$ bash arc.sh 2
  OO
 O  O

O    O
$ bash arc.sh 3
   OO
  O  O

 O    O


O      O
$ bash arc.sh 4
    OO
   O  O

  O    O


 O      O



O        O
— डेनिस
स्रोत
आप sed $nqएक बाइट को बचाने के लिए उपयोग कर सकते हैं ।
— ज़ेपेलिन
दुख की बात है नहीं। मुझे अब और उपयोग करना होगा sed ${n}q।
— डेनिस
आर्ग, मैं देखता हूं, आप sed $n\qइसके बजाय कर सकते हैं , लेकिन इसका कोई मतलब नहीं है, क्योंकि यह उसी बाइट की गिनती के रूप में होगा head!
— जेपेलिन
3

आर, 89 बाइट्स

a=2*v+3
x=matrix(" ",a,v^2+1)
for(k in 0:v)x[c(1-k,k+2)+v,k^2+1]="o"
x[a,]="\n"
cat(x,sep="")
  • रिक्त स्थान के एक मैट्रिक्स बनाएँ (चर एक जोड़ी की बचत इस मैट्रिक्स की चौड़ाई है,)
  • आवश्यक स्थानों पर "ओ" एस भरें, नीचे और बाहर की तरफ चाप के ऊपर से काम करना
  • प्रत्येक मैट्रिक्स पंक्ति के अंत में एक नई पंक्ति जोड़ें
  • मैट्रिक्स को एक स्ट्रिंग और नीचे प्रिंट करें

यह गोल्फिंग में मेरा पहला प्रयास है, टिप्पणियों का स्वागत है ...

— user2390246
स्रोत
3

रोड़ा , 53 52 बाइट्स

f n{seq 0,n|{|i|["
"*i," "*(n-i),"O"," "*i*2,"O"]}_}

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

उपयोग: main { f(5) }

Ungolfed संस्करण:

function f(n) {
    seq(0, n) | for i do
        push("\n"*i, " "*(n-i), "O", " "*i*2, "O")
    done
}
— fergusq
स्रोत
क्या आप \n1 बाइट के बजाय एक शाब्दिक न्यूलाइन का उपयोग कर सकते हैं ?
— कृति लिथोस
@KritiiLithos यह काम करता है। धन्यवाद!
— फर्ग्यूसक
2

Befunge, 75 73 बाइट्स

<vp00:&
1<-1_:v#\+55:g01\-g01g00" O"1\*2g01" O"1p0
#@_\:v>$$:!
1\,:\_^#:-

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

पहली पंक्ति वेग, v में पढ़ती है और स्मृति में एक प्रति सहेजती है। दूसरी पंक्ति तब v से शून्य तक नीचे सूचीबद्ध होती है, मैं सूचकांक के साथ , और प्रत्येक पुनरावृत्ति पर ढेर पर चरित्र / लंबाई जोड़े के अनुक्रम को धकेलता है।

Length  Character
-----------------
1       'O'
i*2     ' '
1       'O'
v-i     ' '
i       LINEFEED

यह अनुक्रम रिवर्स आउटपुट में आवश्यक आउटपुट के एक प्रकार के रन-एन्कोडिंग का प्रतिनिधित्व करता है। पिछली दो पंक्तियाँ तो इन पात्रों / लंबाई जोड़े को स्टैक से निकाल देती हैं, आउटपुट करती हैं से अलग कर देती हैं , जब तक कि स्टैक खाली नहीं हो जाता, तब तक प्रत्येक वर्ण की लंबाई घटती है।

— जेम्स होल्डरनेस
स्रोत
2

जावा 8, 129 124 109 बाइट्स

golfed:

v->{String s="",t="";for(int j,y=0;y<=v;++y){for(j=0;j<v;++j)s+=j<y?"\n":" ";s+="o"+t+"o";t+="  ";}return s;}

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

Ungolfed:

public class DrawTheArcOfABall {

  public static void main(String[] args) {
    for (int i = 1; i < 6; ++i) {
      System.out.println(f(v -> {
        String s = "", t = "";
        for (int j, y = 0; y <= v; ++y) {
          for (j = 0; j < v; ++j) {
            s += (j < y ? "\n" : " ");
          }
          s += "o" + t + "o";
          t += "  ";
        }
        return s;
      } , i));
      System.out.println();
      System.out.println();
    }
  }

  private static String f(java.util.function.IntFunction<String> f, int v) {
    return f.apply(v);
  }
}
— पोक
लूप के लिए दूसरे नेस्टेड के लिए, मुझे लगता है for(;j<v;++)कि काम करेगा, क्योंकि इस समय पर j==y। इसके अलावा, आप पहले नेस्टेड लूप के अंदर लूप String t="";(12) और t+=" ";(8) के लिए मुख्य के अंदर एक दूसरा स्ट्रिंग चर जोड़कर तीसरे को निकाल सकते हैं । फिर तीसरा लूप बस बन जाता हैs+="o"+t+"o";
— nmjcman101
इसके अलावा, आप पहले दो नेस्टेड छोरों को जोड़ सकते हैं, for(j=0;j<v;++j)s+=j<y?"\n":" ";हालांकि मुझे यकीन नहीं है कि मेरी पिछली टिप्पणी के साथ यह कैसे होता हैt
— nmjcman101
आप t=""शुरुआत में साथ-साथ शुरुआत कर सकते हैं , और उसके t+=" "बाद आप प्रत्येक लूप को जोड़ देंगेs+="o"+t+"o"
— nmjcman101
2

VBA, 124 112 85 88 66 63 59 बाइट्स

For i=0To[A1]:?Space([A1]-i)"O"Space(2*i)"O"String(i,vbCr):Next

टेलर स्कॉट के लिए कुल धन्यवाद में 29 बाइट्स बचाए

यह VBA तत्काल विंडो में चलाया जाना चाहिए और उसी में परिणाम प्रिंट करें।

विस्तारित / प्रारूपित, यह हो जाता है:

For i=0 To [A1]
   Debug.Print Space([A1]-i) & "O" & Space(2*i) & "O" & String(i,vbCr)
Next

(यह पता चला है कि एक प्रिंट कमांड में एक ऑपरेटर के बिना कॉन्टैटेनेशन स्वचालित है।)

— इंजीनियर टोस्ट
स्रोत
b & s &स्पेस अलर्ट!
— कैलक्यूलेटरफल
मैंने कोशिश की और यह पहली बार हुआ। वापस जाने पर, मुझे एहसास हुआ कि इसका विस्तार होगा b &s &Stringलेकिन नहीं b&s&String। इसके अलावा, सबसे पहले मैंने सोचा था कि आप उस Spaceफ़ंक्शन का उपयोग करें, जो मेरे पास पूरी तरह से होना चाहिए और इससे अधिक बाइट्स की बचत हुई।
— इंजीनियर टोस्ट
आप गाढ़ा कर सकते हैं for i=0 To vऔर debug.? bकरने के लिए for i=0To vऔर Debug.?bके लिए क्रमश: -2बाइट्स। और जैसा कि आप जानते हैं, समुदाय की सहमति यह है कि ऑटोफोर्मेटिंग वाली भाषाओं के लिए, आप इसे स्वतः पूर्ण करने से पहले गिन सकते हैं, जिसका अर्थ है कि इन परिवर्तनों को करने के बाद आपके पास 85 बाइट्स की एक बाइट गिनती होनी चाहिए
— टेलर स्कॉट
दूसरी नज़र में, यह एक स्निपेट है - फ़ंक्शन या सबरूटीन नहीं; तो यह एक वैध समाधान नहीं है। मेरा मानना ​​है कि आप इसे एक्सेल वीबीए तत्काल विंडो फ़ंक्शन में परिवर्तित करके और [A1]( v=[A1]) से इनपुट लेते हुए इसे ठीक कर सकते हैं , मुझे नहीं लगता कि आपको वास्तव में sचर की आवश्यकता है ।
— टेलर स्कॉट
1
@TaylorScott रेट्रोस्पेक्ट में एक स्पष्ट सुधार की तरह लगता है, लेकिन मुझे नहीं पता था कि तत्काल खिड़की में एक ऑपरेटर को एक ऑपरेटर की आवश्यकता नहीं थी। वह मुझे भविष्य में कुछ बाइट्स बचाएगी। मुझे ;प्रिंट कमांड के अंत में एक जोड़ना था , हालांकि, क्योंकि यह डिफ़ॉल्ट रूप से एक अतिरिक्त लाइन ब्रेक जोड़ रहा था। धन्यवाद!
— इंजीनियर टोस्ट
1

जेली , 17 16 बाइट्स

‘Ḷ+\Ṛ⁶ẋ;€”Om0z⁶Y

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

कैसे?

‘Ḷ+\Ṛ⁶ẋ;€”Om0z⁶Y - Main link: v         e.g. 3
‘                - increment: v+1            4
 Ḷ               - lowered range             [0,1,2,3]
  +\             - reduce with addition      [0,1,3,6]
    Ṛ            - reverse                   [6,3,1,0]
     ⁶           - a space                   ' '
      ẋ          - repeat (vectorises)       ['      ','   ',' ','']
       ;€        - concatenate each with
         ”O      -     an 'O'                ['      O','   O',' O','O']
           m0    - concatenate reflection    ['      O','   O',' O','O','O','O ','O   ','O      ']
             z⁶  - transpose with space fill ['   OO   ','  O  O  ','        ',' O    O ','        ','        ','O      O']
               Y - join with line feeds      ['   OO   \n  O  O  \n        \n O    O \n        \n        \nO      O']
                 - implicit print
— जोनाथन एलन
स्रोत
1

PHP, 76 बाइट्स

for(;$argn>=0;$s.="  ")echo($r=str_repeat)("
",$i++),$r(" ",$argn--),o,$s,o;

इसे ऑनलाइन चलाएं echo <v> | php -nR '<code>'या परीक्षण करें ।

$argnइनपुट से नीचे 0और $iऊपर से 0 से छोरों ;
प्रिंट - उस क्रम में - प्रत्येक पुनरावृत्ति में

  • $i newlines (पहले पुनरावृत्ति में कोई नहीं)
  • बाएँ गद्दी: $argnरिक्त स्थान
  • बाईं गेंद: o
  • भीतरी गद्दी: 2*$iरिक्त स्थान
  • सही गेंद: o
— टाइटस
स्रोत
1

वी , 23 19 बाइट्स

2éoÀñYço/^2á O
HPJ>

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

समझाना

2éo            " Insert two 'o's
   Àñ          " <Arg> times repeat
     Y         " Yank the current (top) line.  This is always '\s*oo'
      ço/      " On every line that matches 'o'
         ^     " Go to the first non-whitespace character (the 'o')
          2á   " Append two spaces (between the two 'o's
             O " Add a blank line on top of the current one
H              " Go to the first line
 P             " Paste in front ('\s*oo')
  J            " Join this line with the blank line immediately after it
   >           " Indent once
— nmjcman101
स्रोत
1

जावास्क्रिप्ट (ईएस 6), 87 बाइट्स

f=
n=>' '.repeat(n+1).replace(/./g,"$`#$'O$`$`O").replace(/ *#/g,s=>[...s].fill``.join`
`)
<input type=number min=0 oninput=o.textContent=f(+this.value)><pre id=o>
स्निपेट का विस्तार करें

गैर-समाधान। अनुक्रमण की आवश्यकता कष्टप्रद थी, उपरोक्त दोनों और निम्नलिखित 62-बाइट (मुझे नहीं पता कि क्या यह एक छोटे रेटिना पोर्ट में परिणाम देगा) पुनरावर्ती समाधान:

f=n=>~n?` `.repeat(n)+`OO`+f(n-1).replace(/^ *O/gm,`
$&  `):``
— नील
स्रोत
0

ढेर, 67 63 बाइट्स

args 0#1+:@x:>{!n x\-1-' '*'O'+n 2*' '*+'O'+x 1-n!=n*LF*+out}"!

प्रारंभिक प्रयास, 67 बाइट्स

args 0# :@v 1+2*:>[:v:+1+\-2/*' '*'O'+''split]"!fixshape tr rev out

पूरा कार्यक्रम। कुछ इस तरह उत्पन्न करता है:

('O'
 ' ' 'O'
 ' ' 'O'
 'O')

जो गद्देदार, अनुप्रस्थ, उलट और आउटपुट होता है।

— कोनोर ओ ब्रायन
स्रोत
0

बैच, 163 बाइट्स

@set l=@for /l %%i in (1,1,%1)do @call
@set s=
%l% set s= %%s%%
@set t=
%l%:c&for /l %%j in (2,1,%%i)do @echo(
:c
@echo %s%O%t%O
@set s=%s:~1%
@set t=  %t%
— नील
स्रोत
0

रूबी, 52 बाइट्स

->x{(0..x).map{|a|$><<$/*a+' '*(x-a)+?O+' '*a*2+?O}}

कोई अनुगामी नईलाइन (नियमों द्वारा अनुमत: " अधिकतम एक अनुगामी नईलाइन पर ")

— जीबी
स्रोत
0

एएचके, 93 बाइट्स

m=0
n=1
f=%1%-1
Loop,%1%{
r=%r%{VK20 %f%}O{VK20 %m%}O{`n %n%}
m+=2
n++
f--
}
FileAppend,%r%,*

अगर मैं कैसे कीस्ट्रोक्स को दोहराने के अंदर गणित करने का पता लगा सकता हूं, तो यह बहुत अच्छा होगा।
- VK20एक स्थान के बराबर है
- यदि फ़ाइल नाम है, तो FileAppendआउटपुटstdout*

— इंजीनियर टोस्ट
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.