यह सिर्फ एक बग था

76

इस हीरे की चुनौती को प्रिंट करने के लिए @Carcigenicate क्लोजर जवाब में खराब हुए आउटपुट से प्रेरित ।

इस सटीक पाठ को प्रिंट करें:

1        2        3        4        5        6        7        8        9        0
1       2       3       4       5       6       7       8       9       0
1      2      3      4      5      6      7      8      9      0
1     2     3     4     5     6     7     8     9     0
1    2    3    4    5    6    7    8    9    0
1   2   3   4   5   6   7   8   9   0
1  2  3  4  5  6  7  8  9  0
1 2 3 4 5 6 7 8 9 0
1234567890
1 2 3 4 5 6 7 8 9 0
1  2  3  4  5  6  7  8  9  0
1   2   3   4   5   6   7   8   9   0
1    2    3    4    5    6    7    8    9    0
1     2     3     4     5     6     7     8     9     0
1      2      3      4      5      6      7      8      9      0
1       2       3       4       5       6       7       8       9       0
1        2        3        4        5        6        7        8        9        0

(दोनों दिशाओं में मध्य की ओर से, प्रत्येक अंक को पिछली पंक्ति की तुलना में एक अधिक स्थान द्वारा अलग किया जाता है।)

चुनौती नियम:

  • कोई इनपुट नहीं होगा ( या एक खाली अप्रयुक्त इनपुट )।
  • अनुगामी स्थान वैकल्पिक हैं।
  • एक एकल अनुगामी नई-लाइन वैकल्पिक है।
  • अग्रणी स्थान या नई-लाइनों की अनुमति नहीं है।
  • स्ट्रिंग-ऐरे को वापस करने की अनुमति नहीं है। आपको या तो पाठ को आउटपुट करना चाहिए, या एक फ़ंक्शन होना चाहिए जो सही परिणाम के साथ एक स्ट्रिंग देता है।

सामान्य नियम:

  • यह कोड-गोल्फ है , इसलिए बाइट्स जीत में सबसे छोटा जवाब है।
    कोड-गोल्फ भाषाओं को गैर-कोडगॉल्फिंग भाषाओं के साथ उत्तर पोस्ट करने से हतोत्साहित न करें। 'किसी भी' प्रोग्रामिंग भाषा के लिए यथासंभव संक्षिप्त उत्तर के साथ आने का प्रयास करें।
  • मानक नियम आपके उत्तर के लिए लागू होते हैं , इसलिए आपको उचित पैरामीटर और रिटर्न-टाइप, पूर्ण कार्यक्रमों के साथ STDIN / STDOUT, फ़ंक्शन / विधि का उपयोग करने की अनुमति दी जाती है। तुम्हारा कॉल।
  • डिफ़ॉल्ट ढीले निषिद्ध हैं।
  • यदि संभव हो, तो कृपया अपने कोड के लिए एक परीक्षण के साथ एक लिंक जोड़ें।
  • इसके अलावा, यदि आवश्यक हो तो एक स्पष्टीकरण जोड़ें।
code-golf  ascii-art  number  kolmogorov-complexity 
— केविन क्रूज़सेन
स्रोत
स्ट्रिंग्स की एक सरणी आउटपुट कर रहा है - प्रति पंक्ति 1 स्ट्रिंग - अनुमत है?
— झबरा
@ क्षमा करें, इस मामले में इसे या तो नई लाइनों के साथ एक स्ट्रिंग लौटा देना चाहिए, या परिणाम को आउटपुट करना चाहिए। मैंने इसे चुनौती के नियम के रूप में जोड़ा है।
— केविन क्रूज़सेन
कोई चिंता नहीं, केविन; सिर्फ यह देखने के लिए कि क्या मैं अपने आप को बाइट्स से बचा सकता था, मेरी बांह को सहला रहा था।
— झबरा
3
@ षग्गी हेहे। कोड-गोल्फ चुनौती में उन कुछ बाइट्स को बचाने के उद्देश्य के अलावा हमें और क्या कारण पूछने होंगे? ;)
— केविन क्रूज़सेन
8
हा, यह कमाल है। मैं सोच रहा था कि अचानक उस जवाब पर इतना ध्यान क्यों गया। धन्यवाद!
— कारजीनिकेट

जवाबों:

7

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

9{SUē↕∑}¹№╬«

यह कोशिश करो! स्पष्टीकरण:

9{     }      9 times do
  SU            push "1234567890"
    ē           push e, predefined with the input, which defaults to 0, and then increase it
     ↕          get that many spaces
      ∑         join the string of digits with those spaces
        ¹     collect the results in an array
         №    reverse the array vertically
          ή  palindromize vertically with 1 overlap
