यह लुटेरों का धागा है। पुलिस का धागा यहाँ जाता है ।

एक कोड लिखें जिसमें पुलिस पोस्ट के समान बाइट्स हों और जहां प्रकट अक्षर समान हों। कोड को 1अपनी प्रारंभिक स्थिति में उत्पादन करना चाहिए , और 2, 3 ..एकल परिवर्तन किए जाने पर संख्या का उत्पादन करना चाहिए ।

विजेता सबसे अधिक पदों को तोड़ने वाला डाकू होगा।

उदाहरण पोस्ट:

मायलैंग, 9 बाइट्स, 8 नंबर (जवाब देने के लिए लिंक सहित), कॉप का यूजरनेम।

मूल कोड:

abc1efghi

कोड जो 1 - 8 का उत्पादन करता है:

1: abc1efghi
2: abc2efghi
3: abc2efghij
4: kbc2efghij
5: kbc23fghij
6: kbc23fghi
7: kbc63fghi
8: kbc63fhi

स्पष्टीकरण को प्रोत्साहित किया जाता है। डाकू पोस्ट का सटीक प्रारूप वैकल्पिक है।

cops-and-robbers

— स्टीवी ग्रिफिन
स्रोत

13

मार्टिन एंडर द्वारा रेटिना, 2 बाइट्स, 10 नंबर ।

मूल कोड:

यह खाली इनपुट को नंबर 1 से बदल देता है।

वह कोड जो 1 - 10 का उत्पादन करता है ( \nसुविधा के लिए नए रूप दिखा रहा है ):

1 : \n1
2 : \n1\n
3 : \n11\n
4 : \n111\n
5 : \n1111\n
6 : \n11111\n
7 : \n111111\n
8 : \n1111111\n
9 : \n11111111\n
10: \n111111111\n

2 और उसके बाद, हम पिछले चरण में खाली तारों की संख्या की गणना करते हैं। 2 के लिए, पहले और बाद में एक खाली स्ट्रिंग है। 3 के लिए लोगों के बीच, लोगों के बीच और बाद में एक खाली स्ट्रिंग है। यह 10 तक सभी तरह से काम करता है।

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

— FryAmTheEggman
स्रोत

8

Perl, 12 बाइट्स, 10 नंबर, ais523 द्वारा

मूल कोड:

____;say__-9

कोड जो 1 - 10 का उत्पादन करता है:

wait;say$!-9
wait;say$!-8
wait;say$!-7
wait;say$!-6
wait;say$!-5
wait;say$!-4
wait;say$!-3
wait;say$!-2
wait;say$!-1
wait;say$!-0

स्पष्टीकरण:

wait;         # waits for a child process to end (there is no child so it just returns)
     say      # put the following on the screen:
        $!    # current value of the C errno. In this case, ECHILD (No child processes)
              # which has a value of 10
          -9  # minus 9

— रिले
स्रोत

7

जावास्क्रिप्ट, 30 बाइट, 10 नंबर, ETHproductions द्वारा ।

मूल कोड:

1: alert(Array(2).join(3).length)

अन्य संख्याएँ

 2: alert(Array(2).join(31).length)
 3: alert(Array(2).join(314).length)
 4: alert(Array(2).join(3141).length)
 5: alert(Array(2).join(31415).length)
 6: alert(Array(2).join(314159).length)
 7: alert(Array(2).join(3141592).length)
 8: alert(Array(2).join(31415926).length)
 9: alert(Array(2).join(314159265).length)
10: alert(Array(2).join(3141592653).length)

व्याख्या

Array(2)दो खाली कोशिकाओं के साथ एक सरणी बनाता है। .joinविधि परिसीमक है, जो यह एक स्ट्रिंग में धर्मान्तरित का उपयोग कर किसी सरणी में सभी तत्वों को मिलती है। मूल कोड में, परिसीमन था 3। इसका मतलब यह था कि ऐरे में दो खाली कोशिकाएं एक साथ जुड़कर 3उनके सीमांकक के रूप में उपयोग की जाती हैं। यह मूल्यांकन करता है "3", 3क्योंकि ऐरे के दोनों तरफ कुछ भी बिना खाली है। और क्योंकि lengthकी "3"है 1, यह मान सांत्वना लिए outputted है।

अन्य संख्याओं के लिए, मैं सीमांकक में 1 और अंक जोड़ता हूं जो एरे के तत्वों में शामिल हो रहा है। इसलिए, यह इसकी लंबाई बढ़ाता है, इस प्रकार alertबढ़ते मूल्यों के साथ जुड़ा हुआ है। ध्यान दें कि सीमांकक का संख्यात्मक मान महत्वपूर्ण नहीं है, केवल इसकी लंबाई है।

स्नैक स्निपेट!

