अंकगणितीय योग में गुम संख्या

14

चुनौती

कुछ गुम संख्याओं के साथ एक मान्य अंकगणित राशि देते हुए, पूर्ण अभिव्यक्ति का उत्पादन करते हैं।

उदाहरण: 

    1#3                 123
+   45#     =>     +    456
--------            --------
    579                 579

इनपुट

  • अभिव्यक्ति प्रारूप एक सरणी ["1#3", "45#", "579"], एक स्ट्रिंग "1#3+45#=579"या 3 इनपुट हो सकता हैf("1#3","45#","579")

उत्पादन

  • इनपुट के रूप में ही
  • आपको परिणाम को आउटपुट करने की आवश्यकता नहीं है

टिप्पणियाँ

  • अनुपलब्ध संख्याओं का उपयोग #या किसी अन्य निरंतर गैर-संख्यात्मक चरित्र का प्रतिनिधित्व करने जा रहे हैं जो आप चाहते हैं
  • मान लें कि अभ्यस्त के पास एक लापता संख्या है
  • मान लें कि इनपुट / आउटपुट 2 शब्दों और अंतिम परिणाम में शामिल है
  • दोनों शब्द> 0 और परिणाम> = 2 मान लें
  • कई समाधान हो सकते हैं। जब तक आप योग परिणाम मिलान करते हैं, तब तक आप किसी को भी आउटपुट दे सकते हैं

संभवतः आउटपुट के साथ परीक्षण के मामले (सुंदर प्रारूप)

    #79                     879
+   44#         =>      +   444
--------                --------
    1323                   1323

    5#5                     555
+   3#3         =>      +   343
--------                --------
    898                     898

      #                       1
+     #         =>      +     1
--------                --------
      2                       2

    ###                     998
+   ###         =>      +     1     PD: there are a lot of possible outputs for this one
--------                --------
    999                     999


    123                     123
+     #         =>      +     1
--------                --------
    124                     124


      9                       9
+    #6         =>      +    46
--------                --------
     55                      55


    #123651                     1123651
+      #98#         =>      +      7981
------------                -----------
    1131632                     1131632

मानक कोड-गोल्फ नियम लागू होते हैं

code-golf  arithmetic  integer 
— लुइस फेलिप डी जीसस मुनोज
स्रोत
क्या हमें अग्रणी शून्य को पट्टी करने की आवश्यकता है?
@ मेनोमोनिक जरूरी नहीं
— लुइस फेलिप डी
क्या मैं =स्वैप किए गए किनारों के साथ इनपुट ले सकता हूं ? जैसे579=1#3+45#
— द्विजिमा
2
"दोनों अवधि मान लें> 0" "मान" क्या मतलब है मुझे लगता है कि है उत्पादन के लिए दोनों पदों> 0 या मैं यह मान सकते हैं हमेशा दोनों> 0 लेकिन उत्पादन जो कुछ के साथ एक समाधान उपलब्ध न हो कि?
— dzima
1
आपके जोड़े गए टेस्ट-केस से भी वही बचता है जो मैं पूछ रहा था - प्रमुख शून्य
— dzima

जवाबों:

9

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

{Ṣ∧Ị∋|}ᵐ²ịᵐ.k+~t

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

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

व्याख्या

{Ṣ∧Ị∋|}ᵐ²ịᵐ.k+~t
{     }ᵐ²                   #   for each letter in each string
 Ṣ∧Ị∋                       #       if " " return a digit; else input
     |                      #
         ịᵐ                 #   cast each string to number
            k+              #   the sum of all but the last one
              ~t            #       is equal to the last one
           .                #   output that list
— Kroppeb
स्रोत
1
{"#"∧Ị∋|}ᵐ²ịᵐ.k+~t4 बाइट्स छोटी है। मुझे यकीन नहीं है कि आपने अपने नक्शे में कुछ ऐसा क्यों किया है।
— Fatalize
चूंकि हम किसी भी गैर-संख्यात्मक चरित्र का उपयोग कर सकते हैं, इसलिए आपको उदाहरण के लिए स्थान का उपयोग करना चाहिए जिसके Ṣबजाय "#"दो और बाइट्स बचाएंगे।
— 6
8

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

इनपुट के रूप में लेता है (a)(b)(result), जहां एक और बी. अज्ञात अंकों के लिए तार होते हैं और परिणाम एक पूर्णांक होता है। 2 पूर्णांकों की एक सरणी देता है।

