इस हीरे को छापो

76

यह प्रश्न मेरे कार्यालय में वायरस की तरह फैल रहा है। काफी तरह के दृष्टिकोण हैं:

निम्नलिखित प्रिंट करें:

        1
       121
      12321
     1234321
    123454321
   12345654321
  1234567654321
 123456787654321
12345678987654321
 123456787654321
  1234567654321
   12345654321
    123454321
     1234321
      12321
       121
        1

कम पात्रों में उत्तर बेहतर तरीके से बनाए जाते हैं।

code-golf  ascii-art  kolmogorov-complexity 
— एरिक विल्सन
स्रोत
4
जीतने की कसौटी क्या है? और क्या यह एक चुनौती या एक गोल्फ है?
— पॉल आर
21
मैंने "kolmogorov-complexity" को "कोड-गोल्फ" के रूप में पढ़ा।
— डेविड
1
सवाल पूछने के बाद @DavidCarraher "kolmogorov-complexity" को संपादित किया गया। मूल प्रश्नकर्ता ने विजयी मानदंड अभी तक निर्दिष्ट नहीं किया है।
— गारेथ
@Gareth मेरी टिप्पणी "kolmogorov-complexity" टैग जोड़े जाने के बाद की गई थी, लेकिन "कोड-गोल्फ" टैग जोड़े जाने से पहले। उस समय लोग अभी भी पूछ रहे थे कि क्या यह एक कोड-गोल्फ प्रश्न था।
— डेविड ऑक्ट
3
perlmonks.com/?node_id=891559 के पास पर्ल समाधान हैं।
— 19

जवाबों:

24

जे, २ ९ २६ २४ २३ २२ २१ चरस

,.(0&<#":)"+9-+/~|i:8

चाल के लिए FUZxxl के लिए धन्यवाद "+(मुझे नहीं लगता कि मैंने पहले कभी इस्तेमाल किया है u"v, हे)।

व्याख्या

                  i:8  "steps" vector: _8 _7 _6 ... _1 0 1 ... 7 8
                 |     magnitude
              +/~      outer product using +
            9-         inverts the diamond so that 9 is in the center
  (      )"+           for each digit:
      #                  copy
   0&<                   if positive then 1 else 0
       ":                copies of the string representation of the digit
                         (in other words: filter out the strictly positive
                          digits, implicitly padding with spaces)
,.                     ravel each item of the result of the above
                       (necessary because the result after `#` turns each
                        scalar digit into a vector string)