नोट: मैंने अपने स्नैक स्निपेट के console.logबजाय alertस्पष्ट कारणों के लिए उपयोग किया । इसके अलावा, कंसोल से आउटपुट स्निपेट में प्रदर्शित होता है।

console.log(Array(2).join(3).length)
console.log(Array(2).join(31).length)
console.log(Array(2).join(314).length)
console.log(Array(2).join(3141).length)
console.log(Array(2).join(31415).length)
console.log(Array(2).join(314159).length)
console.log(Array(2).join(3141592).length)
console.log(Array(2).join(31415926).length)
console.log(Array(2).join(314159265).length)
console.log(Array(2).join(3141592653).length)

स्निपेट का विस्तार करें

— क्रिकटी लिथोस
स्रोत

1

अच्छा! ); यही इरादा समाधान था (हालांकि मैं में शामिल होने से संख्या के साथ कल्पनाशील के रूप में नहीं था)

— ETHproductions

7

ऑक्टेव, 17 बाइट्स, 10 नंबर, स्टीवी ग्रिफिन द्वारा

original:
_i_(__i__(2_5_))

solution:
fix( 'i'-(2*52))
fix( 'j'-(2*52))
fix( 'k'-(2*52))
fix( 'l'-(2*52))
fix( 'm'-(2*52))
fix( 'n'-(2*52))
fix( 'o'-(2*52))
fix( 'p'-(2*52))
fix( 'q'-(2*52))
fix( 'r'-(2*52))

— flawr
स्रोत

हाह, मेरे समाधान से दूर! बहुत बढ़िया! :) मैं अपनी पोस्ट में इच्छित एक पोस्ट करूंगा :)

— स्टेवि ग्रिफिन

7

अजगर 2, 17 बाइट्स, 10 नंबर, xnor द्वारा

print len(['  '])
print len(*['  '])
print len(*['   '])
print len(*['    '])
print len(*['     '])
print len(*['      '])
print len(*['       '])
print len(*['        '])
print len(*['         '])
print len(*['          '])

repl.it

— जोनाथन एलन
स्रोत

7

अजगर 2, 9 बाइट्स, 10 नंबर, xnor

print 8/8
print 18/8
print 28/8
print 38/8
print 38/7
print 38&7
print 31&7
print 31&72
print 31&73
print 31&74

— Sp3000
स्रोत

1

बधाई! मैंने भी यही सोचा था। मैं उत्सुक था और एक खोज को दौड़ा। यह पता चला है कि कई समाधान हैं, जिनमें बिटकॉइन संचालन का उपयोग नहीं किया जाता है।

— xnor

print 10/10&पेड़ की खोज के अनुसार, यदि आप प्रतिबंध लगाते हैं तो यह काफी दिलचस्प है । या, यदि आपको 11 तक जाने की आवश्यकता है

— xnor

6

पर्ल, 14 बाइट्स, दादा द्वारा 10 नंबर

मूल कोड:

say_!"___"%""_

कोड जो 1 - 10 का उत्पादन करता है:

say"!"+1#"%""r
say"!"+2#"%""r
say"!"+3#"%""r
say"!"+4#"%""r
say"!"+5#"%""r
say"!"+6#"%""r
say"!"+7#"%""r
say"!"+8#"%""r
say"!"+9#"%""r
say"1"+9#"%""r

मुझे लगता है कि यह वह नहीं है जो आप के लिए जा रहे थे।

— समुदाय
स्रोत

1

मेरे पास और पत्र होने चाहिए ... मूल कोड say"!"=~y"%""c(इसलिए say"!!"=~y"%""c, आदि, !एक बार और अधिक के साथ ) था। लेकिन अच्छा खेला! :)

— दादा

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

1

मैं बहुत अधिक जानकारी नहीं देना चाहता था: =या ~एक बहुत बड़ा संकेत रहा होगा, और "जैसा कि मैंने उन्हें दिखाया था उसका ढांचा भ्रामक था (मुझे उम्मीद है) ... लेकिन मुझे इस बात पर विचार करना चाहिए कि इसमें से आधी टिप्पणी उल्लेखनीय थी!

— दादा

मैं वास्तव में अनुमान लगाया था कि वहाँ एक =~इरादा समाधान में था। हालाँकि, मैं कोशिश में व्यस्त था s, mऔर /नहीं सोचा था y।

1

PPCG btw पर आपका स्वागत है! नए पर्ल गोल्फरों को देखकर अच्छा लगा!

— दादा

6

Arnauld द्वारा जावास्क्रिप्ट, 22 बाइट्स, 10 नंबर

मूल कार्यक्रम:

alert(0_6_4_>_0_2_0_7)

फटा:

alert(0+6^42>101210^7)
alert(0+5^42>101210^7)
alert(0+4^42>101210^7)
alert(0+3^42>101210^7)
alert(0+2^42>101210^7)
alert(0+1^42>101210^7)
alert(0+0^42>101210^7)
alert(0+0^42>101210^8)
alert(0+0^42>101210^9)
alert(0+3^42>101210^9)

इससे निपटने के लिए कठिन हिस्सा है >, जिसकी बहुत कम पूर्वता है। मैंने इसे एक में बदलने की कोशिश की >>, लेकिन यह आसान है कि इसे बेकार करके एक बूलियन झूठी ( 42>101210खंड) जो संख्यात्मक रूप से 0 है, की गणना करके इसे अवशोषित करें , और सिर्फ 1 से 10 तक की संख्या ऑपरेटर से भी कम पूर्वता के साथ उत्पन्न करें >। मैंने उपयोग किया ^, बिटवाइज़ एक्सर, क्योंकि यह 1 से 10 तक की संख्याओं को आसानी से उत्पन्न कर सकता है (आसानी से, मूल इनपुट में 6 और 7 मुझे अभिव्यक्ति को सरल बनाने की अनुमति 6^7देता है जिसमें 1)।

— समुदाय
स्रोत

5

जावास्क्रिप्ट, 9 बाइट्स, हेडी

मूल कोड:

alert(+1)

संशोधन:

alert(1+1)   // 2
alert(2+1)   // 3
alert(3+1)   // 4
alert(4+1)   // 5
alert(5+1)   // 6
alert(6+1)   // 7
alert(7+1)   // 8
alert(8+1)   // 9
alert(9+1)   // 10

— ETHproductions
स्रोत

5

ऑक्टेव, 55 बाइट्स, 10 नंबर, फ्लोटर

(o=@(O,o)(@(O,o)o{2-O} ) (0<O,{ (yo=O-1)+1,@()1}))(1,o)

फाइनल 1को 9 तक साइकल किया जा सकता है, और फिर इसे बदल सकते +1हैं +2।

— feersum
स्रोत

अच्छा काम, क्या आपने शायद एसओ पर इसके बारे में मेरी पोस्ट ढूंढी? :)

— दोष

@flawr हम्म? किस बारे मेँ?

— फ़ेरसम

ओह, मुझे लगता है कि आपने मूल पोस्ट में पुनरावर्ती कार्यों के बारे में कुछ लिखा है। मेरी दरार किसी भी पुनरावृत्ति का उपयोग नहीं करती है।

— फर्सम

ओह अब मैं देख रहा हूं, मैं पहली नज़र में अंतर बताने में सक्षम नहीं था ^ ^

— त्रुटी

5

पायथन 3, 16 बाइट्स, 10 नंबर, Sp3000 द्वारा

यह मजेदार था।

print(?%??f?r?t)

print(1%0xfor t)
print(2%0xfor t)
...
print(8%0xfor t)
print(84%0xfor t)
print(85%0xfor t)

इस तथ्य को उजागर करता है (जो मुझे अब तक नहीं पता था) कि एक हेक्स शाब्दिक के रूप में जल्द ही एक चरित्र 0-9a-fA-Fका सामना नहीं होता है - इस प्रकार 0xforलिखने का एक बहुत ही डरपोक तरीका है 15 or। उसके बाद, यह 10 modulo 15 के लिए सही मूल्य के अनुरूप खोजने की बात थी।

— DLosc
स्रोत

तेज: पी लेकिन कम से कम यह अब स्पष्ट होना चाहिए कि bin()किसी को भी हल करने का इरादा कैसे था।

— Sp3000

5

जावास्क्रिप्ट, 22 बाइट्स, अर्नुलद द्वारा 10 नंबर

मूल कोड :

alert(__14_337__xc_de)

संशोधित :

alert(00140337-0xc0de) // 1
alert(00140337-0xc0dd) // 2
alert(00140337-0xc0dc) // 3
alert(00140337-0xc0db) // 4
alert(00140337-0xc0da) // 5
alert(00140337-0xc0d9) // 6
alert(00140337-0xc0d8) // 7
alert(00140337-0xc0d7) // 8
alert(00140337-0xc0d6) // 9
alert(00140337-0xc0d5) // 10

मुझे लगता है कि यह इरादा समाधान नहीं है, लेकिन मुझे उम्मीद है कि यह बहुत दूर नहीं है ...

— डोम हेस्टिंग्स
स्रोत

यह वास्तव में इच्छित समाधान है। बहुत बढ़िया!

— Arnauld

2

यह वास्तव में होना चाहिए था alert(0140337-0xc0de)(एक बाइट कम) लेकिन मैंने गलती से ईएस 6 ऑक्टल नोटेशन का इस्तेमाल किया 0o140337और इसे इस तरह से करने का फैसला किया।

— अरनौलद

@Arnauld मुझे खुशी है कि मैं 'सही' समाधान प्राप्त करने में सक्षम था! चुनौती के लिए धन्यवाद!

