32

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

123
123
123

फिर आप वर्ग से सभी पंक्तियों और स्तंभों को लेते हैं, और उन्हें एक साथ जोड़ते हैं:

123+123+123+111+222+333

जिसका परिणाम हमें मिलता है 1035।

नकारात्मक संख्याओं के लिए, आप सामान्य रूप से स्टैक करते हैं (याद रखें कि आप केवल अंकों की संख्या की गणना करते हैं , इसलिए ऋणात्मक चिन्ह लंबाई में शामिल नहीं है), और फिर सामान्य रूप से क्षैतिज संख्या पढ़ें (नकारात्मक संकेतों के साथ), और फिर नकारात्मक संकेतों को अनदेखा करें ऊर्ध्वाधर संख्या। तो, संख्या के लिए -144हमें वर्ग मिलता है:

-144
-144
-144

जो हमें देता है -144-144-144+111+444+444, जो बराबरी देता है567

केवल एक अंक वाली संख्याओं के लिए, वर्ग हमेशा दोगुनी संख्या के बराबर होता है (एक बार क्षैतिज रूप से और एक बार लंबवत पढ़ें)। तो 4हमें देता है

जो हमें देता है 4+4, जो बराबरी देता है 8।

दशमलव भागों के साथ संख्याओं के लिए, सामान्य रूप से स्टैक करें (याद रखें कि केवल अंक को उस संख्या में गिना जाता है जिसे आप संख्या को ढेर करते हैं, और इसलिए दशमलव बिंदु की गणना नहीं की जाती है), और ऊर्ध्वाधर संख्याओं को पढ़ने पर दशमलव प्रतीकों को अनदेखा करें। उदाहरण के लिए, संख्या 244.2हमें देती है

जो हमें देता है 244.2+244.2+244.2+244.2+2222+4444+4444+2222, जो बराबरी देता है 14308.8।

आंशिक या जटिल संख्याओं को चुकता नहीं किया जा सकता है।

आपका कार्य:

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

उदाहरण:

123    -> 1035
388    -> 3273
9999   -> 79992
0      -> 0
8      -> 16
-6     -> 0
-25    -> 27
-144   -> 567
123.45 -> 167282.25
244.2  -> 14308.8
2      -> 4
-0.45  -> 997.65
0.45   -> 1000.35

स्कोरिंग:

मेरे हाथ उन सभी चौकों को लिखने से ऐंठ रहे हैं, और मेरा कंप्यूटर कॉपी / पेस्ट का समर्थन नहीं करता है, इसलिए मेरे लिए टाइप करने के लिए कम से कम कोड वाली प्रविष्टि (किसी कारण से बाइट्स में मापी गई) जीत है?

code-golf number

— ग्रीफॉन - मोनिका को बहाल करना
स्रोत

1

"123.45" और "244.2" अपने आप में मान्य फ़्लोट नहीं हैं क्योंकि कंप्यूटर बाइनरी में नंबर संग्रहीत करता है। यह आम तौर पर एक समस्या नहीं है जब तक कि समस्या दशमलव प्रतिनिधित्व पर निर्भर न हो।

— लीक नन

@LeakyNun, मुझे वास्तव में नहीं पता है कि आपका क्या मतलब है। समस्या अकल्पनीय नहीं है (कम से कम अजगर में), मुझे पूरा यकीन है कि मैं इसे आसानी से कर सकता हूं, हालांकि बड़ी संख्या में बाइट्स में। हालाँकि इसके लिए कुछ स्ट्रिंग हेरफेर की आवश्यकता होगी।

— ग्रीफॉन -

@Gryphon तो हमें एक स्ट्रिंग के रूप में इनपुट लेना चाहिए?

— लीक नन

3

@Gryphon यह वह जगह है जहाँ यह विफल रहता है। 244.2एक फ्लोट संख्या नहीं है। इसे स्ट्रिंग में परिवर्तित नहीं किया जा सकता है "244.2"।

— लीक नन

3

@Gryphon लेकिन इस तरह का व्यवहार इसे बहुत असुविधाजनक बनाता है।

— लीक नन

8

05AB1E , 7 बाइट्स