— dzaima
स्रोत
ओह अच्छा, यह स्वीकृत उत्तर से भी छोटा है। हम्म, एक जवाब स्वीकार किए जाने के दो महीने बाद छोटे उत्तरों पर क्या नीति है? क्या अब यह जांच हो जाती है (वर्तमान में स्वीकृत उत्तर जो मुझे लगता है कि अनुचित है), या मुझे कुछ और करना चाहिए? महान जवाब की परवाह किए बिना! मुझ से +1।
— केविन क्रूज़सेन
@ केविनक्रूजसेन आमतौर पर सबसे अच्छा अभ्यास स्वीकार किए गए उत्तर को अपडेट करना है, लेकिन जैसा कि यह एक दो नई सुविधाओं का उपयोग करता है, मैं कहूंगा कि किसी भी तरह से जाने का कारण है - आप चुनते हैं।
— द्विजिमा
62

पायथन 2 , 59 57 56 55 बाइट्स

i=8;exec"print(' '*abs(i)).join('1234567890');i-=1;"*17

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

@ लीक नन ने इसे बहुत मदद की, @Praind ने 1 बाइट को बचाने के लिए एक विधि का सुझाव दिया, जिसे मैंने पहले सोचा था, लेकिन संपादित करना भूल गया, @CotyJohnathanSaxman ने लूप बदलने का सुझाव दिया।

व्याख्या

  • i=8- 8एक चर नामक मान को असाइन करता है i।

  • exec"..."*17- कोड के उस ब्लॉक को निष्पादित करें ( ...) 17 बार।

  • print(...) - परिणाम का उत्पादन।

  • ' '*abs(i)- बार- |i|बार स्पेस वाली स्ट्रिंग बनाएं ।

  • .join('1234567890')- ऊपर बनाए गए स्ट्रिंग को इंटरलेव करें 1234567890, जैसे कि |i|अंकों के बीच रिक्त स्थान डाले जाते हैं।

  • i-=1- कमी i, और इसे 17 बार निष्पादित करके, यह पहुंचता है -8, जो की मदद से ते दोहराव पैटर्न बनाता है abs()।

— श्री Xcoder
स्रोत
5
— लीकी नून
23
यह किसी भी गोल्फिंग भाषा इमो में 25 बाइट्स से अधिक प्रभावशाली है।
— ज्योलू जूल
4
@ जाइलो धन्यवाद, लेकिन 25 बाइट समाधान बहुत प्रभावशाली हैं, क्योंकि वे अपने लेखकों द्वारा किए गए बहुत सारे गोल्फ प्रयास दिखाते हैं। आपको पहले पता होना चाहिए कि उनके स्रोत में प्रत्येक चरित्र का क्या मतलब है, और फिर आप समझ पाएंगे कि वे कितने सुंदर रूप से गोल्फ हैं।
— श्री एक्सकोडर
2
@ जैसनचैन नहीं, पायथन उस वाक्य रचना की अनुमति नहीं देता है, क्योंकि यह सी जैसी भाषाओं के लिए विशिष्ट है।
— श्री Xcoder
5
संभावित प्रेरणा: exec 55 बाइट्स के बिना भी किया जा सकता है । पायथन 3 को 57 बाइट्स पर लाने के लिए एक समान दृष्टिकोण का उपयोग किया । इसे कम करके देखने के लिए कोई स्पष्ट रास्ता नहीं देखा exec, लेकिन मुझे लगा कि मैं इसे एक संभावना के रूप में उल्लेख करूंगा।
— शैडो रेंजर
32

विम, 35 बाइट्स:

i1234567890<esc>qqYP:s/\d/& /g
YGp{q7@q

स्पष्टीकरण:

i1234567890<esc>    " insert '1234567890'
qq                  " Record the following into register 'q'
  Y                 "   Yank a line
   P                "   Paste it above us
    :s/\d/& /g      "   Put a space after each number
Y                   "   Yank this line
 G                  "   Move the end of the buffer
  p                 "   Paste the line
   {                "   Move the beginning of the buffer
    q               " Stop recording
     7@q            " Call macro 'q' 7 times
— DJMcMayhem
स्रोत
6
मुझे यह भी ध्यान नहीं है कि यह विजेता नहीं है, यह सुंदर है।
— मृदुक
@ मृदु थैंक्यू! मुझे खुशी है कि आप इसे पसंद :) हूँ
— DJMcMayhem
21

05AB1E ,  14  13 बाइट्स

17F9ÝÀN8αð×ý,

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

व्याख्या

17F            # for N in [0 ... 16] do
   9Ý          # push [0 ... 9]
     À         # rotate left
      N8α      # compute the absolute difference between N and 8
         ð×    # push that many spaces
           ý   # merge the list of digits with the space string as separator
            ,  # print
— Emigna
स्रोत
1
हम्म ... यदि आप की जरूरत नहीं है तो आप एसओजीएल को हरा सकते हैं s... क्या यह एक सूची के साथ एक स्ट्रिंग या एक स्ट्रिंग के साथ एक सूची में शामिल होने के लिए समझ में आता है? मैं अदनान को सुधारने का सुझाव दूंगा। ओह, और वहाँ के .∊लिए है û»।
— आउटगोल्फ जूल
@EriktheOutgolfer: या मैं अपना तरीका बदल सकता हूं और उस 1 बाइट को बचा सकता हूं जिसकी मुझे जरूरत है :)
— Emigna
सॉरी पहले से ही अपडाउन किया हुआ।
— निकोलस
3
इसका मतलब है कि मैंने फिर
— से उत्थान किया है
4
8F9ÝÀNð×ý}».∊मैंने किया था एक अंतरिक्ष यान बनाया! और मैं 12-बाइट संपादित करने का सुझाव देने के बारे में उत्साहित था।
— मैजिक ऑक्टोपस Urn
20