— डोम हेस्टिंग्स

4

ऑक्टेव, 32 बाइट्स, 10 नंबर, द्वारा लुइस मेंडो

मूल कोड:

nnz(isprime(floor(s=3):i*-2i))+1

संशोधित कोड:

2:  nnz(isprime(floor(s=3):i*-3i))+1
3:  nnz(isprime(floor(s=3):i*-5i))+1
4:  nnz(isprime(floor(s=3):i*-9i))+1
5:  nnz(isprime(floor(s=3):i*-9i))+2
6:  nnz(isprime(floor(s=3):i*-9i))+3
7:  nnz(isprime(floor(s=3):i*-9i))+4
8:  nnz(isprime(floor(s=3):i*-9i))+5
9:  nnz(isprime(floor(s=3):i*-9i))+6
10: nnz(isprime(floor(s=3):i*-9i))+7

यहां संशोधन करने के कई तरीके हैं (उदाहरण के लिए s=2और +0शुरुआत में)।

संपादित करें: एक अधिक संभावित विकल्प:

nnz(isprime(floor(s=2):i*-2i))+0
nnz(isprime(floor(s=2):i*-2i))+1
nnz(isprime(floor(s=2):i*-2i))+2
nnz(isprime(floor(s=2):i*-2i))+3
nnz(isprime(floor(s=2):i*-2i))+4
nnz(isprime(floor(s=2):i*-2i))+5
nnz(isprime(floor(s=2):i*-2i))+6
nnz(isprime(floor(s=2):i*-2i))+7
nnz(isprime(floor(s=2):i*-2i))+8
nnz(isprime(floor(s=2):i*-2i))+9

— स्टीवी ग्रिफिन
स्रोत

4

05AB1E , 11 बाइट्स, 10 नंबर, द्वारा ओलिवर

मूल कोड:

 1: 3628801zï0>

अन्य संख्याएँ

 2: 3628801zï0>>
 3: 3628801zï0>>>
 4: 3628801zï0>>>>
 5: 3628801zï0>>>>>
 6: 3628801zï0>>>>>>
 7: 3628801zï0>>>>>>>
 8: 3628801zï0>>>>>>>>
 9: 3628801zï0>>>>>>>>>
10: 3628801zï0>>>>>>>>>>

व्याख्या

3628801                        # push this number
       z                       # find its reciprocal
        ï                      # round it to the nearest integer (becomes 0)
         0                     # push 0
          >>>>                 # increment by 1 for each `>` present (this is for 4)
                               # implicit output

इसे सारांशित करने के लिए, धक्का दें 3628801, इसके पारस्परिक और गोल को निकटतम पूर्णांक तक ले जाएं (मूल्यांकन करता है)0 )। फिर स्टैक को बढ़ाएं। टाडा!

इसे ऑनलाइन आज़माएं! आउटपुट = 1 के लिए फिर जितने चाहें उतने >एस जोड़ें कि आप किस नंबर पर आउटपुट देना चाहते हैं।

— क्रिकटी लिथोस
स्रोत

4

जावास्क्रिप्ट, 12 बाइट्स, 10 नंबर, हेडी

मूल कोड:

alert(+[+1])

10 के माध्यम से 2:

alert(+[1+1])
alert(+[2+1])
alert(+[3+1])
alert(+[4+1])
alert(+[5+1])
alert(+[6+1])
alert(+[7+1])
alert(+[8+1])
alert(+[9+1])

वहाँ केवल इतना है कि आप इस बहुत कोड के साथ कर सकते हैं ...

— ETHproductions
स्रोत

1

'केवल इतना है कि आप इस बहुत कोड के साथ कर सकते हैं ...' फिर भी आपको एक समाधान मिला जो मैंने ^ ^ के बारे में नहीं सोचा था 'समाधान की मुझे ज़रूरत नहीं है +।

— हेडी

4

जेली, 7 बाइट्स, 10 नंबर, जोनाथन एलन

मूल कोड:

“1‘ỌȮḊ‘

फिर:

“1‘‘ỌȮḊ‘
“1‘‘‘ỌȮḊ‘
“1‘‘‘‘ỌȮḊ‘
“1‘‘‘‘‘ỌȮḊ‘
“1‘‘‘‘‘‘ỌȮḊ‘
“1‘‘‘‘‘‘‘ỌȮḊ‘
“1‘‘‘‘‘‘‘‘ỌȮḊ‘
“1‘‘‘‘‘‘‘‘‘ỌȮḊ‘
“1‘‘‘‘‘‘‘‘‘ỌvḊ‘

आप TryItOnline पर पिछले एक की जांच कर सकते हैं !

एक और तरीका होगा