þSDg×+O

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

व्याख्या

þSDg×+O Implicit input
þ       Keep digits
 S      Get chars
  D     Duplicate
   g    Length
    ×   Repeat string(s)
     +  Add (implicit input added to all elements)
      O Sum

— आउटगोल्फर को एरिक करें
स्रोत

3

जब आप खुश कर सकते हैं, तो ओउ स्पष्टीकरण

— जोनाथन एलन

1

इसके अलावा, मैं ध्यान देता हूं कि एकल अग्रणी शून्य इनपुट पर एक आवश्यकता है -1 <इनपुट <1 (यानी 0.45 और .45 अलग-अलग इनपुट हैं लेकिन एक ही नंबर, केवल पूर्व स्वीकार्य है)

— जोनाथन एलन

@JonathanAllan उत्तरार्द्ध को किसी भी तरह से नियंत्रित नहीं किया गया है।

— निकोल आउटफोलर जूल

@JonathanAllan किया।

— आउटगॉल्फ जूल

7

जेली , 13 12 बाइट्स

fØDẋ€L$ŒV+VS

पात्रों की एक सूची (एक अच्छी तरह से बनाई गई दशमलव संख्या, एकल अग्रणी शून्य -1 <n <1 ) के लिए एक आवश्यकता को स्वीकार करने और एक नंबर लौटाने के लिए एक विवादास्पद लिंक ।

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

14 बाइट्स स्वीकार करने और संख्या वापस करने के लिए (इनपुट +/- 10 ^-5 द्वारा सीमित ŒṘ) ŒṘfØDẋ€L$ŒV+⁸S:।

कैसे?

fØDẋ€L$ŒV+VS - Link: list of characters         e.g. "-0.45"
 ØD          - yield digit characters                "0123456789"
f            - filter keep                           "045"
      $      - last two links as a monad:
     L       -   length (number of digit characters) 3
   ẋ€        -   repeat list for €ach digit          ["000","444","555"]
       ŒV    - evaluate as Python code (vectorises)  [0,444,555]
          V  - evaluate (the input) as Jelly code    -0.45
         +   - addition (vectorises)                 [-0.45,443.55,554.55]
           S - sum                                   997.65

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

उम्म, आप बदल सकते हैं +€के साथ +-1 के लिए 15-बाइट संस्करण में।

— निकोलस

पहले ही किया था, धन्यवाद!

— जोनाथन एलन

उम्म 15-बाइट संस्करण में नहीं है। संपादित करें: 3 सेकंड बहुत जल्दी मुझे लगता है ...

— निकोलस जुल्फिकार

हाँ अभी आपने 15 बाइट संस्करण कहा - फिर से धन्यवाद!

— जोनाथन एलन

6

हास्केल, 59 56 बाइट्स

f s|l<-filter(>'.')s=0.0+sum(read<$>(s<$l)++[c<$l|c<-l])

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

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

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

l<-filter(>'.')s      -- let l be the string of all the numbers of the input string
f s   = 0.0 + sum     -- the result is the sum of (add 0.0 to fix the type to float)
   read<$>            -- turn every string of the following list into a number
   s<$l               -- length of l times the input string followed by
   [c<$l|c<-l]        -- length of l times c for each c in l

— nimi
स्रोत

5

जाप v2 , 16 बाइट्स

o\d
l
¬xpV +V*Ng

इसे ऑनलाइन टेस्ट करें!

व्याख्या

o\d    First line: Set U to the result.
o      Keep only the chars in the input that are
 \d      digits. (literally /\d/g)

l    Second line: Set V to the result.
l    U.length

¬xpV +V*Ng    Last line: implicitly output the result.
¬             Split U into chars.
 x            Sum after
  pV            repeating each V times.
     +V*Ng    Add V * first input (the sum of the horizontals) to the result.

— ETHproductions
स्रोत

4

सी # (.NET कोर), 150 141 133 बाइट्स

~~सहेजे गए 9 बाइट्स @TheLethalCoder की बदौलत @TheLethalCoder की बदौलत~~
एक और 8 बाइट्स बच गए