C64 ASM, 358 बाइट्स (102 बाइट्स बेसिकस्टब से संकलित)

यह स्पष्ट सीमाओं के कारण मुझे निकटतम मिल सकता है:

C64

jsr $E544
lda #9
sta $FD
nl1: jsr dl
jsr il
dec $FD
bne nl1
inc $FD
nl2: ldy $FD
cpy #9
bne nt1
bl: jmp bl
nt1: iny
sty $FD
jsr dl
jsr il
jmp nl2
dl: clc
ldx #$31
ldy #0
lp: txa
sm: sta $0400, y
inx
cpx #$31
bne c1
rts
c1: cpx #$3A
bne nt2
ldx #$30
clc
nt2: tya
adc $FD
cmp #40
bcc c2
rts
c2: tay
jmp lp
il: lda sm+1
adc #39
bcc nc
inc sm+2
nc: sta sm+1
rts

(शायद थोड़ा बहुत अनुकूलित किया जा सकता है)

— Jupp3
स्रोत
PPCG में आपका स्वागत है! सुंदर पोस्ट करने के लिए कृपया कोड टैग का उपयोग करें। मैंने आपको पोस्ट एडिट किया। परिवर्तनों को लागू करने के बाद आप देख सकते हैं, संपादन पर क्लिक करके क्या बदला
— Евгений Новиков
मैंने अभी-अभी जाँच की है और यह 80 कोल के पीईटी पर भी नहीं बैठेगा क्योंकि पहली और आखिरी पंक्ति में 82 कॉलम की आवश्यकता होती है।
— शॉन बेबर्स
17

TSQL, 220 148 बाइट्स

ZLK द्वारा पोस्ट किया गया सुधार:

DECLARE @ VARCHAR(MAX)=''SELECT TOP 17@+=REPLACE('1@2@3@4@5@6@7@8@9@0','@',SPACE(ABS(9-RANK()OVER(ORDER BY object_id))))+'
'FROM sys.objects PRINT @

आउटपुट:

1        2        3        4        5        6        7        8        9        0
1       2       3       4       5       6       7       8       9       0
1      2      3      4      5      6      7      8      9      0
1     2     3     4     5     6     7     8     9     0
1    2    3    4    5    6    7    8    9    0
1   2   3   4   5   6   7   8   9   0
1  2  3  4  5  6  7  8  9  0
1 2 3 4 5 6 7 8 9 0
1234567890
1 2 3 4 5 6 7 8 9 0
1  2  3  4  5  6  7  8  9  0
1   2   3   4   5   6   7   8   9   0
1    2    3    4    5    6    7    8    9    0
1     2     3     4     5     6     7     8     9     0
1      2      3      4      5      6      7      8      9      0
1       2       3       4       5       6       7       8       9       0
1        2        3        4        5        6        7        8        9        0
— जान ड्रोजेन
स्रोत
DECLARE @ VARCHAR(MAX)=''SELECT TOP 17@+=REPLACE('1@2@3@4@5@6@7@8@9@0','@',SPACE(ABS(9-RANK()OVER(ORDER BY object_id))))+' 'FROM sys.objects PRINT @
— ZLK
के sys.objectsसाथ बदलें sysobjects, और 1object_id` के साथ idमैंने sysस्कीमा में छोटी तालिकाओं की तलाश की , लेकिन कुछ भी छोटा नहीं था, जैसेsysobjects
— जलोपा
और आप इनर CAST(के साथ POWER(10))VARCHAR
— जलूपा
वास्तव में, उन सभी से बचें जो सामान का उपयोग करके प्रतिस्थापित करते हैं LOG10और REPLICATE:DECLARE @o VARCHAR(MAX)=''SELECT TOP 17 @o+=REPLACE('1@2@3@4@5@6@7@8@9@0','@',replicate(' ',LOG10(POWER(10,ABS(ROW_NUMBER()OVER(ORDER BY id)-9)+1)/10)))+' 'FROM sysobjects PRINT @o
— जलोपा
आप केवल @3 वर्णों को शेव करने के लिए चर नाम बदल सकते हैं ।
— ब्रिज
14

एपीएल (डायलॉग) , 22 बाइट्स

↑∊¨(1+|¯9+⍳17)↑¨¨⊂1⌽⎕D

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

⎕D डी शून्य से नौ तक igits

1⌽ एक कदम दाएं घुमाएं (अंत में शून्य डालता है)

⊂ संलग्न करें (इकाई के रूप में मानें)

(... )↑¨¨ के लिए प्रत्येक इन नंबरों की, से है कि कई पात्रों ले प्रत्येक पत्र की:

 ⍳17 सत्रह के माध्यम से एक

 ¯9+ नौ घटाना

 | पूर्ण मूल्यों का पता लगाएं

 1+ एक जोड़ें

∊¨ enlist (समतल) प्रत्येक

↑ गहराई की एक परत को रैंक के स्तर में बदलें (परिपक्व करें)

— एडम
स्रोत
3
इस तरह एक कॉम्पैक्ट भाषा में यह गंभीरता से एक को जोड़ने के लिए दो बाइट्स लेता है?
— 12
3
@aschepler हां। एपीएल एक गोल्फ भाषा नहीं है, और एक वृद्धि आदिम नहीं है। जे करता है, लेकिन यह दो बाइट्स लेता है; >:।
— एडम जूल
4
APL is not a golfing language... ↑⊃¨,/¨(1+|¯9+⍳17)↑¨¨⊂1⌽⎕D... at_ ...
— अलेक्जेंडर
1
@Alexander इस एक पर मेरा ध्यान आकर्षित करने के लिए धन्यवाद। मैं 3 बाइट गोल्फ कर सकता था।
— 15
12

जावा 11 (JDK) , 98 बाइट्स

o->{for(int i=-9;++i<9;)System.out.println("".join(" ".repeat(i<0?-i:i),"1234567890".split("")));}

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

  • -14 बाइट्स को JDK 11 पर स्विच करके, जिसमें अब एक देशी है String::repeat।

पिछला उत्तर ( जावा (OpenJDK 8) ), 113 112 बाइट्स

o->{for(int i=-9;++i<9;)System.out.printf("".join("%1$"+(i<0?-i:i>0?i:"")+"s","1234567890".split(""))+"%n","");}

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

स्पष्टीकरण

मैं मूल रूप से निम्नलिखित String17 बार निर्माण कर रहा हूं ( Nएक चर है, वास्तविक मूल्य नहीं):

"1%1$Ns2%1$Ns3%1$Ns4%1$Ns5%1$Ns6%1$Ns7%1$Ns8%1$Ns9%1$Ns0%n"

यह सभी अपेक्षित अंक हैं, %1$Nsजहां Nप्रत्येक अंक के बीच रिक्त स्थान की संख्या से जुड़ते हैं ।

%1$Nsमूल रूप से इसका अर्थ है "पहले तर्क को लें और इसे तब तक पैड करें जब तक कि लंबाई कम से कम न हो N"। इसके अलावा, %1$0sसमर्थित नहीं है इसलिए एक विशेष मामले के %1$sलिए बनाया गया है 0।

अंत में, मैं एक तर्क का उपयोग करके उस स्ट्रिंग ""को प्रारूपित करता हूं: इसलिए फॉर्मेटर हमेशा एक ही खाली स्ट्रिंग का पुन : उपयोग करता है, इसे आवश्यकतानुसार रिक्त स्थान के साथ पैडिंग करता है।

बचाता है

  • केविन क्रूज़सेन के लिए 1 बाइट धन्यवाद
— ओलिवियर ग्रेजायर
स्रोत
2
अच्छा जवाब! Btw, मैं स्पष्ट रूप से चुनौती एक अप्रयुक्त खाली पैरामीटर अनुमति दी है में उल्लेख किया है, तो आप बदल सकते हैं ()->के साथ o->एक बाइट को बचाने के लिए। :)
— केविन क्रूज़सेन
क्या आप oएक बना सकते हैं intऔर इसे अपने लूप के लिए उपयोग कर सकते हैं ? for(o=-9;++o<9;)
— शीतकालीन
2
@ नहीं, क्योंकि चुनौती " अप्रयुक्त " कहती है , और जो पैरामीटर चर का उपयोग करेगा, भले ही मूल्य का उपयोग नहीं किया जाएगा।
— ओलिवियर ग्राएगोयर
@ OlivierGrégoire यह इस पोस्ट कोडगॉल्फ.मेटा.stackexchange.com/questions/12681/… से लिंक करता है और यह पोस्ट केवल यह कहता है कि यह खाली होना चाहिए (ints के लिए 0)।
— विंटर
@ इंडिड वास्तव में, लेकिन चुनौती खुद को "अप्रयुक्त" कहती है। डिफॉल्ट को चुनौती देने वाले विशिष्ट नियम।
— ओलिवियर ग्रैगोइरे
11

जाप -R , 19 18 16 14 13 बाइट्स

Aõ%A
£qYçÃÔÅê

इसे टेस्ट करें या ऑनलाइन प्रयास करें

व्याख्या

A             :10
 õ           :Range [1,10]
  %A         :Modulo each by 10
\n           :Assign to variable U
£            :Map each element at 0-based index Y
 q           :  Join U with
  Yç         :   Space repeated Y times
    Ã        :End map
     Ô       :Reverse
      Å      :Slice off first element
       ê     :Mirror
             :Implicitly join with newlines and output
— झबरा
स्रोत
2
अच्छा लगा। मेरा 16-बाइट समाधान था9ÆAõ%A qXîÃw ê ·
— ETHproductions
8

जावास्क्रिप्ट (ES2017), 83 73 72 68 बाइट्स

10 बाइट बचाने के लिए धन्यवाद झबरा । 1 बाइट बचाने के लिए क्रेग धन्यवाद । 4 बाइट बचाने के लिए धन्यवाद आर्क्स ।

for(i=-9,a="";i++<8;)a+=[...`1234567890
`].join("".padEnd(i<0?-i:i))


for(i=-9,a="";i++<8;)a+=[...`1234567890
`].join("".padEnd(i<0?-i:i))

console.log(a);
.as-console-wrapper { max-height: 100% !important; top: 0; }
.as-console-row:after { display: none !important; }
स्निपेट का विस्तार करें

— तुषार
स्रोत
के लिए एक पॉलीफ़िल का उपयोग करके 1 बाइट बचाएं Math.abs। मैंने aसूची को हार्डकोड नहीं किया, लेकिन यह एक प्राथमिकता है ...a=[...Array(10).keys()];for(i=-8;i<9;i++)console.log(a.join(' '.repeat(i<0?-i:i)))
— थॉमस डब्ल्यू
1
कुछ बाइट्स बचाएं[..."1234567890"].join("".padEnd(i<0?-i:i))
— झबरा
@ शगुन थैंक्स। जिससे 10 बाइट बच गईं। :)
— तुषार
1
@ThomasW: पहले तत्व के रूप में [...Array(10).keys]होगा 0, अंतिम नहीं।
— झबरा
1
आप अपनी विधि का उपयोग करके एक बाइट को बचा सकते हैं जैसे कि लॉग करने के बजाय एक स्ट्रिंग में परिणाम जमा करना: for(i=-8,s="";i<9;i++)s+=[..."1234567890"].join("".padEnd(i<0?-i:i))+`X`जहां Xएक वास्तविक नई रेखा है
— क्रेग आयरे
7

ब्रेकीलॉग , 30 29 28 बाइट्स

Ị↺{∧≜;Ṣj₍g;?↔zcc}ᶠ⁹↔;XcP↔Pẉᵐ

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

लीक नयन के लिए एक बाइट धन्यवाद ।

व्याख्या

Ị↺                               The string "1234567890"
  {               }ᶠ⁹            Find the first 9 outputs of:
   ∧≜                              Take an integer
       ;Ṣj₍                        Juxtapose " " that number of times
           g;?↔z                   Zip that string of spaces with "1234567890"
                cc                 Concatenate twice into one string
                    ↔            Reverse the resuling list
                     ;XcP↔P      Palindromize the list (concatenate X to it into the list P,
                                   P reversed is still P)
                           ẉᵐ    Map writeln
— Fatalize
स्रोत
2
— लीकी नून
@ लीकन्यू मैं बड़े "इस सटीक पाठ को प्रिंट करें" पर अटक गया और यह नहीं पढ़ा कि हमारे पास अनुगामी लाइनें हो सकती हैं ...
— जूल
4
— लीकी नून
1
@LeakyNun आपने अपना उत्तर क्यों नहीं दिया?
— जूल
7

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

Ｆ⁹⪫⁺…Ｉ¹:⟦0¶⟧× ι‖Ｂ↑

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

Ｆ⁹      Repeat 9 times (i = loop variable)
  ⪫       Join
   ⁺       Concatentate
    …Ｉ¹:    All the characters from str(1) below ":" (i.e. to "9") as a list
    ⟦0¶⟧    A list whose element is the string "0\n"
   × ι     With i spaces
‖Ｂ↑     Reflect everything upwards but without duplicating the top line

नोट: Cast(1)बाइट्स की एक ही संख्या लेता है क्योंकि "1"इससे पहले एक विभाजक की आवश्यकता होगी ":"(जैसा कि ऐसा होता है कि डिवर्बोसिफायर डालने में विफल रहता है)।

— नील
स्रोत
7

आर , 108 बाइट्स

for(i in abs(-8:8))cat(paste0(el(strsplit("1234567890","")),paste(rep(" ",i),collapse=""),collapse=""),"\n")

बस तार को चिपकाना और ढहाना।

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

संपादित करें: एक समस्या को इंगित करने के लिए चैलेंजर 5 के लिए धन्यवाद। अब निश्चित कर दिया।

संपादित करें 2: बाउंसीबॉल के लिए एक बाइट धन्यवाद बचाया।

— Probel
स्रोत
साइट पर आपका स्वागत है! :)
— डीजेएमकेम
2
यह बिल्कुल सही नहीं लगता है - मध्य रेखा में बिल्कुल भी रिक्त स्थान नहीं होना चाहिए।
— फलन
@ चैलेंजर 5 आप सही हैं! के paste0बजाय का उपयोग करके इसे तय किया pasteथा एक बाइट जोड़ने के लिए :(
— Probel
1
2 बाइट्स का उपयोग करके elel(strsplit("1234567890",""))strsplit("1234567890","")[[1]]
— बचाएं
आप 70 बाइट्स को पाने के pasteलिए sepतर्क का उपयोग करके catऔर थोड़ा और करके बयानों से छुटकारा पा सकते हैं
— Giuseppe
7

पायथन 3 , 58 57 54 बाइट्स

i=8
while i+9:print(*'1234567890',sep=' '*abs(i));i-=1

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

(पिछले तीन बाइट्स के लिए @flornquake के लिए धन्यवाद; मैं sepबनाम बचाने के लिए उपयोग करना पूरी तरह से भूल गया .join)

— ShadowRanger
स्रोत
1
54 बाइट्स:while i+9:print(*'1234567890',sep=' '*abs(i));i-=1
— जूल
6

जावा 8, 235 234 206 163 बाइट्स

interface A{static void main(String[]a){for(int i=-8;i<9;i++){String s="";for(int j=1,k;j<10;j++){s+=j;for(k=0;k<(i>0?i:-i);k++)s+=" ";}System.out.println(s+0);}}}

अपडेट : -28 बाइट का शुक्रिया Leaky Nun!
अपडेट 2 : -43 बाइट्स फिर से लीक नून के लिए धन्यवाद!

अधूरा:

interface A {
    static void main(String[] a) {
        for (int i = -8; i < 9; i++) {
            String s = "";
            for (int j = 1, k; j < 10; j++) {
                s += j;
                for (k = 0; k < (i > 0 ? i : -i); k++)
                    s += " ";
            }
            System.out.println(s + 0);
        }
    }
}

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

संपादित करें: पहले वाला कोड गलत था! कोड को गोल्फ करते समय एक गलती हुई, इसे अभी के अनुसार काम करना चाहिए!

— एलेक्स फेरेटी
स्रोत
4
PPCG में आपका स्वागत है! जावा में गोल्फ के लिए सुझाव और टिप्स <सभी भाषाओं> में गोल्फ के लिए के माध्यम से पढ़ने के लिए दिलचस्प हो सकता है। :) कुछ चीजें जो आप गोल्फ को हटा सकते हैं public, और कुछ अनावश्यक स्थानों से छुटकारा पा सकते हैं। और सुधार करने के लिए कुछ और चीजें हैं, लेकिन मैं सुझाव के माध्यम से पढ़ने का सुझाव देता हूं, और देखें कि आप अपने आप को कहां सुधार सकते हैं। फिर से स्वागत है, और अपने प्रवास का आनंद लें! :)
— केविन क्रूज़सेन
2
हम्म, भी, क्या आप सुनिश्चित हैं कि आपने सही कोड पोस्ट किया है? जब मैं TryItOnline में आपके कोड को कॉपी-पेस्ट करता हूँ तो यह सही आउटपुट नहीं देता है।
— केविन क्रूज़सेन
1
Aww लानत है, मैंने कोड को गोल्फ करते समय कुछ गलत किया है! मैं इसे ठीक कर दूंगा!
— एलेक्स फेरेटी
1
— लीकी नून
1
— लीकी नून
6

भूसी , 21 बाइट्स

mΣṪ`:§+↔tḣR8' ṁs`:0ḣ9

