अबाध संख्या का एक गुच्छा प्रिंट करें!

40

एक निर्बाध संख्या (जो मैंने पूरी तरह से केवल इस चुनौती के लिए नहीं बनाई थी) इस तरह बनाई गई है:

  1. एक सकारात्मक पूर्णांक N लें
  2. N के अंत में N का अंक जोड़कर एक नया नंबर O बनाएं
  3. अंतिम निर्बाध संख्या O * N है

उदाहरण के लिए N = 12:

  1. ओ = १२१२
  2. ओ * एन = 1212 * 12
  3. अंतिम संख्या 14544 है

इनपुट

एक सकारात्मक पूर्णांक N (N> 0) या आपकी भाषा के समकक्ष। आपको गलत इनपुट को पकड़ने की आवश्यकता नहीं है।

उत्पादन

इसी निर्बाध संख्या।

परीक्षण के मामलों

  1 -> 11
  2 -> 44
  3 -> 99
 10 -> 10100
174 -> 30306276

स्कोरिंग

बाइट्स में सबसे छोटा कोड जीतता है।

code-golf  math  number  sequence 
— सिम्स
स्रोत
9
एक प्रासंगिक OEIS प्रविष्टि होनी चाहिए ...
— MKII
1
@ सिम्स यह एक मजाक था, "अनइंस्टालरिंग" नाम के आधार पर
— MKII
7
@MKII मेरा बुरा, मैं मजाक नहीं बोलता
— बजे
1
क्या संख्या को एक स्ट्रिंग तर्क के रूप में लेना नियमों को थोड़ा बहुत झुका रहा है?
— डोम हेस्टिंग्स
1
आगे बढ़ो, नियमों को मोड़ो! : पी
— देखता है

जवाबों:

38

05AB1E , 3 बाइट्स

Ы*

व्याख्या की

Ð    # triplicate input
 «   # conactenate
  *  # multiply

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

— Emigna
स्रोत
2
आह, अच्छा! निंजा मुझे सेकंड के द्वारा: पी।
— अदनान
2
@ अदनान हेहे। उस समय के लिए बदला जो आपने मुझसे किया था: P
— एमिग्ना
1
3 संचालन, 3 बाइट्स, मुझे नहीं लगता कि आप इसे इससे छोटा बना सकते हैं।
— लासे मेयर
2
@ जुसुकुकुआन यप। कॉनटेनटेट स्वचालित रूप से संख्या को धर्मान्तरित करता है strऔर *स्ट्रिंग को एक संख्या के रूप में व्याख्या करता है। बहुत उपयोगी :)
— Emigna
2
@busukxuan हाँ, Pyth और 05AB1E का संयोजन इसे 2 बाइट्स में कर सकता है :)
— Emigna
29

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

_=>(_+_)*_

एक के रूप में तर्क के साथ बुलाया जाना चाहिए String, नहीं Number।

उपयोग:

(_=>(_+_)*_)('3')
99

-3 बाइट्स @Quill के सुझाव के लिए धन्यवाद ।

— डोम हेस्टिंग्स
स्रोत
1
यदि आप एक स्ट्रिंग के रूप में पैरामीटर पास कर सकते हैं तो आप इस समाधान से दो बाइट्स काट सकते हैं:_=>(_+_)*+_
— क्विल करें
3
यह वास्तव में कैसे काम करता है? अगर मैं सही ढंग से समझूं, तो क्या आप _एक चर के लिए एक मनमाना चरित्र के रूप में उपयोग कर रहे हैं ? (पुनश्च - (_+_)पूरी तरह से एक बट की तरह दिखता है)
— 13:१६ को क्रेज
@charredgrass $भी काम करेगा
— बिल्ली
11
टाइप कास्टिंग
— अब्यूज़
3
हित के बाहर, सबसे अच्छा मैं विशुद्ध रूप से गणितीय रूप से कर सकता था ES7 में 30 बाइट्स n=>(1+10**-~Math.log10(n))*n*n(दुख की बात यह है -~कि ईएस 6 की तुलना में अधिक है **) या 31 n=>-~`1e${-~Math.log10(n)}`*n*n। यहां तक ​​कि पुनरावृत्ति ने मुझे 32 बाइट्स ले लीं:f=(n,m=1)=>n<m?-~m*n*n:f(n,m*10)
— नील
24