a=>{var c=(a+"").Replace(".","").Replace("-","");int i=0,l=c.Length;var r=a*l;for(;i<l;)r+=int.Parse(new string(c[i++],l));return r;}

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

एक इनपुट के रूप में एक स्ट्रिंग लेता है और एक फ्लोट के रूप में 'स्क्वेयर' नंबर को आउटपुट करता है।

यह कोड निम्न एल्गोरिथम का अनुसरण करता है:

इनपुट से एक नया स्ट्रिंग बनाएं, लेकिन दशमलव बिंदुओं और प्रतीकों के बिना, इसलिए हम अपनी लंबाई और वहां से स्तंभों की संख्या प्राप्त कर सकते हैं।
बिंदु 1 पर हमारे द्वारा बनाए गए स्ट्रिंग की लंबाई के इनपुट समय की गणना करें।
हमारे 'स्क्वायर' में प्रत्येक कॉलम के लिए, कॉलम संख्या और पंक्ति की लंबाई के साथ एक नया स्ट्रिंग बनाएं और इसे हमारे परिणाम में जोड़ें।

उदाहरण:

इनपुट: -135.5

यदि हम दशमलव बिंदुओं और प्रतीकों को प्रतिस्थापित करते हैं तो हमें स्ट्रिंग मिलती है 1355, जिसकी लंबाई होती है 4।
इनपुट समय 4 -135.5 * 4 = -542:।
अब हम प्रत्येक स्तंभ के लिए नई तार बनाने के लिए, उन्हें पार्स और उन्हें हमारे परिणाम में जोड़ें:
1111, 3333, 5555, 5555।

यदि हम इन नंबरों को जोड़ते हैं 15012, तो हम प्राप्त करते हैं , जो कि हमारे प्रोग्राम का आउटपुट होगा।

— इयान एच।
स्रोत

1

साइट पर आपका स्वागत है, और अच्छा पहला उत्तर (विशेष रूप से स्पष्टीकरण की सराहना की जाती है!)।

— दादा

@ दादा शुक्रिया! यहां तक कि कठिन है कि मैं बाइट्स से अनफिट हूं string.Replace(), जैसे कि सामान से मैंने प्राप्त किया , लेकिन मुझे लगता है कि यह काम करने का एकमात्र तरीका है!

— इयान एच।

सेटिंग iऔर lफ्लोट्स द्वारा कुछ बाइट्स को बचाने में सक्षम हो सकता है।

— द लीथलकोडर

@ TheLethalCoder उस अस्वस्थ के बारे में सोचा, दुख की बात है अनुक्रमण फ़्लोट्स के साथ काम नहीं करता है, और .Length अंतर्निहित रूप से फ़्लोट में परिवर्तित नहीं किया जा सकता है।

— इयान एच।

1

a=>{var c=a.Replace(".","").Replace("-","");int i=0,l=c.Length;var r=float.Parse(a)*l;for(;i<l;)r+=int.Parse(new string(c[i++],l));return r;}

141 बाइट्स। हो सकता है कि इनपुट floatको एक स्ट्रिंग के रूप में ले कर सहेजा जा सके, n+""लेकिन मैं जाँच नहीं कर पाया।

— TheLethalCoder

3

ब्रेकीलॉग , 23 बाइट्स

{∋ịṫ}ᶠ⟨≡zl⟩j₎ᵐ;[?]zcịᵐ+

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

Brachylog फ्लोट के साथ अच्छी तरह से नहीं जाता है ...

स्पष्टीकरण:

{∋ịṫ}ᶠ⟨≡zl⟩j₎ᵐ;[?]zcịᵐ+ Takes string (quoted) input, with '-' for the negative sign
     ᶠ                  Return all outputs (digit filter)
{   }                    Predicate (is digit?)
 ∋                        An element of ? (input)
  ị                       Convert to number (fails if '-' or '.')
   ṫ                      Convert back to string (needed later on)
      ⟨   ⟩             Fork
       ≡                 Identity
         l               Length
                        with
        z                Zip
             ᵐ          Map
            ₎            Subscript (optional argument)
           j              Juxtapose (repeat) (this is where we need strings)
              ;         Pair with literal
               [ ]       List
                ?         ?
                  z     Zip
                   c    Concatenate (concatenate elements)
                     ᵐ  Map
                    ị    Convert to number
                      + Add (sum elements)