a=>b=>F=(c,n)=>`${r=[c,n]}`.match(`^`+[a,b])?r:F(c-1,-~n)

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

टिप्पणी की गई

a => b =>                // a, b = term patterns (e.g. a = ".79", b = "44.")
  F = (c,                // c = expected result (e.g. 1323)
          n) =>          // n = guessed value of b, initially undefined
    `${r = [c, n]}`      // we coerce r = [c, n] to a string (e.g. "879,444")
                         // if n is still undefined, this gives just c followed by a comma
    .match(`^` + [a, b]) // we coerce [a, b] to a string, prefixed with "^" (e.g. "^.79,44.")
    ?                    // this is implicitly turned into a regular expression; if matching:
      r                  //   return r
    :                    // else:
      F(c - 1, -~n)      //   decrement c, increment n and do a recursive call
— Arnauld
स्रोत
आह, तो यही हो रहा है। मैंने कल बिना स्पष्टीकरण के आपके कोड को समझने की कोशिश की (और मैं JS में बुरा हूं), लेकिन यह नहीं समझा कि -~nसिर्फ n+1और कैसे F=(c,n)=>इस्तेमाल किया जा सकता है। अब जब आपने एक स्पष्टीकरण जोड़ा तो यह सब समझ में आता है। cतीसरा इनपुट है, nअपरिभाषित है (और विपरीत ~undefinedहो जाता है )। अब सभी स्पष्ट है (और कुछ नहीं जो मैं दुर्भाग्य से जावा में पोर्ट कर सकता हूं, जो मुख्य रूप से इसलिए मैंने इसे एक्सडी समझने की कोशिश की थी)। पुनश्च: पहले से ही कल उखाड़ा गया है, इसलिए मैंने आपके अन्य उत्तरों में से एक को उकेरा है (जो मैंने पहले से ही नहीं बनाया था, बहुत उपलब्ध नहीं है ..); पी-1undefined+1
— केविन क्रूज़सेन
@KevinCruijssen FWIW, मैंने कुछ समय पहले इस बारे में एक टिप लिखा था। लेकिन हाँ ... यह एक जेएस बात है और शायद कई अन्य भाषाओं के लिए पोर्टेबल नहीं है।
— अरनुलड
ठीक है, मैं इसे अर्ध-पोर्ट करने में सक्षम हो सकता हूं लेकिन बस एक पुनरावर्ती दूसरा तरीका बना सकता हूं, और एक टर्नरी का उपयोग कर सकता हूं-अगर यह जांचना है null, तो मैन्युअल रूप से इसे परिवर्तित करना -1। हालांकि, जावा में एक (बहुत) सीमित पुनरावर्ती StackOverflow की सीमा है, इसलिए यादृच्छिकता के साथ एक पुनरावर्ती पद्धति का उपयोग करके उम्मीद है कि यह लगभग 1024 में पुनरावर्ती कॉलों को सही करेगा जो कि जावा में वैसे भी काम नहीं करने वाला है। ठीक है। मैंने तुम्हारे सिरे को उखाड़ दिया है। आपका सप्ताहांत शुभ हो! :)
— केविन क्रूज़सेन
@ केविनक्रूजसेन मेरा पहला जेएस प्रयास बिल्कुल यही कर रहा था: एक पुनरावर्ती कार्य के साथ यादृच्छिक मूल्यों की कोशिश करना। और यह आमतौर पर काउंटर का उपयोग करने वाले की तुलना में काफी कम पुनरावृत्तियों कर रहा था। मजेदार तथ्य: यहां तक ​​कि ###+###=999, आपके हालात 1000 में 1 हैं। तो 1024 पुनरावृत्तियों के साथ, आपको असफल होने की तुलना में अक्सर अधिक सफल होना चाहिए। :)
— अरनौलड
7

मतलाब, 143 134 132 119 119 बाइट्स

function[m]=f(x,y,r),p=@(v)str2num(strrep(v,'#',char(randi([48,57]))));m=[1,1];while sum(m)-r,m=[p(x),p(y)];end;end

-4 बाइट्स @Luismendo का धन्यवाद

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

बहुत बड़ा और बहुत मस्त चुदक्कड़। यह बस #यादृच्छिक अंकों के साथ सभी को बदल देता है जब तक कि यह सही नहीं पाता।

— DimChtz
स्रोत
5