जावा 8, 29 26 25 21 बाइट्स

भगवान भला करे लंबोदर

c->new Long(c+""+c)*c

ग> Long.decode (ग + "" + स) * ग;

— user902383
स्रोत
28
आपको जावा से प्यार होगा; यहां तक ​​कि जावा 8 के लैम्ब्डा के साथ और कोडगॉल्फ पर यहां अब तक के सबसे छोटे जावा उत्तरों में से एक है, यह अभी भी अन्य सभी वर्तमान उत्तरों से भिन्न है। xD
— केविन क्रूज़सेन
3
java bae है, लैम्ब्डा bae है
— Seims
3
@KevinCruijssen मुझे अभी भी एक उम्मीद है, एक दिन जावा कोडगोल्फ प्रतियोगिता
— जीतेगी
1
अपने संपादन के बाद आपने 1 रेट बाइट में अपने रेटिना उत्तर के साथ @MartinEnder को आउट किया ! o. o
— केविन क्रूज़सेन
1
@ केविनक्रूजसेन लेकिन अभी भी जीतने के लिए या कम से कम अजगर को हरा देने के लिए पर्याप्त नहीं है :(
— user902383
20

विम, ११

C<C-r>=<C-r>"<C-r>"*<C-r>"<cr>

crcrcrcrcr ...

C       change (delete and enter insert mode) until the end of the line
<C-r>=  insert an expression via the special "expression register"
<C-r>"  insert the contents of the default register (what we just C'd)
<C-r>"  ... again
*       multiplied by
<C-r>"  the input (again)
<cr>    insert the result of this expression
— Doorknob
स्रोत
11 क्या? बाइट्स?
— इन्सान
3
@ आइने बाइट्स यदि आप इसे कमांड लाइन से कहते हैं, तो यदि आप इसे सीधे वीम से करते हैं, तो कीस्ट्रोक्स करता है। मैं आमतौर पर अपने विम उत्तरों से इकाई को छोड़ देता हूं क्योंकि यह या तो एक हो सकता है।
— दरवाज़े
v.tryitonline.net/#code=QxI9EiISIioSIgo&input=MTI खराब करने के लिए अनुचित <C-r>है।
— DJMcMayhem
क्या <C-r>गाड़ी वापसी है?
— कप्तान मैन
@CaptainMan नहीं, <C-r>नियंत्रण प्लस r है। कैरिज रिटर्न है <cr>।
— दरवाज़े
15

एमएसीएस, 17 बाइट्स

(*SPACEC-SPACEC-EM-YSPACEC-YC-Y)C-J

व्याख्या

  • (*SPACE(*बिंदु पर (संख्या से पहले) जोड़ता है ;
  • C-SPACEC-EM-Y संख्या का चयन करें और कॉपी करें;
  • SPACE बिंदु पर एक अंतरिक्ष चरित्र जोड़ता है (संख्या के बाद);
  • C-YC-Y बिंदु पर संख्या से दो गुना चिपकाता है;
  • ))अंत में जोड़ता है ;
  • C-J लाइन को LISP अभिव्यक्ति के रूप में व्याख्या करता है और इसके परिणाम को प्रिंट करता है।

उदाहरण के लिए

एक पाइप द्वारा प्रस्तुत कर्सर ( |)

  • |174
  • (*SPACE (* |174
  • C-SPACEC-EM-Y (* 174|
  • SPACE (* 174 |
  • C-YC-Y (* 174 174174|
  • ) (* 174 174174)|
  • C-J

नतीजा

(* 174 174174)
30306276|
— YSC
स्रोत
3
नमस्ते, और PPCG में आपका स्वागत है! अच्छी पहली पोस्ट!
— R
13

सी #, 19 23 बाइट्स

n=>int.Parse(""+n+n)*n;

बिना तार के, 47 बाइट्स

n=>{int i=1;while(i<=n)i*=10;return(i+1)*n*n;};
— वेस्टन
स्रोत
4
यह एक स्निपेट है, न कि एक पूर्ण कार्यक्रम या फ़ंक्शन। यह (n)=>{int.Parse(""+n+n)*n}
— बिल्ली
@ बेहतर है? क्या मुझे अनुगामी की आवश्यकता है ;?
— पश्चिम जूल
— बिल्ली
12

पायथन 2.7, 21 बाइट्स:

lambda f:int(`f`*2)*f

खैर, यह सबसे छोटा पायथन जवाब होना चाहिए जो मैंने अब तक के सबसे कम समय में लिखा है। यह एक अनाम लंबो फ़ंक्शन है जिसे आप चाहते हैं और फिर इसे किसी सामान्य फ़ंक्शन की तरह लपेट कर नामांकित करके निष्पादित किया जा सकता है print()। उदाहरण के लिए, यदि आपका इनपुट है 12और फ़ंक्शन का नाम दिया गया है H, तो इसे इस तरह कहा जाएगा print(H(12))।

यह ऑनलाइन की कोशिश करो! (Ideone)

ध्यान दें कि यह केवल मान के लिए काम करता है और 9223372036854775807किसी भी उच्च मूल्य के बराबर है और पूर्णांक के अंत में repr()डालता है L। इसलिए, मानों से अधिक के लिए 9223372036854775807, यह 24 बाइट संस्करण वह होगा जो काम करता है:

lambda f:int(str(f)*2)*f

यह ऑनलाइन कोशिश करो! (Ideone)

— आर। कप
स्रोत
मैं अभी भी Phytons स्ट्रिंग संचालन जादुई लगता है ...
— देखता है
@ सईम किस तरीके से?
— बसुकक्सुआन
स्ट्रिंग गुणा और जोड़। अक्सर ऐसा नहीं देखा गया।
— देखता है
@ मुझे लगता है कि आप ज्यादातर स्थैतिक भाषाओं से निपटते हैं?
— बसुकक्सुआन
@busukxuan मुझे एक noob अगर आप चाहते हैं कॉल करें: ^)
— सिम्स
11

जेली, 4 बाइट्स

;DḌ×

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

व्याख्या

;DḌ×    Main link. argument : N

 D      Decimal; Yield the digits of N
;       Concatenate N and its digits
  Ḍ     Convert to integer; We get O
   ×    Multiply O and N
— Essari
स्रोत
1
यह एक बकरी के साथ एक बहुत खुश winking चेहरा है! ;DDx
— बिल्ली
किस एन्कोडिंग में Ḍकेवल 1 बाइट लगती है ? आमतौर पर हम UTF-8 का उपयोग करते हैं, जिसमें यह 3 लेता है (और × 2 लेता है, लेकिन यह ISO8859-1 में 1 बाइट है)।
— 1:11 बजे o11c
@ o11c जेली अपने स्वयं के कस्टम कोड पेज का उपयोग करती है जहां ये अक्षर प्रत्येक बाइट हैं।
— एक स्पेगेटो
10

सी, 70 68 54 53 52 44

f(n){return(pow(10,(int)log10(n)+1)*n+n)*n;}

पिछला संस्करण (48 बाइट्स, कोई गणित कार्य नहीं), @LeakyNun की बदौलत 16 बाइट्स बचाए गए, 1 बाइट की बदौलत @FryAmTheEggman, 4 बाइट्स @TobySpeight की बदौलत:

f(n,d,i){for(i=d=n;d;d/=10)i*=10;return(i+n)*n;}

f()एक तर्क, संख्या के साथ कॉल करें , और यह संबंधित निर्बाध संख्या लौटाता है।

परीक्षण कार्यक्रम

#include <stdio.h>
#include <stdlib.h>

int main(int argc, char **argv)
{
    while (*++argv) {
        int n = atoi(*argv);
        printf("%d -> %d\n", n, f(n));
    }
    return 0;
}

परीक्षण के परिणाम:

$ ./84712 1 2 3 4 10 174
1 -> 11
2 -> 44
3 -> 99
4 -> 176
10 -> 10100
174 -> 30306276

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

— owacoder
स्रोत
f(n){int b=1;while(a)b*=10,a/=10;return(n+n*b)*n;}
— लीकी नून
यह सहित बिना ठीक से काम नहीं करना चाहिए math.h, लेकिन आप जीसीसी, जहां में इसके साथ दूर होने log10()और pow()निर्मित कर रहे हैं, और संकलक केवल के बारे में "में निर्मित समारोह के असंगत निहित घोषणा" बल्कि यह सोचते हैं की तुलना में चेतावनी दी है (जैसा कि होना चाहिए) कि वे दोनों लौट आए int।
— स्पाइट जूल
@ लीकी - आपने कुछ भी नहीं डाला a...
— टोबी स्पाइट
1
एक अन्य उत्तर को देखना अच्छा है जो पूरी तरह से अंकगणित की दुनिया के भीतर रहता है (स्ट्रिंग संयोजन नहीं कर रहा है)। :-)
— टोबी स्पाईट
1
@ टॉबी - सी में स्ट्रिंग का संघनन गोल्फिंग के साथ असंगत है। ;-)
— उल्लू
9

दिल्लोग एपीएल , 7 बाइट्स

⊢×#⍎⍕,⍕

⍕ स्ट्रिंग प्रतिनिधित्व

⍕, स्ट्रिंग प्रतिनिधित्व प्रस्तुत करना

#⍎ संख्या में बनाएं (रूट नेमस्पेस में)

⊢× मूल संख्या से गुणा करें

— एडम
स्रोत
1
उन लोगों को मार दिया टाई टाई अजीब हैं!
— लुइस मेन्डो
2
— Adám
1
कांटा जागता है :
— लुइस मेंडो
मुझे पूरा यकीन है कि वे किसी भी एन्कोडिंग में बाइट नहीं कर रहे हैं, क्योंकि वे अक्षर समान या बहुत आम नहीं हैं।
— o11c
@ o11c क्या आपने "बाइट्स" शब्द के लिए प्रीमेप्टिव लिंक की जांच की, अर्थात। meta.codegolf.stackexchange.com/a/9429/43319 ।
— Adám
9

जे, 7 बाइट्स

*,~&.":

व्याख्या

*,~&.":  Input: n
     ":  Format n as a string
 ,~&.    Reflect and join the string to make "nn"
         and parse the string to get a number
*        Multiply that number by n
— मील की दूरी पर
स्रोत
+1। मैं यह भी नहीं सोच सकता था कि Underस्ट्रिंग संघनन के साथ ठीक से काम कर रहा है। मेरे लिए कितनी बड़ी खोज है! धन्यवाद।
— डैन ओक
अफसोस की बात है, मुझे लगता है कि यह कोष्ठक में होना चाहिए, क्योंकि यह एक हुक है जो सीधे टाइप होने पर काम नहीं कर रहा है * ,~ &.": n, और इसका उपयोग अन्य क्रियाओं के निर्माण में भी नहीं किया जा सकता है।
— डैन ओक
1
@dahnoak यहाँ PPCG में, हमें केवल यह बताना है कि किसी फ़ंक्शन के लिए क्या आवश्यक है, और इसलिए उपरोक्त सभी जे में एक फ़ंक्शन बनाने के लिए आवश्यक है। फिर एक तर्क के रूप में कुछ इनपुट का उपयोग करके इसे लागू करने के लिए, यह या तो इसमें होगा। कोष्ठक या एक चर में संग्रहीत।
— मील
आह, मुझे यह मिल गया, ty।
— डैन ओक
9

रेटिना , 27 20 बाइट्स

^
$_$*: $_
:
$_$*:
:

बड़े इनपुट के लिए थोड़ा धीमा हो जाता है, क्योंकि अंतिम चरण से पहले परिणाम एकात्मकता में दर्शाया जाता है।

इसे ऑनलाइन आज़माएं! (पहली पंक्ति एक लाइनफ़ीड-पृथक परीक्षण सूट को सक्षम करती है।)

व्याख्या

मैं 2एक उदाहरण इनपुट के रूप में उपयोग करूँगा (क्योंकि एकात्मक अभ्यावेदन बड़े इनपुट के लिए थोड़ा सा अस्पष्ट है)।

चरण 1: प्रतिस्थापन

^
$_$*: $_

स्ट्रिंग की शुरुआत के साथ मिलान करके ^हम बस कुछ सामान तैयार करते हैं। $_स्वयं इनपुट स्ट्रिंग को संदर्भित करता है और $*:इसका मतलब है कि हम कई कॉलोन सम्मिलित करते हैं। तो हमें मिलता है:

:: 22

चरण 2: प्रतिस्थापन

:
$_$*:

अब हम हर मैच करते हैं :और इसे फिर से बदलते हैं $_$*:। बेशक, यह समय $_एक पूर्णांक (लेकिन :: 22हमारे उदाहरण में) का मूल्यांकन नहीं करता है , लेकिन $*सिर्फ स्ट्रिंग में पहले दशमलव की तलाश करता है, इसलिए यह इनपुट को स्वयं ( Oचुनौती के विनिर्देश में) के लिए मूल्यांकन करता है। हम N*Oकॉलन के साथ समाप्त करेंगे , उसके बाद O:

:::::::::::::::::::::::::::::::::::::::::::: 22

स्टेज 3: मैच

:

जो कुछ बचा है वह :एस को वापस यूनिरी से दशमलव में बदलने के लिए गिन रहा है , जो कि इस चरण को ठीक करता है।

— मार्टिन एंडर
स्रोत
ऊह, जावा के रूप में लंबे समय तक होने के करीब। इसे केवल 2 बाइट्स द्वारा आउटगोल्फ किया गया। +1
— आर। कप
@ R.Kap दरअसल, 3 बाइट निकालने के बाद Java 8 ने इसे पछाड़ दिया! o. o
— केविन क्रूज़सेन
4
क्षमा करें, जावा ....
— मार्टिन एंडर
9

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

ri_`_+i*

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

r     e# Read input
i     e# Convert to integer
_     e# Duplicate
`     e# Convert to string
_     e# Duplicate
+     e# Concatenate
i     e# Convert to integer
*     e# Multiply. Implicitly display
— लुइस मेंडो
स्रोत
2
मैं सुझाव देने वाला था कि वह तुरंत वापस स्ट्रिंग में परिवर्तित नहीं होगा, लेकिन अनुभवहीन दृष्टिकोण (यानी पहले कभी सीजेएम का उपयोग नहीं किया गया है) r__+i\i*, जो कि एक ही लंबाई है।
— निक हार्टले
@QPaysTaxes आह अच्छा। मैंने आप के रूप में एक ही बात पर ध्यान दिया: क्यों पहले इसे int में परिवर्तित करें और फिर वापस स्ट्रिंग में। मैंने कभी भी सीजेएम का उपयोग नहीं किया और वास्तव में सभी संभावित ऑपरेटरों पर पर्याप्त रूप से करीब नहीं देखा , इसलिए मैं पहली नज़र में एक समाधान खोजने में असमर्थ था। इसे वापस उसी स्ट्रिंग-लंबाई में परिवर्तित किए बिना अपने दृष्टिकोण को साझा करने के लिए धन्यवाद।
— केविन क्रूज़सेन
अगर दो बाइट्स में पूरे स्टैक के लिए एक ऑपरेशन को लागू करने का एक तरीका था, तो यह एक बाइट छोटा होगा (कुछ ऐसा है r__+si*, जहां s"स्टैक के ऊपर इस ऑपरेशन को लागू करें"), लेकिन मुझे ऐसा कुछ दिखाई नहीं देता
— निक हार्टले
8

जेली, 8 6 बाइट्स

ŒṘẋ2v×

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

व्याख्या

ŒṘẋ2v× - Main link. Left argument: the number to convert

     × - Multiply
    v  - an evaluation of the left argument
ŒṘ     - converted to string
  ẋ    - multiplied by
   2   - two and the left argument
— user48538
स्रोत
1
मुझे नहीं लगता कि आपको उन दोनों में से किसी की आवश्यकता है ³।
— मार्टिन एंडर
8

Awk, 13 बाइट्स

$0=($0$0)*$0

पंक्ति को स्वयं से गुणा करके 2 पर सेट करें

— User112638726
स्रोत
7

पायथन, 42 बाइट्स

शुद्ध अंकगणित दृष्टिकोण, तार के बिना!

f=lambda n,m=1:m<=n and f(n,m*10)or-~m*n*n

Ideone यह!

— लीक नन
स्रोत
7

मतलाब / ऑक्टेव, 20 बाइट्स

@(x)eval([x x 42 x])

यह एक अनाम फ़ंक्शन है जो इनपुट को स्ट्रिंग के रूप में लेता है।

उदाहरण का उपयोग करें:

>> f = @(x)eval([x x 42 x])
f = 
    @(x)eval([x,x,42,x])
>> f('12')
ans =
       14544

या ideone के साथ इसे ऑनलाइन आज़माएँ ।

व्याख्या

कोड दो बार इनपुट स्ट्रिंग को बदलकर एक स्ट्रिंग बनाता है, फिर चरित्र *(जिसमें ASCII कोड 42 है), फिर स्ट्रिंग फिर से। संघटित स्ट्रिंग का मूल्यांकन किया जाता है।

— लुइस मेंडो
स्रोत
क्या 42मतलब है?
— लीकेई नन
4
@LeakyNun यह जीवन, ब्रह्मांड और सब कुछ के अंतिम प्रश्न का उत्तर है । इसके अलावा, इसके लिए ASCII कोड होना चाहिए*
— लुइस मेंडो
आह। मैं 42 वें फ़ंक्शन की तरह कुछ खोज रहा था।
— लीकी नून
कोड बस एक स्ट्रिंग दो बार इनपुट स्ट्रिंग को फिर से *जमा करके बनाता है, फिर , फिर से स्ट्रिंग। संघटित स्ट्रिंग का मूल्यांकन किया जाता है। मैं जवाब में कि संपादित करेंगे
— लुइस Mendo
6

zsh, 13 बाइट्स

<<<$[$1$1*$1]

कमांड लाइन तर्क के रूप में इनपुट लेता है, STDOUT को आउटपुट करता है।

यह केवल zsh में काम करता है, लेकिन यहाँ 15 बाइट में बाइट का उपयोग echoकरने के बजाय <<<:

echo $[$1$1*$1]
— Doorknob
स्रोत
6

पर्ल, 11 बाइट्स

$_*=$_ x2

+ pऔर lझंडे।

(साथ चलाएं perl -ple '$_*=$_ x2')

-2 बाइट्स पाइप के लिए धन्यवाद।

— बापू
स्रोत
दो बाइट्स बचाएं:$_*=$_ x2
— पाइप करें
मुझे नहीं लगता कि आपको जरूरत है-l
— ब्रैड गिल्बर्ट b2gills
@ ब्रैडगिल्बर्ब २ग्लस हां मुझे इसकी आवश्यकता है क्योंकि इसके बिना, $_ x2उत्पादन होगा ...\n...\nजब एक संख्या के रूप में पर्ल पहले में समाप्त होता है\n
— दादा
मैं इसे पर्ल 5 और 6 दोनों के साथ परीक्षण कर रहा था, और ध्यान नहीं दिया कि मैं हटाना भूल गया था 6।
— ब्रैड गिल्बर्ट
6

एक्सेल VBA, 35 बाइट्स

सब को नंबर के साथ बुलाया गया, मेसोबॉक्स रिटर्न का जवाब

Sub B(a)
MsgBox (a & a) * a
End Sub

वैकल्पिक एक्सेल VBA, 42 बाइट्स

फॉर्मूला में दिया गया नंबर, रिटर्न का जवाब।

Function B(a)
B = (a & a) * a
End Function
— tjb1
स्रोत
एक MsgBox और एक उप के बारे में सोचो। अगर मैं सही तरीके से
— गिनूं
मुझे मूल्य प्राप्त करने के लिए इनपुट बॉक्स के कुछ रूप की आवश्यकता होगी, नहीं?
— tjb1
उप B (a) MsgBox (a) a की कोशिश करें * एक उप उप
— GER_Moki
मान को पास करने के लिए एक और उप की आवश्यकता होती है, मुझे यकीन नहीं है कि गोल्फ में इसकी अनुमति है।
— tjb1
समारोह को भी बुलाया जाना चाहिए;)
— GER_Moki
6

लुआ, 20 बाइट्स

एक कमांड-लाइन तर्क में ले जाता है, और STDOUT के माध्यम से आउटपुट करता है

a=...print((a..a)*a)

और @LeakyNun ने टिप्पणी में पूछा :)