— आउटगोल्फर को एरिक करें
स्रोत

3

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

§+ȯṁrfΛ±TṁrSR#±

एक स्ट्रिंग लेता है और एक नंबर लौटाता है। इसे ऑनलाइन आज़माएं!

व्याख्या

यह थोड़ा कष्टप्रद है कि अंतर्निहित पार्सिंग फ़ंक्शन rडिफ़ॉल्ट मान वापस करने के बजाय अमान्य इनपुट पर पार्स त्रुटियां देता है, जिसका अर्थ है कि मुझे उन स्तंभों को स्पष्ट रूप से फ़िल्टर करना होगा जिनमें गैर-अंक शामिल हैं। यदि यह विकृत इनपुट पर 0 लौटा है, तो मैं fΛ±3 बाइट्स को छोड़ और बचा सकता हूं ।

§+ȯṁrfΛ±TṁrSR#±  Implicit input, e.g. "-23"
             #±  Count of digits: 2
           SR    Repeat that many times: ["-23","-23"]
         ṁr      Read each row (parse as number) and take sum of results: -46
  ȯṁrfΛ±T        This part is also applied to the result of SR.
        T        Transpose: ["--","22","33"]
     fΛ±         Keep the rows that contain only digits: ["22","33"]
   ṁr            Parse each row as number and take sum: 55
§+               Add the two sums: 9

— Zgarb
स्रोत

3

पायथन 3 , 95 94 87 85 84 बाइट्स

def f(i):l=[x for x in i if"/"<x];k=len(l);print(k*float(i)+sum(int(x*k)for x in l))

टेस्ट सूट ।

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

lambda x:sum(float(i*len(z))for z in[[i for i in str(x)if"/"<i]]for i in[x]+z)

परीक्षण सूट।

दूसरा तरीका @ आधिकारिक के समाधान से प्रेरित पायथन 3 के लिए एक बंदरगाह है।

— मिस्टर एक्सकोडर
स्रोत

3

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

-7 बाइट्स @Mr को धन्यवाद। Xcoder :'/'<i

पूर्णांक या फ्लोट में ले जाता है, फ्लोट लौटाता है।

lambda x:sum(float(i*len(z))for z in[[i for i in`x`if"/"<i]]for i in[x]+z)

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

स्पष्टीकरण:

कहते हैं 123.45इनपुट के रूप में दिया गया है। [i for i in`x`if"/"<x]स्ट्रिंग पूर्णांक ['1','2','3','4','5'](जो भी है z) की एक सूची देता है । अब हम पुनरावृति के माध्यम से [x]+zयानी [123.45,'1','2','3','4','5'], द्वारा प्रत्येक तत्व गुणा len(z)यहाँ, 5और एक फ्लोट करने के लिए प्रत्येक परिवर्तित (ताकि तार भी तदनुसार परिवर्तित कि), उपज [617.25,11111.0,22222.0,33333.0,44444.0,55555.0]। अंत में हम गणना करते हैं sum(...)और प्राप्त करते हैं 167282.25।

— officialaimm
स्रोत

78 बाइट्स । के i.isdigit()साथ बदलें"/"<i<":"

— श्री Xcoder

1

74 बाइट्स । आप बदल सकते हैं i.isdigit()के साथ "/"<i, वास्तव में, क्योंकि दोनों .और -अंक की तुलना में कम ASCII कोड है, ए डी एन /उन दोनों के बीच में है

— श्री Xcoder

आपका स्वागत है। मैंने अपने उत्तर के विकल्प के रूप में इसे पायथन 3 में रखा है

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

3

जावास्क्रिप्ट, 75 62 बाइट्स

a=>(b=a.match(/\d/g)).map(b=>a+=+b.repeat(c),a*=c=b.length)&&a

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

