उन्हें 10,000 रु

Question

हम हाल ही में PPCG पर 10,000 सवालों की दहलीज पर पहुंचे हैं। हुर्रे! चलो इसे एक सरल चुनौती के साथ मनाते हैं।

इनपुट

दो पूर्णांक $A$ और $B$ , दोनों $[1..9999]$ , जैसे कि $A+B<10000$ ।

कार्य

आपका कार्य इन पूर्णांकों में से एक में एक एकल अंक या उन दोनों में एक एकल अंक जोड़ना है जैसे कि $A+B=10000$ । यदि $A$ और $B$ दोनों के लिए एक अंक जोड़ते हैं , तो जरूरी नहीं कि एक ही अंक हो।

नया अंक शुरुआत में, अंत में या मूल पूर्णांक के बीच में कहीं भी जोड़ा जा सकता है। हालाँकि, आप एक अग्रणी शून्य नहीं जोड़ सकते।

उदाहरण:

के लिए $A=923$ , निम्नलिखित परिवर्तन मान्य हैं:

$$\color{red}1923\\92\color{red}73\\923\color{red}8$$

लेकिन ये अमान्य हैं :

$$\color{red}{0}923\\\color{red}{10}923\\9\color{red}{4}2\color{red}{7}3$$

$A=923$ और $B=72$ को देखते हुए , दो संभावित समाधान हैं:

$$923\color{red}8 + 7\color{red}62 = 10000\\92\color{red}73 + 72\color{red}7 = 10000$$

उत्पादन

आपको सभी संभावित समाधानों की सूची को प्रिंट या आउटपुट करना होगा।

उपरोक्त उदाहरण के लिए, अपेक्षित आउटपुट होगा [[9238,762],[9273,727]]।

नियम

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

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

Input    --> Output

934, 654 --> [[9346,654]]

737, 628 --> [[7372,2628]]

9122, 88 --> [[9122,878]]

923, 72  --> [[9238,762],[9273,727]]

998, 3   --> [[9968,32],[9987,13]]

900, 10  --> [[9900,100],[9090,910]]    NB: solutions such as [9000,1000] are NOT valid
                                            (more than one digit added to 10)

363, 632 --> [[3673,6327],[3638,6362]]

288, 711 --> [[2881,7119],[2882,7118],[2883,7117],[2884,7116],[2885,7115],[2886,7114],
              [2887,7113],[2888,7112],[2889,7111]]

365, 635 --> [[365,9635],[1365,8635],[2365,7635],[3365,6635],[4365,5635],[5365,4635],
              [6365,3635],[7365,2635],[8365,1635],[9365,635],[3065,6935],[3165,6835],
              [3265,6735],[3465,6535],[3565,6435],[3665,6335],[3765,6235],[3865,6135],
              [3965,6035],[3605,6395],[3615,6385],[3625,6375],[3635,6365],[3645,6355],
              [3655,6345],[3675,6325],[3685,6315],[3695,6305],[3650,6350]]

Comments

यह आसान चुनौती नहीं है अगर मैं इसे टाइप नहीं कर सकता हूं और आश्वस्त हूं कि यह मेरी कार में काम करता है। ; पी

— क्विंट

@ क्विंट मैं आपको अपनी कार में रहने के दौरान कुछ भी टाइप करने की सलाह दूंगा । : पी

— अरनुल्द

