अल्फा-न्यूमेरिकल बोवी

14

इस सटीक पाठ का आउटपुट:

1                i
12              hi
123            ghi
1234          fghi
12345        efghi
123456      defghi
1234567    cdefghi
12345678  bcdefghi
123456789abcdefghi
12345678  bcdefghi
1234567    cdefghi
123456      defghi
12345        efghi
1234          fghi
123            ghi
12              hi
1                i

एक एकल अनुगामी न्यूलाइन स्वीकार्य है, लेकिन किसी अन्य स्वरूपण परिवर्तन की अनुमति नहीं है।

नियम और आई / ओ

  • कोई निवेश नहीं
  • आउटपुट किसी भी सुविधाजनक विधि द्वारा दिया जा सकता है ।
  • या तो एक पूर्ण कार्यक्रम या एक समारोह स्वीकार्य हैं। यदि कोई फ़ंक्शन है, तो आप इसे प्रिंट करने के बजाय आउटपुट वापस कर सकते हैं।
  • मानक खामियों को मना किया जाता है।
  • यह कोड-गोल्फ है इसलिए सभी सामान्य गोल्फिंग नियम लागू होते हैं, और सबसे छोटा कोड (बाइट्स में) जीतता है।
code-golf  kolmogorov-complexity 
— AdmBorkBork
स्रोत
1
क्या हम इसके बजाय अपरकेस वर्णमाला का उपयोग कर सकते हैं?
— user41805
3
@Cowsquack यह एक नियम परिवर्तन होगा। यह आउटपुट का सटीक पाठ कहता है ।
— डेनिस
@ कॉवसैक नोप - लोअरकेस की आवश्यकता है।
— AdmBorkBork

जवाबों:

13

सी, 87 85 81 80 बाइट्स

j;main(i){for(;++i<19;)for(j=19;j--;)putchar(j?j<i^j<20-i?32:106-j-j/10*39:10);}

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

व्याख्या

j; // same as int j;
main(i){ // same as int main(int i){, where i = argc (1 with no arguments)
  for(;++i<19;) // loop over rows, i = 2..18
    for(j=19;j--;) // loop over chars, j = 19..0
      putchar(j?j<i^j<20-i?32:106-j-j/10*39:10); // output characters:
      //      j?                           :10 // on last char (j=0), output \n
      //        j<i                            // check for top/left half
      //            j<20-i                     // check for bottom/left half
      //           ^                           // 1 if only one half matched
      //                  ?32:                 // if so, output space
      //                      106              // char code for j
      //                         -j            // get desired letter
      //                           -j/10*39    // subtract 39 for j>9 (numbers)
}
— PurkkaKoodari
स्रोत
मैं आश्चर्यचकित हूं ^कि इससे कम पूर्वता है <... क्या एक सुंदर जवाब है!
— लिन
@ लियन सी (और यहां तक ​​कि जावा / जेएस और इस तरह के) में बिटवाइज़ ऑपरेटरों की तुलना की तुलना में कम पूर्वता है। यह कोड गोल्फ के लिए अच्छा है और त्रुटियों का एक बहुत अच्छा स्रोत है (सोचिए if (x & 2 == 0), जो हमेशा मूल्यांकन करता है 0)
— PurkkaKoodari
6

आर , 64 बाइट्स

for(i in abs(8:-8))cat(intToUtf8(c(57-8:i,32*!!-i:i,97+i:8,13)))

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

  • -3 बाइट्स @Giuseppe के लिए धन्यवाद
  • -5 बाइट्स के लिए धन्यवाद @ जे। डी। ओ
— digEmAll
स्रोत
67 बाइट्स के साथintToUtf8
— J.Doe
catएक बाइट के लिए?
— JayCe
2
64 बाइट्स आपके समाधान पर बन रहे हैं, @ Giuseppe के शॉर्टकट का उपयोग करके repप्लस की सुविधा intToUtf8एक में 0बदल जाती है ""।
— जे। सेप J. ’
@ जे .Doe महान चाल!
— JayCe
@ J.Doe: बहुत बढ़िया, धन्यवाद!
— digEmAll
3

QBasic, 72 बाइट्स