-2 बाइट्स को धन्यवाद अर्नुल्ड
-5 बाइट्स शैगी की बदौलत (हालांकि फंक्शन को एक नंबर मिलना चाहिए, लेकिन अब मैं देख रहा हूं कि बहुत से अन्य जवाब भी स्ट्रिंग मिलते हैं)

3

पर्ल ५ , 37 33 + 1 (-पी) = 38 34 बाइट्स

$_*=@n=/\d/g;for$\(@n){$_+=$\x@n}

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

4 बाइट शेव करने के लिए डोम के कोड से कुछ ट्रिक्स का इस्तेमाल किया

व्याख्या की:

@n=/\d/g;    # extract digits from input
$_*=@n;      # multiply input by number of digits
for$\(@n){   # for each digit:
  $_+=       # add to the input
  $\x@n}     # this digit, repeated as many times as there were digits
             # taking advantage of Perl's ability to switch between strings
             # and numbers at any point

— Xcali
स्रोत

बहुत ही समान दृष्टिकोण के साथ आया था, लेकिन $ \ _ का उपयोग करके और लूप को बाहर करने के लिए कुछ बाइट्स प्राप्त करने में कामयाब रहा: इसे ऑनलाइन आज़माएं!

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

आपसे शेव करने के लिए आपसे कुछ प्रेरणा लेते थे। आपके अंत में "} {" निर्माण क्या है? मैं उस एक से परिचित नहीं हूँ।

— Xcali

