आपका कार्य, यदि आप इसे स्वीकार करना चाहते हैं, तो एक प्रोग्राम लिखना है जो एक सकारात्मक पूर्णांक (0 से अधिक) को आउटपुट करता है। यदि स्रोत कोड को डुप्लिकेट किया जाता है तो आउटपुट समान रहना चाहिए। मुश्किल हिस्सा यह है कि अगर स्रोत कोड तीन बार टाइप किया गया है ( तीन गुना ?) आउटपुट 3 से गुणा किया जाएगा।

नियम

आपको एक पूर्ण कार्यक्रम बनाना चाहिए । यानी आपका आउटपुट STDOUT पर प्रिंट करना होगा।
प्रारंभिक स्रोत कम से कम 1 बाइट लंबा होना चाहिए।
दोनों पूर्णांक बेस 10 में होने चाहिए (किसी अन्य आधार पर या वैज्ञानिक संकेतन के साथ उन्हें निषिद्ध करना)।
आपके प्रोग्राम को इनपुट नहीं लेना चाहिए (या अप्रयुक्त, खाली इनपुट) होना चाहिए ।
अनुगामी / अग्रणी स्थानों के साथ पूर्णांक आउटपुट की अनुमति है।
अग्रणी शून्य केवल तभी अनुमत होते हैं जब अंकों की संख्या सुसंगत हो जैसे: 001 - 001 - 003 या 004 - 004 - 012
आप अपने स्रोत की प्रतियों के बीच एक नई पंक्ति नहीं मान सकते हैं।
यह कोड-गोल्फ है , इसलिए प्रत्येक भाषा में सबसे छोटा (मूल) कोड जीत जाता है!
डिफ़ॉल्ट ढीले लागू होते हैं।

उदाहरण

मान लीजिए कि आपका स्रोत कोड है Abcऔर उसका संबंधित आउटपुट है 4। अगर मैं AbcAbcइसके बजाय लिखता हूं और इसे चलाता हूं , तो आउटपुट अभी भी होना चाहिए 4। हालाँकि अगर मैं AbcAbcAbcइसे लिखता और चलाता हूँ, तो आउटपुट अवश्य होना चाहिए 12।

मिस्टर एक्सकोडर की चुनौती से ~~बेशर्म चोरी हो~~ गई

code-golf source-layout

— workoverflow
स्रोत

क्या हमारे कोड को अपने स्वयं के स्रोत कोड को पढ़ने की अनुमति है?

— AdmBorkBork

@AdmBorkBork मैं ऐसा मान सकता हूं, क्योंकि यह क्वीन के रूप में टैग नहीं किया गया है ।

— आउटगोल्फर

@AdmBorkBork हाँ।

— वर्कओवरफ्लो

9

मुझे नहीं लगता कि 1 बाइट प्रतिबंध की आवश्यकता है क्योंकि यह 3 बार दोहराया और कुछ भी नहीं के बीच का अंतर बताना संभव नहीं होगा।

— 12Me21

1

@ r12 "Abc" किसी भी प्रोग्रामिंग लैंग्वेज प्रोग्राम के लिए एक उदाहरण है, यदि आपका कोड है ( int i=1;print i;) तो डुप्लिकेट किए गए कोड ( int i=1;print i;int i=1;print i;) को मूल कोड के समान संख्या में आउटपुट करना होगा, और जब कोड को ट्रिपल किया जाता है (तो int i=1;print i;int i=1;print i;int i=1;print i;) उसे दिखाना होगा संख्या 3 से गुणा

— वर्कओवरफ्लो

21

वम्पस , 6 बाइट्स

{~)
@O

इसे ऑनलाइन आज़माएं!
इसे दोगुना करने की कोशिश करो!
इसे तीन गुना करने की कोशिश करो!

प्रिंट 1और 3।

व्याख्या

मुझे जानवर बल खोज द्वारा 6-बाइट समाधानों का एक टन मिला, लेकिन 5 बाइट्स के लिए कोई नहीं। यह जरूरी नहीं है कि 5 बाइट्स में कोई भी नहीं है, लेकिन वे शायद अजीब अक्षर या कुछ का उपयोग करेंगे।

मैंने इस समाधान को चुनना समाप्त कर दिया क्योंकि यह किसी भी अग्रणी शून्य को प्रिंट नहीं करता है (उनमें से अधिकांश करते हैं) और इसमें कुछ दिलचस्प नियंत्रण प्रवाह है। आइए एकल कार्यक्रम से शुरू करते हैं:

इसलिए निष्पादित कोड है:

{~)O@

{   Turn the IP left by 60°.
~   Swap two implicit zeros on the stack, does nothing.
)   Increment the top zero to 1.
O   Print it.
@   Terminate the program.

काफी आसान। अब दोगुना हो गया कार्यक्रम। चूंकि पहली पंक्ति दूसरी पंक्ति में जुड़ जाती है, ग्रिड चौड़ाई 5 (और ऊंचाई 3) तक फैली हुई है जो नियंत्रण प्रवाह को महत्वपूर्ण रूप से बदल देती है:

आईपी उस लूप के चारों ओर एक बार जाता है, इसलिए निष्पादित कोड है:

{~){~)){~O@

{~) As before, we end up with a 1 on top of the stack.
{   Turn left by 60° again.
~   Swap the 1 with the 0 underneath.
))  Increment the zero to 2.
{   Turn left by 60° again.
~   Swap the 2 with the 1 underneath.
O   Print the 1.
@   Terminate the program.

अंत में, ट्रिपल्ड प्रोग्राम काफी हद तक दोगुने से मिलता-जुलता है, लेकिन हमें उस तीसरी लाइन पर कुछ और महत्वपूर्ण कमांड मिलते हैं:

इसलिए निष्पादित कोड है:

{~){~)){~~)O@