“2‘ỌȮḊ‘
“3‘ỌȮḊ‘
...
“9‘ỌȮḊ‘
“9‘ỌvḊ‘

— Hedi
स्रोत

4

ऑक्टेव, 21 बाइट्स, 10 नंबर, स्टीवी ग्रिफिन द्वारा

fprएक अच्छा बुरा प्रबंध था =) लेकिन मैं प्यार (1') -> 2(1') -> 2+(1')अनुक्रम!

original:
disp(fpr___f__e_(_'_)     % original
disp(fprintf= e=(1'))     % my solution
disp(fprintf= e=2(1'))
disp(fprintf= e=2+(1'))
disp(fprintf= e=3+(1'))
disp(fprintf= e=4+(1'))
disp(fprintf= e=5+(1'))
disp(fprintf= e=6+(1'))
disp(fprintf= e=7+(1'))
disp(fprintf= e=8+(1'))
disp(fprintf= e=9+(1'))

— flawr
स्रोत

यह अनुक्रम वास्तव में एक अच्छी चाल है!

— लुइस मेंडो

4

Hexagony, 7 बाइट्स, 10 नंबर, द्वारा मार्टिन Ender

मूल:

1<@|!__

कोड जो 1 - 10 का उत्पादन करता है:

1<@|!).
2<@|!).
3<@|!).
4<@|!).
5<@|!).
6<@|!).
7<@|!).
8<@|!).
9<@|!).
9<@|!).!

1: इसे ऑनलाइन आज़माएं!
9: इसे ऑनलाइन आज़माएं!
10: यह ऑनलाइन कोशिश करो!

यहां पहले 9 कार्यक्रमों के लिए हेक्स है (जहां # वह संख्या है जिसे आप प्रिंट करना चाहते हैं):

 # <
@ | !
 ) .

मेमोरी एज केवल उस मान पर सेट है, जिसे आप प्रिंट करना चाहते हैं, एसई के लिए विक्षेपित और मुद्रित।

और 10 के लिए हेक्स:

  9 < @
 | ! ) .
! . . . .
 . . . .
  . . .

यहां, मैंने अंत में एक चरित्र जोड़ा, जिसने हेक्स आकार में वृद्धि की। सबसे पहले, मेमोरी एज को 9 पर सेट किया जाता है, पॉइंटर को एसई में डिफ्लेक्ट किया जाता है, मेमोरी बढ़ाई जाती है, चारों ओर लपेटता है, पॉइंटर को SW में डिफ्लेक्ट किया जाता है, वैल्यू प्रिंट की जाती है और प्रोग्राम खत्म होता है।

यहाँ एक दूसरा समाधान है:

1<@|!$)
2<@|!$)
3<@|!$)
...
8<@|!$)
9<@|!$)
9#@|!$)

1: इसे ऑनलाइन आज़माएं!
9: इसे ऑनलाइन आज़माएं!
10: यह ऑनलाइन कोशिश करो!

1 - 9 के लिए हेक्स (यह समय *प्रिंट करने की संख्या है):

 * <
@ | !
 $ )

यह ऊपर 1 - 9 के समान काम करता है।

10 के लिए हेक्स:

 9 #
@ | !
 $ )

इस हिट ने 9फिर #इंस्ट्रक्टर पॉइंटर को नीचे दायीं ओर स्विच किया, मेमोरी को 10 तक $बढ़ा दिया गया !, ऊपर से कूदता है , पॉइंटर को वापस पूर्व की ओर उलट दिया जाता है, जहां यह ऊपर )और अंत में कूदता है।

— रिले
स्रोत

1

वह आश्चर्यजनक है। : DI एक पुलिस वाले को डिजाइन करने की कोशिश कर रहा था, जहां वे दो समाधान (साइड-लेंथ 3 पर और #9 का उपयोग करके ) संभव थे, लेकिन हमेशा उन पुलिस के साथ समाप्त होते थे जिनमें बोरिंग शॉर्टकट भी होते थे। मैं उम्र की तलाश कर रहा था कि क्या केंद्र में #समाधान के साथ काम करने का एक तरीका था |, लेकिन एक नहीं मिला। वैसे भी छँटाई पर अच्छा काम! :)

— मार्टिन एंडर

4

सी #, 90 बाइट्स, 10 नंबर, Scepheo

मूल:

using ______________________________________________;class C{static void Main(){_______;}}

प्रथम:

using System;class D{public D(){Console.Write(+1);}};class C{static void Main(){new D();}}

फिर:

using System;class D{public D(){Console.Write(1+1);}};class C{static void Main(){new D();}}
using System;class D{public D(){Console.Write(2+1);}};class C{static void Main(){new D();}}
using System;class D{public D(){Console.Write(3+1);}};class C{static void Main(){new D();}}
using System;class D{public D(){Console.Write(4+1);}};class C{static void Main(){new D();}}
using System;class D{public D(){Console.Write(5+1);}};class C{static void Main(){new D();}}
using System;class D{public D(){Console.Write(6+1);}};class C{static void Main(){new D();}}
using System;class D{public D(){Console.Write(7+1);}};class C{static void Main(){new D();}}
using System;class D{public D(){Console.Write(8+1);}};class C{static void Main(){new D();}}
using System;class D{public D(){Console.Write(9+1);}};class C{static void Main(){new D();}}

— Hedi
स्रोत

यही वास्तव में इच्छित समाधान है। अच्छा काम।

— Scepheo

... एक ही कोशिश की, लेकिन विचारक पर एक अजीब संकलक त्रुटि थी ... पता था कि यह कुछ स्पष्ट था ...

— MasterX244

4

रूबी, 81 बाइट्स, 10 नंबर, हिस्टोक्रेट

मूल कोड:

x=##/=#%#
)
###x

फटा:

x=/$/=~%q
)

p x

यह एक मुश्किल था। कई चरित्र जो सामने आए थे, वे लाल झुंड थे! /विभाजन नहीं है लेकिन रेगेक्स शाब्दिक का हिस्सा है। %आधुनिक नहीं है, लेकिन एक असामान्य स्ट्रिंग शाब्दिक वाक्य रचना का हिस्सा है। यह प्रोग्राम बस एक स्ट्रिंग की लंबाई को प्रिंट करता है जिसे न्यूलाइन्स द्वारा सीमांकित किया जाता है। दूसरी पंक्ति में अतिरिक्त वर्ण सम्मिलित करके बाद के कार्यक्रम प्राप्त किए जा सकते हैं।

— xsot
स्रोत

यह मेरे इच्छित समाधान के समान है, लेकिन मेरा उपयोग नहीं करता है p-~x। क्या आप रूबी संस्करण को इंगित कर सकते हैं, जहां इसकी सही व्याख्या की गई है? दो में मेरे पास स्थानीय रूप से p~-xकाम करता है, लेकिन एक त्रुटि के कारण के p-~xरूप में व्याख्या की जाती है । p()-~xundefined method '-' for nil

— हिस्टोक्रैट

@ हिस्टोक्रेट उस ओर इशारा करने के लिए धन्यवाद। मैंने मान लिया कि यह काम करेगा और इसका परीक्षण नहीं किया। उम्मीद है कि यह संपादन आपके मन में था।

— Xsot

और भी करीब, लेकिन वह प्रिंट 0अनमॉडिफाइड है। खोजने के लिए एक आखिरी चाल बची है।

— हिस्टोक्रैट

@ हिस्टोक्रेट मुझे लगता है कि मैंने आखिर इसे समझ लिया।

— xsot

डिंग! शाबाश :)

— histocrat

3

ऑक्टेव, 25 बाइट्स, 10 नंबर, लुइस मेंडो द्वारा

mean(repmat(1,ones(1,1)))
mean(repmat(2,ones(1,1)))
mean(repmat(3,ones(1,1)))
mean(repmat(4,ones(1,1)))
mean(repmat(5,ones(1,1)))
mean(repmat(6,ones(1,1)))
mean(repmat(7,ones(1,1)))
mean(repmat(8,ones(1,1)))
mean(repmat(9,ones(1,1)))

— flawr
स्रोत

यहाँ

— लुइस मेंडो

3

Ui (Aheui), 19 बाइट्स, 10 नंबर, द्वारा जेएचएम

मूल कोड:

봃法희
반자뭉

संशोधित:

2
봃法희
반반뭉
3
봃法희
반밬뭉
4
봃法희
반밭뭉
5
봃法희
반발뭉
6
봃法희
반타뭉
7
봃法희
반밝뭉
8
봃法희
반밣뭉
9
봃法희
반밢뭉
10
봃法희
반다뭉

— jimmy23013
स्रोत

3

ऑक्टेव, 24 बाइट्स, 9 नंबर, त्रुटिपूर्ण द्वारा

max(repmat(1,ones(),1))%
max(repmat(2,ones(),1))%
max(repmat(3,ones(),1))%
max(repmat(4,ones(),1))%
max(repmat(5,ones(),1))%
max(repmat(6,ones(),1))%
max(repmat(7,ones(),1))%
max(repmat(8,ones(),1))%
max(repmat(9,ones(),1))%

ऑक्टेव, 24 बाइट्स 9 10 नंबर

नोट: यह दरार पुलिस पोस्ट के पहले संस्करण के लिए है (गलत स्निपेट पोस्ट किया गया है), इस तरह से प्रकट कोड के साथ ___a__repmat(__one__),__):। सही संस्करण ऊपर है।

मूल कोड:

+mean(repmat(1,ones(),1))

संशोधित संस्करण जो 2-10 प्रिंट करते हैं

1+mean(repmat(1,ones(),1))
2+mean(repmat(1,ones(),1))
3+mean(repmat(1,ones(),1))
4+mean(repmat(1,ones(),1))
5+mean(repmat(1,ones(),1))
6+mean(repmat(1,ones(),1))
7+mean(repmat(1,ones(),1))
8+mean(repmat(1,ones(),1))
9+mean(repmat(1,ones(),1))

— स्टीवी ग्रिफिन
स्रोत

3

जावास्क्रिप्ट, 15 बाइट्स, 10 नंबर, ETHProductions

मूल कोड:

alert( +"+1"+0)  // Prints 1

कार्यक्रम:

alert( +"+1"+1)  // Prints 2
alert( +"+1"+2)  // Prints 3
alert( +"+1"+3)  // Prints 4
alert( +"+1"+4)  // Prints 5
alert( +"+1"+5)  // Prints 6
alert( +"+1"+6)  // Prints 7
alert( +"+1"+7)  // Prints 8
alert( +"+1"+8)  // Prints 9
alert( +"+1"+9)  // Prints 10

— अदनान
स्रोत

3

ऑक्टेव, 21 बाइट्स, 9 नंबर, त्रुटिपूर्ण द्वारा

मुझे वास्तव में यह बहुत अच्छा लगा ... चतुर :)

a='repmat(1one'(1,8)
a='repmat(2one'(1,8)
a='repmat(3one'(1,8)
a='repmat(4one'(1,8)
a='repmat(5one'(1,8)
a='repmat(6one'(1,8)
a='repmat(7one'(1,8)
a='repmat(8one'(1,8)
a='repmat(9one'(1,8)

— स्टीवी ग्रिफिन
स्रोत

1

क्या बिल्ली, नहीं है कि अभी भी मेरा समाधान नहीं था =)

