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

Gryphon 08/21/2017. 20 answers, 1.959 views
code-golf number

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

123
123
123 

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

123+123+123+111+222+333 

जो हमें 1035 परिणाम देता है।

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

-144
-144
-144 

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

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

4 

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

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

244.2
244.2
244.2
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 

स्कोरिंग:

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

5 Comments
Gryphon 07/29/2017
मुझे एहसास है कि यह बहुत लंबे समय तक सैंडबॉक्स में नहीं था (केवल एक दिन में थोड़ा सा), लेकिन इसमें पहले से ही 7 अपवॉट थे, इसलिए, मैंने सोचा कि यह शायद पोस्ट करने के लिए तैयार था।
1 Leaky Nun 07/29/2017
"123.45" और "244.2" वैध फ्लोट्स नहीं हैं क्योंकि कंप्यूटर बाइनरी में नंबर स्टोर करता है। यह आमतौर पर एक समस्या नहीं है जब तक कि समस्या दशमलव प्रतिनिधित्व पर निर्भर न हो।
3 Leaky Nun 07/29/2017
@Gryphon यह वह जगह है जहां यह विफल रहता है। 244.2 एक फ्लोट नंबर नहीं है। इसे "244.2" स्ट्रिंग में परिवर्तित नहीं किया जा सकता है।
2 Leaky Nun 07/29/2017
@Gryphon लेकिन इस तरह के व्यवहार यह बहुत असुविधाजनक बनाता है।
7 Gryphon 07/29/2017
तीन करीबी मत क्यों? यदि 11 लोग सवाल का जवाब दे सकते हैं, तो मुझे लगता है कि यह शायद स्पष्ट है!

20 Answers


Erik the Outgolfer 07/29/2017.

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 
4 comments
3 Jonathan Allan 07/29/2017
ओउ स्पष्टीकरण जब आप कृपया कर सकते हैं
1 Jonathan Allan 07/29/2017
साथ ही मैं ध्यान दूंगा कि एकल अग्रणी शून्य -1 इनपुट के लिए इनपुट पर एक आवश्यकता है <इनपुट <1 (यानी 0.45 और .45 अलग-अलग इनपुट हैं लेकिन एक ही संख्या है, केवल पूर्व स्वीकार्य है)
Erik the Outgolfer 07/29/2017
@ जोनाथनअलन बाद में किसी भी तरह से संभाला नहीं जाता है।
Erik the Outgolfer 07/29/2017
@ जोनाथन एलन हो गया।

Jonathan Allan 07/29/2017.

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

fØDẋ€L$ŒV+VS 

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

Try it online!

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 
4 comments
Erik the Outgolfer 07/29/2017
उम्म, आप -1 के साथ 15 +€ बाइट संस्करण में + साथ प्रतिस्थापित कर सकते हैं।
Jonathan Allan 07/29/2017
पहले से ही धन्यवाद, धन्यवाद!
Erik the Outgolfer 07/29/2017
उम 15-बाइट संस्करण में नहीं है। संपादित करें: मुझे लगता है कि 3 सेकंड बहुत जल्दी लगता है ...
Jonathan Allan 07/29/2017
हाँ बस आपने देखा 15 बाइट संस्करण - धन्यवाद फिर से!

nimi 07/29/2017.

हास्केल, 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 

ETHproductions 07/29/2017.

जैप्ट वी 2 , 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. 

Ian H. 07/31/2017.

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

Saved 9 bytes thanks to @TheLethalCoder
@TheLethalCoder के लिए धन्यवाद 8 बाइट्स बचाया

