इसे अपने तरीके से डबल करें

Question

स्रोत कोड को दोगुना करने से जुड़ी कुछ चुनौतियाँ हैं: यहाँ और यहाँ । हमारे यहां जो काम है वह थोड़ा कठिन है, लेकिन लगभग हर भाषा में करना चाहिए।

इस चुनौती में, आप एक मनमाना सकारात्मक पूर्णांक लेंगे। आपका प्रोग्राम आउटपुट होना चाहिए जो पूर्णांक दोगुना हो । जब आपका स्रोत कोड दोगुना हो जाता है, तो यह एक सकारात्मक पूर्णांक में ले जाएगा, और आउटपुट इसे चुकता करेगा ।

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

के प्रारंभिक कार्यक्रम के लिए ABCDEFGHIJKL, (लंबाई 12) यहाँ सभी संभावित दोगुने कार्यक्रम हैं:

Chunk length |   Doubled source code
-------------+-------------------------
           1 | AABBCCDDEEFFGGHHIIJJKKLL
           2 | ABABCDCDEFEFGHGHIJIJKLKL
           3 | ABCABCDEFDEFGHIGHIJKLJKL
           4 | ABCDABCDEFGHEFGHIJKLIJKL
           6 | ABCDEFABCDEFGHIJKLGHIJKL
          12 | ABCDEFGHIJKLABCDEFGHIJKL

ध्यान दें कि इसका मतलब है कि प्राइम लेंथ के प्रोग्राम केवल दो तरीके से दोहराए जा सकते हैं: हर कैरेक्टर दोगुना, या पूरा प्रोग्राम दो बार दोहराया जाता है।

नियम:

• कोड एक पूर्ण कार्यक्रम या फ़ंक्शन होना चाहिए।
• मानक खामियों को मना किया जाता है।
• मानक I / O विधियों की अनुमति है।
• व्हाट्सएप और न्यूलाइन सहित सभी पात्रों / बाइट्स को कोड की लंबाई में गिना जाता है और विखंडू में योगदान देता है।
• आप मान सकते हैं कि इनपुट और उसके वर्ग को आपकी भाषा के इंट / पूर्णांक प्रकार द्वारा दर्शाया जा सकता है।
• आप एक अनुगामी न्यूलाइन या अन्य वर्ण नहीं मान सकते हैं ।
• बाइट काउंट के बाद हैडिंग में अपना चंक साइज प्रदान करें।
• यह कोड-गोल्फ है , इसलिए छोटे कार्यक्रम बेहतर हैं! यदि दो प्रोग्राम एक ही लंबाई के हैं, तो वह जो छोटे चंक लेंथ जीत का उपयोग करता है। (यदि आपके पास एक लंबा कार्यक्रम है जो एक छोटी सी लम्बाई का उपयोग करता है, तो वह भी पोस्ट करने लायक है!)
• यदि आपके प्रोग्राम को दूसरे इनपुट / लाइन की आवश्यकता है, तो आप इसके मूल्य पर कोई धारणा नहीं बना सकते हैं। विशेष रूप से, आपका प्रोग्राम काम करना चाहिए यदि दूसरा इनपुट खाली है, पहले जैसा है, या एक अलग पूर्णांक है। यदि आपके प्रोग्राम को दूसरे इनपुट / लाइन की आवश्यकता नहीं है, तो आप इस प्रतिबंध को अनदेखा कर सकते हैं।

सैंडबॉक्स लिंक

Comments

क्या मैं फ्लोट ( .0अंत में) के रूप में परिणाम कर सकता हूं ?

— वैल का कहना है कि मोनिका

क्या कोड दोगुना होने पर हम दो बार वर्ग प्रिंट कर सकते हैं? एकल कोड 5 -> 10:; डबल कोड 5 -> 25 25:।

— रॉबिन राइडर

@RobinRyder नहीं, आप नहीं कर सकते।

— गामा फंक्शन

@val आप फ्लोट के रूप में आउटपुट कर सकते हैं।

— गामा फंक्शन

Answer 1

पर्ल 5 , 8 बाइट्स (चंक साइज़ 4)

$_*=~~+2

इसे ऑनलाइन आज़माएँ , या दोगुने संस्करण आज़माएँ ।

Unary ~बिटवाइज़ नेगेट है, इसलिए इसे दो बार लगाना एक noop है। इस प्रकार, बेस प्रोग्राम केवल 2 से गुणा $_(निहित इनपुट-आउटपुट चर) को बढ़ाता है ।