— 23

क्या? क्या आप मेरे साथ मजाक कर रहे हैं? माय ओह माय ...

— स्टीवी ग्रिफिन

वैसे मैं अपना समाधान अभी पोस्ट करूंगा))

— 23

3

एसीसी !! , DLOS द्वारा, 10 बाइट्स, 9 नंबर

मूल कोड:

Write 49+_

संख्या 1 से 9 का उत्पादन करने के लिए:

Write 49+_
Write 49+1
Write 49+2
Write 49+3
Write 49+4
Write 49+5
Write 49+6
Write 49+7
Write 49+8

49 की आस्की कोड है 1। _डिफ़ॉल्ट रूप से 0 शामिल है (इसलिए 49+_ = 1)। और Writeइसके तर्क के कोड के अनुरूप चरित्र को प्रिंट करता है। बहुत सीधा।

— बापू
स्रोत

3

पायथन 2, 49 बाइट्स, 10 नंबर, एलेक्सरजर

हो सकता है कि (सिर्फ हो सकता है) अभीष्ट समाधान हो, लेकिन यदि ऐसा है, तो बहुत सारे बाइट्स बंद हो सकते हैं:

y=10-6;s='0901100000';print int(s[8-8+y-2+0+0:y])
y=10-6;s='0902100000';print int(s[8-8+y-2+0+0:y])
y=10-6;s='0903100000';print int(s[8-8+y-2+0+0:y])
y=10-6;s='0904100000';print int(s[8-8+y-2+0+0:y])
y=10-6;s='0905100000';print int(s[8-8+y-2+0+0:y])
y=10-6;s='0906100000';print int(s[8-8+y-2+0+0:y])
y=10-6;s='0907100000';print int(s[8-8+y-2+0+0:y])
y=10-6;s='0908100000';print int(s[8-8+y-2+0+0:y])
y=10-6;s='0909100000';print int(s[8-8+y-2+0+0:y])
y=10-4;s='0909100000';print int(s[8-8+y-2+0+0:y])