आर , 67 51 बाइट्स

रॉक सरल और तराजू, बस सभी योग संयोजन grep। उपयोग "।" अज्ञात अंकों के लिए। इसे टेस्ट केस नंबर 4 के समान उत्तर नहीं मिलेगा, लेकिन यह एक संभावित उत्तर देगा, जो दिए गए नियमों के अक्षर का अनुसरण करता है।

-16 आउटपुट को बनाने और ऑपरेटर के pasteसाथ बदलने के बाद grepping द्वारा बाइट्स ?।

function(x,y,z,`?`=paste)grep(x?y,1:z?z:1-1,v=T)[1]

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

— J.Doe
स्रोत
1
बहुत बढ़िया विचार है, मैंने ऐसा कभी नहीं सोचा होगा। आप grepl के स्थान पर * का उपयोग करके कुछ बाइट्स बचा सकते हैं: tio.run/##PYzLCoMwEEX3/…
— JayCe
1
मैं विभिन्न ऑपरेटरों की तलाश में था और आप के साथ आते हैं ?... मुझे लगता है कि यह पहली बार है। वैसे, मैं भूल गया था अगर मैंने आपको पहले ही बता दिया था, लेकिन हम इस महीने की सितंबर भाषा के लिए आर नामित होने की कोशिश कर रहे हैं - यदि आप पहले से ही नहीं किए गए हैं तो आप इसे अपवोट कर सकते हैं।
— JayCe
मैं कम मिसाल के साथ कुछ भी चुन सकता था। ऐसा लगता है कि मैच पाने के लिए एक बेहतर तरीका होना चाहिए ...
— जे।
3

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

Ｆ²⊞υ0Ｗ⁻ζΣＩυ≔Ｅ⟦θη⟧⭆κ⎇⁼μ#‽χμυ←Ｅυ⮌ι

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

Ｆ²⊞υ0

लूप जा रहा पाने के लिए 0पूर्वनिर्धारित खाली सूची में दो स्ट्रिंग एस पुश करें u।

Ｗ⁻ζΣＩυ

दोहराएँ जब uपूर्णांक में मूल्यों को कास्टिंग का योग वांछित परिणाम के बराबर नहीं है।

≔Ｅ⟦θη⟧

दो इनपुट की एक सरणी बनाएँ और उस पर मैप करें।

⭆κ⎇⁼μ#‽χμυ

प्रत्येक #को यादृच्छिक अंक से बदलें और परिणाम को वापस असाइन करें u।

←Ｅυ⮌ι

परिणाम को सही ठहराते हुए प्रिंट करें। (लेफ्ट जस्टिफ़ाइड सिर्फ υ4-बाइट की बचत के लिए होगा।)

— नील
स्रोत
3

05AB1E (विरासत), 23 20 बाइट्स

[²³«εð9ÝΩ:}²gôJDO¹Q#

-3 बाइट्स @Emigna की बदौलत ।

अज्ञात अंक रिक्त स्थान हैं ( )। इनपुट ऑर्डर होना चाहिए: अपेक्षित परिणाम; सबसे लंबा तार; सबसे छोटा तार।

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

स्पष्टीकरण:

[                 # Start an infinite loop
 ²³«              #  Take the second and third inputs, and merge them together
               #   i.e. " 79" and " 4 " → " 79 4 "
    ε     }    #  Map each character to:
     ð   :     #   Replace a space with:
      9ÝΩ      #   A random digit in the range [0,9]
               #    i.e. " 79 4 " → ['3','7','9','2','4','3']
               #    i.e. " 79 4 " → ['5','7','9','7','4','4']
²g             #  Get the length of the second input
               #   i.e. " 79" → 3
  ô            #  And split it into two numbers again
               #   i.e. ['3','7','9','2','4','3'] and 3 → [['3','7','9'],['2','4','3']]
               #   i.e. ['5','7','9','7','4','4'] and 3 → [['5','7','9'],['7','4','4']]
   J           #  Join each list together to a single number
               #   i.e. [['3','7','9'],['2','4','3']] → [379,243]
               #   i.e. [['5','7','9'],['7','4','4']] → [579,744]
    D          #  Duplicate this list
     O         #  Sum the list
               #   i.e. [379,243] → 622
               #   i.e. [579,744] → 1323
      ¹Q#      #  If it's equal to the first input: stop the infinite loop
               #  (and output the duplicate list implicitly)
               #   i.e. 1323 and 622 → 0 (falsey) → continue the loop
               #   i.e. 1323 and 1323 → 1 (truthy) → stop the loop and output [579,744]