यह एक ऐसा है जिसे मैंने इस साइट से सीखा है, मूल रूप से -nऔर कोड के चारों ओर -pलिपटता है while(){...}इसलिए इससे }{बाहर निकलता है। यह अनिश्चित है, $_लेकिन अगर आप $\ अपने चर के रूप में उपयोग करते हैं तो यह अभी भी मुद्रित हो जाएगा क्योंकि $\ हर प्रिंट में जोड़ा जाता है। इसका मतलब है कि आप संख्या और कुछ को उस में स्टोर कर सकते हैं और अवहेलना कर सकते हैं $_। यकीन नहीं था कि एक महान विवरण था, लेकिन पर्ल थ्रेड में गोल्फ जी के लिए युक्तियों की जांच करें , मुझे यकीन है कि यह बेहतर समझाएगा! खुशी है कि अपने स्कोर में मदद की है, हालांकि!

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

2

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

ŒṘfØDẋ€L©$ŒV;ẋ®$S

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

— आउटगोल्फर को एरिक करें
स्रोत

2

पायथ, 18 बाइट्स

s+RvQsM*RF_lB@jkUT

इसे यहाँ आज़माएँ।

— आउटगोल्फर को एरिक करें
स्रोत

2

पायथ , 21 20 बाइट्स

K@jkUTQ+smv*lKdK*lKv

परीक्षण सूट।

@ EriktheOutgolfer के उत्तर से पूरी तरह से अलग दृष्टिकोण का उपयोग करता है , जिसने मुझे 22 से 21 तक चैट में 1 बाइट की मदद की।

व्याख्या

K@jkUTQ+s.ev*lKbK*lKv

K @ jkUTQ - अंकों को फ़िल्टर करता है और उन्हें एक चर K को असाइन करता है।
         एम - नक्शा। एक चर के साथ अंक के माध्यम से बदल दिया
           v - मूल्यांकन (फ्लोट में परिवर्तित)।
            * lKd - प्रत्येक स्ट्रिंग अंक को K की लंबाई से गुणा करता है।
        s - सम
       + - सम
                 * lKvQ - अंकों की संख्या को स्ट्रिंग की लंबाई से गुणा करता है

— मिस्टर एक्सकोडर
स्रोत

2

ऑक्टेव , 100 82 बाइट्स

बहुत बहुत धन्यवाद @TomCarpenter मुझे सिखाने के लिए कि असाइनमेंट का रिटर्न वैल्यू है और मुझे 18बाइट्स की बचत है !

@(v)(n=nnz(s=strrep(num2str(abs(v)),'.','')-'0'))*v+sum(sum(s'*logspace(0,n-1,n)))

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

Ungolfed / स्पष्टीकरण

function f=g(v)
  s=strrep(num2str(abs(v)),'.','')-'0';  % number to vector of digits (ignore . and -)
  n=nnz(s);                              % length of that vector
  f=n*v+sum(sum(s'*logspace(0,n-1,n)))   % add the number n times and sum the columns of the square
end

जिस तरह से यह काम करता है वह यह है कि हमें मूल रूप से संख्याओं को nबार-बार जोड़ना होगा और फिर स्तंभों का योग जोड़ना होगा। स्तब्ध हो जाना s' * logspace(0,n-1,n)स्तम्भों का योग प्राप्त करता है, उदाहरण के लिए यदि v=-123.4वह मैट्रिक्स होगा:

[ 1     10    100   1000;
  2     20    200   2000;
  3     30    300   3000;
  4     40    400   4000 ]

इसलिए हमें अभी इसकी आवश्यकता है sumऔर हम कर रहे हैं।

— ბიმო
स्रोत

1

आप 18 बाइट्स को एक गुमनाम फंक्शन में स्मूच करके बचा सकते हैं @(v)(n=nnz(s=strrep(num2str(abs(v)),'.','')-'0'))*v+sum(sum(s'*logspace(0,n-1,n)))। इसे ऑनलाइन आज़माएं!

— टॉम कारपेंटर

1

स्विफ्ट 4 , 139 134 बाइट्स

func f(s:String){let k=s.filter{"/"<$0};print(Float(s)!*Float(k.count)+k.map{Float(String(repeating:$0,count:k.count))!}.reduce(0,+))}

परीक्षण सूट।

व्याख्या

func f(s:String)- fएक स्पष्ट स्ट्रिंग पैरामीटर के साथ एक फ़ंक्शन को परिभाषित करता है s।
let k=s.filter{"/"<$0}- अंकों को फिल्टर करता है: मैंने देखा कि दोनों -और .सभी अंकों की तुलना में छोटे ASCII-मान हैं, और /बीच है ., -और 0। इसलिए, मैंने अभी जाँच की है कि "/"क्या मैं वर्तमान चरित्र से छोटा हूँ, जैसा कि मैंने अपने पायथन उत्तर में किया था।
print(...) - परिणाम प्रिंट करता है।
Float(s)!*Float(k.count)- दोनों को स्ट्रिंग और अंकों की संख्या को फ्लोट में परिवर्तित करता है और उन्हें गुणा करता है (स्विफ्ट फ्लोट और इंट गुणा को अनुमति नहीं देता है :())। तो यह संख्या xबार जोड़ता है , जहां xअंकों की संख्या होती है।
k.map{Int(String(repeating:$0,count:k.count))!- वर्तमान मूल्य के साथ k.map{}नक्शे । प्रत्येक अंक लेता है, समान अंकों का एक स्ट्रिंग बनाता है और इसे एक फ़्लोटिंग-पॉइंट संख्या में परिवर्तित करता है।k$0String(repeating:$0,count:k.count)xFloat(...)!
.reduce(0,+) - उपरोक्त सूची का योग बनता है।
और अंत +में दो परिणामों को बोता है।

चलिए एक उदाहरण लेते हैं!

कहते हैं हमारा स्ट्रिंग है "0.45"। सबसे पहले, हम अंकों को फ़िल्टर करते हैं, इसलिए हमें छोड़ दिया जाता है 0, 4, 5। हम "0.45"फ्लोट में परिवर्तित होते हैं और अंकों की संख्या से गुणा करते हैं 0.45 * 3 = 1.35:। फिर हम प्रत्येक अंक लेते हैं और इसे उस स्ट्रिंग को दोहराते हुए उस अंक में बदल देते हैं जब तक कि यह वर्ग की चौड़ाई (कितने अंक हैं) भरता है 0, 4, 5 -> 000, 444, 555:। हम इस योग, 000 + 444 + 555 = 999। फिर हम सिर्फ एक साथ परिणाम जोड़ते हैं 1.35 + 999 = 1000.35:।

— मिस्टर एक्सकोडर
स्रोत

1

सी #, 139 137 बाइट्स

using System.Linq;n=>{var d=(n+"").Where(char.IsDigit);return d.Sum(i=>int.Parse(new string(i,d.Count())))+new int[d.Count()].Sum(_=>n);}

बची 2 बाइट की बदौलत @ इयान एच।

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

पूर्ण / प्रारूपित संस्करण:

namespace System.Linq
{
    class P
    {
        static void Main()
        {
            Func<double, double> f = n =>
            {
                var d = (n + "").Where(char.IsDigit);
                return d.Sum(i => int.Parse(new string(i, d.Count()))) + new int[d.Count()].Sum(_ => n);
            };

            Console.WriteLine(f(123));
            Console.WriteLine(f(-144));
            Console.WriteLine(f(4));
            Console.WriteLine(f(244.2));

            Console.ReadLine();
        }
    }
}

— TheLethalCoder
स्रोत

आप var d=(n+ ...इसके बजाय शुरुआत में 2 बाइट्स बचा सकते हैं var d = (n ...।

— इयान एच।

@IanH। सभी स्पेस को हटाना भूल गया -_- मुझे एक समर्थन कॉल करने के दौरान जवाब देने के लिए जो मिलता है।

— TheLethalCoder

1

गणितज्ञ, 107 बाइट्स

(t=Length[s=#&@@RealDigits[#]//.{a___, 0}:>{a}];If[IntegerPart@#==0,t++];t#+Tr[FromDigits@Table[#,t]&/@s])&

— J42161217
स्रोत

1

PHP, 78 88 +1 बाइट्स

for($e=preg_match_all("#\d#",$n=$argn);~$c=$n[$i++];)$s+=str_repeat($c,$e);echo$s+$n*$e;

साथ पाइप के रूप में चलाएँ -nR।

PHP 7.1 में चेतावनी दे सकते हैं। Repace $c,$eसाथ $c>0?$c:0,$eठीक करने के लिए।

— टाइटस
स्रोत

0

पायथन 3 , 68 70 73 77 बाइट्स

lambda n:sum(float(n)+int(_*sum(x>"/"for x in n))for _ in n if"/"<_)

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

प्रत्येक अंक चरित्र पर लूप्स और इसे कुल अंकों की संख्या के अनुसार दोहराता है, जो एक पूर्णांक में बनाता है, और इसे जोड़ता है n। इस तरह से कई बार nजोड़ दिया जाता dहै, अंक के क्षैतिज भाग के साथ-साथ अंक दोहराव, जो कि ऊर्ध्वाधर भाग है। मूल रूप से उपयोग किया जाता है str.isdigitलेकिन >"/", इस धागे में दूसरों के लिए धन्यवाद, बहुत सारे बाइट्स को बचाया। nएक स्ट्रिंग के रूप में दो बाइट्स बचाता है , लेकिन आउटपुट गड़बड़ है।

lambda n:sum(n+int(_*sum(x>"/"for x in str(n)))for _ in str(n)if"/"<_)

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

— C मैकवायो
स्रोत

स्क्वायर ए नंबर माय वे

आपका कार्य:

उदाहरण:

स्कोरिंग:

05AB1E , 7 बाइट्स

जेली , 13 12 बाइट्स

कैसे?

हास्केल, 59 56 बाइट्स

जाप v2 , 16 बाइट्स

व्याख्या

सी # (.NET कोर), 150 141 133 बाइट्स

ब्रेकीलॉग , 23 बाइट्स

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

व्याख्या

पायथन 3 , 95 94 87 85 84 बाइट्स

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

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

स्पष्टीकरण:

जावास्क्रिप्ट, 75 62 बाइट्स

पर्ल ५ , 37 33 + 1 (-पी) = 38 34 बाइट्स

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

पायथ, 18 बाइट्स

पायथ , 21 20 बाइट्स

व्याख्या

ऑक्टेव , 100 82 बाइट्स

Ungolfed / स्पष्टीकरण

स्विफ्ट 4 , 139 134 बाइट्स

व्याख्या

चलिए एक उदाहरण लेते हैं!

सी #, 139 137 बाइट्स

गणितज्ञ, 107 बाइट्स

PHP, 78 88 +1 बाइट्स

पायथन 3 , 68 70 73 77 बाइट्स