टेलर स्कॉट की अधीनता के आधार पर ।

FOR y=-8TO 8
z=ABS(y)
?"123456789abcdefghi";
LOCATE,10-z
?SPC(2*z)"
NEXT

मूल व्याख्या

प्रत्येक पंक्ति पर, हम पूर्ण स्ट्रिंग प्रिंट करते हैं 123456789abcdefghi। फिर हम वापस जाते हैं और रिक्त स्थान के साथ इसके हिस्से को अधिलेखित करते हैं।

पूरी व्याख्या

कोड के साथ थोड़ा असंयमित:

FOR y = -8 TO 8           ' Loop for 17 rows
 z = ABS(y)               ' z runs from 8 to 0 and back to 8
 ? "123456789abcdefghi";  ' Print the full string and stay on the same line (important!)
 LOCATE , 10-z            ' Go back to column 10-z on that line
 ? SPC(2*z); ""           ' Print 2*z spaces
                          ' (SPC keeps the cursor on the same line unlesss you print
                          ' something after it, so we'll use the empty string)
NEXT                      ' Go to the next y value
— DLosc
स्रोत
यह Locateकमांड का एक बहुत ही चतुर उपयोग है
— टेलर स्कॉट
2

टी-एसक्यूएल, 108 बाइट्स

DECLARE @ INT=8a:
PRINT STUFF('123456789abcdefghi',10-abs(@),2*abs(@),SPACE(2*abs(@)))
SET @-=1IF @>-9GOTO a

रिटर्न केवल पठनीयता के लिए है।

संख्या तालिका सहित कई अन्य विविधताओं की कोशिश की, यह सबसे छोटा था।

— BradC
स्रोत
2

जाप , 20 बाइट्स

9Æ9Ç>YÃê1 Ë?S:°EsH
ê

जाप दुभाषिया

वर्णों के सरणियों के एक सरणी के रूप में आउटपुट। -Rझंडा नहीं आवश्यक काम करने के लिए, यह सिर्फ उत्पादन नज़र अच्छे बनाता है।

स्पष्टीकरण:

9Æ9Ç                    create a 9x9 2D array 
    >YÃ                 fill bottom left triangle with "false", upper right with "true"
       ê1               mirror horizontally
          Ë?S           replaces "true" with a space
             :°EsH      replaces "false" with the horizontal index + 1 converted to base 32
                  \n    Store the result in U (saves bytes by not closing braces)
                    ê   palindromize vertically
— कामिल दकरी
स्रोत
1

स्टैक्स , 18 बाइट्स

â4+╤jo♂▐▀3bkWíæß╝╖

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

स्पष्टीकरण:

9R$|[|<Va17T|]r|>\|pm Full program
9R$                   Produce "123456789"
   |[|<               Left-aligned prefixes (["1        ", "12       ", ...])
       Va17T          Produce "abcdefghi"
            |]        Suffixes (["abcdefghi", "bcdefghi", ...])
              r|>     Reverse and left-align (["        i", "       hi", ...])
                 \    Zip both arrays (["1                i", "12              hi", ...])
                  |p  Palindromize array
                    m Map over array, printing each with a newline
— wastl
स्रोत
1

एपीएल (डायलॉग यूनिकोड) , 30 बाइट्स

(⊢⍪1↓⊖)(↑,\1↓⎕d),⌽↑,\⌽819⌶9↑⎕a

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

↑ एक मैट्रिक्स में बदलें (रिक्त स्थानों के साथ ऑटो पैड)

  • ,\ के उपसर्ग

  • 1↓ पहले तत्व से गिरा दिया

  • ⎕d यह स्ट्रिंग '0123456789'

  • यह चरित्र मैट्रिक्स देता है

1        
12       
123      
1234     
12345    
123456   
1234567  
12345678 
123456789

, के साथ मिला हुआ

  • ⌽ उलटा हुआ

  • ↑ matrixified

  • ,\ के उपसर्ग

  • ⌽ उलटा हुआ

  • 819⌶ और कम किया गया

  • 9↑ के पहले 9 तत्व

  • ⎕a यह स्ट्रिंग 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'

  • यह चरित्र मैट्रिक्स देता है

        मैं
       नमस्ते
      GHI
     fghi
    efghi
   defghi
  cdefghi
 bcdefghi