— केविन क्रूज़सेन
स्रोत
1
बदलें 3 बचाता है अगर पर।
— एमिगा
@Emigna आह, बिल्कुल। धन्यवाद!
— केविन क्रूज़सेन
3

पर्ल 6 , 81 74 बाइट्स

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

{first {try S/\=/==/.EVAL},map {$^a;S:g[\#]=$a[$++]},[X] ^10 xx.comb('#')}

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

अनाम कोड ब्लॉक जो एक स्ट्रिंग के रूप में एक अंकगणितीय अभिव्यक्ति युक्त इनपुट लेता है जैसे "12 # + 45 # = 579"। #अंकों के संभावित क्रमपरिवर्तन के साथ प्रत्येक को उपार्जित करें, के =साथ प्रतिस्थापित करता है ==और पहला वैध परिणाम पाता है।

स्पष्टीकरण:

{  # Anonymous code block                                                      }
 first   # Find the first of:
                                                               ^10  # The range of 0 to 9
                                                                   xx.comb('#') # Multiplied by the number #s in the code
                                                          ,[X]  # The cross-product of these lists
                          map   # Map each crossproduct to:
                              {$^a;.trans: "#"=>{$a[$++]}}  # The given string with each # translated to each element in the list
      {try S/\=/==/.EVAL}, # Find which of these is true when = are changed to == and it is eval'd
— मजाक कर रहा है
स्रोत
आप उपयोग कर सकते हैं S:g[\#]=$a[$++]के बजाय transके लिए 74 बाइट्स ।
— nwellnhof
@nwellnhof मुझे महसूस नहीं हुआ कि आप S///उस तरह के वाक्य रचना में उपयोग कर सकते हैं ! धन्यवाद!
— जो किंग
2

जावा 10, 203 198 193 बाइट्स

(a,b,c)->{int A=0,B=0,l=a.length();for(a+=b,b="";A+B!=c;A=c.valueOf(b.substring(0,l)),B=c.valueOf(b.substring(l)),b="")for(var t:a.getBytes())b+=t<36?(t*=Math.random())%10:t-48;return A+"+"+B;}

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

स्पष्टीकरण:

(a,b,c)->{           // Method with 2 Strings & integer parameters and String return-type
  int A=0,B=0,       //  Result-integers, starting both at 0
      l=a.length();  //  Length of the first String-input
  for(a+=b,          //  Concat the second String-input to the first
      b="";          //  Reuse `b`, and start it as an empty String
      A+B!=c         //  Loop as long as `A+B` isn't equal to the integer-input
      ;              //    After every iteration:
       A=c.valueOf(b.substring(0,l)),
                     //     Set `A` to the first String-part as integer
       B=c.valueOf(n.substring(l)),
                     //     Set `B` to the second String-part as integer
       b="")         //     Reset `b` to an empty String
    for(var t:a.getBytes())
                     //   Inner loop over the characters of the concatted String inputs
      b+=t<36?       //    If the current character is a '#':
          (t*=Math.random())%10
                     //     Append a random digit to `b`
         :           //    Else (it already is a digit):
          t-48;      //     Append this digit to `b`
  return A+"+"+B;}   //  After the loop, return `A` and `B` as result
— केविन क्रूज़सेन
स्रोत
2

सी (जीसीसी) , 228 213 203 172 170 बाइट्स

-15 बाइट्स @ceilingcat की बदौलत । मैंने पहले कभी इस्तेमाल नहीं किया index।

-10 बाइट्स @Logem की बदौलत । प्रीप्रोसेसर जादू

exit(0)पैरामीटर के रूप में पुट के साथ रिफैक्टेड कॉल ।

char*c,*p[9],k;main(i,v)int**v;{for(i=X[1],35))||X[2],35))?p[k++]=c,main(*c=57,v):k;!c*i--;)47==--*p[i]?*p[i]=57:Y[1])+Y[2])^Y[3])?main(i,v):exit(puts(v[2],puts(v[1])));}

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