— जुगनू
स्रोत
"0]लिखने के बजाय "+।
— फ़ूजएक्सएक्सएल
एक कम चरित्र के लिए, लिखें,.0(<#":)"+9-+/~|i:8
— FUZxxl
1
यहाँ आपके समाधान का APL के 25 अक्षरों में अनुवाद किया गया है:⍪↑{(0<⍵)/⍕⍵}¨9-∘.+⍨|9-⍳17
— FUZxxl
25

एपीएल ( 33 31)

A⍪1↓⊖A←A,0 1↓⌽A←⌽↑⌽¨⍴∘(1↓⎕D)¨⍳9

यदि स्थानों को अलग करने की अनुमति दी जाती है (जैसा कि गणितज्ञ प्रविष्टि में), तो इसे 28 26 तक छोटा किया जा सकता है :

A⍪1↓⊖A←A,0 1↓⌽A←⌽↑⌽∘⍕∘⍳¨⍳9

स्पष्टीकरण:

  • (लंबा कार्यक्रम :)
  • ⍳9: संख्या 1 से 9 तक की सूची
  • 1↓⎕D: ⎕Dस्ट्रिंग '0123456789' है, 1↓पहला तत्व निकालता है
  • ⍴∘(1↓⎕D)¨⍳9: के प्रत्येक तत्व एन के लिए ⍳9, पहले एन तत्वों से लें 1↓⎕D। यह एक सूची देता है: ["1", "12", "123", ... "123456789"] तार के रूप में

  • ⌽¨: इस सूची के प्रत्येक तत्व को उल्टा करें। ["1", "21", "321" ...]

  • (लघु कार्यक्रम :)

  • ⍳¨⍳9: एन [1..9] के लिए 1 से एन की सूची। यह एक सूची [[1], [1,2], [1,2,3] ... [1,2,3,4,5,6,7,8,9]] संख्याओं के रूप में देता है।
  • ⌽∘⍕∘: इनमें से प्रत्येक सूची के स्ट्रिंग प्रतिनिधित्व का उल्टा। ["१", "२ १" ...]
  • (अब से वही :)
  • A←⌽↑: सूचियों की सूची से एक मैट्रिक्स बनाता है, रिक्त स्थान के साथ दाईं ओर पैडिंग करता है, और फिर उसे उल्टा करता है। इससे हीरे का ऊपरी भाग निकलता है। यह ए में संग्रहीत है।
  • A←A,0 1↑⌽A: A, A के उल्टे दाएं से जुड़ा पहला स्तंभ है। यह आयत का ऊपरी आधा भाग देता है। यह फिर ए में संग्रहीत किया जाता है।
  • A⍪1↓⊖A: ⊖AA को मिरर किया गया है (निचले आधे हिस्से को), निचले आधे हिस्से 1↓की शीर्ष पंक्ति को हटा देता है और शीर्ष A⍪आधा ऊपर की तरफ है 1↓⊖A।
— मारीनस
स्रोत
5
+1 अद्भुत। क्या आप हमारे लिए एपीएल निरक्षरों का अनुवाद कर सकते हैं?
— डेविड
3
क्या गैर-एससीआईआई कोड को यूटीएफ -8 में कोड-पॉइंट के बजाय नहीं गिना जाना चाहिए? यह एपीएल को उसके सांसारिक रिश्तेदारों के करीब धकेल देगा।
— जॉन ड्वोरक
5
@JDDvorak नहीं, चूंकि एक एपीएल कोड पेज है , जो पूरे चरित्र को एक बाइट में सेट करता है। लेकिन मुझे लगता है कि आपने शायद 2013 के बाद किसी बिंदु पर इसका पता लगाया है;)
— मार्टिन एंडर
23

क्लोजर, 191 179 बाइट्स

#(loop[[r & s](range 18)h 1](print(apply str(repeat(if(< r 8)(- 8 r)(- r 8))\ )))(doseq[m(concat(range 1 h)(range h 0 -1))](print m))(println)(if s(recur s((if(< r 8)inc dec)h))))

-12 बाइट्स में बाहरी doseqको बदलकर a loop, जिसने मुझे atom(yay) से छुटकारा पाने की अनुमति दी ।

एक डबल "लूप के लिए"। बाहरी लूप ( loop) प्रत्येक पंक्ति पर जाता है, जबकि आंतरिक लूप ( doseq) पंक्ति में प्रत्येक संख्या पर जाता है, जो कि सीमा में है (concat (range 1 n) (range n 0 -1)), जहां nपंक्ति में सबसे अधिक संख्या है।