बाइनरी ~~स्मार्टमैच है, जो एक बूलियन देता है। ~~+2~~+2के रूप में पर्स (~~+2) ~~ (+2)। 2 के बाद से 2 के बराबर है, यह पैदावार सच (1)। इस प्रकार, दोगुना कार्यक्रम पहले $_1 से गुणा करता है, फिर $_खुद से गुणा करता है।

Answer 2

05AB1E , 4 बाइट्स (चंक साइज़ 2 या 4)

·Inr

इसे ऑनलाइन आज़माएँ या सिंगल 4-बाइट चंक के रूप में या दो 2-बाइट विखंडू के रूप में दोगुना करें ।

·        # double the implicit input
 In      # square the input
   r     # reverse the stack: it's now [input ** 2, input * 2]
         # if we stop here: implicitly output the top of the stack (input * 2)
·        # double the top of the stack (giving input * 4, not that it matters)
 In      # square the input
   r     # reverse the stack: it's now [input ** 2, input * 4, input ** 2]
         # implicitly the top of the stack (input ** 2)

Answer 3

पायथन 3 , 26 बाइट्स (चंक आकार 13)

lambda n:"and n*n#"and 2*n

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

दोगुनी:

lambda n:"andlambda d:"and n*n#"and 2*n n*n#"and 2*n

यह समाधान @Grimy द्वारा प्रदान किया गया है।

---

पायथन 3 , 32 30 28 बाइट्स (चंक साइज़ 16 15 14)

lambda n:bool(0)*n*n or  2*n

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

-4 बाइट्स @negativeSeven की बदौलत

दोगुनी:

lambda n:bool(lambda n:bool(0)*n*n or  2*n0)*n*n or  2*n

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

फ़ंक्शन इस चुनौती के अनूठे चंक नियम का लाभ उठाता है।

Comments

26: टीआईओ

— ग्रिम्मी

@ ग्रेमी अच्छा तरीका। मुझे लगता है कि यह काफी अलग है और इसके अपने पद के हकदार हैं।

— जोएल

@ ग्रेमी मैंने अपनी पोस्ट में आपका समाधान जोड़ा क्योंकि आपको एक अलग पोस्ट बनाने में कोई दिलचस्पी नहीं है।

— जोएल

Answer 4

Befunge-98 (FBBI) , 8 बाइट्स (चंक लंबाई 2)

;&:#* +q

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

;&;&:#:#* * +q+q

इसे ऑनलाइन आज़माएं! (दोगुनी)

नियंत्रण प्रवाह को छोड़कर, पहला प्रोग्राम निष्पादित करता है &:+q(इनपुट, स्टैक के डुप्लिकेट टॉप, ऐड, रिटर्न कोड के साथ बाहर निकलें), और दूसरा निष्पादित &:*+q(इनपुट, स्टैक के डुप्लिकेट टॉप, गुणा, एक जोड़ के साथ (0 के साथ रकम), वापसी से बाहर निकलें कोड)

Answer 5

हेक्सागोनी , 14 बाइट्स (चंक आकार 14)

?"+==*/}=+!@!<

विस्तारित:

  ? " +
 = = * /
} = + ! @
 ! < . .
  . . .

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

दोगुनी

?"+==*/}=+!@!<?"+==*/}=+!@!<

विस्तारित:

   ? " + =
  = * / } =
 + ! @ ! < ?
" + = = * / }
 = + ! @ ! <
  . . . . .
   . . . .

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

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

यह समाधान सबसे छोटे रूप में तुच्छ विचार है जिसे मैं फिट कर सकता था, लेकिन मुझे संदेह है कि छोटे, चतुर उत्तर हैं। यह संस्करण बहुत ही भोलेपन से इनपुट के लिए दो मान निर्धारित करता है और उन्हें स्रोत या दोगुना होने पर निर्भर करता है। एकमात्र कोड पुन: उपयोग होता है "+जो मूल प्रोग्राम से अप्रयुक्त स्थान में फिट होने के लिए दोगुने प्रोग्राम के लिए प्रतिलिपि कोड बनाता है।

मुझे संदेह है कि आईपी परिवर्तन निर्देशों []का उपयोग करने से भागों को अलग करना आसान हो जाएगा, लेकिन वास्तव में आदर्श समाधान दोनों के बीच बहुत सारे कोड का पुन: उपयोग करेगा। मैंने हेक्सागोनी स्रोत कोड को दोगुना करने के लिए एक सहायक कार्यक्रम बनाया । ध्यान दें कि यह अनुगामी नो-ऑप्स को हटा देता है, इसलिए यदि आप अंत में प्लेसहोल्डर नो-ऑप्स रखना चाहते हैं तो बस किसी अन्य पात्र में भरें और इसे बाद में बदल दें। यह अलग-अलग चंक आकारों को संभाल सकता है, हालांकि मैंने अभी तक प्रत्येक संभावित कार्यक्रम के उत्पादन के लिए कोड नहीं लिखा था (हेक्सागोनी खुद को पूर्ण चंक आकार का उपयोग करने के लिए उधार देता है)।