a=>{var c=(a+"").Replace(".","").Replace("-","");int i=0,l=c.Length;var r=a*l;for(;i 

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

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


यह कोड निम्नलिखित एल्गोरिदम का पालन करता है:

  1. इनपुट से एक नई स्ट्रिंग बनाएं, लेकिन दशमलव बिंदुओं और प्रतीकों के बिना, इसलिए हम वहां से कॉलम के लिए हमारी लंबाई और संख्या प्राप्त कर सकते हैं।

  2. पॉइंट 1 पर बनाए गए स्ट्रिंग की लंबाई के इनपुट समय की गणना करें।

  3. हमारे 'वर्ग' में प्रत्येक कॉलम के लिए, कॉलम संख्या और पंक्ति लंबाई के साथ एक नई स्ट्रिंग बनाएं और इसे हमारे परिणाम में जोड़ें।

उदाहरण:

इनपुट: -135.5

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

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

5 comments
1 Dada 07/31/2017
साइट पर आपका स्वागत है, और अच्छा पहला जवाब (विशेष रूप से स्पष्टीकरण की सराहना की जाती है!)!
Ian H. 07/31/2017
@ दादा धन्यवाद! यहां तक ​​कि कठिन भी मैं string.Replace() जैसी string.Replace() से प्राप्त बाइट्स से string.Replace() , लेकिन मुझे लगता है कि यह एकमात्र तरीका है!
TheLethalCoder 07/31/2017
i और l को तैरने के लिए कुछ बाइट्स को सहेजने में सक्षम हो सकता i
Ian H. 07/31/2017
@TheLethalCoder इसके बारे में सोचा, दुख की बात है कि अनुक्रमण फ़्लोट्स के साथ काम नहीं करता है, और। .Length को फ्लोट में परिवर्तित नहीं किया जा सकता है।
1 TheLethalCoder 07/31/2017
a=>{var c=a.Replace(".","").Replace("-","");int i=0,l=c.Length;var r=float.Parse(a)*l;for(;i 141 बाइट्स। एक float रूप में इनपुट ले कर और n+"" साथ स्ट्रिंग में कास्टिंग करके सहेजने में सक्षम हो सकता है लेकिन मैंने चेक नहीं किया है।

Erik the Outgolfer 07/29/2017.

ब्रैचिलोग , 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) 

Zgarb 07/29/2017.

हुस्क , 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 

Mr. Xcoder 07/29/2017.

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

 def f(i):l=[x for x in i if"/" 

टेस्ट सूट

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

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

परीक्षण सूट।

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


ThePirateBay 07/31/2017.

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

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

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

-2 bytes thanks to Arnauld
-5 bytes thanks to Shaggy (हालांकि मुझे फ़ंक्शन को एक संख्या प्राप्त होनी चाहिए, लेकिन अब मुझे लगता है कि कई अन्य उत्तरों स्ट्रिंग भी प्राप्त करते हैं)


Xcali 08/05/2017.

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

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

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

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

Explained:

 @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 
3 comments
Dom Hastings 07/31/2017
एक बहुत ही समान दृष्टिकोण के साथ आया, लेकिन $ \ और लूप से बाहर निकलने के लिए कुछ बाइट्स प्राप्त करने में कामयाब रहे: इसे ऑनलाइन आज़माएं!
Xcali 08/05/2017
मेरा नीचे दाढ़ी देने के लिए आपसे कुछ प्रेरणा मिली। आपके अंत में "} {" निर्माण क्या है? मैं उस से परिचित नहीं हूँ।
Dom Hastings 08/05/2017
यह एक है जिसे मैंने इस साइट से सीखा है, मूल रूप से -n और -p सचमुच कोड के आस-पास while(){...} लपेटता है }{ उसमें से टूट जाता है। यह $_ अनसेट करता है लेकिन यदि आप अपने चर के रूप में $\ उपयोग करते हैं तो यह अभी भी प्रिंट हो जाएगा क्योंकि प्रत्येक प्रिंट में $\ संलग्न किया गया है। मतलब है कि आप उसमें नंबर या कुछ स्टोर कर सकते हैं और $_ उपेक्षा कर सकते हैं। यकीन नहीं है कि एक महान स्पष्टीकरण था, लेकिन पर्ल थ्रेड में गोल्फ़िंग जी के लिए टिप्स देखें , मुझे यकीन है कि यह बेहतर समझाएगा! यद्यपि आपका स्कोर मदद करने में खुशी हुई!

Erik the Outgolfer 07/29/2017.

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

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

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


Erik the Outgolfer 07/29/2017.

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

s+RvQsM*RF_lB@jkUT 

इसे आजमाएं


Mr. Xcoder 07/29/2017.

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

K@jkUTQ+smv*lKdK*lKv 

परीक्षण सूट।

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


व्याख्या

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

officialaimm 07/30/2017.

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

-7 bytes thanks to @Mr. Xcoder -7 bytes thanks to @Mr. Xcoder : '/'

  • पूर्णांक या फ्लोट में लेता है, फ्लोट लौटता है।
 lambda x:sum(float(i*len(z))for z in[[i for i in`x`if"/" 

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

स्पष्टीकरण:

कहें 123.45 इनपुट के रूप में दिया जाता है। [i for i in`x`if"/" पूर्णांक ['1','2','3','4','5'] (जो भी z ) की एक सूची देता है। अब हम [x]+z यानी [123.45,'1','2','3','4','5'] माध्यम से [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 प्राप्त 167282.25

4 comments
Mr. Xcoder 07/29/2017
78 बाइट्स i.isdigit() को "/" साथ बदलें
1 Mr. Xcoder 07/29/2017
74 बाइट्स आप i.isdigit() को "/" , वास्तव में, दोनों के साथ प्रतिस्थापित कर सकते हैं . और - अंकों के मुकाबले एएससीआईआई कोड कम हैं, एडीएन / उनके बीच है
officialaimm 07/29/2017
@ श्री एक्सकोडर बहुत बहुत धन्यवाद!
Mr. Xcoder 07/29/2017
आपका स्वागत है। मैंने इसे अपने उत्तर के विकल्प के रूप में पायथन 3 पर पोर्ट किया है

Bruce Forte 07/30/2017.

ऑक्टवे , 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 comments
1 Tom Carpenter 07/30/2017
आप इसे सभी अज्ञात फ़ंक्शन @(v)(n=nnz(s=strrep(num2str(abs(v)),'.','')-'0'))*v+sum(sum(‌​s'*logspace(0,n-1,n)‌​)) में smush करके 18 बाइट्स को सहेज सकते हैं @(v)(n=nnz(s=strrep(num2str(abs(v)),'.','')-'0'))*v+sum(sum(‌​s'*logspace(0,n-1,n)‌​))इसे ऑनलाइन आज़माएं!

Mr. Xcoder 07/30/2017.

स्विफ्ट 4 , 13 9 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 परिभाषित करता है।

  • let k=s.filter{"/"<$0} - अंकों को फ़िल्टर करें: मैंने देखा कि दोनों - और . सभी अंकों की तुलना में छोटे ASCII-values ​​हैं, और / के बीच है . , - और 0 । इसलिए, मैंने अभी जांच की है कि "/" वर्तमान चरित्र से छोटा है, जैसा कि मैंने अपने पायथन उत्तर में किया था।

  • print(...) - परिणाम प्रिंट करता है।

  • Float(s)!*Float(k.count) - दोनों स्ट्रिंग और अंकों की संख्या को फ़्लोट करने के लिए परिवर्तित करता है और उन्हें गुणा करता है (स्विफ्ट फ्लोट और इंट गुणा की अनुमति नहीं देता है :())। तो यह संख्या x बार जोड़ता है, जहां x इसमें अंकों की संख्या है।

  • k.mapNO maps over k with the current value $0 . - k.map{} वर्तमान मूल्य $0 साथ के ऊपर नक्शा। String(repeating:$0,count:k.count) प्रत्येक अंक लेता है, x समान अंकों और Float(...)! का एक स्ट्रिंग बनाता है Float(...)! इसे फ़्लोटिंग-पॉइंट नंबर में बदल देता है।

  • .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


TheLethalCoder 07/31/2017.

सी #, 13 9 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);} 

Saved 2 bytes thanks to @Ian H.

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

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

 namespace System.Linq
{
    class P
    {
        static void Main()
        {
            Func 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();
        }
    }
} 
2 comments
Ian H. 07/31/2017
आप var d=(n+ ... बजाय var d=(n+ ... का उपयोग कर शुरुआत में 2 बाइट्स को बचा सकते हैं।
TheLethalCoder 07/31/2017
@IanH। सभी रिक्त स्थान को हटाने के लिए भूल गए-_- एक समर्थन कॉल करते समय मुझे जवाब देने के लिए यही मिलता है।

Jenny_mathy 08/09/2017.

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

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

Titus 08/11/2017.

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 में चेतावनियां पैदा कर सकते हैं। $c,$e $c>0?$c:0,$e को ठीक करने के लिए $c>0?$c:0,$e का भुगतान करें।


C McAvoy 07/31/2017.

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

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

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

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

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

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

Related questions

Hot questions

Language

Popular Tags