abcdefghi

और इस परिणाम पर

1 मैं
१२ हाय
123 घी
1234 फ़िजी
12345 आफगी
123456 डेफगी
1234567 cdefghi
12345678 bcdefghi
123456789abcdefghi

निम्नलिखित ट्रेन का प्रदर्शन करें (⊢⍪1↓⊖)

⊢ सही तर्क

⍪ के साथ खड़ी

1↓ पहली पंक्ति से (यह बीच की पंक्ति को दोहराने से बचा जाता है)

⊖ सही तर्क लंबवत रूप से उलट है

अन्य उपाय

33 बाइट्स

(⊢⍪1↓⊖)(↑,\⍕¨q),⌽↑,\⎕ucs 106-q←⍳9

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

33 बाइट्स

(⊢⍪1↓⊖)(↑,\⍕¨q),⌽↑,\⌽⎕ucs 96+q←⍳9

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

— user41805
स्रोत
1

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

Ｇ↗↓←⁹β←Ｇ↖↓⁹⭆χι‖Ｏ↓

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

Ｇ↗↓←⁹β

निचला दायाँ त्रिभुज बनाएँ और इसे लोअरकेस वर्णमाला का उपयोग करके भरें। (भरण विमान को वर्णमाला के साथ बांधने और फिर खींचे गए क्षेत्र की नकल पर आधारित है।)

←

संख्यात्मक त्रिभुज को खींचने के लिए बायाँ मूव करें।

Ｇ↖↓⁹⭆χι

निचले बाएँ त्रिकोण को ड्रा करें और अंकों का उपयोग करके इसे भरें। (चूंकि त्रिकोण मूल के बाईं ओर खींचा गया है, इसलिए अंकों को सही-सही लिया जाता है, इसलिए केवल 1 से 9 अंक का उपयोग किया जाता है।)

‖Ｏ↓

नीचे के आधे हिस्से को पूरा करने के लिए प्रतिबिंबित करें।

— नील
स्रोत
1

वी , 25 , 21 बाइट्स

¬19¬ai8ñHÄ/á
r ge.YGp

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

2-4 बाइट्स ने nmjcman101 को धन्यवाद बचाया!

Hexdump:

00000000: ac31 39ac 6169 38f1 48c4 2fe1 0a72 2067  .19.ai8.H./..r g
00000010: 652e 5947 70                             e.YGp
— जेम्स
स्रोत
मुझे पता है कि मैं जो कुछ भी कर रहा हूं वह आज आपके जवाबों को प्रभावित कर रहा है लेकिन मुझे लगता है कि यह 23 के लिए काम करता है: इसे ऑनलाइन आज़माएं!
— nmjcman101
@ nmjcman101 जो भी कारण से, मैं समझ नहीं पा रहा हूं कि वह संस्करण कैसे काम करता है। लेकिन मुझे पता चला कि एक छोटा भी है, इसलिए धन्यवाद!
— जेम्स
यह एक /\d*खोज के अंत में चला गया
— nmjcman101
1

जे , 44 बाइट्स