{~){~)){~
    As before. We end up with a 1 on top of the stack and a 2 underneath.
~   Swap the 1 with the 2 underneath.
)   Increment the 2 to a 3.
O   Print the 3.
@   Terminate the program.

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

1

मुझे लगता है कि मुझे इस भाषा से प्यार है।

— विजय

11

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

KΣK+1

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

दो बार दोहराया!

तीन बार दोहराया!

व्याख्या

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

K, जो एक स्थिर फ़ंक्शन का निर्माण करता है। K a bके बराबर है a।
Σ, जो एक पूर्णांक n लेता है और n वें त्रिकोणीय संख्या देता है।
+, जो दो नंबर जोड़ता है।
1, जो शाब्दिक है 1।

मूल कार्यक्रम की व्याख्या इस तरह की जाती है:

   K Σ (K+) 1
== Σ 1
== 1

(K+)एक अतर्कसंगत समारोह है कि पहले द्वारा खाया जाता है K।

दो बार दोहराए गए कार्यक्रम की व्याख्या इस प्रकार की जाती है:

   K Σ (K+1KΣK+) 1
== Σ 1
== 1

कोष्ठक में कार्य फिर से पहले खाया जाता है K।

तीन बार दोहराए गए कार्यक्रम की व्याख्या इस प्रकार की जाती है:

   K (Σ (K (+1) (KΣK+) 1)) (KΣK+1)
== Σ (K (+1) (KΣK+) 1)
== Σ ((+1) 1)
== Σ (+1 1)
== Σ 2
== 3

— Zgarb
स्रोत

यह चलाने के लिए वास्तव में लंबा समय लगता है ...

— वीजुन झोउ

@ WeijunZhou यदि आपके पास Kकिसी प्रोग्राम की कई घटनाएँ हैं , तो टाइप इंफ़ेक्शन बहुत धीमा हो जाता है, क्योंकि उनमें से प्रत्येक टोकन की किसी भी संख्या को संभावित रूप से "खा सकता है" और दुभाषिया सभी संयोजनों का प्रयास करेगा ...

— ज़र्गब मार्क

मैं देखता हूं, आपके स्पष्टीकरण के लिए धन्यवाद।

— वीजुन झोउ

2

@Zgarb +1 के लिए केक +1

— workoverflow

10

जेली , 7 5 बाइट्स

»‘µ*Ḃ

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

इसे दोगुना करने की कोशिश करो!

इसे तीन गुना करने की कोशिश करो!

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

»‘µ*Ḃ            Main link. No arguments. Implicit argument: x = 0

 ‘               Increment; yield x + 1 = 1.
»                Take the maximum of x and 1. Yields 1.
  µ              Begin a new, monadic chain. Argument: y = 1
    Ḃ            Bit; yield 1 if y is odd, 0 if it is even. Yields 1.
   *             Power; yield y**1 = 1.

»‘µ*Ḃ»‘µ*Ḃ       Main link.

»‘µ*Ḃ            As before.
      ‘          Increment; yield y + 1 = 2.
     »           Take the maximum of 1 and 2. Yields 2.
       µ         Begin a new, monadic chain. Argument: z = 2
         Ḃ       Bit; yield 1 if z is odd, 0 if it is even. Yields 0.
        *        Power; yield z**0 = 1.

»‘µ*Ḃ»‘µ*Ḃ»‘µ*Ḃ  Main link.

»‘µ*Ḃ»‘µ*Ḃ       As before.
           ‘     Increment; yield z + 1 = 3.
          »      Take the maximum of 1 and 3. Yields 3.
            µ    Begin a new, monadic chain. Argument: w = 3
              Ḃ  Bit; yield 1 if w is odd, 0 if it is even. Yields 1.
             *   Power; yield w**1 = 3.

— डेनिस
स्रोत

10

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

main=print.div 3$4
 -1--

प्रिंट 1: इसे ऑनलाइन आज़माएं!

main=print.div 3$4
 -1--main=print.div 3$4
 -1--

इसके अलावा प्रिंट 1: इसे ऑनलाइन आज़माएं!

main=print.div 3$4
 -1--main=print.div 3$4
 -1--main=print.div 3$4
 -1--

प्रिंट 3: इसे ऑनलाइन आज़माएं!

— Laikoni
स्रोत

10

क्यूबिक्स , 5 बाइट्स

)<@OP

इसे ऑनलाइन आज़माएं: एक बार , दो बार , तीन बार ।

व्याख्या

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

मुझे यह स्वीकार करना चाहिए कि यह एक ब्रूट-फोरसर द्वारा पाया गया था; मुझे यह कभी नहीं मिला। वास्तव में, @MartinEnder वह था जिसने मुझे पाशविक-बलपूर्वक प्रयास करने के लिए कहा, क्योंकि वह बिना किस्मत के इस समाधान की तलाश में था। यह ब्रूट-फॉरेसर का एकमात्र समाधान है, और मुझे विश्वास है कि यह क्यूबिक्स में सबसे छोटा और एकमात्र समाधान है।

एकल कार्यक्रम

इसे देखो!

मूल कार्यक्रम एक यूनिट क्यूब पर फिट बैठता है। यहां सामने आया नेट:

  )
< @ O P
  .

IP (इंस्ट्रक्शन पॉइंटर) <पूर्व की ओर मुख वाले सबसे बाएं चेहरे ( ) पर शुरू होता है । <तुरंत यह पश्चिम बताते हैं, और यह करने के इर्द-गिर्द घूमती P। Pप्रतिपादक है, और चूंकि स्टैक पर कुछ भी नहीं है, दुभाषिया दो 0 एस को बाहर निकालता है और 0 ^{0 की} गणना करता है, जो जावास्क्रिप्ट के अनुसार 1 है । Oफिर इस मूल्य को प्रिंट करता है, और @प्रोग्राम को समाप्त करता है।