a=...       -- alias for the first argument
print(
     (a..a) -- concatenate a with itself, equivalent to a:rep(2)
     *a)    -- multiply the resulting number by a
— Katenkyo
स्रोत
यदि आप स्पष्टीकरण को जोड़ते हैं तो यह एक प्रकार का जबरदस्त प्रदर्शन हो सकता है ...
— Leaky Nun
5

PHP, 25 24 बाइट्स

छोटे उद्घाटन टैग आश्चर्यजनक रूप से कुछ गोल्फ चुनौतियों के लिए उपयोगी होते हैं, सौभाग्य से यह उनमें से एक है। दुर्भाग्य से ऑपरेटर पूर्वता उस क्रम के विपरीत है जिसे आपको इतने सारे कोष्ठक में करने की आवश्यकता है।

<?=($a=$argv[1])*"$a$a";

संपादित करें: मुझे एहसास हुआ कि वैसे भी मैं कैसे कोष्ठक का उपयोग कर रहा हूं, यह देखते हुए कि मैं प्रभावी रूप से आसपास के संचालन के लिखित क्रम को बदलकर संघचालक को छोड़ सकता हूं।

— user55641
स्रोत
5

डीसी, 11 10 बाइट्स

ddZAr^1+**

मुझे पता था कि अंततः मुझे Zकमांड के लिए एक उपयोग मिलेगा !