(m]\u:49+i.9),.(m=.,}.@|.)]\&.(|."1)u:97+i.9

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

मैंने संख्यात्मक रूप से अनुक्रमण के लिए उपयोग करने के लिए 1 और शून्य का मुखौटा उत्पन्न करने की कोशिश की, लेकिन अतिरिक्त पंक्ति से छुटकारा पाने की लागत अधिक थी और मैंने हार मान ली:

   (9-.~i.18){0<:-/~(,|.)i.9
1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1
1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1
1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1
1 1 1 1 0 0 0 0 0 0 0 0 0 0 1 1 1 1
1 1 1 1 1 0 0 0 0 0 0 0 0 1 1 1 1 1
1 1 1 1 1 1 0 0 0 0 0 0 1 1 1 1 1 1
1 1 1 1 1 1 1 0 0 0 0 1 1 1 1 1 1 1
1 1 1 1 1 1 1 1 0 0 1 1 1 1 1 1 1 1
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
1 1 1 1 1 1 1 1 0 0 1 1 1 1 1 1 1 1
1 1 1 1 1 1 1 0 0 0 0 1 1 1 1 1 1 1
1 1 1 1 1 1 0 0 0 0 0 0 1 1 1 1 1 1
1 1 1 1 1 0 0 0 0 0 0 0 0 1 1 1 1 1
1 1 1 1 0 0 0 0 0 0 0 0 0 0 1 1 1 1
1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1
1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1
1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1
— गैलेन इवानोव
स्रोत
1

जाप, 24 बाइट्स

लाइनों की एक सरणी देता है

9Æ´AçXÄ
c¡A°îYd#a
Vù y ê

झसे आज़माओ

व्याख्या

9Æ            :Map each X in the range [0,9)
  ´A          :  Prefix decrement A (initially 10)
    ç         :  Repeat
     XÄ       :  X+1
\n            :Assign to variable U
 ¡            :Map each element at index Y in U
  A°          :  Postfix increment A
    î         :  Repeat
      d       :  The character at codepoint
     Y #a     :  Y+97
c             :Concatenate with U
\n            :Assign to variable V
Vù            :Left pad each element in V to the length of the longest element
   y          :Transpose
     ê        :Palindromise

वैकल्पिक

9õÈîZqÃú Ë+EòdEn#i)¬ù9Ãê

झसे आज़माओ

9ÇòdZn#i)cZòÄ)¬Ãú ®éJ´Ãê

झसे आज़माओ

— झबरा
स्रोत
मैं अब सोच रहा था कि इस क्षैतिज निर्माण के कारण शायद कोई छोटा समाधान न हो! : \
— झबरा
1

QBasic , 87 बाइट्स

एक अनाम फ़ंक्शन जो कंसोल के लिए कोई इनपुट और आउटपुट नहीं लेता है।

For y=-8To 8:z=Abs(y):a$="123456789abcdefghi":?Mid$(a$,1,9-z)Spc(2*z)Mid$(a$,10+z):Next

यह उत्तर तकनीकी रूप से एक बहुविकल्पी है, और VBA में कार्य करेगा

— टेलर स्कॉट
स्रोत
1

बेफुज -93 , 314 308 बाइट्स

<p0+3*67p0+4*77p0+3*77p0-7*88p0-6*88"#v#v>"
"i        "11g1-21p56+1g1+56+1p28*1g1+28*1p  ^       >25*
"        1"92g1+82p56+2g1-56+2p28*2g1-28*2p91g00g`#v_^   >
"ihgfedcba "93p26*3g1-26*3p">^"88*7-0p88*7-4pv     >25*
"987654321 "14p26*4g1+26*4p26*4g12g`#v_            ^
                             >:#,_@#:<

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

निर्देश के >साथ रख कर 6 बाइट्स गोल्फिंग pकरें

— ItsJ0el
स्रोत
1

पावरशेल 5.1, 70 69 64 57 बाइट्स

धन्यवाद Mazzy -7 बाइट्स के लिए

1..9+8..1|%{-join(1..$_+'  '*(9-$_)+' ihgfedcba'[$_..1])}

मैन्युअल रूप से बाइट को सहेजने के साथ इसे ग्लूइंग करता है। यह सब एक मेगा में शामिल होने से 5 और बचत होती है। चींटियों की एक श्रृंखला को एक [] में बदलने के लिए भी काम करता है। वास्तविक अक्षरों पर एक सीमा का उपयोग करना 5 बाइट्स बेहतर है।

— Veskah
स्रोत
1
इसे आज़माएँ 1..9+8..1|%{-join(1..$_+' '*(9-$_)+' ihgfedcba'[$_..1])}:। नोट ' '*(9-$_)में 2 स्थान चिन्ह हैं
— mazzy
1
@ माज़ी ऊफ़, उस डबल स्पेस ट्रिक को याद कर रहा है। मैं कई तरह के गणित के बयानों के बारे में सोच रहा था लेकिन स्पष्ट समाधान मेरे लिए कभी नहीं हुआ।
— विस्कह
1

सी (जीसीसी) ,143 142 127 + 10 = 137 136 + 10 = 146 (संकलक झंडे) बाइट्स

-1 बाइट को तार्किक या बिटवाइज ऑपरेटर के साथ बदलकर।

-5 बाइट्स लोगर्न के लिए धन्यवाद।

+9 बाइट्स माध्य रेखा को ठीक करने के लिए, जो दो बार आउटपुट था।

char*s="123456789abcdefghi";G{for(;j<18;++j)putchar(i>j|j>17-i?s[j]:32);puts("");}f(){int i=0,j=0;for(;i++<8;)G;g(i+1,j);for(;i-->1;)G;}

संकलक ध्वज:

-DG=g(i,j)

यह मैक्रो g(i,j)निम्न घटनाओं का कारण बनता है : फ़ंक्शन घोषणा और कॉल।

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

Pietu1998 के शानदार जवाब से अलग दृष्टिकोण , अधिक सीधा (और पठनीय), लेकिन उच्च स्कोर।

प्रवेश बिंदु कार्य है f(); फंक्शन g()प्रत्येक लगातार लाइन की प्रिंटिंग को हैंडल करता है।

नाम बदलकर एक पूरा कार्यक्रम बनाया जा सकता है fके लिए mainहै, लेकिन यह अभी तक स्कोर में वृद्धि होगी।

सुंदर संस्करण, मैक्रो का Gविस्तार:

char *s = "123456789abcdefghi";
int g(int i, int j) {
    for(; j < 18; ++j)
        putchar((i > j | j > 17 - i) ? s[j] : 32);
    puts(""); // Break the line -- shorter than putchar(10) or printf("\n")
}
int f() {
    int i = 0, j = 0; // j is constant, declared here to not have to declare and init it inside g()
    for(; i++ < 8;) // Upper half of the tie
        g(i, j);
    g(i + 1, j); // Median line
    for(; i-- > 1;) // Lower half; --i > 0 would also work for the condition
        g(i, j);
}
— joH1
स्रोत
— लोगन
संकलक झंडे के लिए 137 लेकिन +10 हालांकि
— जोह 1
137 कुल है, कोड के 127 बाइट्स और संकलक झंडे के 10 बाइट्स हैं।
— लोगन
ओफ़ सॉरी, मेरा बुरा। अब अपडेट हो रहा है!
— joH1
@ लोर्गेन मैंने Gफ़ंक्शन नाम से मिलान करने के लिए मैक्रो का नाम बदलने की स्वतंत्रता ली ।
— 19
0

VBA, 75 बाइट्स

एक अनाम VBE तत्काल विंडो फ़ंक्शन जो कंसोल के लिए कोई इनपुट और आउटपुट नहीं लेता है।

For y=-8To 8:z=Abs(y):a="123456789abcdefghi":Mid(a,10-z)=Space(2*z):?a:Next
— टेलर स्कॉट
स्रोत
0

जेली , 22 21 बाइट्स

9R€z⁶Zµạ106Ọ$Ṡ¡€Uṭ)ŒḄ

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

(संभावना) अनपेक्षित व्यवहार पर निर्भर करता है कि जब Ṡ(संकेत) एक चरित्र पर कार्य करता है तो यह पायथन की उपज देता है None। इस वजह से, Ṡयह तर्क के लिए एक बाइट की जाँच है कि यह एक गैर-पूर्णांक पूर्णांक है क्योंकि Noneपायथन में गलत है। यदि यह व्यवहार बदल जाता है तो OƑएक और बाइट के लिए भी काम करता है।

फ़ंक्शन जो लाइनों की सूची लौटाता है।

— dylnan
स्रोत
0

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

i=o="123456789abcdefghi";c=8
while c:i=i[:c]+' '*(9-c)*2+i[-c:];o=i+'\n'+o+'\n'+i;c-=1
print o

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

केवल उपयोग करने के विकल्प के रूप में पोस्ट किया गया है eval() और क्योंकि मुझे अंत में यह 100 से कम में मिला है। मूल रूप से मध्य पंक्ति के साथ शुरू होता है और फिर एक ही समय में ऊपर और नीचे दोनों काम करता है।

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