दोहरा कार्यक्रम

इसे देखो!

)<@OP)<@OP

10-बाइट प्रोग्राम एक यूनिट क्यूब पर फिट होने के लिए बहुत लंबा है, और इसलिए इसे आकार -2 क्यूब तक विस्तारित किया जाता है:

    ) <
    @ O
P ) < @ O P . .
. . . . . . . .
    . .
    . .

पहले की तरह, आईपी बाईं-सबसे चेहरे के शीर्ष-बाईं ओर शुरू होता है। इस बार, पहला पहला निर्देश है P, जो पहले की तरह 1 धक्का देता है । अगला है ), जो शीर्ष आइटम को बढ़ाता है , इसे 2 में बदल देता है । फिर <आईपी को चारों ओर घुमाता है, और यह )फिर से हिट करता है , 2 को 3 में बदल देता है ।

यहां यह दिलचस्प है। Pपहले आइटम की शक्ति के लिए दूसरा-से-शीर्ष आइटम उठाता है, जो 0 ³ = 0 देता है । फिर आईपी सबसे दाहिने चेहरे के चारों ओर लपेटता है और .दूसरे को मारने से पहले दो नो-ऑप्स से गुजरता है P। यहां हमें क्यूबिक्स का एक और क्विकर दिखाई देता है: बाइनरी ऑपरेटर (जैसे P) स्टैक से अपने ऑपरेंड को नहीं हटाते हैं। इसलिए चूंकि स्टैक अब है [3, 0], हम 3 ⁰ = 1 की गणना करते हैं , जो Oआउटपुट करता है, और @प्रोग्राम को समाप्त करता है।

ट्रिपल कार्यक्रम

इसे देखो!

)<@OP)<@OP)<@OP

दोहरे कार्यक्रम के साथ, ट्रिपल आकार -2 घन पर फिट हो सकता है:

    ) <
    @ O
P ) < @ O P ) <
@ O P . . . . .
    . .
    . .

: इस कार्यक्रम के पिछले के रूप में एक ही तरह से बाहर शुरू होता है Pधक्का 1 , )वेतन वृद्धि, <पश्चिम आईपी बताते हैं, )वेतन वृद्धि फिर से, और Pअब धक्का 0 । आईपी को फिर <सबसे दाहिने चेहरे पर लपेटा जाता है , जो कि कुछ भी नहीं करता है क्योंकि आईपी पहले से ही पश्चिम की ओर इशारा करता है।

यहाँ डबल प्रोग्राम से एक अंतर है: स्टैक के शीर्ष पर 0 की )वृद्धि 1 से । जब फिर से अपना जादू करता है, तो इस बार 3 ¹ = 3 की गणना करता है । आउटपुट और समाप्त होता है, और हम निर्णायक रूप से साबित करते हैं कि तीसरी बार वास्तव में आकर्षण है।PO@

— ETHproductions
स्रोत

1

मैं वास्तव में आपके स्पष्टीकरण का आनंद लिया। +1

— वर्कओवरफ्लो

7

ब्रेन-फ्लैक , 10 बाइट्स

<>([]{}())

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

इसे दोगुना करने की कोशिश करो!

इसे तीन गुना करने की कोशिश करो!

स्पष्टीकरण:

#Toggle stacks
<>

#Push
(
    #Stack-height (initially 0) + 
    []

    #The TOS (initially 0) + 
    {}

    #1
    ()
)

जब हम इसे एक बार चलाते हैं, तो इसे (0 + 0 + 1) == 1वैकल्पिक स्टैक पर रखा जाएगा । दूसरी बार दौड़ा, यह मुख्य स्टैक पर समान है। हालाँकि, तीसरी बार चलाते हैं , यह इसका मूल्यांकन करता है (1 + 1 + 1) == 3, और इसे वैकल्पिक स्टैक और अंतर्निहित रूप से प्रिंट करता है।

— DJMcMayhem
स्रोत

7

एसक्यूएल, 25 24 23 बाइट्स

( -1 बाइट एक गलत लिखे गए चरित्र है जो हमेशा बाहर टिप्पणी की गयी है और कुछ भी नहीं कर निकाला गया )
( -1 बाइट बदल दिया SELECTकरने के लिए PRINTराज़्वान Socol द्वारा सिफारिश के रूप में )

PRINT 2/*
*2+1--*/-1
--

यह कैसे काम करता है:
एसक्यूएल में, आप टिप्पणी टैग से टिप्पणी कर सकते हैं, जैसे:

/*
'Comment'--*/

बनाम

--/*
'Not Comment'--*/

बाहर रखी गई टिप्पणियों के साथ 1 पंक्ति पर कोड:
पहला पुनरावृत्ति: SELECT 2-1आउटपुट: 1
दूसरा पुनरावृत्ति: SELECT 2-1*2+1आउटपुट: 1
तीसरा पुनरावृत्ति: SELECT 2-1*2+1*2+1आउटपुट:3

— Chronocidal
स्रोत

1

PRINTइसके बजाय SELECTएक अतिरिक्त बाइट बचाना होगा।

— रज़वान सोकोल

6

SOGL V0.12 , 7 5 4 बाइट्स

ē»«I

यहाँ यह कोशिश करो!

इसे दोगुना करने की कोशिश करो!

इसे तीन गुना करने की कोशिश करो!

स्पष्टीकरण:

ē»«I
ē     push counter, then increment it.
      First time running this will push 0, then 1, then 2.
             TOS on each: 0  1  2
 »    floor divide by 2   0  0  1
  «   multiply by 2       0  0  2
   I  and increment       1  1  3

— dzaima
स्रोत