Comments

@JoKing अच्छा किया! यह मेरे जवाब से अलग है, इसलिए क्या आप इसे पोस्ट करना चाहेंगे (अप्रयुक्त स्थान को भरने के लिए अलग-अलग चंक आकार का उपयोग करना बहुत साफ है!)। अन्यथा मैं इसे और एक स्पष्टीकरण जोड़ूंगा जब मेरे पास अधिक समय होगा।

— FryAmTheEggman

Answer 6

हेक्सागोनी , 12 बाइट्स (चंक आकार 4)

?"2+...}=*!@

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

प्रारूपित:

  ? " 2
 + . . .
} = * ! @
 . . . .
  . . .

और दोगुना , फिर स्वरूपित:

   ? " 2 +
  ? " 2 + .
 . . } . . .
} = * ! @ = *
 ! @ . . . .
  . . . . .
   . . . .

मूल रूप से, यह पहले किनारे को इनपुट पर सेट करता है, फिर दूसरे किनारे को या तो 2इनपुट की कॉपी के लिए, फिर उन दो किनारों को तीसरे किनारे में गुणा करता है, प्रिंट करता है और समाप्त करता है। निष्पादित निर्देशों की सूची बस है

?"2}=*!@

तथा

?"2+}=*!@

एकमात्र अंतर के साथ दूसरे प्रोग्राम पर +ओवरराइडिंग है 2।

Answer 7

जावास्क्रिप्ट (ईएस 6),  24  22 बाइट्स

अपने असामान्य प्रारूप के बावजूद, यह एक अनाम फ़ंक्शन की परिभाषा है, जिसे या तो सीधे कहा जा सकता है या एक चर को सौंपा जा सकता है।

+(g=x=>x*x)?g:(x=>x*2)

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

+(g=x=>x*x)?g:(x=>x*2)+(g=x=>x*x)?g:(x=>x*2)

इसे ऑनलाइन दोगुना करने का प्रयास करें!

कैसे?

+एक समारोह में यूरी को लागू करने को एक संख्या में परिणत करने के प्रयास के रूप में व्याख्या की जाती है और NaN में परिणाम होता है । इसलिए, अग्रणी +(g=x=>x*x)दोनों संस्करणों में मिथ्या है।

दूसरी ओर, +2 फ़ंक्शन के बीच बाइनरी को लागू करने से एक स्ट्रिंग होती है। इसलिए, (x=>x*2)+(g=x=>x*x)दोहरे संस्करण में सच्चाई है।

Comments

यार, क्या तुमने देखा है कि यह भी 11 के विखंडू में विभाजित किया जा सकता है?

— गस्ट वैन डे वाल

Answer 8

पर्ल 6 , 8 बाइट्स (चंक आकार 1)

* *<1 2>

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

एक जो भी / हाइपरविटवर लैम्ब्डा जो एक नंबर लेता है और पहले प्रोग्राम के लिए एक नंबर देता है और दूसरे प्रोग्राम के लिए सिंगलटन लिस्ट। मूल रूप से यह सटीक एक ही तर्क रखता है, सिवाय इसके कि गुणन ऑपरेटर ( *) को घातीय एक ( **) द्वारा बदल दिया जाता है ।

**  **<<11  22>>

जो भी शाब्दिक (भ्रामक रूप से भी प्रतिनिधित्व किया जाता है *) हाइपर व्हाट्सएवर ( **) तक दोगुना हो जाता है जो मूल रूप से समान होता है सिवाय इसके कि यह सूचियों के नक्शे को दर्शाता है। जो कुछ भी शाब्दिक को गुणन से अलग करने के लिए स्थान की आवश्यकता होती है और जब दोगुना हो जाता है तो इसे अनदेखा कर दिया जाता है। इसके बजाय सिर्फ 2(जो दोगुना हो जाएगा 22) हम एक सूची का उपयोग करते हैं जिसमें दो तत्व होते हैं, जो एक संख्यात्मक संदर्भ में 2 का मूल्यांकन करता है)। <>प्रक्षेप के साथ एक सूची में दोगुनी हो जा सकता है और अंदर दो तत्वों दोगुनी कर रहे हैं, लेकिन न तो उन परिवर्तन की सूची की लंबाई।

