सेमी-ज़िगज़ैग बनाएँ

29

आपको Nइनपुट के रूप में एक सकारात्मक पूर्णांक दिया जाएगा । आपका काम Nप्रत्येक पक्ष की लंबाई के सेमी-ज़िगज़ैग का निर्माण करना है N। चूंकि कार्य का स्पष्ट रूप से वर्णन करना अपेक्षाकृत कठिन है, इसलिए यहां कुछ उदाहरण दिए गए हैं:

जैसा कि आप देख सकते हैं, सेमी-ज़िगज़ैग बारी-बारी से विकर्ण और क्षैतिज रेखाओं से बना है, और यह हमेशा ऊपर-नीचे से दाएं तिरछे रेखा से शुरू होता है। ध्यान दें कि क्षैतिज रेखाओं पर वर्ण एक स्थान से अलग हो गए हैं।

नियम

  • आप इसके बजाय किसी भी गैर-व्हाट्सएप चरित्र का चयन कर सकते हैं O, यह असंगत भी हो सकता है।

  • आप परिणाम को स्ट्रिंग के रूप में या स्ट्रिंग्स की सूची के रूप में परिणाम दे सकते हैं, प्रत्येक एक पंक्ति का प्रतिनिधित्व करता है ।

  • आपके पास एक अनुगामी या अग्रणी नई रेखा हो सकती है।

  • डिफ़ॉल्ट ढीले लागू होते हैं।

  • आप इनपुट ले सकते हैं और किसी भी मानक माध्यम से आउटपुट प्रदान कर सकते हैं ।

  • यदि संभव हो, तो कृपया अपने सबमिशन में एक परीक्षण लिंक जोड़ें। मैं किसी भी जवाब को उकेरूंगा जो गोल्फ के प्रयासों को दिखाता है और इसका स्पष्टीकरण है।

  • यह कोड-गोल्फ है , इसलिए हर भाषा में बाइट्स में सबसे छोटा कोड जीत जाता है!

code-golf  ascii-art 
— श्री Xcoder
स्रोत
1
— मिस्टर एक्सकोडर
क्या हमें O के बीच रिक्त स्थान रखना है जो क्षैतिज हैं?
— HatsuPointerKun
1
@HatsuPointerKun ध्यान दें कि क्षैतिज रेखाओं पर वर्ण एक स्थान से अलग हो गए हैं। - हां, आपको स्पेस देना होगा।
— श्री एक्सकोडर
1
आह येस। मुझे पढ़ना सीखना चाहिए। धन्यवाद
— HatsuPointerKun
1
@ जॉन हैमिल्टन इनपुट के रूप में दिए गए किसी भी नंबर के लिए सैद्धांतिक रूप से काम करना चाहिए । उन्हें इस बात की चिंता नहीं करनी चाहिए कि स्क्रीन क्या पकड़ सकती है।
— मिस्टर एक्सकोडर

जवाबों:

10

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

ＦＮ«↶§7117ι×⁺#× ﹪ι²⁻Ｉθ¹»#

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

-5 नील को धन्यवाद ।

एएसटी:

Program
├Ｆ: For
│├Ｎ: Input number
│└Program
│ ├↶: Pivot Left
│ │└§: At index
│ │ ├'7117': String '7117'
│ │ └ι: Identifier ι
│ └Print
│  └×: Product
│   ├⁺: Sum
│   │├'#': String '#'
│   │└×: Product
│   │ ├' ': String ' '
│   │ └﹪: Modulo
│   │  ├ι: Identifier ι
│   │  └2: Number 2
│   └⁻: Difference
│    ├Ｉ: Cast
│    │└θ: Identifier θ
│    └1: Number 1
└Print
 └'#': String '#'
— आउटग्रॉफर को एरिक करें
स्रोत
चारकोल के लिए यह बहुत आसान था :)
— श्री एक्सकोडर
@ Mr.Xcoder यह वास्तव में वास्तव में ungolfed लगता है ... यकीन है कि यह कैसे गोल्फ के लिए नहीं।
— एर्ग आउटफोलर जूल
ओपी ने कहा कि चरित्र कोई भी हो सकता है और उसे सुसंगत होने की आवश्यकता नहीं है, इसलिए मैं ＦＮ§⟦↘→↗→⟧ι⁻Ｉθ¹→(केवल 15 बाइट्स) की तर्ज पर कुछ करने जा रहा था , लेकिन दिशाओं की सूचियाँ चारकोल में सही काम नहीं कर रही हैं। दया।
— चार्ली
@CarlosAlejo ने भी कोशिश की लेकिन दुर्भाग्य से यह काम नहीं करता है।
— आउटगॉल्फ जूल
1
@CarlosAlejo ＦＮ✳§⟦↘→↗→⟧ι⁻θ¹Oडेनिस के खींचने के बाद काम करेगी, ✳निर्देशन के लिए डाली जा रही है
— ASCII-only
7

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