मैंने की तर्ज पर कुछ करने की कोशिश की ē1|, लेकिन जाहिर तौर पर बिटवाइस के लिए कोई आज्ञा नहीं है या ...

— ETHproductions

@ETHproductions हाँ, मैं भी ऐसा ही कुछ करना चाहता था, और मुझे जो सबसे अच्छा मिला वह था ē:2\+: /

— dzaima

5

05AB1E , 6 5 बाइट्स

.gDÈ+

इसे ऑनलाइन आज़माएं! या यह दोगुना करने की कोशिश करो! या यह तीन गुना कोशिश करो!

व्याख्या

.g     # push length of stack
  D    # duplicate
   È   # check if even
    +  # add

एकल: 0 + (0 % 2 == 0) -> 1
डबल: 1 + (1 % 2 == 0) -> 1
ट्रिपल:2 + (2 % 2 == 0) -> 3

— Emigna
स्रोत

क्या यह % 2ट्रिपल स्पष्टीकरण में होना चाहिए ?

— लार्सव

@ लार्स: हाँ वास्तव में :)

— एमिग्ना

@Emigna मुझे लगता है कि "जाँच करें कि क्या" वास्तव में 2%_सही है?

— मैजिक ऑक्टोपस Urn

2 + (2 % 2 == 0) -> 2लेकिन 2 + !(2 % 2 == 0) -> 3(आपके स्पष्टीकरण के लिए)।

— मैजिक ऑक्टोपस Urn

@MagicOctopusUrn हाँ 2%_के समान है È। समझ में नहीं आता कि आप स्पष्टीकरण के बारे में क्या सोचते हैं। 2+(2%2==0) = 2+(0==0) = 2+1 = 3। यह संभवत: स्पष्ट हो जाता अगर मैंने संगणनाओं की पड़ताल की होती।

— एमिग्ना

5

> <> , 9 बाइट्स

\5 n;
\\1

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

इसे दोगुना करने की कोशिश करो!

इसे तीन गुना करने की कोशिश करो!

मुझे इस तरह की किस्मत मिली, दर्शन का उपयोग करते हुए कि "यदि आप मछली के मार्ग को पर्याप्त रूप से जटिल बनाते हैं, तो अंततः कुछ काम करेगा"। मूल और दोगुना संस्करण 5 प्रिंट करते हैं, और ट्रिपल संस्करण 1 फिर 5 को 15 = 3 × 5 बनाते हैं। यहाँ आपके गुणन के लिए कई गुणा संस्करण हैं:

\5 n;
\\1\5 n;
\\1

\5 n;
\\1\5 n;
\\1\5 n;
\\1

— पेड़ नहीं
स्रोत

5

पायथन 2 , 46 45 39 बाइट्स

हलवार्ड के जवाब से प्रेरित । मुझे खुशी है कि मेरी चुनौती ने एक नई प्रेरणा दी, जो मुझे और भी दिलचस्प लगती है। केविन क्रूज़सेन की बदौलत 6 बाइट्स बचाए ।

print open(__file__,"a").tell()/79*3|1#

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

इसे दोगुना करने की कोशिश करो!

इसे तीन गुना करने की कोशिश करो!

यह कैसे काम करता है (पुराना)

k=open(__file__,"a").tell() # Read the source code in "append" mode and get its length.
                            # Assign it to a variable k.
;print k>>(k==90)#          # Print k, with the bits shifted to the right by 1 if k
                            # is equal to 90, or without being shifted at all overwise.
                            # By shifting the bits of a number to the right by 1 (>>1),
                            # we basically halve it.

जब इसे दोगुना किया जाता है, तो लंबाई 90 हो जाती है , लेकिन नए कोड को धन्यवाद की अनदेखी की जाती है #, इसलिए इसका k==90मूल्यांकन करता है True। बूलियन अजगर में पूर्णांक के उपवर्ग हैं, इसलिए k>>Trueइसके बराबर है k>>1, जो अनिवार्य रूप से k / 2 = 45 है । जब यह तीन गुना है, नए कोड फिर से, पर ध्यान नहीं दिया गया है और इसलिए नई लंबाई है 135 जो क्योंकि स्थानांतरित कर दिया है नहीं मिलता है, k==90पर मूल्यांकन करता है False, इसलिए k>>(k==90) ⟶ k>>(135==90) ⟶ k>>False ⟶ k>>0 ⟶ k, और कश्मीर के रूप में है छपा है।

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

यह 38 बाइट्स में Aidan F. Pierce का एक सुझाव था, और मैंने इसे 2 बाइट्स में पूरा किया। मैं इसे अपने मुख्य समाधान के रूप में पोस्ट नहीं कर रहा हूं क्योंकि मैं इसके साथ नहीं आया था।

0and""
True+=1
print True>3and 3or 1

इसे ऑनलाइन आज़माएं! इसे दोगुना करने की कोशिश करो! इसे तीन गुना करने की कोशिश करो!

— श्री Xcoder
स्रोत

एक टिप्पणी का उपयोग करने के विचार के लिए धन्यवाद - मुझे 6 बाइट्स बचाए।

— AdmBorkBork

print open(__file__,"a").tell()/79*3|1#शायद?

— केविन क्रूज़सेन

@ केविनक्रूजसेन ग्रेट, धन्यवाद!

— श्री एक्सकोडर

एक कम बाइट, कोई स्रोत कोड पढ़ना: tio.run/##K6gsycjPM/r/… दो और तीन दोहराव के लिए प्रमुख रिक्त स्थान के साथ प्रिंट, लेकिन यह अनुमति दी प्रतीत होता है।

— एदान एफ। पियर्स

@ AidanF.Pierce बहुत बहुत धन्यवाद! मैंने इसे थोड़ा और गोल्फ दिया और इसे वैकल्पिक समाधान के रूप में पोस्ट किया।

— श्री एक्सकोडर

5