यह एक पूर्ण कार्यक्रम है जो STDOUT पर प्रिंट करता है। इसे ऑनलाइन आज़माएं! बहुत सारे अनुगामी स्थान हैं।

व्याख्या

हस्क अभी भी दो-तर्क रेंज फ़ंक्शन जैसे आवश्यक सामानों को बहुत याद कर रहा है, इसलिए इस समाधान के कुछ हिस्सों को थोड़ा हैक किया गया है।

mΣṪ`:§+↔tḣR8' ṁs`:0ḣ9
              ṁs`:0ḣ9  This part evaluates to the string "1234567890".
                   ḣ9   Range from 1 to 9.
                `:0     Append 0.
              ṁs        Convert each number to string and concatenate.
     §+↔tḣR8'          This part evaluates to a list like ["  "," ",""," ","  "]
                       but with 17 elements instead of 5.
          R8'           A string of 8 spaces.
         ḣ              Take prefixes.
     §+                 Concatenate
       ↔                the reversal and
        t               tail of the prefix list, palindromizing it.
  Ṫ                    Take outer product of the two lists
   `:                  with respect to flipped prepeding.
                       This prepends each digit to each string of spaces.
mΣ                     Map concatenation over the results, computing the rows.
                       Implicitly join with newlines and print.
— Zgarb
स्रोत
आप बदल सकते ṁs`:0ḣ9साथ uṁsḣ10स्ट्रिंग "1234567890" एक कम बाइट के साथ उत्पन्न करने के लिए!
— सोफिया लेचनर
6