Answer 9

रूनिक एनकाउंटर , 9 बाइट्स (चंक साइज़ 3)

i3?:*@:+@

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

3?(निष्पादित) अगले 3 निर्देश को छोड़ देता है, एक में जिसके परिणामस्वरूप i3?...:+@। जब दोगुना यह एक निष्पादित में परिणाम हैi3?...:*@ जहां .3 NOP'd निर्देशों का प्रतिनिधित्व करता है। @"पूरे स्टैक को प्रिंट करें और समाप्त करें।"

Answer 10

सी # (विजुअल सी # इंटरएक्टिव कंपाइलर) / जावास्क्रिप्ट, 22 बाइट्स, चंक साइज़ 11

m=>/*      /2*m//*/m*2

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

Comments

इसके अलावा जावास्क्रिप्ट में काम करता है

— झबरा

में बदलकर भी जावा में काम करता =है -। अच्छा जवाब!

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

मुझे पसंद है कि टिप्पणी वास्तव में कैसे कोड का वर्णन करती है। : पी

— अरनुलद

Answer 11

ब्रेन-फ्लैक , 48 30 बाइट्स (चंक आकार 10)

(({}))<>( {({}[()])}{}<>{}{}) 

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

यह मूल रूप से तीन कदम उठाता है, फिर जब दोगुना हो जाता है तो उन चरणों को प्रत्येक दो बार निष्पादित करता है। प्रारंभिक कार्यक्रम है:

1. डुप्लीकेट टीओएस, स्विच को ढेर करें और एक मूल्य को धक्का देना शुरू करें
2. टीओएस की त्रिकोणीय संख्या n * (n-1) / 2 प्राप्त करें
3. पॉप टीओएस, स्विच स्टैक और पॉप दो बार, फिर परिणाम को धक्का दें।

nएक निस्संदेह कार्यक्रम में एक इनपुट के लिए , इसमें परिणाम होता है:

1.  Start stack: n n
    Other stack: <
    Third stack: 
2.  Start stack: n n
    Other stack: 0 <
    Third stack: tri(0) = 0
3.  Start stack: n+n+tri(0) = 2n <
    Other stack:
    Third stack:

दोहरे कार्यक्रम के लिए:

1a. Start stack: n n
    Other stack: <
    Third stack: 
1b. Start stack: n n <
    Other stack: 0 0
    Third stack: 
2a. Start stack: n 0 <
    Other stack: 0 0
    Third stack: tri(n)
2b. Start stack: n 0 <
    Other stack: 0 0
    Third stack: tri(n)+tri(0) = tri(n)
3a. Start stack: n
    Other stack: tri(n) <
    Third stack: tri(n)
3a. Start stack: 0+n+tri(n)+tri(n) = n + 2*tri(n) = n + n*(n-1) = n*n <
    Other stack: 
    Third stack: 

Comments

28 बाइट्स (चंक आकार 7)

— नाइट्रोडन

Answer 12

ब्रेन-फ्लैक , 76 बाइट्स, 76 बाइट चंक्स

({}<>)(()[([][()])]{(<{}{}({({})({}[()])}<>)<>>)}{}){{}(({})({})<>)(<>)}{}<>

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

दोगुना (स्पष्टता के लिए नई रेखा के साथ)

({}<>)(()[([][()])]{(<{}{}({({})({}[()])}<>)<>>)}{}){{}(({})({})<>)(<>)}{}<>
({}<>)(()[([][()])]{(<{}{}({({})({}[()])}<>)<>>)}{}){{}(({})({})<>)(<>)}{}<>

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

यहां एक संस्करण है जो एक अधिक जटिल दोहरीकरण प्रक्रिया का उपयोग करता है। यह आकार के 5 भाग करता है। हालांकि यहां कोड 46 बाइट्स है लेकिन आवश्यक पैडिंग के कारण यह काफी लंबा है।

105 90 बाइट्स, 15 बाइट चंक्स

(              {<><({}()())><><><            <>>({})({}[()])}{}            )<>            

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

संदेह (स्पष्टता के लिए नई सुर्खियों के साथ)

(              (              
{<><({}()())><>{<><({}()())><>
<><            <><            
<>>({})({}[()])<>>({})({}[()])
}{}            }{}            
)<>            )<>            

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

Answer 13

क्यूबिक्स , 18 14 बाइट्स (चंक की लंबाई 9 7)

*OI$|:/@O+:I. 

ट्रेलिंग स्थान पर ध्यान दें। इसे ऑनलाइन आज़माएं!

दोगुनी:

*OI$|:/*OI$|:/@O+:I. @O+:I. 

फिर, एक अनुगामी स्थान है। इसे ऑनलाइन आज़माएं!

व्याख्या

मुख्य विचार यह है कि कोड को दोगुना करने से क्यूब बड़ा हो जाता है, इसलिए निर्देश सूचक एक अलग प्रतीक पर शुरू होता है। चूंकि जोड़ कार्यक्रम को साइड लंबाई 1 के क्यूब पर नहीं रखा जा सकता है, साइड की लंबाई 2 होने वाली है। इसके अलावा, डबल कोड को साइड लंबाई 3 के क्यूब पर होना चाहिए, इसलिए दोगुना कोड कम से कम 25 बाइट्स होना चाहिए । इसका मतलब है कि कोड कम से कम 13 बाइट्स लंबा होना चाहिए। जैसे, 1 से अधिक बाइट को बचाया जा सकता है।

अब वास्तविक कोड पर। पहला अवलोकन यह है कि शीर्ष चेहरा (अर्थात, पहले 4 वर्ण) अतिरिक्त प्रोग्राम द्वारा उपयोग नहीं किए गए हैं। इसके अलावा, अगर हम 5 वें वर्ण को क्यूब के चारों ओर आईपी को दर्शाते हैं, तो हम 2 और वर्णों को मुक्त कर सकते हैं। हम इन पात्रों का उपयोग स्क्वरिंग प्रोग्राम को रखने के लिए करेंगे।

Answer 14

मॉर्निंगटन क्रिसेंट , 656 बाइट्स (चंक आकार 328)

बस सिद्धांत को वजन जोड़ने के लिए कि यह लगभग किसी भी भाषा में हल किया जा सकता है ...

Take Northern Line to Bank
Take District Line to Bank
Take District Line to Parsons Green
Take District Line to Bank
Take District Line to Hammersmith
Take Piccadilly Line to Russell Square
Take Piccadilly Line to Bounds Green
Take Piccadilly Line to Hammersmith
Take District Line to Upminster
Take District Line to Embankment
Take District Line to Hammersmith
Take District Line to Upminster
Take District Line to Acton Town
Take District Line to Acton Town
Take Piccadilly Line to Bounds Green
Take Piccadilly Line to Bounds Green
Take Piccadilly Line to Leicester Square
Take Northern Line to Leicester Square
Take Northern Line to Mornington Crescent

(अनुगामी न्यूलाइन महत्वपूर्ण है)

एकल संस्करण का प्रयास करें! ... या ... दोगुना संस्करण आज़माएं!

---

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

यहां सिद्धांत सरल है: एकल संस्करण में, 'बाउंड्स ग्रीन' एक यादृच्छिक स्ट्रिंग से भरा होता है, लेकिन दोहरे संस्करण में यह चुकता इनपुट से भर जाता है। चंक समाप्त होने के बाद, दोनों संस्करण 'इनपुट' को दोगुना कर देते हैं, लेकिन कोड के दोहरे संस्करण में, इनपुट को 0 से बदल दिया गया है।

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

---

यदि मेरा स्पष्टीकरण पर्याप्त नहीं था, तो मेरा सुझाव है कि आप लंदन की यात्रा करें और दो मार्गों को स्वयं आज़माएँ।

Comments

टाइपो: आपका हिस्सा आकार 328 है और 326 नहीं है। CGCC में आपका स्वागत है!

— रॉबिन राइडर

अच्छी जगह, धन्यवाद!

— एलेविया

@ जॉकिंग यकीन नहीं है कि मैं कैसे याद किया! जैसा कि यह है, मैंने इसे रूट किया इसलिए 2 के आधे हिस्से में कोई अतिरिक्त चार्ट नहीं है, और अतिरिक्त व्हाट्सएप की आवश्यकता के बिना मैच के पहले हाफ को पैड करने का एक तरीका मिला। इस तरह से बेहतर लगता है;)

— एलेव्या

Answer 15

जावास्क्रिप्ट (Node.js) , 15 12 बाइट्स (चंक आकार: 6)

x=>/**/2*(x)

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

एकल मामला:

x=>/**/2*(x)

दोहरा मामला:

x=>/**x=>/**/2*(x)/2*(x)

अगर बदलने के =>लिए भी सी # में काम करता है, और जावा लगता है ->?

Answer 16

आर , 42 35 28 बाइट्स (चंक आकार 4)

अब एक छोटा हिस्सा और कोई त्रुटि नहीं है। मेरे पास चंक आकार 3 के साथ एक लंबा समाधान भी है; निचे देखो।