आर , 37 31 28 बाइट्स

अंतिम 3 बाइट्स को बंद करने के लिए Giuseppe का धन्यवाद ।

length(readLines())%/%2*2+1

(अनुगामी न्यूलाइन के साथ)।

एक बार आजमा कर देखिए!

इसे दो बार आज़माएं!

इसे तीन बार आज़माएं!

यह 8-गेंद चुनौती के लिए Giuseppe के उत्तरreadLines() से चाल का उपयोग करता है , जहां स्रोत फ़ाइल पर रीडायरेक्ट करता है। यह कोड मूल रूप से सिर्फ यह बताता है कि पहली पंक्ति के नीचे कितनी लाइनें मौजूद हैं और अगर 1 या 3 लाइनें हैं (यानी कोड एकल या दोगुना है), या अगर 5 लाइनें हैं (यानी कोड तीन गुना है)।stdin13

— rturnbull
स्रोत

ओह, साफ, +1! यह निश्चित नहीं था कि आर में यह कैसे किया जाए। मुझे लगता है कि इसके sठीक से काम करने के लिए आपको एक नई रूपरेखा की आवश्यकता है , लेकिन क्या आपको कुछ गणनाओं को फिर से काम करके इसे 28 बाइट्स में गोल्फ में सक्षम होना चाहिए ।

— ग्यूसेप

@Giuseppe न्यूलाइन समस्या को इंगित करने के लिए धन्यवाद! कोड को तीन गुना करने पर मैं आपका संस्करण प्राप्त करने में सक्षम नहीं था - क्या मुझे कुछ याद आ रहा है?

— rturnbull

ओह अजीब मैं मस्ता एक अनुगामी newline था, लेकिन अगर आप %/%2इसे काम करना चाहिए

— Giuseppe

5

खोया , 38 बाइट्स