टी-एसक्यूएल 145 152 बाइट्स

DECLARE @ VARCHAR(MAX)=''SELECT TOP 17@+=REPLACE('1x2x3x4x5x6x7x8x9x0','x',SPACE(ABS(number-8)))+'
'FROM master..spt_values WHERE type='P'PRINT @

उपयोग करने के लिए अद्यतन :

  • master..spt_valuesसंख्या उत्पन्न करने के लिए ( WHERE type = 'P', ये हमेशा लगातार होते हैं, 0 पर शुरू होते हैं)
  • @ ZLK का TOP 17आइडिया
  • प्रिंट (नियमों का पालन करने के लिए - कोई स्ट्रिंगर नहीं)
  • @ जनरोजेन के महान विचार सहित गाड़ी की वापसी स्ट्रिंग में है (मैंने गिना कि सिर्फ एक बाइट के रूप में - विंडोज सीआरएलएफ क्या है?)
  • वैरिएबल नाम के लिए @Bridge का उपयोग करने का आईडिया - ये सभी ट्रिक !!

परिणाम:

1        2        3        4        5        6        7        8        9        0
1       2       3       4       5       6       7       8       9       0
1      2      3      4      5      6      7      8      9      0
1     2     3     4     5     6     7     8     9     0
1    2    3    4    5    6    7    8    9    0
1   2   3   4   5   6   7   8   9   0
1  2  3  4  5  6  7  8  9  0
1 2 3 4 5 6 7 8 9 0
1234567890
1 2 3 4 5 6 7 8 9 0
1  2  3  4  5  6  7  8  9  0
1   2   3   4   5   6   7   8   9   0
1    2    3    4    5    6    7    8    9    0
1     2     3     4     5     6     7     8     9     0
1      2      3      4      5      6      7      8      9      0
1       2       3       4       5       6       7       8       9       0
1        2        3        4        5        6        7        8        9        0