@Arnauld उन्होंने कहा कि वह ड्राइवर नहीं है। ;-) (सीरियस नोट: 4 ऑफ टॉपिक

— कॉमेंट्स

जब जेली समाधान 20 से अधिक बाइट लेते हैं तो यह एक कठिन चुनौती है!

— Regis Portalez

output a list of all possible solutionsओह बमर। यह मेरी रूनिक भाषा के लिए मुश्किल होगा। मैं शायद एक कार्यक्रम लिख सकता हूं जो एक समाधान का उत्पादन कर सकता है !

— ड्रेको

Answer 1

हास्केल , 99 97 82 81 बाइट्स

^{-16 बाइट्स Delfad0r के लिए धन्यवाद (एक सूची के रूप में इनपुट्स लेते हुए, गाली देते हुए कि हमें कटौती करने की आवश्यकता नहीं है -> n हमेशा [0,4] में हो सकता है और इनपुट-प्रारूप के एक चतुर संयोजन का उपयोग करके ap) और !}

filter((==1e4).sum).mapM([read.(take n<>(c:).drop n)|c<-['0'..'9'],n<-[0..4]]<*>)

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

Comments

वास्तव में मैं थोड़ा मूर्खतापूर्ण महसूस कर रहा हूं: अजीब इनपुट स्वरूपों या हाल ही में जीएचसी संस्करणों के बिना 81 बाइट्स ...

— डेल्फ़्रेड0

Answer 2

आर , 96 बाइट्स

function(a,b)(w<-grep(gsub("",".?",a?b),1:1e4?9999:0)?r<-1e4-w)[w+a<2&r+b<2]
"?"=paste
"+"=adist

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

स्पष्टीकरण (अपुष्ट)

function(a,b){
    # Regex inserting ".*": (998,3) => ".?9.?9.?8.? .?3.?"
  regex <- gsub("",".?",paste(a,b)) 
    # Positions matching in the whole vector of strings that add to 10K ("1 9999", "2 9998", "3 9997", "4 9996", ...)
  w <- grep(regex,paste(1:1e4,9999:0)) 
    # 10K minus these matching positions
  r <- 1e4-w 
    # Form position-string vector of ('pos1 10K-pos1', 'pos2 10K-pos2', ...)
  paste(w,r)[
  # Filter only those positions where the edit distance between the matched numbers and the originals are less than 2
    adist(w,a)<2 & adist(r,b)<2 
  ]
}

हम असाइन ?करते हैं paste। यह हमें कुछ अच्छा करने देता है: कॉल के a<-b?c<-dभीतर इनलाइन असाइनमेंट करता है paste, जिसे हम किसी भी अन्य ऑपरेटर के साथ नहीं कर सकते हैं ?, क्योंकि इसकी तुलना में कम पूर्वता है <-।

अब जैसा कि @JoKing ने कहा है, ऐसे मामले हो सकते हैं जैसे 900 10दो सम्मिलन हो सकते हैं जैसे कि 9100 8100। इसलिए हम मैचों को फ़िल्टर करते हैं जहाँ या तो संख्या में वर्णों की संख्या 1 से अधिक हो गई है। ऐसा करने का त्वरित तरीका लेवेंसहाइट संपादित दूरी के साथ है adist जिसे हम बांधते हैं +।

Comments

जाँच के लिए धन्यवाद! मैं अब उन मैचों को फ़िल्टर करता हूं जहां प्रति नंबर एक से अधिक सम्मिलन हैं।

— जे। सेप

Answer 3

पायथ, 28 27 25 24 22 20 बाइट्स

fq^;4sT*FmvsmXLkdThl

इसे यहां ऑनलाइन आज़माएं , या यहां सभी परीक्षण मामलों को सत्यापित करें - परीक्षण सूट एक प्री प्रीपेड करके परिणाम को काटता है {।

इनपुट स्ट्रिंग्स की एक सूची के रूप में है।

fq^;4sT*FmvsmXLkdThldQ   Implicit: Q=eval(input()), T=10
                         Trailing d, Q inferred
         m           Q   Map each input string, as d, using:
                   ld      Take the length of d
            m     h        Map 0 to the above (inclusive), as k, using:
             X  d            Insert into d...
               k             ... at position k...
              L  T           ... each number [0-9]
           s               Flatten the result
          v                Convert each back to an integer
       *F                Take the cartesian product of the result
                         (this generates all possible pairs of mutated numbers)
f                        Keep the pairs, as T, where...
     sT                  ... the sum of the pair...
 q                       ... is equal to...
  ^;4                    ... 10,000 (; == 10 here, so this is 10^4)

संपादित करें 4: एक और 2 बाइट्स को सहेजा, श्री Xcoder के लिए धन्यवाद - vडिफ़ॉल्ट रूप से वेक्टराइज Lकरता mहै, और नीचे का उपयोग करता है, इसलिए रेंज पर मैपिंग को निहित किया जाता है, जो कि Uअनावश्यक को भी बनाता है।

3 संपादित करें: ;2 बाइट्स को बचाने के लिए 10 तक पहुंच बनाए रखने के लिए ऑपरेटर के वैश्विक उपयोग का परिचय , FryAmTheEggman और issacg के लिए धन्यवाद:

fq^T4sT*FmvMsmXLkdUThl

संपादित करें 2: मैं भूल गया कि संचालक मौजूद है, कितना शर्मनाक है ...

संपादित 1: पिछले संस्करण ने इनपुट के रूप में पूर्णांकों की एक सूची को स्वीकार किया, 27 बाइट्स के लिए मैन्युअल रूप से स्ट्रिंग रूपांतरण का प्रदर्शन किया:

fq10000+FT*FmvMsmXLk`dUThl`

Comments

@KevinCruijssen यह वास्तव में करता है, 10 आम तौर पर होता है T, लेकिन फ़ंक्शन ब्लॉक में चर को पुन: purposed किया जाता है बजाय इसके पुनरावृत्ति चर के रूप में - फ़िल्टर ब्लॉक में पुनरावृत्ति चर बस ऐसा होता है T, इसलिए इसका उपयोग नहीं किया जा सकता है। इसका मतलब है कि 10 ^ 4होगा ^10 4, जो 5 बाइट्स लंबा है, इसलिए दुर्भाग्य से कोई छोटा नहीं

— सोक

@ सो आह। तो रेंज के लिए अभी भी 10 Tमें UTहै [0,10)। लेकिन कम से फिल्टर के लिए एक यात्रा चर बन गया है। स्पष्टीकरण के लिए धन्यवाद, जो समझ में आता है! और पहले कर रहा है , इसे एक चर में सहेज रहा है, और फ़िल्टर में उस चर का उपयोग कर रहा है (कम से कम) 5 बाइट्स के रूप में अच्छी तरह से। f...TTT4^

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

आप बदल सकते हैं 10000के साथ ^;4।

— FryAmTheEggman

;हमेशा वैश्विक संदर्भ में पुनरावृत्ति चर का मान होता है, इस मामले में 10. इसलिए ^;4आप जो खोज रहे हैं।

— isaacg

20 बाइट्स: fq^;4sT*FmvsmXLkdThl। ( पायल की पिटाई जैली? ऊ

— हुरे

Answer 4

पर्ल 6 , 64 बाइट्स

->\a{grep {all (a Z~$_)X~~/^(.*)(.*)$0.?$1$/},(^1e4 Z(1e4...1))}

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

यह जीबी के उत्तर का एक पोर्ट है, जो यह जांचने के लिए कि क्या वैध हैं, एक रेग्क्स का उपयोग कर रहा है। इसे पोर्ट करने के लिए nwellnhof का धन्यवाद ।

पुराना जवाब, 127 110 , 88 बाइट्स

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

->\a{grep {all ~<<a Z∈.map:{.comb.combinations(.comb-1..*)>>.join}},(^1e4 Z(1e4...1))}

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

बेनामी कोड ब्लॉक जो दो नंबरों की सूची में लेता है और संख्याओं के जोड़े की सूची देता है।

अंकों को सम्मिलित करने के बारे में फिडेल के बजाय, यह समाधान संख्याओं के प्रत्येक संयोजन की जांच करता है जो 10000 तक की राशि और फ़िल्टर करता है कि दिए गए संख्याएं जोड़ी का हिस्सा हैं।

स्पष्टीकरण:

->\a{  # Anonymous code block that takes an argument a
     grep ... ,(^1e4 Z(1e4...1))    # Filter from all pairs that add to 10000
         {      ~<<a     # Stringify the contents of a
                     .map:{      # Map the pair to
                           .comb  # The digits of the number
                           .combinations(.comb-1..*)  # The combinations of the digits
                           >>.join  # Each combination joined
                           # Note that combinations preserve order
                           # "123" -> (12,13,123)
                          }
          all       Z∈   # Zip that each element of a is an element of the combination
         }
}

Comments

बस जिज्ञासु: क्या आप इस तथ्य का उपयोग नहीं कर सकते हैं कि जोड़े को (i,1e4-i)हर पर चलने (i,j)और उन्हें छानने के बजाय लिखा जा सकता है ?

— एरिक डुमिनील

Answer 5

आर , 179 161 150 144 बाइट्स

function(a,b,w=g(a),r=rep(g(b),e=1e4))paste(w,r)[w+r==1e4]
g=function(x,n=sum(x|1)){for(i in 0:n)for(j in 0:9)F=c(F,append(x,j,i)%*%10^(n:0));F}

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

@JayCe और @Giuseppe द्वारा सहेजे गए 35 बाइट्स।

व्याख्या

हेल्पर फंक्शन जी को सभी संभव सम्मिलन मिलते हैं।

g <- function(x,            # Input vector of digits
              n=sum(x|1)    # Length of x
              ) {
  for(i in 0:n)             # i is the insertion point
    for(j in 0:9)           # j is a digit from 0 to 9
      # Dot product of vector of digits with insert and 10^(n:0) performs the
      # conversion to integer (and gets rid of the leading 0s)
      F=c(F,append(x,j,i)%*%10^(n:0))  # F is a non-reserved built-in alias to FALSE (numerically 0)
  F
}

मुख्य कार्य।

f <- 
function(a,                 # Input vectors of digits
         b,
         w=g(a),            # Get all possible insertions for a
         r=rep(g(b),e=1e4)  # Insertions for b replicated 1e4 times each
         )
  paste(w,r)[w+r==1e4]      # paste and w+r recycle w to match length of r
                            # Lots of duplication!

मैंने इस तथ्य के बाद देखा है कि यह अनिवार्य रूप से पाइथ उत्तर के समान तर्क है ।

Comments

स्ट्रिंग आउटपुट का उपयोग करने से 10 बाइट

— बचती हैं

@JayCe 10 से अधिक बाइट बचाता है! Deduplication को चुनौती कोड के बाहर जगह लेने की अनुमति है।

— एनजीएम

-11 बाइट्स का उपयोग करना Fऔर%*%

— Giuseppe

चलो कुछ और बाइट्स को मारते हैं - बाहरी की आवश्यकता नहीं है, प्रतिनिधि पर्याप्त है

— जेसीई

मुझे लगता है कि हम इस एक में कांटा चुभने के करीब हैं!

— एनजीएम

Answer 6

रूबी , 93 91 बाइट्स

->a,b{(1..r=10000).map{|x|/^(.*)(.*:)\1.?\2(.*)(.*):\3.?\4$/=~[a,x,b,y=r-x]*?:&&[x,y]}-[p]}

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

10000 तक हर एक संख्या का प्रयास करें, और यदि संख्या से मेल खाता है, तो यह जांचने के लिए regex का उपयोग करें।

Answer 7

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

DµJṬ€k€jþ9Ż¤;9R¤;€$ḌF)ŒpS=ȷ4ƊƇ

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

अनाड़ी की तरह क्योंकि जेली कोई सम्मिलन नहीं है।

व्याख्या

                                   Given [a, b].
Dµ                   )             Get [digits(a), digits(b)] then map:
  JṬ€k€jþ9Ż¤;9R¤;€$ḌF                Generate all the insertions.
                      Œp           Cartesian product: get all pairs.
                        S=ȷ4ƊƇ     Filter for: sum equal to ȷ4 (10000).

                       Given e.g. [6,3,5]:
J                      Get [1,2,3].
 Ṭ€                    Get [[1], [0,1], [0,0,1]].
   k€                  Split input with these: gets us
                         [[6],[3,5]] , [[6,3],[5]] , [[6,3,5],[]]
     jþ9Ż¤             Join table-wise with [0..9]
                         → [[[6,0,3,5], [6,3,0,5], [6,3,5,0]],
                            [[6,1,3,5], [6,3,1,6], [6,3,5,1]], …]
          ;9R¤;€$      Append the prefixings of the input by [1..9].
                           [[1,6,3,5], [2,6,3,5], [3,6,3,5]]…
                 ḌF    Undigits all, and flatten.

Answer 8

PHP, 162 159 बाइट्स

एक जनरेटर समारोह के लिए सुंदर उदाहरण!

function f($n){for($n+=.1;$n>=1;$n/=10)for($d=-1;$d++<9;)yield strtr($n,".",$d)/10|0;}foreach(f($argv[1])as$x)foreach(f($argv[2])as$y)$x+$y-1e4||print"$x+$y\n";

कमांड लाइन तर्कों से इनपुट लेता है; प्रिंट डुप्लिकेट। इसे ऑनलाइन चलाएं -nr '<code>या इसके लिए प्रयास करें ।

Answer 9

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

fqsT^;4*FsMvXLRRTT

प्रदर्शन , परीक्षण सूट (टेस्ट सूट अग्रणी के साथ काट दिया गया है {)।

इनपुट दो तारों की सूची के रूप में है।

XLRRTT: एल और आर नेस्टेड मैप्स परफॉर्म करते हैं। चूंकि उनमें से 3 हैं, हम Xफ़ंक्शन का एक ट्राइस्टली नेस्टेड मैप प्रदर्शन करेंगे । इस स्थिति में, Xफ़ंक्शन एक स्ट्रिंग में एक निर्दिष्ट स्थान पर एक चरित्र सम्मिलित करेगा।

स्ट्रिंग एक इनपुट है, जिसे पहले से अंतर्निहित और रखा गया है R। चरित्र खत्म हो गया है 0 ... 9, इसलिए हमारे पास सभी संभव सम्मिलित अंक हैं, और इसके द्वारा रखा गया है L। सीमा द्वारा दी गई है T, जिसे अंतर्निहित रूप से सेट किया गया है 10, जिसे अंतर्निहित रूप से माना जाता है [0 ... 9]। स्थिति सीमा से अधिक है 0 ... 9, जो पर्याप्त है, क्योंकि 10 वीं स्थिति के बाद एक संख्या सम्मिलित करना कभी उपयोगी नहीं होगा। डुप्लिकेट परिणाम ठीक हैं। सीमा दूसरे द्वारा रखी गई है R, और दूसरी द्वारा दी गई है T।

v: घोंसले में घोंसले के तार काटे।

sM: सूचियों के दूसरे स्तर को समतल करें, हमें प्रत्येक इनपुट संख्याओं के लिए अंकों के सम्मिलन के बाद सभी संभावित नंबरों की सूची के साथ छोड़ दें।

*F: संभावित संख्याओं की दो सूचियों का कार्टेशियन उत्पाद लें।

fqsT^;4: उन जोड़ों पर फ़िल्टर करें जिनके उत्पाद हैं 10000। यहाँ ;का मान लेता 10है, जैसा Tकि फ़िल्टर चर के रूप में उपयोग में है, और ;हमेशा चर के मूल्य के रूप में जो उपयोग में है।

Answer 10

जाप , 30 29 25 23 बाइट्स

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

£L²ôs f_à øX
rï k@L²aXx

कोशिश करो

---

व्याख्या

£L²ôs f_à øX
£                :Map each X
 L               :  100
  ²              :  Squared
   ô             :  Range [0,L²]
    s            :  Convert each to a string
      f_         :  Remove elements that return false
        à        :    All combinations of current element
          øX     :    Contains X?
rï k@L²aXx
r                :Reduce by
 ï               : Cartesian product
   k@            :Remove each X that returns true (not 0)
     L²          :  100 squared
      a          :  Absolute difference with
        Xx       :   X reduced by addition

Answer 11

जावास्क्रिप्ट (नोड) - 183 136 123 बाइट्स

123 बाइट्स झबरा के लिए धन्यवाद

a=>b=>(o={},g=(s,h)=>[...s+0].map((y,x)=>{for(y=10;y--;)h(s.slice(0,x)+y+s.slice(x))}))(a,x=>g(b,y=>1e4-x-y?0:o[+x]=+y))&&o

136 बाइट्स अरनौलड को धन्यवाद

e=(h,c,i=h.length+1,j)=>{for(;i--;)for(j=10;j--;)c(h.slice(0,i)+j+h.slice(i))}
f=(a,b,c=[])=>e(a,n=>e(b,m=>1E4-n-m||c.push([+n,+m])))||c

पुराना कोड

इस पर गर्व नहीं है, लेकिन मुझे लगा कि मैं वैसे भी जमा करूंगा। एक स्ट्रिंग प्रोटोटाइप फ़ंक्शन बनाता है जो मैप करता है जो बाइट्स के थोक लेता है। फ़ंक्शन केवल दोनों क्रमपरिवर्तन के माध्यम से पुनरावृत्त करता है, और पाता है जब 1000-एबी 0. स्ट्रिंग्स के रूप में इनपुट लेता है।

String.prototype.e=function(c){let h=this,L=h.length,i,j;for(i=0;i<=L;i++)for(j=0;j<=9;j++)c(h.slice(0,i)+j+h.slice(i,L));}
f=(a,b,c=[])=>a.e(n=>b.e(m=>1E4-n-m?c:c.push([+n,+m])))?c:c

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

Ungolfed

String.prototype.e=function(c) {
  let h=this,L=h.length,i,j;
  for(i=0;i<=L;i++)
    for(j=0;j<=9;j++)
      c(h.slice(0,i)+j+h.slice(i,L));
}
f=(a, b, c=[]) =>
  a.e(n =>
    b.e(m =>
      1E4-n-m ? c : c.push([+n,+m])
    )
  ) ? c : c

Comments

यहां कुछ त्वरित जीत हैं । यह मूल रूप से ( 'गोल्फ अमित्र के बयानों के बिना एक ही कोड है String.prototype, function, let, this) और कुछ अन्य अनुकूलन के साथ।

— अरनुलद

वहाँ से, आप को बचा सकता है 4 अधिक बाइट्स एक का उपयोग करके map()बाहरी के बजाय forपाश। NB: एकमात्र कारण है कि हम jकॉलबैक फ़ंक्शन के 1 पैरामीटर के रूप में उपयोग करते हैं, इसलिए हम इसे इस दायरे में परिभाषित करना चाहते हैं।

— अरनुलद

@ अर्नुलद धन्यवाद मैं वास्तव में इसकी सराहना करता हूं, आप एक किंवदंती आदमी हैं। अपना उत्तर पोस्ट करें, मैं आपका नहीं लेना चाहता, मैं सिर्फ मनोरंजन के लिए कर रहा हूं।

— सोपल

मैं अपनी चुनौती का जवाब नहीं देने वाला हूं और यह कोड सिर्फ आपका एक संशोधन है, इसलिए इसे बेझिझक इस्तेमाल करें। कोई चिंता नहीं!

— अरनुलद

नॉट आउट @ अरनॉल्ड के सुझाव 123 बाइट्स तक

— झबरा

Answer 12

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

œcL’$$€ċ"⁹o⁼"Ạ
ȷ4ḶṚĖDçƇ

अंकों की सूचियों की सूची को स्वीकार करने वाला एक विचित्र लिंक
(उदाहरण के लिए 923 और 72 इनपुट है [[9,2,3],[7,2]])

इसे ऑनलाइन आज़माएं! (पाद लेख इसे बनाता है इसलिए I / O दो पूर्णांकों की एक जोड़ी है और पूर्णांक के जोड़े की एक [स्वरूपित] सूची है]

या परीक्षण-सूट देखें ।

कैसे?

"संख्या" (अंकों की सूची) के सभी जोड़े की जाँच करता है, जो कि वैधता के लिए 10000 का योग है, जो उन "संख्याओं" से एन -1 अंक चुनने के सभी तरीकों को बनाकर क्रम बनाए रखता है; और जो वैध हैं (जहां वैधता भी परीक्षण के तहत "संख्या" मूल "संख्या" के बराबर होने की अनुमति देता है) रखता है।

œcL’$$€ċ"⁹o⁼"Ạ - Link 1, is piar valid?: pairToCheck, originalInputPair
      €        - for each list of digits in pairToCheck: e.g. [9,2,3]
     $         -   last two links as a monad:
    $          -     last two links as a monad:
  L            -       length                                 3
   ’           -       decremented                            2
œc             -     choices of that many items               [[9,2],[9,3],[2,3]]
         ⁹     - chain's right argument (originalInputPair)
        "      - zip with: (i.e. apply the following f(x,y) *respectively* across the results above and the originalInputPair)
       ċ       -   count occurrences
            "  - zip with (this time with an implicit right argument of originalInputPair)
           ⁼   -   equal (non-vectorising version)
          o    - locgical OR (vectorising version) i.e. we now have: [OR(isOneDigitLonger(item1),isEqual(item1)), OR(isOneDigitLonger(item2),isEqual(item2))]
             Ạ - all?

ȷ4ḶṚĖDçƇ - Main Link: list (pair) of lists of digits
ȷ4       - literal 10^4 -> 10000
  Ḷ      - lowered range -> [0,1,2,...,9998,9999]
   Ṛ     - reversed -> [9999,9998,...,2,1,0]
    Ė    - enumerate -> [[1,9999],[2,9998],...,[9998,2],[9999,1],[10000,0]] (N.B. last is redundant, but this does not matter)
     D   - to decimals -> [[[1],[9,9,9,9]],[[2],[9,9,9,8]],...,[[9,9,9,8],[2]],[[9,9,9,9],[1]],[[1,0,0,0,0],[0]]]
       Ƈ - filter keep those for which this is truthy:
      ç  -   call last link as a dyad (with a right argument of the pair of lists of digits)

Answer 13

स्टैक्स , 24 बाइट्स

⌐çΘ♠╖øû°-h∟ñµ%üw▲∞Ç╫[½π=

इसे चलाएं और डीबग करें

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

["934", "654"]

Answer 14

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

ΦＥ×χφＩ⟦ι⁻×χφι⟧⌊Ｅι№Ｅ⊕ＬλΦλ⁻ξρ§⟦θη⟧μ

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

   χ                                10
    φ                               1000
  ×                                 Multiply
 Ｅ                                  Map over implicit range
       ι    ι                       Current value
        ⁻×χφ                        Subtract from 10000
      ⟦      ⟧                      Pair of values
     Ｉ                              Cast to string
Φ                                   Filter
                ι                   Current pair
               Ｅ                    Map
                     λ              Current value
                    Ｌ               Length
                   ⊕                Increment
                  Ｅ                 Map over implicit range
                       λ            Current value
                      Φ             Filter over characters
                         ξ          Range value
                          ρ         Character index
                        ⁻           Subtract
                            ⟦θη⟧    Original inputs as a list
                                μ   Index of current value
                           §        Get input at that index
                 №                  Count matching values
              ⌊                     Minimum
                                    Implicitly print each pair double-spaced

यदि आप यह नहीं समझ पाए कि, यह उन सभी मानों के युग्मों से चलता है जो 10000 (तार के रूप में) जोड़ते हैं, तो यह गिनता है कि प्रत्येक इनपुट संबंधित मान से 1 वर्ण तक हटाने के परिणाम से कितनी बार मेल खाता है। यदि न्यूनतम गणना नॉनजरो है तो दोनों इनपुट मेल खाते हैं और यह एक संभावित समाधान है।

Answer 15

पायथन 3, 165 160 153 125 117 बाइट्स

• सहेजे गए 5 बाइट्स @JackBrounstein setको रिटर्न वैल्यू से हटाने के सुझाव के लिए धन्यवाद , क्योंकि आउटपुट में डुप्लिकेट हो सकते हैं।
• के range(len(s))साथ प्रतिस्थापित करके 7 सहेजा गया range(5)।
• itertoolsनेस्टेड सूची समझ (और एक स्थान को हटाने) के साथ बदलने के लिए @ एरिक डुमिनील के सुझाव के लिए 23 बाइट्स का धन्यवाद ।
• सहेजे गए 8 धन्यवाद @Jo King के सुझाव के साथ नेस्टेड लिस्ट कॉम्प्रिहेंशन को सिंगल लूप और मॉडुलस ऑपरेटर से बदलना है।

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

c=lambda s:[int(s[:i%5]+str(i//5)+s[i%5:])for i in range(50)]
lambda a,b:{(i,j)for i in c(a)for j in c(b)if i+j==1e4}

Comments

क्योंकि आउटपुट में डुप्लिकेट शामिल हो सकते हैं, आपको set-5 बाइट्स के लिए अंतिम पंक्ति में कॉल करने की आवश्यकता नहीं है ।

— जैक ब्रूनस्टीन

@JackBrounstein, धन्यवाद। मुझे नियमों का वह हिस्सा याद आ गया।

— user2699

@EricDuminil, धन्यवाद। मैं सेट की समझ के बारे में नहीं जानता था, यह एक साफ चाल है।

— user2699

117 बाइट्स

— जो किंग

@JoKing चतुर। इन सभी सुझावों के बाद समाधान मुश्किल से मिलता-जुलता है जो मैंने शुरू किया था।

— user2699

Answer 16

रूबी , 110 बाइट्स

इनपुट के रूप में स्ट्रिंग्स को स्वीकार करता है, पूर्णांकों की एक सरणी देता है।

अजगर संस्करण पर आधारित है । किसी दिए गए पूर्णांक के लिए, Cसंख्याओं की एक सरणी बनाता है जिसे एक अंक जोड़कर बनाया जा सकता है।

लैंबडा हर संभावित जोड़ी से अधिक पुनरावृत्त करता है और उसी का चयन करता है जिसका योग 10000 है।

C=->n{(0..49).map{|i|([n[0...i%5],i/5,n[i%5..-1]]*'').to_i}}
->(a,b){C[a].product(C[b]).select{|i,j|i+j==1e4}}

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

Answer 17

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

0ìε.œʒg3‹}εU9ÝεXDgiìësý}}}˜}`âʒOT4mQ

एक शक के बिना काफी हद तक गोल्फ हो सकता है .. खासकर अंकों को सम्मिलित करना, जिसमें एक अग्रणी / अनुगामी भी शामिल है।

इसे ऑनलाइन आज़माएं या सभी परीक्षण मामलों को सत्यापित करें ( êपाद लेख में विशिष्ट और क्रमबद्ध करें)।

स्पष्टीकरण:

0ì                            # Prepend a 0 before each of the input numbers
  ε                        }  # Map each to:
   .œ                         #  Take all possible partitions
     ʒg3‹}                    #  Only keep those of length 1 or 2
          ε              }    #  Map each partition to:
           U                  #   Pop and store the partition in variable `X`
            9Ý                #   List in the range [0, 9]
              ε         }     #   Map each of those digits to:
               X              #    Get the variable `X`
                Dgi           #    If it's a single number (length == 1):
                   ì          #     Prepend `X` before this digit
                  ë           #    Else (length == 2):
                   sý         #     Join both numbers in `X` with the current digit
                  }           #    Close the if-else
                          ˜   #   Flatten the list of lists
`                             # Now push both lists to the stack
 â                            # Create all possible pairs (cartesian product)
  ʒ                           # Filter this list of pairs by:
   O                          #  Take the sum of the two numbers
    T4m                       #  Push 10000 (10^4)
       Q                      #  And check if they are equal

Answer 18

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

LŻœṖ€z⁶ZjþØDVẎṢḊ)p/S⁼ȷ4ƊƇ

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

यहां सबसे छोटा जेली समाधान नहीं है, लेकिन शायद कोई इसे गोल्फ कर सकता है? मैं स्तब्ध हूं