— boboquack
स्रोत

ब्लास्ट मैंने नोटिस नहीं किया कि आपने पहले ही इसे क्रैक कर दिया था जब तक कि मैं अपना प्रस्तुत करने वाला नहीं था। मैं था: y=10*6;s='0910_____1';print int(s[8+(y>4or-6):y])बदल रहा है कि अंतिम 1एक करने के लिए 2, ..., 9और उसके बाद *करने के लिए -: repl.it/EW5q :(

— जोनाथन एलन

वाह, एक अच्छा, मुझे पता था कि मैंने बहुत से पात्रों को छिपाया :)

— एलेक्सरजेर

3

बेफ़ुंज -93 , 11 बाइट्स, 10 नंबर, जेम्स होल्डरनेस

905:**-8-.@
905:**-7-.@
905:**-6-.@
905:**-5-.@
905:**-4-.@
905:**-3-.@
905:**-2-.@
905:**-1-.@
905:**-0-.@
905:**-~-.@

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

शायद इरादा समाधान नहीं है।

मैंने जो किया उसे pesky 25 ( 5:*) से गुणा करके छुटकारा पा लिया 0। यदि हम 9शुरुआत में डालते हैं तो आउटपुट एक ही कमांड से 9 - Nउत्पन्न करने की आवश्यकता होगी N। केवल मुद्दा है -1पाने के लिए 10है, लेकिन अगर कोई इनपुट को आसानी से धक्का एक पूर्णांक पढ़ने का प्रयास -1।

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