ऑपरेशन काफी सरल है - अंकों की गणना करें, उस शक्ति को 10 तक ले जाएं और एक जोड़ दें। यह एक गुणक देता है जो संख्या को स्वयं के साथ समेटता है। फिर बस गुणा करें।

I / O स्टैक का उपयोग करता है, हमेशा की तरह dc के लिए।

पूरा कार्यक्रम

यह वही है जो मैंने परीक्षणों के लिए उपयोग किया था:

#!/usr/bin/dc
?
ddZAr^1+**
p

दो अतिरिक्त कमांड हमें पाइपलाइन I / O देते हैं।

टेस्ट

$ for i in 1 2 3 10 174; do printf '%d -> ' $i; ./84712.dc <<<$i; done
1 -> 11
2 -> 44
3 -> 99
10 -> 10100
174 -> 30306276

सर बिडेन XVII (1 बाइट) के कारण धन्यवाद।

— टोबी स्पाईट
स्रोत
आप एक बाइट को बचाने के Aलिए स्थानापन्न कर सकते हैं 10। बहुत बढ़िया!
— जो
4

कण्ठमाला, 11 बाइट्स

R I W I_I*I

यह उन दुर्लभ गोल्फ चुनौतियों में से एक है, जहां मंप्स की मूर्तियां बहुत काम में आ सकती हैं। सबसे पहले, सभी चर तार हैं, और सभी गणित समीकरणों का सख्ती से बाएं से दाएं (जैसे: PEMDAS में नहीं) का मूल्यांकन किया जाता है, इसलिए 1 + 2 * 4 = 12 के बजाय माइम में = 9 जिस तरह से PEMDAS होगा। तो, (बमुश्किल) अपुष्ट:

R I ;     Read from stdin to variable I
W I_I*I ; Write out I concatenated with I, then multiplied by I.

सतर्कता का शब्द - क्योंकि मैंड्स (इंटरसिस्टम एन्सेम्बल) का उपयोग करने वाले मम्प्स का स्वाद स्टड के लिए गाड़ी की वापसी को प्रतिध्वनित नहीं करता है, इनपुट और आउटपुट नंबर संक्षिप्त रूप में दिखाई देगा। उस सुधार / पठनीयता को बढ़ाने के लिए, आपको दो बाइट्स जोड़ने और एक मैनुअल CR / LF जोड़ने की आवश्यकता होगी, इस प्रकार:

R I W !,I_I*I

हालाँकि, जैसा कि मैंने चुनौती के नियमों में उस आवश्यकता को नहीं देखा था, मुझे पूरा यकीन है कि मैं छोटे कोड के साथ अच्छा हूँ। अगर मुझसे गलती हुई है, तो कृपया मुझे LART से बेझिझक बताएं और मैं अपना जवाब संशोधित कर दूंगा। :-)

— zmerch
स्रोत
4

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

मुझे याद दिलाने के लिए TessellatingHeckler को धन्यवाद कि पीएस पाइपलाइन से कितना प्यार करता है।

नई 18 बाइट्स:

process{$_*"$_$_"}

पुराने 25 बाइट्स:

param($a);[int]"$a$a"*$a

स्पष्टीकरण:

# new
process{$_*"$_$_"}
process{         } # runs code block once for each passed item
        $_*        # multiple the first parameter
           "$_$_"  # concatenate as a string for ease
                   # in this case, the order does the typecasting for us
# old
param($a);[int]"$a$a"*$a
param($a)                 # assigns the first passed parameter to variable $a
         ;                # line terminator
          [int]           # type cast string "$a$a" to int32
               "$a$a"     # convert $a$a to string for easy concatenation
                     *$a  # multiply by $a

परीक्षण (बोरिंग के रूप में सहेजें ।ps1):

# new
12 | .\boring.ps1
14544
174 | .\boring.ps1
30306276

# old
.\boring.ps1 12
14544
.\boring.ps1 174
30306276

निश्चित रूप से जीत का जवाब नहीं है, लेकिन मज़ा की परवाह किए बिना!

— ThePoShWolf
स्रोत
यदि आप चर को दूसरे तरीके से इधर-उधर करते हैं, तो int * string संक्षेप में स्ट्रिंग को int में डाल देगा, और आप 5 बाइट्स को कास्टिंग के लिए बचा सकते हैं। process{$_*"$_$_"}18 बाइट्स है, और "स्टडिन" (यानी पाइपलाइन) से इनपुट लेता है, जैसे174|script.ps1
— TessellatingHeckler
हम्म् ... दिलचस्प बात। मैं भी अपनी संरचना का उपयोग करके उन्हें स्विच कर सकता हूं और समान परिणाम प्राप्त कर सकता हूं:param($a);$a*"$a$a"
— ThePoShWolf
इर, मैं इसे वापस लेता हूं, मेरा एक बाइट लंबा है!
— ThePoShWolf
@TessellatingHeckler उस जवाब के साथ सावधान, क्योंकि PowerShell का REPL वातावरण प्रोग्राम या फ़ंक्शन डिफ़ॉल्ट के लिए योग्य नहीं है । कुछ ऐसा है param($n)$n*"$n$n"(डार्थ के पास, बिना ;) एक ही लंबाई है और एक REPL नहीं है।
— AdmBorkBork
@TimmyD एक test.ps1फाइल क्यों नहीं जो पाइपलाइन काउंट से पढ़ता है? क्या स्टड से पढ़ने वाली बैश शेल लिपि की भी गिनती नहीं है?
— TessellatingHeckler
4

बैच, 27 20 18 बाइट्स

@cmd/cset/a%1%1*%1

संपादित करें: @TessellatingHeckler के लिए 7 बाइट्स सहेजे गए। @ E aG by की बदौलत एक और 2 बाइट्स बचाए।

— नील
स्रोत
set /aप्रांप्ट पर असाइनमेंट का परिणाम उत्पन्न करता है। -> @cmd/c set/a n=%1%1*%122 बाइट्स के लिए।
— TessellatingHeckler
@TessellatingHeckler यदि आप आउटपुट कर रहे हैं तो असाइन करने से क्यों परेशान हैं?
— नील
@TessellatingHeckler हुह, मैंने छह सप्ताह पहले ही यह चाल चली थी, और मैं इसे पहले ही भूल चुका हूँ ..
— नील
@cmd/cset/a%1%1*%118 के लिए।
— निकोल निकोल
1
@ नील नोप, लेकिन मैंने इसका परीक्षण किया (विंडोज़ 10 पर!) cmd/cभाग की आवश्यकता है क्योंकि बैच फ़ाइल निष्पादन उपकरण स्वयं नहीं cmd है।
— निकोलग्राफ जूल
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.