(साभार @JanDrozen for REPLACE विचार)

— उलटा इंजीनियर
स्रोत
यह एक अच्छा जवाब है! आपका स्वागत है साइट के लिए :)
— DJMcMayhem
धन्यवाद। मैं देख रहा हूँ कि हममें से कुछ लोगों ने यहाँ अपनी भाषाओं का आविष्कार किया है :)
— उल्टा इंजीनियर
1
इस उत्तर और दूसरे के बीच एक मिश्रण इष्टतम है: उदाहरण के लिए SELECT TOP 17REPLACE('1x2x3x4x5x6x7x8x9x0','x',SPACE(ABS(9-RANK()OVER(ORDER BY object_id))))FROM sys.objects(यह मानते हुए कि आपको प्रिंट करने की आवश्यकता नहीं है)।
— ZLK
Aha @ZLK - कुछ अच्छी ट्रिक्स - TOP 17, RANK OVER, और sys.objects - धन्यवाद!
— उल्टा इंजीनियर
6

क्लोजर, 126 99 बाइट्स

-27 एक दो गूंगा गलतियों को ठीक करके। बाहरी उपयोग aआवश्यक नहीं था, इसलिए मैं aपूरी तरह से छुटकारा पाने में सक्षम था और बस apply strएक बार लिखता था। उसने मुझे मुख्य फ़ंक्शन के लिए फ़ंक्शन मैक्रो का उपयोग करने की भी अनुमति दी, जिसने कुछ बाइट्स को बचाया। मैंने रिबॉन्डिंग के Math/absबजाय कॉल को इनलाइन किया n-spaces।

मूल रूप से @ Mr.Xcoder के पाइथन विचार का एक क्लोजर पोर्ट। रेट्रोस्पेक्ट में, मुझे मूल रूप से हीरे की चुनौती के लिए abs/ rangeविधि का उपयोग करना चाहिए था , लेकिन तब मैंने बगेड आउटपुट का उत्पादन नहीं किया होगा!

बहुत साधारण। संख्या स्ट्रिंग को कई रिक्त स्थान से जोड़ता है जो वर्तमान पंक्ति पर निर्भर करता है।

#(doseq[n(range -8 9)](println(clojure.string/join(apply str(repeat (Math/abs n)\ ))"1234567890")))
(defn bugged []
  (doseq [n-spaces (range -8 9)]
    (println
        (clojure.string/join
          ; "String multiplication"
          (apply str
                 (repeat (Math/abs n-spaces) \space))
          "1234567890"))))
— Carcigenicate
स्रोत
5

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

Column@Join[Reverse@(s=Row/@Table[Riffle[Range@10~Mod~10,""<>Table[" ",i]],{i,0,8}]),Rest@s]

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

ctrl-v
प्रेस शिफ्ट + के साथ कॉपी / पेस्ट कोड चलाने के लिए दर्ज करें

— J42161217
स्रोत
क्या आप शायद TryItOnline लिंक जोड़ सकते हैं ?
— केविन क्रूज़सेन
@ केविनक्रूजसेन मैथेमेटिका एक स्वतंत्र भाषा नहीं है, और मैथिक्स काम नहीं करता है ।
— लीक नून
@LeakyNun आह ठीक है, धन्यवाद। मुझे मार्टिनएंडर की पोस्ट TIO- लिंक कभी-कभी दिखाई देती है, लेकिन वे वास्तव में मैथिक्स लिंक थे।
— केविन क्रूज़सेन
1
@ केविन क्रूज़सेन बेशक, मैंने निर्देश के साथ लिंक जोड़ा
— J42161217
5

सी, 97 बाइट्स

i=-9;main(j){for(;++i<9;putchar(10))for(j=0;++j<11;printf("        "+8-abs(i)))putchar(48+j%10);}

आपका कंपाइलर शायद इस कोड के बारे में बहुत शिकायत करेगा ; खदान ने 4 विभिन्न प्रकारों की 7 चेतावनियां दीं। बाद में कोड में सुधार कर सकते हैं।

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