मुझे नहीं लगता कि चंक साइज़ 1 या 2 के साथ R उत्तर लिखना संभव है; मैं ख़ुशी से किसी को भी इनाम दूंगा जो मुझे गलत साबित करे।

s =scan#
n=s()# 
  
n/2*4#  

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

#3 लाइन केवल रिक्त स्थान है, न्यू लाइन + 2 रिक्त स्थान + न्यू लाइन का एक हिस्सा है, जिससे पिछले और अगले हिस्सा नहीं न्यू लाइन हो सकता है इतना है कि आर में टिप्पणी के लिए है।

संदेह, यह हो जाता है:

s =ss =scan#can#
n=s
n=s()# ()# 
  

  
n/2*n/2*4#  4#  

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

एकल संस्करण गणना करता है$\frac n2\times4=2n$$\frac n2\times \frac n2\times4=n^2$

यहाँ थोड़ा लंबा समाधान है, लेकिन चंक आकार 3 के साथ:

आर , 39 बाइट्स (चंक साइज़ 3)

s =bbb=scan#
n=s(#
 
)# 
n* 1/ 2/ 1* 4#

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

दोगुनी:

s =s =bbbbbb=sc=scan#an#
n=
n=s(#s(#
 

 
)# )# 
n*
n* 1/ 1/ 2/ 2/ 1* 1* 4# 4#

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

ध्यान दें कि Giuseppe का एक और उत्तर है, जिसमें 30 बाइट्स का एक हिस्सा है।

Answer 17

आर , 59 30 बाइट्स (चंक आकार 59 30)

F=F+1;f=function(n)n*c(2,n)[F]

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

इसे प्रेरित करने के लिए रॉबिन राइडर को श्रेय ; Fहर बार वेतन वृद्धि , और फ़ंक्शन fउचित आउटपुट का चयन करता है।

यह विशेष रूप से दिलचस्प नहीं है, लेकिन संदेह है कि चंक आकार में हेरफेर करने वाले कुछ चतुर सपने देखे जाएंगे। जैसा कि उम्मीद थी, रॉबिन राइडर इस के साथ आया था जो दोनों छोटे हैं और कुछ साफ-सुथरे जोड़ तोड़ हैं।

Answer 18

पॉवरशेल , 22 बाइट्स (चंक साइज़ 11)

param($p)
#   /
2 * $p

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

दोगुनी:

param($p)
#param($p)
#   /
2 * $p   /
2 * $p

यह समाधान @ ShieruAsakoto के समाधान पर आधारित है ।

@Grimy समाधान जो कि PowerShell, 26 बाइट्स (चंक आकार 13) में बदल दिया गया है

param($p)$t=';$p*$p#';$p*2

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

दोगुनी:

param($p)$t=';param($p)$t=';$p*$p#';$p*2$p*$p#';$p*2

Comments

दुर्भाग्यवश आपको एक चंक आकार की आवश्यकता होती है जो आपके कोड को समान मात्रा में विभाजित करता है। प्राइम लेंथ सॉल्यूशंस के बारे में सवाल के उदाहरण के अनुसार।

— जॉन रीस

@ जॉन, मैंने अपना उत्तर सही किया, धन्यवाद।

— आंद्रेई ओडेगो

Answer 19

पर्ल 5 ( -p), 22 15 बाइट्स

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

$_*=$'/4||2;//;

TIO

Comments

15: टीआईओ

— ग्रैमी

आपके समाधान को देखते हुए, मुझे सिर्फ 22 बाइट्स का समाधान मिला

— नाहुएल फौइलुल

समझ में आया, पहले इनपुट * = 2, फिर इनपुट * = इनपुट / 4 द्वारा

— नहुएल फौइउल

एक और 16 बाइट्स (-ए)$_*=/@F/?2:$_/4;

— नहुएल फोइउलुल

8 से नीचे (एक अलग उत्तर के रूप में पोस्ट किया गया क्योंकि यह बहुत अलग है)।

— ग्रिम्मी

Answer 20

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

ＰＩ×Ｉθ⎇υＩθ²⊞υω

इसे ऑनलाइन आज़माएं! स्पष्टीकरण: पूर्वनिर्धारित खाली सूची गलत है इसलिए इनपुट 2 से गुणा किया जाता है। जब दूसरा पास दोगुना होता है तो रिक्त स्ट्रिंग को सूची में धकेल दिया गया है, इसलिए यह इनपुट को इसके बजाय गुणा करता है। इसे ऑनलाइन आज़माएं! क्रिया सिंटैक्स में यह से मेल खाती है Multiprint(Cast(Times(Cast(q), Ternary(u, Cast(q), 2)))); Push(u, w);।