(defn diamond []
  (let [spaces #(apply str (repeat % " "))] ; Shortcut function that produces % many spaces
    (loop [[row-n & r-rows] (range 18) ; Deconstruct the row number from the range
           high-n 1] ; Keep track of the highest number that should appear in the row
      (let [top? (< row-n 8) ; Are we on the top of the diamond?
            f (if top? inc dec) ; Decided if we should increment or decrement
            n-spaces (if top? (- 8 row-n) (- row-n 8))] ; Calculate how many prefix-spaces to print
        (print (spaces n-spaces)) ; Print prefix-spaces
        (doseq [m (concat (range 1 high-n) (range high-n 0 -1))] ; Loop over the row of numbers
          (print m)) ; Print the number
        (println)

        (if r-rows
          (recur r-rows (f high-n)))))))

मेरे पहले प्रयास में तर्क में एक बग के कारण (गलती से प्रत्येक संख्या के बजाय उपसर्ग-रिक्त स्थान सम्मिलित करना), मैं इसे प्राप्त करने में कामयाब रहा:

1
1       2       1
1      2      3      2      1
1     2     3     4     3     2     1
1    2    3    4    5    4    3    2    1
1   2   3   4   5   6   5   4   3   2   1
1  2  3  4  5  6  7  6  5  4  3  2  1
1 2 3 4 5 6 7 8 7 6 5 4 3 2 1
12345678987654321
1 2 3 4 5 6 7 8 9 10 9 8 7 6 5 4 3 2 1
1  2  3  4  5  6  7  8  9  8  7  6  5  4  3  2  1
1   2   3   4   5   6   7   8   7   6   5   4   3   2   1
1    2    3    4    5    6    7    6    5    4    3    2    1
1     2     3     4     5     6     5     4     3     2     1
1      2      3      4      5      4      3      2      1
1       2       3       4       3       2       1
1        2        3        2        1
1         2         1

स्पष्ट बग को अनदेखा करने पर भी सही नहीं, लेकिन यह अच्छा लग रहा था।

— Carcigenicate
स्रोत
20

गणितज्ञ 83 49 43 54 51

Print@@#&/@(Sum[k~DiamondMatrix~17,{k,0,8}]/.0->" ")

स्वरूपण में सुधार हुआ

केली लोडर की बदौलत 3 बाइट बच गए।

विश्लेषण

कोड का मुख्य भाग Sum[DiamondMatrix[k, 17], {k, 0, 8}], वुल्फरामअल्फा पर जांचा जा सकता है ।

निम्नलिखित दृष्टिकोण के अंतर्निहित तर्क को छोटे पैमाने पर दिखाता है। 

a = 0~DiamondMatrix~5;
b = 1~DiamondMatrix~5;
c = 2~DiamondMatrix~5;
d = a + b + c;
e = d /. 0 -> "";
Grid /@ {a, b, c, d, e}

ग्रिड

— DavidC
स्रोत
1
डेविड, तुमने मुझे इस बार हराया! :-)
— श्री। छिपकली
1
एक और कोशिश (55 वर्ण):f = Table[# - Abs@k, {k, -8, 8}] &; f[f[9]] /. n_ /; n < 1 -> "" // Grid
— डेविड मार्क
अभी भी एक और (71 वर्ण):Table[9 - ManhattanDistance[{9, 10}, {j, k}], {j, 18}, {k, 18}] /. n_ /; n < 1 -> "" // Grid
— डेविड मार्क
2
Grid@#@#@9&[Table[#-Abs@k,{k,-8,8}]&]/.n_/;n<1->""50 चरस।
— च्यानयोग
कोड का एक दृश्य प्रदर्शन:ArrayPlot[Sum[k~DiamondMatrix~17, {k, 0, 8}], AspectRatio -> 2]
— डेविड नोव 23'13
15

अजगर 2, 72 69 67 61

चतुर नहीं:

s=str(111111111**2)
for i in map(int,s):print'%8s'%s[:i-1]+s[-i:]
— स्टीवन रूंबल्स्की
स्रोत
1
पायथन 3+ में काम नहीं करता है, जिसे मुद्रित करने के लिए तर्कों के चारों ओर परेंस की आवश्यकता होती है :(
— ग्रिफिन
7
@Griffin: कोड गोल्फ में मैं पायथन 2 या पायथन 3 को चुनता हूं, जो इस बात पर निर्भर करता है कि मुझे फंक्शन होने के लिए प्रिंट की आवश्यकता है या नहीं।
— स्टीवन रूंबल्स्की
3
s=`0x2bdc546291f4b1`
— gnibbler
1
@gnibbler। बहुत चतुर सुझाव है। दुर्भाग्य से, उस हेक्साडेसिमल के रीप्रो में एक अनुगामी शामिल है 'L'।
— स्टीवन रूंबल्स्की
1
@gnibbler: यह 64-बिट प्लेटफॉर्म पर चलने वाले पायथन में काम करता है, लेकिन 32-बिट प्लेटफार्मों पर नहीं।
— कोनराड बोरोस्की
14

C, 79 वर्ण

v;main(i){for(;i<307;putchar(i++%18?v>8?32:57-v:10))v=abs(i%18-9)+abs(i/18-8);}
— बच्चे-खरगोश
स्रोत
4
कृपया स्पष्टीकरण दें?
— लुकास हेनरिक
1
@LucasHenrique कुल 307 वर्ण। i- 18-9 कार्टेज़ियन प्लेन पर x वैल्यू है जो खुद y- एक्सिस पर मिरर करती है। i / 18-8 x- अक्ष पर खुद को प्रतिबिंबित करने वाले कार्टेशियन विमान पर y मान है। 1: 1 विकर्ण प्राप्त करने के लिए उन्हें एक साथ जोड़ दें (जो 1: 1 हीरे पर संख्यात्मक परिवर्तन का कारण बनता है।-(32:57) -v ASCII 0-9 के लिए unichar संख्यात्मक मान है। 10 नई लाइन।
— अल्बर्ट रेनशॉ
14

अजगर 2, 60 59

for n in`111111111**2`:print`int('1'*int(n))**2`.center(17)

गालियाँ बकती हैं और फटकारती हैं।

— nneonneo
स्रोत
inकीवर्ड के बाद का स्थान हटाया जा सकता है, जैसे आपने printकीबोर्ड से किया था ।
— कोनराड बोरोस्की
@GlitchMr: धन्यवाद! अपडेट किया गया।
— nnonneo
मुझे Lआउटपुट के मध्य सात लाइनों में एक अतिरिक्त मिलता है ।
— स्टीवन रंबलस्की
आपको नहीं करना चाहिए ... आप पायथन के किस संस्करण का उपयोग कर रहे हैं?
— nnonneo
12

GolfScript, 33 31 30 अक्षर

एक और GolfScript समाधान

17,{8-abs." "*10@-,1>.-1%1>n}%

एक और चार्ट के लिए @PeterTaylor को धन्यवाद ।

पूर्व संस्करण:

17,{8-abs" "*9,{)+}/9<.-1%1>+}%n*

( ऑनलाइन रन करें )

17,{8-abs" "*9,{)+}/9<.-1%1>n}%
— हावर्ड
स्रोत
1
आपको अनुगामी रिक्त स्थान (प्रश्न में पाठ उनके पास नहीं है) की आवश्यकता नहीं है, इसलिए आप रिक्त स्थान में संख्याओं को जोड़ना छोड़ सकते हैं और एक चार को बचा सकते हैं17,{8-abs." "*10@-,1>.-1%1>n}%
— पीटर टेलर
12

गणितज्ञ 55 50 45 41 38

(10^{9-Abs@Range[-8,8]}-1)^2/81//Grid

Grid[(10^Array[{9}-Abs[#-9]&,17]-1)^2/81]

गणितज्ञ ग्राफिक्स

— chyanog
स्रोत
1
बहुत अच्छा काम।
— डेविड
@DavidCarraher धन्यवाद: D
— chyanog
मैं डेविड की टिप्पणी की प्रतिध्वनि करता हूं। आप इसे लेकर कैसे आए?
— मि। छिपकली
क्या मैंने आपके द्वारा लिखे गए छोटे संशोधन के साथ आपके उत्तर को अपडेट किया?
— श्री। छिपकली २13'१३ को
@ Mr.Wizard निश्चित रूप से।
— च्यानयोग
10

जावास्क्रिप्ट, 114

कोडगॉल्फ पर मेरी पहली प्रविष्टि!

for(l=n=1;l<18;n-=2*(++l>9)-1,console.log(s+z)){for(x=n,s="";x<9;x++)z=s+=" ";for(x=v=1;x<2*n;v-=2*(++x>n)-1)s+=v}
स्निपेट का विस्तार करें

यदि इसे और छोटा किया जा सकता है, तो कृपया टिप्पणी करें :)

— tomsmeding
स्रोत
लानत है!! मैंने अंतरिक्ष को याद किया और आधा हीरा बनाया। मुझे अब सोना चाहिए
— जूमलर
9

PHP, 92 90 वर्ण

<?for($a=-8;$a<9;$a++){for($b=-8;$b<9;){$c=abs($a)+abs($b++);echo$c>8?" ":9-$c;}echo"\n";}

केंद्र से स्थिति की मैनहट्टन दूरी की गणना और प्रिंट करता है। यदि यह 1 से कम है तो एक स्पेस प्रिंट करता है।

एक अनाम उपयोगकर्ता ने निम्नलिखित सुधार का सुझाव दिया (84 वर्ण):

<?for($a=-8;$a<9;$a++,print~õ)for($b=-8;$b<9;print$c>8?~ß:9-$c)$c=abs($a)+abs($b++);
— गैरेथ
स्रोत
दूसरा काम नहीं करता है।
— क्रिश्चियन
मुझे पता है कि बहुत देर हो चुकी है, लेकिन जब मुझे PHP स्क्रिप्ट दिखाई देती है, तो मुझे हमेशा गोल्फ की ज़रूरत होती है। प्रति मेटा के साथ स्किप किए गए 83 बाइट्स । इसके अलावा, आपको लगता है कि दूसरे कोड में कुछ एन्कोडिंग समस्याएं हैं। <?
— रेडक्लोवर
@Soaku दूसरा मेरा नहीं है। यह एक गुमनाम उपयोगकर्ता द्वारा मेरे उत्तर को संपादित करने के रूप में सुझाया गया था। मैंने इसे बिना जाँच के जोड़ा - वास्तव में यह निश्चित नहीं है कि उपयोगकर्ता ने इसे वास्तव में अपने स्वयं के प्रयास के रूप में पोस्ट क्यों नहीं किया। मेटा प्रश्न इस उत्तर को लगभग 3 साल बाद पोस्ट करता है।
— गैरेथ
मेरा मतलब था, कि मैं <?बायटेकाउंट में शामिल नहीं हूं। मैंने कुछ अन्य सुधार भी किए हैं।
— RedClover
8

कॉमन लिस्प, 113 अक्षर

(defun x(n)(if(= n 0)1(+(expt 10 n)(x(1- n)))))(dotimes(n 17)(format t"~17:@<~d~>~%"(expt(x(- 8(abs(- n 8))))2)))

पहले मैंने देखा कि हीरे के तत्वों को इस तरह व्यक्त किया जा सकता है:

  1   =   1 ^ 2
 121  =  11 ^ 2
12321 = 111 ^ 2

आदि।

xपुनरावर्ती रूप से आधार (1, 11, 111, आदि) की गणना करता है, जिसे चुकता किया जाता है, और फिर उसके द्वारा मुद्रित किया जाता है format। संख्याओं को उच्चतम पद तक लाने के लिए और फिर से नीचे जाने के (- 8 (abs (- n 8)))लिए मैं एक दूसरे लूप से बचने के लिए इस्तेमाल किया

— Strigoides
स्रोत
8

चारकोल (गैर-प्रतिस्पर्धात्मक), 13 बाइट्स

प्रतिस्पर्धा नहीं क्योंकि भाषा सवाल से (बहुत) नई है।

Ｆ⁹«ＧX⁻⁹ιＩ⁺ι¹→

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

कैसे?

क्रमिक रूप से छोटे, संकेंद्रित संख्या-हीरे एक-दूसरे के शीर्ष पर स्थित हैं:

Ｆ⁹«   Loop ι from 0 to 8:
ＧX     Draw a (filled) polygon with four equilateral diagonal sides
⁻⁹ι      of length 9-ι
Ｉ⁺ι¹    using str(ι+1) as the character
→       Move right one space before drawing the next one
— DLosc
स्रोत
4
यह अब मेटा में नई आम सहमति के अनुसार प्रतिस्पर्धा होनी चाहिए ।
— आधिकारिक
6

पॉवरशेल (2 विकल्प): 92 84 45 बाइट्स

1..8+9..1|%{' '*(9-$_)+[int64]($x='1'*$_)*$x}
1..9+8..1|%{' '*(9-$_)+[int64]($x='1'*$_)*$x}

संकेत के लिए स्ट्राइगोइड्स का उपयोग करने के लिए 1 ^ 2,11 ^ 2,111 ^ 2 ...

कुछ पात्रों को शेव किया:

  • दूर करना $w।
  • $xइसके पहले उपयोग की जगह नेस्टेड परिभाषा ।
  • रेंटेंट के समाधान से कुछ सुराग लिया :
    • +इसके बजाय पूर्णांक सरणियों को मिलाया जाता है, ,जिसके बजाय सरणियों के चारों ओर कोष्ठक को समाप्त करने और छोरों में घोंसले के शिकार की एक परत की अनुमति देता है।
    • 9-$_अधिक जटिल गणित और ऑब्जेक्ट विधियों के बजाय, आवश्यक रिक्त स्थान की लंबाई की गणना करने के लिए उपयोग किया जाता है। इससे इसकी आवश्यकता भी समाप्त हो गई $y।

स्पष्टीकरण:

1..8+9..1या 1..9+8..11 से 9 तक चढ़ते हुए पूर्णांकों की एक सरणी उत्पन्न करता है और फिर 1 से नीचे आता है।

|%{... }पूर्णांक सरणी को ForEach-Objectलूप में अंतर्निहित अलिया के माध्यम से पाइप करता है %।

' '*(9-$_)+ वर्तमान पूर्णांक को 9 से घटाता है, फिर इस पंक्ति के लिए आउटपुट की शुरुआत में कई रिक्त स्थान बनाता है।

[int64]($x='1'*$_)*$xजब तक वर्तमान पूर्णांक बड़ा है, तब तक एस $xकी एक स्ट्रिंग के रूप में परिभाषित करता 1है। तब इसे int64 ( E नोटेशन का उपयोग किए बिना 111111111 2 को ठीक से आउटपुट करने के लिए आवश्यक ) और वर्ग में परिवर्तित कर दिया जाता है ।

यहाँ छवि विवरण दर्ज करें

— Iszi
स्रोत
1
आप एक बाइट को बचाने के longबजाय कास्टिंग कर सकते हैंint64
— Veskah
बाइट बचाने का दूसरा तरीका1..8+9..1|%{' '*(9-$_)+ +($x='1'*$_+'L')*$x}
— mazzy
5

विम, 62 39 38 कीस्ट्रोक्स

एक टन बाइट बचाने के लिए @DJMcMayhem को धन्यवाद!

मेरा पहला विम जवाब, इतना रोमांचक!

i12345678987654321<ESC>qqYP9|xxI <ESC>YGpHq7@q

मैंने एक रिकॉर्डिंग के माध्यम से संख्या लिखने की कोशिश की, लेकिन यह बहुत लंबा है

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

स्पष्टीकरण:

i123 ... 321<ESC>                   Write this in insert mode and enter normal mode
qq                                  Start recording into register q
  YP                                Yank this entire line and Paste above
    9|                              Go to the 9th column
      xx                            Delete character under cursor twice
        I <ESC>                     Go to the beginning of the line and insert a space and enter normal mode
               Y                    Yank this entire line
                G                   Go to the last line
                 p                  Paste in the line below
                  H                 Go to the first line
                   q                End recording
                    7@q             Repeat this 7 times

संपादित करें:

मैंने 1 बाइट के Hबजाय उपयोग किया ggऔर बचा लिया

— क्रिक्टी लिथोस
स्रोत
आप इसे हटा सकते हैं maऔर बदल `ai<space>सकते हैं I<space>।
— DJMcMayhem
यदि आप चरण 1 को ऊपर और नीचे चिपकाने के लिए बदलते हैं, तो आप शायद चरण 3 को हटा सकते हैं।
— डीजेएमकेमहेम
@DJMcMayhem सुझाव के लिए धन्यवाद! मैं शुरू में कॉपी किए गए बिट्स के लिए एक नया रजिस्टर शुरू करने के बारे में सोच रहा था, लेकिन यह बहुत कम है!
— कृतिका लिथोस
5

APL (Dyalog Classic) , 20 19 बाइट्स

(⍉⊢⍪1↓⊖)⍣2⌽↑,⍨\1↓⎕d

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

⎕d अंक हैं '0123456789'

1↓पहला गिरा ( '0')

,⍨\ अदला-बदली स्कैन, यानी उलटा उपसर्ग '1' '21' '321' ... '987654321'

↑ रिक्त स्थान के साथ एक मैट्रिक्स में मिलाया गया:

1
21
321
...
987654321

⌽ मैट्रिक्स को क्षैतिज रूप से उल्टा करें

(... )⍣2ऐसा दो बार करें:

⍉⊢⍪1↓⊖⍉मैट्रिक्स की ट्रांसपोज़िशन ( ) खुद ( पहली पंक्ति के बिना) उल्टे मैट्रिक्स ( ) के साथ ⊢लंबवत ( ⍪) लंबवत रूप से ⊖( 1↓)

— NGN
स्रोत
4

आर, 71 अक्षर

रिकॉर्ड के लिए:

s=c(1:9,8:1);for(i in s)cat(rep(" ",9-i),s[0:i],s[(i-1):0],"\n",sep="")
— पाओलो
स्रोत
+1 - कुछ के साथ कुछ बचा सकता हैmessage(rep(" ",9-i),s[c(1:i,i:1-1)])
— flodel
@flodel आपको ध्यान देना होगा कि स्टडर्स को प्रिंट करता है, और आप for(i in s<-c(1:9,8:1))...बाइट बचाने के लिए भी कर सकते हैं
— Giuseppe
— Giuseppe
4

k ( 64 50 वर्ण)

-1'(::;1_|:)@\:((|!9)#'" "),'$i*i:"J"$(1+!9)#'"1";

पुरानी विधि: 

-1',/(::;1_|:)@\:((|!9)#\:" "),',/'+(::;1_'|:')@\:i#\:,/$i:1+!9;

— skeevey
स्रोत
(1+!9)#'"1"is,\9#"1"
— ngn
4

सीजेएम, 31 27 बाइट्स

CJam इस चुनौती से बहुत नया है, इसलिए यह उत्तर स्वीकार किए जाने के लिए योग्य नहीं है। हालांकि यह शनिवार की शाम की एक छोटी सी चुनौती थी। ;)

8S*9,:)+9*9/2%{_W%1>+z}2*N*

इसका परीक्षण यहां करें।

विचार पहले ऊपरी बाएँ वृत्त का चतुर्थ भाग बनाने के लिए है। यहाँ है कि कैसे काम करता है:

सबसे पहले, स्ट्रिंग " 123456789"का उपयोग करें 8S*9,:)+। यह तार 17 वर्ण लंबा है। अब हम स्ट्रिंग को 9 बार दोहराते हैं, और फिर इसे लंबाई 9 के सबस्ट्रिंग में विभाजित करते हैं 9/। 9 और 17 के बीच की बेमेल हर दूसरी पंक्ति को एक वर्ण बाईं ओर ले जाएगी। प्रत्येक लाइन पर इसकी प्रत्येक प्रिटिंग हमें मिलती है:

        1
23456789 
       12
3456789  
      123
456789   
     1234
56789    
    12345
6789     
   123456
789      
  1234567
89       
 12345678
9        
123456789

इसलिए यदि हम बस हर दूसरी पंक्ति को छोड़ देते हैं (जो आसानी से काम करके काम करती है 2%), तो हम वांछित के रूप में एक चतुर्थांश प्राप्त करते हैं:

        1
       12
      123
     1234
    12345
   123456
  1234567
 12345678
123456789

अंत में, हम इसे दो बार दर्पण करते हैं, यह सुनिश्चित करने के लिए बीच में ग्रिड को ट्रांसप्लांट करते हैं कि दो मिररिंग ऑपरेशन अलग-अलग अक्षों के साथ चलते हैं। मिररिंग ही है

_      "Duplicate all rows.";
 W%    "Reverse their order.";
   1>  "Discard the first row (the centre row).";
     + "Add the other rows.";

अंत में, हम सिर्फ नई लाइनों के साथ सभी लाइनों को जोड़ते हैं N*।

— मार्टिन एंडर
स्रोत
3

रूबी, 76 वर्ण

def f(a)a+a.reverse[1..-1]end;puts f [*1..9].map{|i|f([*1..i]*'').center 17}

सुधार का स्वागत करते हैं। :)

— मार्क रीड
स्रोत
1
69 वर्ण:f=->x{[*1..x]+[*1...x].reverse};puts f[9].map{|i|(f[i]*'').center 17}
— पैट्रिक ऑस्सिटी
शानदार टिप्पणी, मैं '...' नहीं जानता था और यह नहीं समझ पाया कि यह कैसे काम कर सकता है।
— जीबी
60 चरस:[*-8..8].map{|i|puts' '*i.abs+"#{eval [?1*(9-i.abs)]*2*?*}"}
— GB
3

बेगुंज -93 , 155 वर्ण

9:v:<,+55<v5*88<v-\9:$_68v
> v>     ^>3p2vpv  -1<!  *
, 1^  2p45*3+9<4:    ,:  +
g -^_75g94+4pg7^!    +^ ,<
1 : ^ `0    :-1$_:68*^$
^1_$:55+\-0\>:#$1-#$:_^

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

यह निश्चित रूप से अधिक गोल्फ हो सकता है, लेकिन यह मेरा पहला फ़नगे कार्यक्रम है और मेरा सिर पहले से ही दर्द कर रहा है। हालांकि बहुत मज़ा आया

— सिंह
स्रोत
3

जावास्क्रिप्ट, 170 बाइट्स

मेरा पहला कोड गोल्फ :)

golfed

a="";function b(c){a+=" ".repeat(10-c);for(i=1;i<c;i++)a+=i;for(i=2;i<c;i++)a+=c-i;a+="\n";}for(i=2;i<11;i++)b(i);for(i=9;i>1;i--)b(i);document.write("<pre>"+a+"</pre>");

Ungolfed

var str = "";
function row(line) {
    str += " ".repeat(10 - line);
    for (var i = 1; i < line; i++) {
        str += i;
    }
    for (var i = 2; i < line; i++) {
        str += line - i;
    }
    str += "\n";
}
for (var line = 2; line < 11; line++) {
    row(line);
}
for (var line = 9; line > 1; line--) {
    row(line);
}
document.write("<pre>" + str + "</pre>");
— Cr4xy
स्रोत
PPCG में आपका स्वागत है!
— Julвгений Новиков
2

पर्ल 56 54 वर्ण

-pस्विच के लिए 1 वर्ण जोड़ा गया ।

अनुक्रम उत्पन्न करने के लिए चुकता पुनर्मिलन का उपयोग करता है।

s//12345678987654321/;s|(.)|$/.$"x(9-$1).(1x$1)**2|eg
— ardnew
स्रोत
2

पर्ल, 43 + 1

-Eजिसके लिए आवश्यक है +1 जोड़नाsay

say$"x(9-$_).(1x$_)**2for 1..9,reverse 1..8

संपादित करें: थोड़ा छोटा

— चीनी पर्ल गोथ
स्रोत
2

पायथन, 65

for i in map(int,str(int('1'*9)**2)):print' '*(9-i),int('1'*i)**2
— गत्ते के डिब्बे का बक्सा
स्रोत
I=int;अपने कोड के लिए intI
— पूर्ववर्ती
@ मुझे लगता है कि यह सोचा था। हर बार intउपयोग होने वाले समय में यह 2 चार्ट बचाता है, और यह 3 बार उपयोग किया जाता है, इसलिए यह 6 वर्णों की लागत पर 6 चार्ट बचाता है।
— कार्डबोर्ड_बॉक्स
2

ग्रूवी 77 75

i=(-8..9);i.each{a->i.each{c=a.abs()+it.abs();print c>8?' ':9-c};println""}

पुराना संस्करण:

(-8..9).each{a->(-8..9).each{c=a.abs()+it.abs();print c>8?' ':9-c};println""}
— मार्को मार्टिनेली
स्रोत
एक 57 char groovy समाधान जोड़ा गया। आप बदल सकते हैं दोनों eachके साथ anyदो वर्ण को बचाने के लिए।
— मत्तीस बजरलैंड
2

जावास्क्रिप्ट, 137

पुनरावृत्ति के साथ:

function p(l,n,s){for(i=l;i;s+=" ",i--);for(i=1;i<=n;s+=i++);for(i-=2;i>0;s+=i--);return(s+="\n")+(l?p(l-1,n+1,"")+s:"")}alert(p(8,1,""))

पहली बार CG पर :)

या ११ Or

अगर मुझे एक जेएस कार्यान्वयन मिल सकता है जो 111111111**2उच्च परिशुद्धता के साथ निष्पादित होता है।
(यहां: 12345678987654320)

a="1",o="\n";for(i=0;i<9;i++,o+="         ".substr(i)+a*a+"\n",a+="1");for(i=8;i;i--)o+=o.split("\n")[i]+"\n";alert(o)
— Nippey
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.