3

अदनान द्वारा 05AB1E, 5 बाइट्स, 10 नंबर ।

मूल कोड:

…[==1

1-10:

…[==1
…[==2
…[==3
…[==4
…[==5
…[==6
…[==7
…[==8
…[==9
…[==T

स्पष्टीकरण:

…[==   3 char string
    1  Push number

— acrolith
स्रोत

3

05AB1E, 6 बाइट्स, 10 नंबर, अदनान

मूल कोड:

¼ [==q

¼10 तक के आउटपुट को जोड़ते रहें :

¼¼ [==q
¼¼¼ [==q
¼¼¼¼ [==q
¼¼¼¼¼ [==q
¼¼¼¼¼¼ [==q
¼¼¼¼¼¼¼ [==q
¼¼¼¼¼¼¼¼ [==q
¼¼¼¼¼¼¼¼¼ [==q
¼¼¼¼¼¼¼¼¼¼ [==q

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

यह काम किस प्रकार करता है:

¼        # Increment counter_variable to count_of(¼), it's printed at some point...
  [      # Infinite loop start
   ==    # Print nothing because stack is empty
     q   # Quit

— दूध
स्रोत

कोड सीढ़ी, लुटेरे

मायलैंग, 9 बाइट्स, 8 नंबर (जवाब देने के लिए लिंक सहित), कॉप का यूजरनेम।

मार्टिन एंडर द्वारा रेटिना, 2 बाइट्स, 10 नंबर ।

Perl, 12 बाइट्स, 10 नंबर, ais523 द्वारा

जावास्क्रिप्ट, 30 बाइट, 10 नंबर, ETHproductions द्वारा ।

व्याख्या

स्नैक स्निपेट!

ऑक्टेव, 17 बाइट्स, 10 नंबर, स्टीवी ग्रिफिन द्वारा

अजगर 2, 17 बाइट्स, 10 नंबर, xnor द्वारा

अजगर 2, 9 बाइट्स, 10 नंबर, xnor

पर्ल, 14 बाइट्स, दादा द्वारा 10 नंबर

Arnauld द्वारा जावास्क्रिप्ट, 22 बाइट्स, 10 नंबर

जावास्क्रिप्ट, 9 बाइट्स, हेडी

ऑक्टेव, 55 बाइट्स, 10 नंबर, फ्लोटर

पायथन 3, 16 बाइट्स, 10 नंबर, Sp3000 द्वारा

जावास्क्रिप्ट, 22 बाइट्स, अर्नुलद द्वारा 10 नंबर

ऑक्टेव, 32 बाइट्स, 10 नंबर, द्वारा लुइस मेंडो

05AB1E , 11 बाइट्स, 10 नंबर, द्वारा ओलिवर

व्याख्या

जावास्क्रिप्ट, 12 बाइट्स, 10 नंबर, हेडी

जेली, 7 बाइट्स, 10 नंबर, जोनाथन एलन

ऑक्टेव, 21 बाइट्स, 10 नंबर, स्टीवी ग्रिफिन द्वारा

Hexagony, 7 बाइट्स, 10 नंबर, द्वारा मार्टिन Ender

सी #, 90 बाइट्स, 10 नंबर, Scepheo

रूबी, 81 बाइट्स, 10 नंबर, हिस्टोक्रेट

ऑक्टेव, 25 बाइट्स, 10 नंबर, लुइस मेंडो द्वारा

Ui (Aheui), 19 बाइट्स, 10 नंबर, द्वारा जेएचएम

ऑक्टेव, 24 बाइट्स, 9 नंबर, त्रुटिपूर्ण द्वारा

जावास्क्रिप्ट, 15 बाइट्स, 10 नंबर, ETHProductions

ऑक्टेव, 21 बाइट्स, 9 नंबर, त्रुटिपूर्ण द्वारा

एसीसी !! , DLOS द्वारा, 10 बाइट्स, 9 नंबर

पायथन 2, 49 बाइट्स, 10 नंबर, एलेक्सरजर

बेफ़ुंज -93 , 11 बाइट्स, 10 नंबर, जेम्स होल्डरनेस

अदनान द्वारा 05AB1E, 5 बाइट्स, 10 नंबर ।

05AB1E, 6 बाइट्स, 10 नंबर, अदनान