Answer 21

पायथन 3, 56 53 बाइट्स

print(eval(input()+"**2"[len(*open(__file__))%2:])) #

मेरी अजगर कौशल थोड़े चूसना, तो निश्चित रूप से गोल्फ हो सकता है .. पायथन के जवाब के आधार पर " मैं स्रोत को दोगुना करता हूं, आप आउटपुट को दोगुना करते हैं! " चुनौती ।

चंक की लंबाई ५३।

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

Answer 22

जावा 8, 62 बाइट्स

n->n*(Byte.SIZE>8?n:2);/*
class Byte{static int SIZE=9;}/**///

चंक की लंबाई ६२।

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

स्पष्टीकरण:

n->                    // Method with integer as both parameter and return-type
  n*                   //  The input, multiplied by:
    (Byte.SIZE>8?      //   If Byte.SIZE is larger than 8:
      n                //    Multiply by the input itself
     :                 //   Else:
      2);              //    Multiply by 2
class Byte{            // Class which overwrites Byte
  static int SIZE=9;}  //  And sets the SIZE to 9

जावा में, उपलब्ध टिप्पणियां हैं // commentऔर /* comment */। जो कुछ भागों को अधिलेखित करने के लिए यहां संयुक्त हैं। देखें कि ये टिप्पणियाँ जावा हाइलाइटिंग के लिए कैसे काम करती हैं:

n->n*(Byte.SIZE>8?n:2);/*
class Byte{static int SIZE=9;}/**///

n->n*(Byte.SIZE>8?n:2);/*
class Byte{static int SIZE=9;}/**///n->n*(Byte.SIZE>8?n:2);/*
class Byte{static int SIZE=9;}/**///

डबल प्रोग्राम ने एक कस्टम Byteक्लास और उसका मान बनाया SIZE=9, जो डिफ़ॉल्ट java.lang.Byteक्लास और उसके मूल्य को अधिलेखित करता है SIZE=8।

Answer 23

जाप , 7 5 बाइट्स

*N²jJ

कोशिश करो |दोगुनी

²इनपुट के सरणी पर 2 को धकेलता है और Nफिर jइंडेक्स में तत्व को निकालता है और वापस करता हैJ=-1 (यानी, नया डाला जाता है2 ) और उस द्वारा इनपुट को गुणा करता है।

जब इसे दोगुना Jकरके गुणा किया जाता है 2, तो सूचकांक -2(यानी, इनपुट) पर तत्व jगुणक के रूप में उपयोग किया जाता है।

Answer 24

जेली , 8 6 बाइट्स (चंक लंबाई 3)

Ḥ;²3ị 

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

दोगुनी

Answer 25

अच्छा समाधान: लुआ , 66 बाइट्स (चंक आकार 66 बाइट्स)

a,x=a and...^2 or ...*2,setmetatable(x or{},{__gc=load'print(a)'})

इसे ऑनलाइन आज़माएं!(अपने आप को दोगुना करें, यह इतना कठिन नहीं है)

ओह, हाँ, बहुत यकीन है कि वहाँ इस के लिए छोटे समाधान है, लेकिन यह सबसे अच्छा मैं इस तरह से आने में सक्षम था। पहले तर्क के रूप में इनपुट लें।

संक्षिप्त विवरण: संपूर्ण व्यवसाय सभी के aलिए काफी स्पष्ट है, जबकि दूसरा भाग xअधिक रोचक है। मूल रूप से, मैं एक तालिका बनाता हूं (या अंतिम पास पर मौजूदा एक अपडेट करें)__gc फ़ाइनलीज़र मेटामेथोड) के जिसे प्रोग्राम से बाहर निकलने पर बुलाया जाता है।

लंगड़ा समाधान: लुआ , 60 बाइट्स (चंक आकार 30 बाइट्स)

a=a and...^2 or ...*2;                     print(a)os.exit()

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

छोटे और बेहतर चैंकिंग के साथ, लेकिन अंततः उबाऊ और लंगड़ा बिना किसी चालाक चाल के। मुझे पूरा यकीन है कि इस पर कोई टिप्पणी करने की आवश्यकता नहीं है।

Comments

40, चंक आकार 20

— ग्रैमी

Answer 26

जे , ^{15 10} 9 बाइट्स

+: :(*-:)

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

डब किए गए संस्करण: इसे ऑनलाइन आज़माएं!

f : gएक क्रिया बनाता है जो fएक तर्क के साथ बुलाया जाता है, और gजब 2 तर्क के साथ बुलाया जाता है। इसलिए हमारा +:मूल स्रोत के साथ दोगुना होता है और *-:जब स्रोत दोगुना हो जाता है।