n=input()
o,s=q='O '
def p(k,t=q*n+s*(4*n-6)):print(t*n)[k*~-n:][:n*3/2*~-n+1]
p(2)
for i in range(n-2):p(0,i*s+s+o+s*(4*n-7-2*i)+o+s*(2*n+i-2))
n>1>p(5)

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

  • n*3/2*~-n+1 प्रत्येक पंक्ति की चौड़ाई है: n3n / 2 (· (n + 1) + 1 वर्ण।
  • स्ट्रिंग q*n+s*(4*n-6)ऊपर और नीचे की पंक्तियों का प्रतिनिधित्व करती है। यदि हम इसे दोहराते हैं और टुकड़ा [2*(n-1):]करते हैं तो हमें शीर्ष पंक्ति मिलती है; अगर हम टुकड़ा [5*(n-1):]करते हैं तो हमें नीचे की पंक्ति मिलती है। इसलिए pऔर कॉल की परिभाषा p(2)और p(5)। लेकिन जब से हमें अन्य सभी लाइनों के लिए पुनरावृत्ति और लाइन-लेंथ स्लाइसिंग की आवश्यकता होती है, हम pलूप में पुन: उपयोग करते हैं।
  • i*s+s+o+…मध्य पंक्तियों के लिए सिर्फ एक उबाऊ अभिव्यक्ति है।
  • n>1>p(5)शॉर्ट-सर्किट होगा n≯1, अगर p(5)मूल्यांकन नहीं किया जाएगा। इसलिए, यह शॉर्टहैंड है if n>1:p(5)।
— लिन
स्रोत
वाह, बहुत बढ़िया समाधान, इतना चतुर। आपने मेरा
— उत्कर्ष
वाह, कभी नहीं पता था कि पायथन की तुलना में कम परिचालित किया गया था, +1।
— ज़ाचरी
6

गणितज्ञ, 126 125 121 112 104 89 86 बाइट्स

(m=" "&~Array~{#,#^2-#+1};Do[m[[1[i,#,-i][[j~Mod~4]],j#-#+i+1-j]]="X",{j,#},{i,#}];m)&
  • #एक अनाम फ़ंक्शन के लिए इनपुट संख्या (अंतिम द्वारा समाप्त &) है।
  • m=" "&~Array~{#,#^2-#+1};#,#^2-#+1निरंतर अनाम फ़ंक्शन "आउटपुट ए स्पेस" के आउटपुट के साथ दिए गए आयामों की एक सरणी को भरकर सही आकार के अंतरिक्ष वर्णों का एक मैट्रिक्स बनाता है " "&।
  • Do[foo,{j,#},{i,#}]नेस्टेड लूप्स की एक जोड़ी है, जहां jसे 1लेकर #अंदर तक की iसीमा होती 1है #।
  • m[[1[i,#,-i][[j~Mod~4]],j#-#+i+1-j]]="X"सेट चरित्र होने के लिए मैट्रिक्स के इसी हिस्से Xके आधार पर jऔर i। -iबाइट्स से बचाने के लिए नकारात्मक अनुक्रमण का उपयोग करता है #-i+1। (मैं लिखना भूल Mod[j,4]के रूप में j~Mod~4इस कोड के मूल संस्करण में।) Jenny_mathy ने बताया कि हम मॉड्यूलर अवशेषों अनुक्रमण करने के लिए सूची में सीधे (बजाय का उपयोग करने से उपयोग कर सकते हैं Switch) 9 बाइट्स को बचाने के लिए, और JungHwan मिन कि हम नहीं था 'बताया t का उपयोग करने की आवश्यकता है ReplacePartक्योंकि हम एक सरणी का एक भाग निर्धारित कर सकते हैं और जो बाइट्स को बचाने 1[i,#,-i][[j~Mod~4]]के [[foo]]लिए विषम व्यवहार और व्यापकता का उपयोग करता है{1,i,#,-i}[[j~Mod~4+1]]
  • चूंकि मेटा ने स्थापित किया था कि पात्रों की एक सूची एक स्ट्रिंग है (जैसा कि जुंगवान मिन ने बताया ) हमें वर्णों के मैट्रिक्स की पंक्तियों में किसी भी फ़ंक्शन को मैप करने की आवश्यकता नहीं है क्योंकि यह पहले से ही "स्ट्रिंग" की सूची है।

आप इसे वुल्फराम क्लाउड सैंडबॉक्स में निम्नलिखित की तरह कोड पेस्ट करके और Shift + Enter या numpad दर्ज करके हिट कर सकते हैं।

(m=" "&~Array~{#,#^2-#+1};Do[m[[1[i,#,-i][[j~Mod~4]],j#-#+i+1-j]]="X",{j,#},{i,#}];m)&@9//MatrixForm
— निशान।
स्रोत
1
बहुत अच्छा! आप स्ट्रिंग को इंगित कर सकते हैं ""> <& # 4 बाइट को बचाने के लिए
— J42161217
@ जेनी_माथी टिप के लिए धन्यवाद! यह बहुत उपयोगी लगता है।
— मार्क एस।
2
आप स्विच [...] को {1, i, #, - i} [[j ~ mod ~ 4 + 1]] से बदल सकते हैं और 9 बाइट्स बचा सकते हैं!
— J42161217
1
आप वास्तव में ReplacePartयहाँ की जरूरत नहीं है। m=ReplacePart[...]हो सकता है m[[{1,i,#,-i}[[j~Mod~4+1]],j#-#+i+1-j]]="X"- आप कर सकते हैं Setएक Partएक सूची की। कि 15 बाइट्स से छुटकारा मिलता है।
— जुंगह्वान मिन
1
{1,i,#,-i}[[j~Mod~4+1]]भी हो सकता है 1[i,#,-i][[j~Mod~4]]। यह ट्रिक काम करती है क्योंकि एक एक्सप्रेशन का [[0]]रिटर्न देता है Head।
— जुंगहवान मिन
4

सी ++, 321 234 बाइट्स

-87 बाइट्स Zacharý को धन्यवाद

#include<vector>
#include<string>
auto z(int n){std::vector<std::string>l;l.resize(n,std::string(n*n+n/2*(n-1),32));l[0][0]=79;int i=0,j,o=0;for(;i<n;++i)for(j=1;j<n;++j)l[i%4?i%4-1?i%4-2?0:n-j-1:n-1:j][i*n+j-i+(o+=i%2)]=79;return l;}

स्ट्रिंग्स का एक वेक्टर लौटाता है

— HatsuPointerKun
स्रोत
मैंने इसे 318 बाइट्स में बदल दिया: repl.it/JpJ2
— Zacharý
सुधार, मैं इसे नीचे 239 बाइट्स के लिए मिला : repl.it/JpJ2/1
— Zacharý
स्पैम के लिए क्षमा करें, 234 बाइट्स: repl.it/JpJ2/3
— Zacharý
1
आपके स्वागत के अलावा मैं क्या कह सकता हूं!
— ज़ाचरी
@ Zacharý आपको बहुत बहुत धन्यवाद
— HatsuPointerKun
4

गणितज्ञ, 179 बाइट्स

Rotate[(c=Column)@(t=Table)[{c@(a=Array)[" "~t~#<>(v="o")&,z,0],c@t[t[" ",z-1]<>v,z-1],c@a[t[" ",z-2-#]<>v&,z-1,0],c@t[v,z-Boole[!#~Mod~4<1]-1]}[[i~Mod~4+1]],{i,0,(z=#)-1}],Pi/2]&

@JungHwanMin के लिए संपादन करें

— J42161217
स्रोत
मुझे उम्मीद नहीं थी कि यह छोटा होगा, अच्छी तरह से किया जाएगा!
— मिस्टर एक्सकोडर
बस एक सवाल: Mod[z,4]==0साथ बदला जा सकता है Mod[z,4]<1?
— श्री एक्सकोडर
हां, मैं कुछ चीजें नीचे कर सकता हूं ...
— J42161217
3
मैं वास्तव में गणितज्ञ को नहीं जानता, लेकिन क्या आप -1 बाइट्स के Mod[#,4]साथ बदल सकते हैं #~Mod~4?
— श्री एक्सकोडर
1
उफ़… गलती से नीचे उतर गया। क्या आप उत्तर को संपादित कर सकते हैं ताकि मैं उसे उल्टा कर सकूं?
— जंगवान मिन
4

05AB1E , 21 20 19 बाइट्स

कोड

नए कैनवास मोड का उपयोग करता है:

Fx<)Nè'ONÉúR3212NèΛ

05AB1E एन्कोडिंग का उपयोग करता है । इसे ऑनलाइन आज़माएं!

स्पष्टीकरण:

F                      # For N in range(0, input)
 x<)                   #   Push the array [input, 2 × input - 1]
    Nè                 #   Retrieve the Nth element
      'ONÉúR           #   Push "O" if N is odd, else "O "
            3212Nè     #   Retrieve the Nth element of 3212
                  Λ    #   Write to canvas

इनपुट 6 के लिए , यह कैनवास के लिए निम्न तर्क (उसी क्रम में) देता है:

[<num>, <fill>, <patt>]
[6,     'O',     3]
[11,    'O ',    2]
[6,     'O',     1]
[11,    'O ',    2]
[6,     'O',     3]
[11,    'O ',    2]

यह समझाने के लिए कि कैनवास क्या करता है, हम ऊपर दी गई सूची से तर्कों का पहला सेट चुनते हैं।

संख्या 6 स्ट्रिंग की लंबाई निर्धारित करती है जिसे कैनवास में लिखा जाएगा। भराव का उपयोग कैनवास पर लिखने के लिए किया जाता है, जो इस मामले में है O। यह भराव स्ट्रिंग के माध्यम से चक्रीय रूप से चलता है। स्ट्रिंग की दिशा अंतिम तर्क द्वारा निर्धारित की जाती है, दिशा। निर्देश हैं:

7  0  1
 \ | /
6- X -2
 / | \
5  4  3

इसका मतलब यह है कि 3 दक्षिण-पूर्व की दिशा निर्धारित करता है , जिसे ऑनलाइन भी आज़माया जा सकता है ।

— अदनान
स्रोत
यह भी ध्यान दें कि कैनवास मोड विकास में है और बहुत अस्थिर है
— अदनान
: O 05AB1E चारकोल में बदल रहा है (यह भी चारकोल O_o को हरा रहा है)
— केवल
@ ASCII- केवल हाँ, मैंने सभी ASCII- आधारित भाषाओं (चारकोल, SOGL, V, आदि) का उदय देखा और पृष्ठभूमि में 05AB1E सिंक किया, इसलिए मुझे इसके बारे में कुछ करना था: p
— अदनान
तो आपने चारकोल की नकल की? : P 05ab1e में एक कैनवास और दिशात्मक मुद्रण भी है (हालाँकि लकड़ी का कोयला केवल अजगर के माध्यम से लंबाई के साथ मुद्रण की इस शैली का समर्थन करता है)
— ASCII-only
2

SOGL V0.12 , 36 बाइट्स

╝.H∫2\?.╝}F2%?№@.┌Ο};1w⁄Hh1ž}.4%1>?№

यह कोशिश करो!

मूल विचार इनपुट रेंज के प्रत्येक नंबर के लिए या तो एक विकर्ण या क्षैतिज बिंदीदार भाग को चुनना है, जिस स्थिति में यह आसानी से जोड़ने के लिए सरणी को चारों ओर मोड़ देगा। स्पष्टीकरण:

╝                                     get a diagonal from the bottom-left corner with the length of the input - the starting canvas
 .H∫                        }         for each number in the range [1,inp-1] do, pushing counter
    2\?  }                              if it divides by 2, then
       .╝                                 create another diagonal of the input
          F2%                           push counter % 2
             ?     }                    if that [is not 0]
              №                           reverse the current canvas upside down
               @.┌Ο                       get an alternation of spaces and dashes with the dash amount of the input length
                    ;                   get the canvas on top of the stack
                     1w⁄                get its 1st element length
                        H               decrease it
                         h              swap the bottom 2 items - the canvas is now at the bottom and the current addition ontop
                          1             push 1
                           ž            at 1-indexed coordinates [canvasWidth-1, 1] in the canvas insert the current part made by the Ifs
                             .4%1>?   if input%4 > 1
                                   №    reverse the array vertically

यदि 1 के इनपुट की अनुमति नहीं थी, तो ο.∫2%?.╝}F2\?№@.┌Ο};1w⁄Hh1ž}.4%1>?№यह भी काम करेगा। यदि यादृच्छिक संख्याओं को इधर-उधर करने की अनुमति दी गई है तो .∫2%?.╝}F2\?№@.┌Ο};1w⁄Hh1ž}.4%1>?№यह भी काम करेगा। यदि मैं आलसी और कार्यान्वित नहीं था ‼, }F2%?तो इसे ‼-4 बाइट्स के साथ बदल दिया जा सकता है

— dzaima
स्रोत
2

गणितज्ञ, 106 87 बाइट्स

SparseArray[j=i=1;k=#-1;Array[{j+=Im@i;k∣#&&(i*=I);j,#+1}->"o"&,l=k#+1,0],{#,l}," "]&

की एक SparseArrayवस्तु लौटाता है String। आउटपुट की कल्पना करने के लिए, आप एपेंड कर सकते हैं Grid@। मामले के लिए एक त्रुटि फेंकता है 1, लेकिन इसे अनदेखा करना सुरक्षित है।

व्याख्या

j=i=1

सेट करें iऔर j1 को।

k=#-1

kइनपुट पर सेट करें - 1।

l=k#+1

को सेट lकरेंk*input + 1

Array[ ..., l= ...,0]

Iterate lबार, से शुरू 0, 1प्रत्येक समय में वृद्धि ...

j+=Im@i

के काल्पनिक घटक जोड़े iके लिए j...

k∣#&&(i*=I)

यदि वर्तमान पुनरावृत्ति विभाज्य है k, iतो काल्पनिक इकाई से गुणा करें ...

{... j,#+1}->"o"

एक Ruleऐसी स्थिति बनाएं जो तत्व को स्थिति में बदलता {j, current iteration + 1}है"o"

SparseArray[ ...,{#,l}," "]

SparseArrayउत्पन्न Ruleवस्तुओं का उपयोग करके एक ऑब्जेक्ट बनाएं , आयाम के साथ {input, l}, " "रिक्त के रूप में उपयोग करके ।

वुल्फराम सैंडबॉक्स पर इसे आज़माएं!

— जंगहवान मिन
स्रोत
1
केस n = 3
— J42161217
1
n = 2, 4,5,6 में भी शुद्धता की समस्या है, लेकिन मुझे लगता है कि यह 7 और ऊपर के लिए काम करता है। मैं उत्सुक हूँ: क्या कोई मिसाल के तौर पर कोई मिसाल है SparseArray? इसका उपयोग करके कल्पना की जा सकती है Gridया MatrixForm, लेकिन मैं इसे सामान्य रूप से "तार की एक सूची" के रूप में नहीं गिनूंगा। यदि वर्णों का 2 डी सरणी पर्याप्त होता है, तो उदाहरण के लिए, मेरे समाधान से 8 बाइट्स काटता है (12 जेनी_मैथी की मदद से पहले)।
— मार्क एस।
1
@निशान। इसके अलावा, स्ट्रिंग की एक सरणी प्रति सर्वसम्मति के अनुसार ठीक है । अगर कुछ स्पष्ट नहीं है, तो कृपया ओपी से पूछें (क्योंकि वह / वह नियम बनाता है, हमें नहीं)। इस साइट में "स्पार्सअरे" की एक सरल खोज SparseArray, प्रतिक्रियाओं की बहुतायत देती है , इसलिए मुझे लगता है कि यह ठीक है।
— जुंगह्वान मिन
1
@निशान। इसके अलावा, इस पृष्ठ पर गोल्फ गणितज्ञों की बहुत सारी चालें हैं।
— जुंगहवान मिन
1
@JungHwanMin मैंने अपना उत्तर संपादित किया जैसा आपने पूछा
— J42161217
2

पायथन 3 , 228 226 224 215 197 195 बाइट्स

-11 बाइट्स @Mr को धन्यवाद। Xcoder

-2 बाइट्स @Mr को धन्यवाद। Xcoder

def f(n,s=range):
 x=y=t=c=0;z=[]
 for i in s(n*n-n+2):c+=i%(n-(2<=n))<1;z+=[[x,y]];t=max(t,x);x+=2-c%2;y+=[-1,1][c%4<3]*(c%2)
 return'\n'.join(''.join(' O'[[k,j]in z]for k in s(t))for j in s(n))

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

स्पष्टीकरण और कम-गोल्फ कोड:

def f(n):
 x=y=t=c=0;z=[]                       #initialize everything
 for i in range(n*n-n+2):             #loop n*n-n+2 times which is the numberr of 'o's expected
    c+=i%[~-n,n]<n-1                  #if one cycle has been completed, increase c by 1, if n>1.                                            
    z+=[[x,y]]                        #add [x,y] to z(record the positions of 'o')
    t=max(t,x)                        #trap maximum value of x-coordinate(to be used later while calculatng whole string)
    r=[[2,0],[1,1],[2,0],[1,-1]][c%4] #r gives direction for x and y to move, adjust it as per c i.e. cycles
    x+=r[0];y+=r[1]                   #yield newer values of x and y 
 return '\n'.join(''.join(' o'[[k,j]in z]for k in range(t))for j in range(n)) #place space or 'o' accordingly as per the recorded posititons in z
— officialaimm
स्रोत
1
बहुत अच्छा काम। बधाई हो!
— श्री एक्सकोडर
@ Mr.Xcoder धन्यवाद। मुझे कहना होगा कि यह कठिन था, विशेष रूप से सही रेंज की पहचान करने में समस्याएं थीं।
— आधिकारिक
1
— श्री एक्सकोडर
1
215 बाइट्स , if 2>n:return'o'काफी बेमानी है। मैंने c+=i%[~-n,n][2>n]<1इसके बजाय एक काम बना दिया c+=i%~-n<1।
— श्री एक्सकोडर
1
बहुत देर से सुधार के लिए खेद है, 195 बाइट्स
— श्री Xcoder
1

हास्केल , 197 बाइट्स

a n c=take(2*n)$cycle$c:" "
r i n x y=take(div(3*n)2*(n-1)+1)$(' '<$[1..i])++(cycle$"O "++(a(2*n-i-3)y)++"O "++(a(n+i-2)x))
z n=take n$(r 0 n 'O' ' '):[r i n ' ' ' '|i<-[1..n-2]]++[r(n-1)n ' ' 'O']

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

@Lynn के लिए धन्यवाद: Ozigzag के क्षैतिज खंडों के बीच रिक्त स्थान निर्धारित किया गया था , लेकिन इसमें बहुत सारे बाइट्स खर्च हुए!

कुछ स्पष्टीकरण:

  • rआउटपुट की एक पंक्ति है: इसमें 0 y y y y y 0 x x x 0 y ...प्रारूप xऔर yपंक्ति और प्रारंभिक के आधार पर संख्या होती हैn
  • शीर्ष पंक्ति के लिए, x='0'औरy=' '
  • मध्य पंक्तियों के लिए, x=' 'औरy=' '
  • निचली पंक्ति के लिए, x=' ' औरy='0'
  • take(div(3*n)2*(n-1)+1) सही जगह पर एक अनंत पंक्ति काटता है
  • हर आउटपुट में एक शीर्ष पंक्ति और एक निचला पंक्ति होती है सिवाय जब n=1: take nइस मामले को संभालती है।
— jferard
स्रोत
अच्छी तरह से गोल्फ! आप उन स्थानों के एक जोड़े को गिरा सकते हैं, मुझे लगता है। और replicate n xद्वारा प्रतिस्थापित किया जा सकता है x<$[1..n]। इसके अलावा, आपके उत्तर में ज़िगज़ैग के Oक्षैतिज खंडों के बीच रिक्त स्थान का अभाव है ।
— लिन
@ लाइने थैंक्स! क्षैतिज सेगमेंट पर रिक्त स्थान के साथ, मेरा तरीका बोझिल हो जाता है, लेकिन मैं वैसे भी कोड को ठीक करना चाहता था ...
— जूलर्ड
आप ऑपरेटरों का उपयोग करके और अनावश्यक स्थानों को हटाकर काफी कुछ बचा सकते हैं, यहां देखें ।
— ბიმო
1

पायथन 2 , 155 151 146 137 बाइट्स

m=input()
n=m-1
r=range(n+2)
for L in zip(*[' '*i+'O'+n*' 'for i in(r+[n,m]*~-n+r[-2::-1]+([m,0]*n)[:-1])*m][:1+3*m/2*n]):print''.join(L)

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

— TFeld
स्रोत
@ Mr.Xcoder आह। मुझे अब दिख गया।
— TFeld
@ Mr.Xcoder अब फिक्स्ड।
— TFeld
मुझे गोल्फ पार्टी में एक साल की देर है, लेकिन `L`[2::5]बाइट खत्म हो जाती है''.join(L)
— श्री एक्सकोडर
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.