— cleblanc
स्रोत
— 13
आप मेरी अंतिम टिप्पणी में मैक्रो की जगह दो बाइट्स बचा सकते हैं , TIO लिंक के -DX=c=index(vसाथ -DX=(c=index(v।
— लॉग
धन्यवाद दोस्तों। ऐसा नहीं लगता है कि मैंने पहले भी इसे गोल्फ की कोशिश की थी ...
— क्लैब्लांक
1

C # .NET, 225 220 196 बाइट्स

(a,b,c)=>{int A=0,B=0,l=a.Length;for(a+=b,b="";A+B!=c;A=int.Parse(b.Substring(0,l)),B=int.Parse(b.Substring(l)),b="")foreach(var t in a)b+=(t<36?new System.Random().Next(10):t-48)+"";return(A,B);}

मेरे जावा 10 उत्तर का पोर्ट ।
(मैं सी # .NET गोल्फिंग में बहुत जंग लगा रहा हूं, इसलिए रक्षात्मक रूप से गोल्फ हो सकता है ..)

-3 बाइट्स स्पष्ट रूप से @ user82593 और इस नए C # टिप के लिए धन्यवाद ।
-29 बाइट्स @ धन्यवाद का धन्यवाद ।

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

स्पष्टीकरण:

(a,b,c)=>{        // Method with 2 string & int parameters and int-tuple return-type
  int A=0,B=0,    //  Result-integers, starting both at 0
      l=a.Length; //  Length of the first string-input
  for(a+=b,       //  Concat the second string-input to the first
      b="";       //  Reuse `b`, and start it as an empty string
      A+B!=c      //  Loop as long as `A+B` isn't equal to the integer-input
      ;           //    After every iteration:
       A=int.Parse(b.Substring(0,l)),
                  //     Set `A` to the first string-part as integer
       B=int.Parse(b.Substring(l)),
                  //     Set `B` to the second string-part as integer
       b="")      //     Reset `b` to an empty string
    foreach(var t in a)
                  //   Inner loop over the characters of the concatted string inputs
      b+=(t<36?   //    If the current character is a '#':
           new System.Random().Next(10)
                  //     Use a random digit
          :       //    Else (it already is a digit):
           t-48)  //     Use this digit as is
         +"";     //    And convert it to a string so it can be appended to the string
  return(A,B);}   //  After the loop, return `A` and `B` in a tuple as result
— केविन क्रूज़सेन
स्रोत
आप using System;इसके बजाय नियमित उपयोग कर सकते हैं , यह इससे छोटा है namespace System{}।
— hvd
@hvd यही था! .. मैंने वर्षों में C # नहीं किया है, lol .. मैंने using System.*;जावा में आयात के समान कोशिश की , लेकिन यह काम नहीं किया। भूल गए कि मुझे .*भाग निकालना था .. -5 बाइट्स के लिए धन्यवाद।
— केविन क्रूज़सेन
1
अब इसे फिर से पढ़ना, यह वास्तव में एक उप-इष्टतम सुझाव था। एक और 10 बाइट्स को बचाने के लिए आप int.Parse(-4), new System.Random()(+7) और ड्रॉप using System;(-13) लिख सकते हैं । :) इसके अलावा, आप की जरूरत नहीं है .ToCharArray(), कि 14 से अधिक बाइट्स लेता है।
— hvd
@hvd धन्यवाद! सुनिश्चित नहीं हैं कि मैं के बारे में भूल int.Parseबनाम System.Int32.Parse... यह मूल रूप से की तरह ही है System.Stringऔर string.. और पता था कि नहीं था इसके बिना वर्णों से अधिक पाश करने के लिए संभव हो गया था .ToCharArray()। अन्य -24 बाइट्स के लिए धन्यवाद। : D
— केविन क्रूज़सेन
1

पायथन 3 , 121 155 152 149 बाइट्स

import re
def f(i,k=0,S=re.sub):s=S('#','%s',i)%(*list('%0*d'%(i.count('#'),k)),);print(s)if eval(S('=','==',S('\\b0*([1-9])','\\1',s)))else f(i,k+1)

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

+34 रेगेक्स के साथ नया समाधान इस तथ्य को दरकिनार करने के लिए कि अजगर अग्रणी शून्य के साथ संख्याओं का समर्थन नहीं करता है।

-3 @ जोनाथन फ्रीच को धन्यवाद

पुराना समाधान काम नहीं करता है अगर # किसी भी संख्या में पहला चरित्र है (क्योंकि eval अग्रणी शून्य स्वीकार नहीं करता है) और इसलिए अमान्य है :(

def f(i,k=0):
 s=i.replace('#','%s')%(*list('%0*d'%(i.count('#'),k)),)
 print(s)if eval(s.replace('=','=='))else f(i,k+1)

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

— काला उल्लू काई
स्रोत
1
मुझे डर है कि यह सबमिशन पोस्ट में बताए गए कारण के लिए अमान्य है।
— १०:१० बजे आउटगोल्फर
2
चूंकि आपके फ़ंक्शन में कोई कंपाउंड स्टेटमेंट नहीं है, इसलिए आप इसे केवल एक लाइन तक ही सीमित कर सकते हैं।
— जोनाथन फ्रेच
0

PHP, 112 बाइट्स

लंगड़ा जानवर बल समाधान

for(;$s=$argn;eval(strtr($s,['='=>'==','#'=>0]).'&&die($s);'))for($k=$n++;$k;$k=$k/10|0)$s[strpos($s,35)]=$k%10;

इनपुट के रूप में स्ट्रिंग लेता है, पहले समाधान पर रोकता है। ऑनलाइन के साथ पाइप के रूप में चलाएं -nRया इसे आज़माएं ।

— टाइटस
स्रोत
0

पॉवरशेल, 91 बाइट

स्क्रिप्ट में सभी समाधान मिलते हैं। पुनरावृत्तियों की कुल संख्या 10 शक्ति वर्णों की संख्या है #। पुनरावृत्ति की गहराई वर्णों की संख्या के बराबर है #।

filter f{$h,$t=$_-split'#',2
if($t){0..9|%{"$h$_$t"}|f}elseif($h-replace'=','-eq'|iex){$h}}

टेस्ट स्क्रिप्ट:

filter f{$h,$t=$_-split'#',2
if($t){0..9|%{"$h$_$t"}|f}elseif($h-replace'=','-eq'|iex){$h}}

@(
    ,('1#3+45#=579','123+456=579')
    ,('#79+44#=1323','879+444=1323')
    ,('5#5+3#3=898','505+393=898 515+383=898 525+373=898 535+363=898 545+353=898 555+343=898 565+333=898 575+323=898 585+313=898 595+303=898')
    ,('#+#=2','0+2=2 1+1=2 2+0=2')
    ,('9+#6=55','9+46=55')
    ,('123+##=124','123+01=124')
    ,('#123651+#98#=1131632','1123651+7981=1131632')
    ,('##+##=2','00+02=2 01+01=2 02+00=2')
    ,('##+##=99','00+99=99 01+98=99 02+97=99 03+96=99 04+95=99 05+94=99 06+93=99 07+92=99 08+91=99 09+90=99 10+89=99 11+88=99 12+87=99 13+86=99 14+85=99 15+84=99 16+83=99 17+82=99 18+81=99 19+80=99 20+79=99 21+78=99 22+77=99 23+76=99 24+75=99 25+74=99 26+73=99 27+72=99 28+71=99 29+70=99 30+69=99 31+68=99 32+67=99 33+66=99 34+65=99 35+64=99 36+63=99 37+62=99 38+61=99 39+60=99 40+59=99 41+58=99 42+57=99 43+56=99 44+55=99 45+54=99 46+53=99 47+52=99 48+51=99 49+50=99 50+49=99 51+48=99 52+47=99 53+46=99 54+45=99 55+44=99 56+43=99 57+42=99 58+41=99 59+40=99 60+39=99 61+38=99 62+37=99 63+36=99 64+35=99 65+34=99 66+33=99 67+32=99 68+31=99 69+30=99 70+29=99 71+28=99 72+27=99 73+26=99 74+25=99 75+24=99 76+23=99 77+22=99 78+21=99 79+20=99 80+19=99 81+18=99 82+17=99 83+16=99 84+15=99 85+14=99 86+13=99 87+12=99 88+11=99 89+10=99 90+09=99 91+08=99 92+07=99 93+06=99 94+05=99 95+04=99 96+03=99 97+02=99 98+01=99 99+00=99')
) | % {
    $s,$e = $_
    $r = $s|f
    "$($e-eq$r): $r"
}

पॉवर्सशैल, 'मान लें शब्द> 0' अनिवार्य है, 110 बाइट्स

filter f{$h,$t=$_-split'#',2
if($t){0..9|%{"$h$_$t"}|f}else{$a,$b,$c=$_-split'\D'
$_|?{+$a*+$b*!(+$a+$b-$c)}}}
— Mazzy
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.