\\<<<<</<<<<>
2>((1+@>?!^%^
.........v

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

\\<<<<</<<<<>
2>((1+@>?!^%^
.........v\\<<<<</<<<<>
2>((1+@>?!^%^
.........v

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

\\<<<<</<<<<>
2>((1+@>?!^%^
.........v\\<<<<</<<<<>
2>((1+@>?!^%^
.........v\\<<<<</<<<<>
2>((1+@>?!^%^
.........v

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

व्याख्या

इस चुनौती के लिए लॉस्ट एक बहुत ही दिलचस्प भाषा है। सामान्य लॉस्ट तकनीक "ट्रैप" का निर्माण करना है। एक जाल कार्यक्रम का एक भाग है जिसे सभी कूल्हों को एक स्थान पर पकड़ने के लिए डिज़ाइन किया गया है ताकि उनके ढेर को साफ किया जा सके और उन्हें एक विशिष्ट दिशा में जाने के लिए नियंत्रित किया जा सके। यह लॉस्ट में बहुत अधिक प्रबंधनीय में लेखन कार्यक्रम बनाता है। हालाँकि, चूंकि प्रोग्राम को डुप्लिकेट किया गया है, इसलिए हमें ट्रैप डुप्लीकेशन से भी बचने की आवश्यकता है। इसके लिए हमें एक नया ट्रैप तैयार करना होगा जो ठीक से काम करे लेकिन जब ट्रैप्स में से केवल एक ही डुप्लिकेट हो। यहाँ मेरा मूल विचार निम्नलिखित है

v<<<<>
>%?!^^

जबकि स्टैक गैर-खाली है, ?एक आइटम को हटा देगा और इसे भीख में वापस कूदने का कारण देगा यदि वह आइटम गैर-शून्य है। यहाँ कुंजी यह है कि जब यह स्टैक ^^अप लाइन है

v<<<<>
>%?!^^v<<<<>
>%?!^^v<<<<>
>%?!^^v<<<<>
>%?!^^v<<<<>
>%?!^^

मतलब यह है कि आप कैसे भी प्रवेश करें आप हमेशा उसी जगह से बाहर निकलेंगे।

यहाँ से हम अपने क्लेन उत्तर से उसी विचार को लागू करने का प्रयास कर सकते हैं ।

\\<<<<<v<<<<>
2>((1+@>?!^%^

हमारे कार्यक्रम की रीढ़ की हड्डी बाईं ओर है जो कई 2एस को धकेलता है । हर बार जब हम कार्यक्रम की एक प्रति जोड़ते हैं तो कार्यक्रम 2की रीढ़ में एक और जुड़ जाता है जिसका अर्थ है कि अतिरिक्त 2 को स्टैक में धकेल दिया जाता है। एक बार जब यह नीचे से ऊपर चला जाता है तो यह \\>कोड के माध्यम से उछलता है और निष्पादित होता है

((1+@

यह पहले 2 स्टैक आइटम को हटाता है, जो कुछ भी बचा है उसे जोड़ता है, और बाहर निकलता है। एक बार हमारी रीढ़ की हड्डी में 3 2 एस हो जाए तो हम 1 जोड़ेंगे और 3 प्राप्त करेंगे, अगर हमारे पास 3 से कम आइटम हैं तो हम पूरे स्टैक को छोड़ देंगे और 1 वापस कर देंगे।

अब केवल समस्या यह है कि !हमारे कार्यक्रम में एक अनंत लूप हो सकता है। यदि आईपी !ऊपर की तरफ जाने लगता है तो वह कूद जाएगा और ठीक उसी स्थान पर वापस आ जाएगा जहां वह था। इसका मतलब है कि लूप को रोकने के लिए हमें एक और लाइन जोड़ना होगा।

\\<<<<</<<<<>
2>((1+@>?!^%^
.........^

यह ^जाल में हमारे एस के बीच में कुछ स्लैश डालने की मामूली समस्या है । हालांकि, चमत्कारिक रूप से, सब कुछ बाहर काम करता है। हमारे कूल्हे ठीक से इधर-उधर उछलते हैं ताकि उसमें फर्क न पड़े।

— गेहूं का जादूगर
स्रोत

1

27 बाइट्स , दोगुना , तिगुना

— जो किंग

@ दुर्भाग्य से मैं इस समय मोबाइल पर अटका हुआ हूं। क्या आप इसे स्पष्टीकरण के साथ उत्तर के रूप में पोस्ट कर सकते हैं?

— गेहूं जादूगर

पोस्ट किया गया

— Jo King

4

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

|dhH^

भागो और डिबग ऑनलाइन! · दोगुनी · तिगुनी

व्याख्या

|dhH^
|d       Push Current stack depth `d`, originally 0
         Doubled -> 1, Tripled -> 2
  hH^    Map d to 2*(floor(d/2))+1
         Implicit print

— वीजुन झोउ
स्रोत

4

सी (जीसीसी) , 95 91 85 बाइट्स

#ifndef a
#define a-1
main(){puts(3
#include __FILE__
?"1":"3");}
#define a
#endif
a

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

— l4m2
स्रोत

तब मेरा सुझाव है कि आप सही TIO लिंक को संपादित करें।

— एरिक द आउटग्राफर

मैं कभी-कभी TIO से कनेक्ट नहीं कर सकता, मुझे नहीं पता कि क्यों

— l4m2

4

जाप , 8 6 5 बाइट्स

-1 बाइट @ @Hproductions के लिए धन्यवाद

°U-v

स्पष्टीकरण:

°U-v
 U     # variable U=0                # U=0
°U     # ++U                         # U=1
  -    # minus:
   v   #   1 if U is divisible by 2  
       #     else
       #   0                         # U=1

यह करने के लिए मूल्यांकन करता है 1-0 = 1

दोगुना मूल्यांकन करता है 2-1 = 1

तीन गुना मूल्यांकन करता है 3-0 = 3

— ओलिवर
स्रोत

1

थोड़ा आगे बढ़ते हुए, मुझे लगता है कि आप °U-vदूसरे पर बचाने के लिए (प्लस न्यूलाइन) कर सकते हैं U।

— ETHproductions

@ETHproductions धन्यवाद! vइस चुनौती के लिए एकदम सही है :-)

— ओलिवर

4

शुद्ध बैश (नहीं `wc`या अन्य बाहरी बर्तन), 27

trap echo\ $[a++&2|1] EXIT

— डिजिटल आघात
स्रोत

अच्छा! बदलें EXITके साथ0

— GammaFunction

4

पर्ल 5 , 18 15 13 12 11 बाइट्स

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

say 1|
+.7#

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

दो बार इसे ऑनलाइन आज़माएं!

तीन बार इसे ऑनलाइन आज़माएं!

— टन हास्पेल
स्रोत

1

n;$_=$a++|1;say(15 बाइट्स)

— nwellnhof

@nwellnhof बेशक!। धन्यवाद।

— टन हास्पेल

4

> <> , 10 9 8 बाइट्स

562gn|

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

इसे दोगुना करने की कोशिश करो!

इसे तीन गुना करने की कोशिश करो!

~~मुझे यकीन है कि वहाँ एक 8 बाइट समाधान कहीं बाहर है।~~

अंत में अप्राप्य में ASCII मान 1 है, और केवल gतीसरे पुनरावृत्ति पर एट कमांड द्वारा प्राप्त किया जाता है । पहले दो के लिए यह प्रिंट करता है 05, और फिर प्रिंट करता है 15।

— मजाक कर रहा है
स्रोत

8 बाइट सॉल्यूशन मायावी साबित हो रहा है, लेकिन यहां कुछ और 9 बाइट हैं जो मामले में आपको प्रेरित करते हैं: TIO , TIO

— न कि एक पेड़

1

@Notatree को एक बेजोड़ के साथ 8 बाइट मिली

— जो किंग

4

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

सी (gcc) में मेरा पहला सबमिशन। बहुत लंबा रास्ता ...

i;
#ifdef c
#define c
#ifdef b
i=2;
#else
#define b
#endif
#else
#define c main(){putchar(i+49);}
#endif
c

TIO लिंक: सिंगल , डबल , ट्रिपल ।

— वीजुन झोउ
स्रोत

3

भूलभुलैया , 12 11 9 बाइट्स

: #% @
 7

TIO (1x) , TIO (2x) , TIO (3x)

— हरमन एल
स्रोत

3

जावास्क्रिप्ट, 81 77 74 70 बाइट्स

^{झबरा के लिए धन्यवाद 4 बाइट्स बचाता है}

var t,i=(i||[3,1,1]),a=i.pop()
clearTimeout(t)
t=setTimeout(alert,9,a)

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

सुंदर लंगड़ा जेएस समाधान। मान [3,1,1]को दाईं ओर से सरणी से प्राप्त करता है ( pop())। भविष्य में वर्तमान मूल्य प्रदर्शित करने के लिए एक समयसीमा पंजीकृत करता है। यदि कोई समय सीमा पहले से पंजीकृत थी, तो उसे रद्द कर दें। के गंदे स्वभाव पर निर्भर करता है var, जो परिवर्तनशील घोषणाओं को फहराता है।

दो बार:

कोड स्निपेट दिखाएं

var t,i=(i||[3,1,1]),a=i.pop()
clearTimeout(t)
t=setTimeout(alert,9,a)

var t,i=(i||[3,1,1]),a=i.pop()
clearTimeout(t)
t=setTimeout(alert,9,a)

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

तीन बार:

कोड स्निपेट दिखाएं

var t,i=(i||[3,1,1]),a=i.pop()
clearTimeout(t)
t=setTimeout(alert,9,a)

var t,i=(i||[3,1,1]),a=i.pop()
clearTimeout(t)
t=setTimeout(alert,9,a)

var t,i=(i||[3,1,1]),a=i.pop()
clearTimeout(t)
t=setTimeout(alert,9,a)

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

— क्रिस्टियन लुपस्कू
स्रोत

यह काम करने के लिए एक अनुगामी अर्ध-उपनिवेश या न्यूलाइन की आवश्यकता है, लेकिन आप 4 बाइट्स aको 3 तर्क के रूप में पास करके बचा सकते हैं setTimeout:setTimeout(alert,9,a)

— झबरा

@ शगुन थैंक्स! यह अतिरिक्त अर्ध-बृहदान्त्र के बिना भी ठीक काम करता है।

— क्रिस्टियन लुपस्कु

3

सी (जीसीसी) , 53 52 बाइट्स

नोट के बाद की जगह #endif।

n;main(){putchar(n+49);}
#if __LINE__>7
n=2;
#endif

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

— gastropner
स्रोत

2

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

⎚≔⁺ι¹ιＩ⁻ι⁼ι²

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

इसे दोगुना करने की कोशिश करो!

इसे तीन गुना करने की कोशिश करो!

व्याख्या

⎚             Clear
 ≔⁺ι¹ι        Assign plus(i, 1) to i
       Ｉ      Cast (and implicitly print)
         ⁻ ⁼ι² Subtract equals(i, 2) from
          ι    i

— ASCII-केवल
स्रोत

MapAssignRight(Plus, 1, i)आपको एक बाइट बचाता है, जो आपको @Mr पर मेरे उत्तर के एक बंदरगाह के समान लंबाई में मिलती है। XCoder की चुनौती:ＰＩ∨›³Ｌ⊞Ｏυω³

— नील

ＰＩ⊕⊗÷Ｌ⊞Ｏυω³मेरे जवाब का एक और संस्करण है, लेकिन अभी भी 11 बाइट्स ...

— नील

10-बटर मिला!

— नील

: / मुझे वास्तव में ठीक करना चाहिएMapAssign(Incremented, i)

— केवल

2

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

var t=t?--t:~!setTimeout`t=alert(1|~t)`;

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

2x:

कोड स्निपेट दिखाएं

var t=t?--t:~!setTimeout`t=alert(1|~t)`;var t=t?--t:~!setTimeout`t=alert(1|~t)`;

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

3x:

कोड स्निपेट दिखाएं

var t=t?--t:~!setTimeout`t=alert(1|~t)`;var t=t?--t:~!setTimeout`t=alert(1|~t)`;var t=t?--t:~!setTimeout`t=alert(1|~t)`;

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

— l4m2
स्रोत

ps यह समाधान पर्यावरण को नहीं तोड़ता

— l4m2

2

पॉवरशेल , 54 48 45 44 बाइट्स

if(99-gt(gc $PSCOMMANDPATH|wc -c)){1;exit}3#

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

इसे दोगुना करने की कोशिश करो!

इसे तीन गुना करने की कोशिश करो!

के साथ अपने खुद के आह्वान पथ हो जाता है $PSCOMMANDPATHऔर फ़ाइल पर एक gएट- cऑनेंट प्रदर्शन करता है । Ifउस फ़ाइल की वर्ण गणना 99( wc -cकोरुटिल से जाँच की गई ) से कम है , फिर हम आउटपुट ( 1और exit, स्टॉप एक्ज़ीक्यूट) करते हैं। यह मूल कोड और दोहरे कोड के लिए है। अन्यथा हम आउटपुट 3और निकास करते हैं। वास्तविक कोड जो कि दोगुने या तिगुने वर्गों में है, निरर्थक है, क्योंकि या तो exitइससे पहले कि हम इसे प्राप्त करें, या यह एक टिप्पणी के पीछे है #।

सहेजे गए 6 बाइट्स, श्री एक्सकोडर के लिए धन्यवाद 3 4 बाइट्स
सहेजे गए हैं, जो पावेल के लिए धन्यवाद है

— AdmBorkBork
स्रोत

@ पावेल अहा, हां। मुझे कास्टिंग को सही ढंग से काम करने के -lt99लिए ए के आसपास स्वैप करने की आवश्यकता 99-gtहै, लेकिन यह वास्तव में एक बाइट कम है। धन्यवाद!

— AdmBorkBork

2

C # (178 बाइट्स)

Console.WriteLine(1+2*4%int.Parse(System.Configuration.ConfigurationManager.AppSettings["z"]=(int.Parse(System.Configuration.ConfigurationManager.AppSettings["z"]??"0"))+1+""));

पागल सी # समाधान, लेकिन मुझे खुशी है कि यह सी # में एक पंक्ति में संभव है। :)

मेरे लिए सबसे कठिन भाग वैध C # था, जो या तो एक ही चर को इंटिग्रेट या बढ़ाएगा, इसलिए मैंने कॉन्फ़िगरेशन प्रबंधक का दुरुपयोग करना समाप्त कर दिया, क्योंकि मुझे एक वैश्विक स्थैतिक नाम की आवश्यकता थी। एन्वायर्नमेंट वेरिएबल्स एक और विकल्प था जिसे मैंने देखा था, लेकिन इसमें कोई इंडेक्सर नहीं है इसलिए मुझे यकीन नहीं है कि यह कैसे करना है कि एक पंक्ति में कॉपी किया जा सकता है जो कि आवश्यक आउटपुट को कल्पना के अनुसार उत्पादन करने के लिए चिपकाया जा सकता है।

— ली
स्रोत

2

रूनिक एनकाउंटर , 35 बाइट्स

^w3'\
    f
    1
/1@
/
 '54\w
/yyy

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

इस पर काम करने से मुझे नए विलंबित संशोधक पात्रों के साथ काम करने वाले मेरे पार्सर में एक त्रुटि खोजने की अनुमति मिली, हालांकि अंतिम परिणाम इससे प्रभावित नहीं होता, क्योंकि मुझे उनकी आवश्यकता नहीं थी।

इस तथ्य के कारण कि अंतिम पंक्ति में एक अनुगामी नई रेखा (या उस मामले के लिए, अनुगामी रिक्त स्थान) नहीं है, डुप्लिकेट आईपी को एक अलग स्थान पर रखने की अनुमति देता है। शीर्ष-बाएँ एक ग्रिड के चारों ओर एक बड़ा लूप बनाता है जबकि दूसरा आईपी \6 वीं पंक्ति को ए के साथ बदलने के लिए एक परावर्तन क्रिया करता है । यह आईपी तब हमेशा के लिए लूप करेगा और कुछ नहीं करेगा।

तीसरे आईपी भी एक ही समय में यह एक ही प्रतिस्थापन बनाता है, लेकिन क्योंकि यह पर स्थित है 13 वीं लाइन, कि परावर्तक के अपने प्रतिलिपि यह ऊपर की ओर भेजता है और वह निष्पादित 1f'3wअनुक्रम ऊपरी दाहिने कोने में मौजूद है, जो की जगह 1एक साथ 314 लाइन, मूल आईपी के ठीक पहले इसे निष्पादित किया जाता है, जिसके कारण ट्रिपल्ड प्रोग्राम आउटपुट के 3बजाय 1(मान भी हो सकता है 2और 6, 3और 9, 4और 12, 5और और15 की उपलब्धता की वजह से a-fसंख्यात्मक स्थिरांक, 1और 3मनमाने ढंग से चुने गए हैं)। यह तब एक अंतहीन लूप में छोड़ दिया जाता है जो अधिक प्रतिबिंब कमांड का प्रदर्शन करता है जो कुछ भी नहीं करता है।

इसे तीन प्रतियों में आज़माएं!

— Draco18s
स्रोत

29 बाइट्स , हालांकि मुझे लगता है कि मैं इसे कम कर सकता था अगर मैं वास्तव में इसे समझ पाता: P

— Jo King

@JoKing वास्तव में आश्चर्यचकित नहीं है कि बहुत से व्हाट्सएप बाहर आ सकते हैं। क्या यह एक काम था और दुभाषिया के साथ एक मुद्दे पर चलने के कारण मैं केवल कुछ पाने के लिए खुश था (काम करने के लिए मेरा मूल 52 बाइट्स था और दुभाषिया तय होने के बाद, मैं एक अच्छा हिस्सा निकालने में सक्षम था)।

— ड्रेको

1

पर्ल 5, 28 25 बाइट्स

-3 बाइट्स @ धन्यवाद के लिए धन्यवाद!

print"\e[D$a"if(++$a!=2);

कर्सर को पीछे की ओर ले जाता है (लाइन के शुरू होने पर कुछ नहीं करता है) $a, पहली और तीसरी बार (यानी, तीसरी बार 1 मुद्रित होने पर, कर्सर चलता है, और 3 एक 1 की स्थिति पर मुद्रित होता है) के मूल्य को प्रिंट करता है।

— Marijn
स्रोत

1

print"\e[D$a"if(++$a!=2); शायद?

— नील

1

QBasic, 19 बाइट्स

CLS
x=2^x
?x-1OR 1

स्रोत में एक अनुगामी न्यूलाइन शामिल होनी चाहिए।

व्याख्या

हम के उत्पादन में चाहते हैं 1, 1, 3। निरीक्षण करें कि ये संख्या 2 की शक्तियों से कम है।

CLS      ' CLear Screen of any output from previous copies of the code

x        ' Numeric variables are preset to 0...
 =2^x    ' so as this statement is repeated, the value of x goes 1, 2, 4

 x-1     ' Therefore x-1 goes 0, 1, 3...
    OR 1 ' and we bitwise OR it with 1 to change the 0 to 1...
?        ' and print.

— DLosc
स्रोत

तीसरी बार आकर्षण

नियम

उदाहरण

वम्पस , 6 बाइट्स

व्याख्या

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

व्याख्या

जेली , 7 5 बाइट्स

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

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

क्यूबिक्स , 5 बाइट्स

व्याख्या

एकल कार्यक्रम

दोहरा कार्यक्रम

ट्रिपल कार्यक्रम

ब्रेन-फ्लैक , 10 बाइट्स

एसक्यूएल, 25 24 23 बाइट्स

SOGL V0.12 , 7 5 4 बाइट्स

05AB1E , 6 5 बाइट्स

> <> , 9 बाइट्स

पायथन 2 , 46 45 39 बाइट्स

यह कैसे काम करता है (पुराना)

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

आर , 37 31 28 बाइट्स

खोया , 38 बाइट्स

व्याख्या

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

व्याख्या

सी (जीसीसी) , 95 91 85 बाइट्स

जाप , 8 6 5 बाइट्स

स्पष्टीकरण:

शुद्ध बैश (नहीं wcया अन्य बाहरी बर्तन), 27

पर्ल 5 , 18 15 13 12 11 बाइट्स

> <> , 10 9 8 बाइट्स

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

भूलभुलैया , 12 11 9 बाइट्स

जावास्क्रिप्ट, 81 77 74 70 बाइट्स

दो बार:

तीन बार:

सी (जीसीसी) , 53 52 बाइट्स

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

व्याख्या

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

पॉवरशेल , 54 48 45 44 बाइट्स

C # (178 बाइट्स)

रूनिक एनकाउंटर , 35 बाइट्स

पर्ल 5, 28 25 बाइट्स

QBasic, 19 बाइट्स

व्याख्या

शुद्ध बैश (नहीं `wc`या अन्य बाहरी बर्तन), 27