यह काम करता है क्योंकि J में दो क्रियाओं की एक ट्रेन एक हुक बन जाती है, और इस तरह f fसे निष्पादित की जाती है y f (f y)जहां y मूल इनपुट है। इसके अतिरिक्त, *-:अपने आप में एक "रंगादिक हुक" है जो *बाएं आर्ग को आधे से गुणा करके काम करता है-: से दाहिने आर्ग । बायाँ आर्ग मूल इनपुट होगा, और दायें आर्ग इनपुट दोगुना होगा, इसलिए यह मूल इनपुट के वर्ग का उत्पादन करेगा।

मूल उत्तर

जे , 15 बाइट्स

*:@]`(+:@])@.=~

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

डब किए गए संस्करण: इसे ऑनलाइन आज़माएं!

एकल संस्करण में, हमारे पास एक क्रिया है जो एजेंडा @.का उपयोग करती है यदि ... तो तर्क: यदि तर्क स्वयं के बराबर है =~, तो तर्क को लें और उसे दोहराएं(+:@[) ।

हालाँकि, जब हम कोड को दोगुना करते हैं, तो हमें एक J हुक मिलता है। क्रिया fऔर इनपुट को कॉल करें y। फिर हुक f fइस तरह निष्पादित होता है:

y f (f y)

जिसका अर्थ है कि अब मूल इनपुट बाएं आर्ग है, और दायाँ आर्गन दोगुना इनपुट है। चूँकि ये बराबर नहीं होंगे, इसलिए =~इस बार झूठे लौटेंगे, और अब हम एजेंडा के दूसरे कांटे को अंजाम देंगे *:@], जिसका अर्थ है, "सही arg को वर्गाकार करना।" और चूंकि ~एक डायडिक क्रिया के इनपुट को उलट दिया जाता है, सही एर्ग मूल इनपुट होगा।

Answer 27

अजगर ३ , 60 बाइट्स

चंक आकार 6.
एक महान समाधान नहीं है, लेकिन यह काम करता है। यह एक ऐसी अनोखी चुनौती है, यह वास्तव में आपको एक अलग दृष्टिकोण से सोचने पर मजबूर करता है।

0;  i=input;0;  p=print;n=i()#
x=int(n)##
z=2*x#z=x*x
p(z)##

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

दोगुनी:

0;  i=0;  i=input;input;0;  p=0;  p=print;print;n=i()#n=i()#
x=int
x=int(n)##
(n)##
z=2*x#z=2*x#z=x*x
z=x*x
p(z)##p(z)##

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

Answer 28

कैस्केड , 13 बाइट्स (चंक आकार 13)

]
&/2
#
*
 2&

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

]
&/2
#
*
 2&]
&/2
#
*
 2&

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

यह काफी मुश्किल था। इसका मूल सार यह है कि इनपुट 2को पहले प्रोग्राम के लिए गुणा करके प्रिंट करें , और 2दूसरे के लिए इनपुट की एक प्रति द्वारा प्रतिस्थापित करें ।

स्पष्टीकरण:

पहले कार्यक्रम का निष्पादित भाग जैसा दिखता है

]     Redirection
 /
#     Print
*     The multiplication of
 2&   Input and 2 (wrapping around the left)

दोगुना कार्यक्रम मूल रूप से पहले ]को अंतिम पंक्ति के अंत में जोड़ता है , इसलिए कार्यक्रम इसके बजाय चारों ओर लपेटता है &। यह इसमें बदल जाता है

]     Redirection
 /
#     Print
*     The multiplication of
 2 ]  Set the value of
& 2   The variable '2' to the input
      Then multiply the result of that (input) by '2' (input)

Answer 29

Zsh , 30 बाइट्स (चंक आकार 10)

m=$m[1]*2
x=$[$1$m]
return $x

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

हनन तथ्य यह है कि $varमें $[$var]पहले विस्तार हो जाता है, तो गणित संदर्भ में मूल्यांकन किया।

             # each line is 9 characters long. when doubled, each is run twice.
m=$m[1]*2    # first time: m='*2'   second time: $m[1] is '*', so m='**2'
x=$[$1$m]    # single: x=$[$1*2]    doubled: x=$[$1**2];x=$[$1**2].
return $x    # zsh supports 32-bit return values from functions, unlike bash

अगर किसी को यह कम करने पर एक दरार चाहिए, तो यहां 24/8मैं एक समाधान के निकटतम हूं जो मैंने प्राप्त किया है (आउटपुट x^2+2दोगुना होने पर)