— tomsmeding
स्रोत
5

सी (जीसीसी) , 76 बाइट्स

f(x,y){for(y=-9;++y<9;puts(""))for(x=10;x++;printf("%-*d",abs(y)+1,x%=10));}

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

यह कुछ अनुगामी स्थानों को आउटपुट करता है, जो ठीक माना जाता है।

यह डायनामिक लंबाई के बाएं-औचित्य वाले क्षेत्रों का उपयोग करके संख्याओं को प्रिंट करता है - यही प्रारूप स्ट्रिंग %-*dके लिए है।

आंतरिक लूप में कुछ मज़ेदार इनिशियलाइज़ेशन हैं (10 से शुरू होता है; 10 में से कोई भी कई ठीक होगा) इसकी समाप्ति स्थिति को "सरल" करने के लिए।

— anatolyg
स्रोत
4

चारकोल , 21 20 19 18 बाइट्स

Ｆ⁹«Ｆ…¹χ⁺κ… ι0⸿»‖Ｂ↑

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

वर्बोज़ संस्करण से लिंक करें । मूल रूप से मैं ड्राइंग के निचले हिस्से का निर्माण करता हूं और फिर पाठ को प्रतिबिंबित करता हूं।

— चार्ली
स्रोत
1
जब मैंने सवाल देखा, हालांकि मैं जवाब देखने से पहले खुद चारकोल में यह कोशिश करूंगा। मैंने एक 21-बाइट के उत्तर के साथ शुरुआत की, लेकिन इसे 20 बाइट्स तक पहुंचा दिया ... डरावना!
— नील
@ नील: -डॉ वेल, अब 19 बाइट्स है!
— चार्ली
हाँ, बस उस गोल्फ खुद को पाया। मैं भी Ｅ…⁹⪫Ｅ…·¹χＩ﹪κχ× ι‖Ｂ↑(19 बाइट्स के लिए) देख रहा था, लेकिन दुभाषिया इसे पसंद नहीं करता है (मैं खुद इसके साथ क्या गलत है यह नहीं देख सकता)।
— नील
ओह, सीमा दो तर्क देती है, मूर्खतापूर्ण।
— नील
1
टर्न आउट Mapएक लाल हेरिंग था, इसलिए मैंने अब अपना 18-बाइट उत्तर पोस्ट किया है।
— नील
4

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

A,(+aH*ee{:\8-zS**n}/

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

व्याख्या

A,     e# Get [0 1 2 ... 9].
(+     e# Rotate the 0 to the end.
aH*    e# Wrap in an array and repeat 17 times.
ee     e# Enumerate. This pairs each copy of the array with its index in
       e# the list.
{      e# For each [index array] pair...
  :\   e#   Unwrap the pair and swap its order.
  8-z  e#   Get the absolute difference of the index from 8.
  S*   e#   Get a string of that many spaces.
  *    e#   Riffle the list of digits with the string of spaces.
  n    e#   Print it with a trailing linefeed.
}/
— मार्टिन एंडर
स्रोत
1
वैकल्पिक समाधान (21 बाइट्स भी):9{S*A,(+\*}%_W%);\+N*
— बजे फलों के जूल
4

बैच, 163 बाइट्स

@set s=1 2 3 4 5 6 7 8 9 0
@set t=         
@for %%l in (9 7)do @for /l %%i in (1,1,%%l)do @call:%%l
:7
@set t=  %t%
:9
@set t=%t:~1%
@call echo %%s: =%t%%%

नोट: पहली पंक्ति 9 स्थानों पर समाप्त होती है। स्पष्टीकरण: रचनात्मक लाइन नंबरिंग का उपयोग करता है! पहले लूप को 9 बार चलाने और हर बार एक स्थान को हटाने की आवश्यकता होती है, जबकि दूसरे लूप को 8 बार चलाने और हर बार एक स्थान जोड़ने की आवश्यकता होती है। पूर्व को 7 बार चलाने और 8 वीं बार गिरने से प्राप्त किया जाता है, जबकि बाद में दो रिक्त स्थान जोड़कर और उनमें से एक को फिर से हटाने के लिए प्राप्त किया जाता है।

— नील
स्रोत
4

पॉवरशेल , 30 बाइट्स

8..0+1..8|%{1..9+0-join' '*$_}

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

8,7,6...2,1,0,1,2...8फिर प्रत्येक संख्या के माध्यम से लूप की एक सीमा का निर्माण करता है । पाश अंदर हम की एक श्रृंखला का निर्माण 1..9श्रेणीबद्ध साथ 0तो -joinसंख्या रेंज में एक साथ रिक्त स्थान की उचित संख्या के साथ। प्रत्येक स्ट्रिंग को पाइप लाइन पर छोड़ दिया जाता है, और आउटपुट प्रोग्राम पूरा होने पर निहित होता है।

— AdmBorkBork
स्रोत
1
अच्छा जवाब! पॉवर्सशेल को अचानक अधिक गोल्फ लगता है :)
— श्री एक्सकोडर
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.