আমরা সম্প্রতি পিপিসিজিতে ১০,০০০ প্রশ্নের দোরগোড়ায় পৌঁছেছি। হুররে! আসুন এটি একটি সাধারণ চ্যালেঞ্জের সাথে উদযাপন করি।

ইনপুট

দুটি পূর্ণসংখ্যার $A$ এবং $B$ , উভয় $[1..9999]$ , এই ধরনের যে $A+B<10000$ ।

কার্য

আপনার কাজটি হ'ল এই সংখ্যার একটিতে একটি একক সংখ্যা বা এগুলির উভয়টির জন্য একটি একক অঙ্ক যুক্ত করুন যেমন $A+B=10000$ । যদি $A$ এবং $B$ উভয় ক্ষেত্রে একটি সংখ্যার যোগ করা হয় তবে অগত্যা এটি একই অঙ্ক হওয়ার দরকার নেই।

নতুন সংখ্যার শুরুতে বা শেষ সংখ্যার মাঝখানে যে কোনও জায়গায় যুক্ত করা যেতে পারে। তবে আপনি একটি শীর্ষস্থানীয় শূন্য যোগ করতে পারবেন না।

উদাহরণ:

জন্য $A=923$ , নিম্নলিখিত রূপান্তরের বৈধ আছেন:

1923 9273 9238

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

তবে এগুলি অবৈধ :

0923 10923 94273

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

প্রদত্ত $A=923$ এবং $B=72$ , দুই সম্ভাব্য সমাধান হল:

9238 + 762 = 10000 9273 + 727 = 10000

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

আউটপুট

আপনাকে অবশ্যই সমস্ত সম্ভাব্য সমাধানগুলির একটি তালিকা মুদ্রণ বা আউটপুট করতে হবে।

উপরের উদাহরণের জন্য, প্রত্যাশিত আউটপুট হবে [[9238,762],[9273,727]]।

বিধি

আই / ও কোনও যুক্তিসঙ্গত, দ্ব্যর্থহীন বিন্যাসে প্রক্রিয়া করা যায়। আপনি পূর্ণসংখ্যার পরিবর্তে স্ট্রিং, অঙ্কগুলির তালিকা ইত্যাদি ব্যবহার করতে পারেন।
ইনপুটটিতে কমপক্ষে একটি সমাধান থাকার গ্যারান্টিযুক্ত।
আপনাকে আউটপুটটি নকল করার অনুমতি দেওয়া হচ্ছে। তবে উদাহরণস্বরূপ , টিআইওর পাদচরণ বিভাগে পরীক্ষার কোডটি কোনও পোস্ট-প্রসেসিংয়ের সাথে এটি নকল করে দিলে তা প্রশংসিত হবে ।
এটি একটি কোড-গল্ফ চ্যালেঞ্জ।

পরীক্ষার মামলা

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

code-golf integer

— Arnauld
সূত্র

4

এটি কোনও সহজ চ্যালেঞ্জ নয় যদি আমি এটি টাইপ করতে না পারি এবং আত্মবিশ্বাসী হয়ে উঠি যে এটি আমার গাড়িতে থাকাকালীন কাজ করে। ; পি

— কুইন্টেক

16

@Quintec আমি টাইপিং বিরুদ্ধে বলতে চাই কিছু সময় আপনি আপনার গাড়ী আছেন। : পি

— আর্নল্ড

1

@ আরনাউল্ড তিনি বলেননি যে তিনি ড্রাইভার। ;-) (গুরুতর দ্রষ্টব্য: এখন পর্যন্ত ৪ টি অফ-টপিক মন্তব্য, এই উদ্দেশ্যে আমার 3-মন্তব্যের প্রতিবন্ধকতা উচ্চস্বরে

— শোনাচ্ছে

1

যখন জেলি দ্রবণগুলি 20 বাইটের বেশি নেয় তখন এটি একটি কঠিন চ্যালেঞ্জ!

— রেজিস পোর্টালেজ

output a list of all possible solutionsওহ বমর আমার রুনিক ভাষার পক্ষে এটি কঠিন হবে। আমি সম্ভবত একটি প্রোগ্রাম যা আউটপুট পারা লিখতে পারে একটি সমাধান!

— ড্রাকো 18

12

হাস্কেল , 99 97 82 81 বাইট

^{-16 বেল্টস ডেল্ফ্যাড0r এর জন্য ধন্যবাদ (ইনপুটগুলিকে একটি তালিকা হিসাবে গ্রহণ করে, অপব্যবহার করে যে আমাদের অনুলিপি করতে হবে না -> এন সর্বদা [0,4] এ থাকতে পারে এবং ইনপুট-বিন্যাসের একটি চৌকস সংমিশ্রণ ব্যবহার করে ap)!}

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

এটি অনলাইন চেষ্টা করুন!

— ბიმო
সূত্র

আসলে আমি কিছুটা বোকা অনুভব করছি: অদ্ভুত ইনপুট ফর্ম্যাট বা সাম্প্রতিক জিএইচসি সংস্করণ ছাড়াই 81 বাইট ...

— ডেল্ফ্যাড0

8

আর , 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কল, যা আমরা ছাড়া অন্য অপারেটর সঙ্গে যেত না ?, যেহেতু এটি হয়েছে কম প্রাধান্য চেয়ে <-।

এখন @ জোকিং দয়া করে উল্লেখ করেছেন যে, 900 10দুটি সন্নিবেশ যেমন হতে পারে সেখানে এমন ঘটনাও ঘটতে পারে 9100 8100। সুতরাং আমরা যেখানে পারেন সংখ্যা অক্ষরের সংখ্যা বেশি 1. দ্বারা দ্রুত উপায় এই কাজ করতে বেড়েছে ম্যাচ ফিল্টার সাথে আছেন Levenshtein দূরত্ব সম্পাদন করা adist যা আমরা বাধতে +।

— J.Doe
সূত্র

চেক করার জন্য ধন্যবাদ! আমি এখন মিলগুলিতে ফিল্টার আউট করি যেখানে প্রতি সংখ্যায় একাধিক সন্নিবেশ রয়েছে।

— জে.ডো

7

পাইথ, 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ডিফল্টরূপে vectorises, এবং Lব্যবহারের mনীচে, তাই সীমায় ম্যাপিং উহ্য হয়, উপার্জন Uখুব unneccesary

সম্পাদনা 3: ;ফ্রাইআমডিজম্যান এবং ইস্যাকের জন্য ধন্যবাদ, 2 বাইট সংরক্ষণের জন্য 10 এ অ্যাক্সেস ধরে রাখতে অপারেটরের বৈশ্বিক ব্যবহারের জন্য পরিচিত:

fq^T4sT*FmvMsmXLkdUThl

সম্পাদনা 2: আমি ভুলে গেছি যোগফল অপারেটরটি উপস্থিত রয়েছে, কীভাবে বিব্রত হচ্ছে ...

সম্পাদনা 1: পূর্ববর্তী সংস্করণটি ইনপুট হিসাবে পূর্ণসংখ্যার একটি তালিকা স্বীকার করেছে, 27 বাইটের জন্য ম্যানুয়ালি স্ট্রিং রূপান্তর সম্পাদন করছে:

fq10000+FT*FmvMsmXLk`dUThl`

— সোক
সূত্র

1

@ কেভিন ক্রুজসেন এটি বাস্তবে করে, 10 সাধারণত হয় Tতবে ফাংশন ব্লকগুলিতে পরিবর্তকগুলি পুনরায় পুনরুত্থিত হয় পরিবর্তে পুনরাবৃত্তকরণ ভেরিয়েবল হিসাবে কাজ করার জন্য - ফিল্টার ব্লকটিতে পুনরাবৃত্তি ভেরিয়েবলটি ঠিক তাই ঘটে Tতাই এটি ব্যবহার করা যায় না। এর অর্থ এটি 10 ^ 4হবে ^10 4, যা 5 বাইট দীর্ঘ, সুতরাং দুর্ভাগ্যক্রমে কোনও সংক্ষিপ্ত নয়

— Sok

1

@ সাক আহ ঠিক আছে সুতরাং পরিসীমাটির জন্য Tইন UT10 এখনও রয়েছে [0,10)। কিন্তু ফিল্টারের জন্য একটি পুনরাবৃত্তির পরিবর্তনশীল পরিণত হয়েছে। ব্যাখ্যার জন্য ধন্যবাদ, এটি উপলব্ধি করে! এবং এর আগে করা, এটি একটি ভেরিয়েবলে সংরক্ষণ করা এবং ফিল্টারটিতে সেই পরিবর্তনশীলটি ব্যবহার করা অবশ্যই কমপক্ষে 5 বাইট by f...TTT4^

— কেভিন ক্রুইজসেন

2

আপনি প্রতিস্থাপন করতে পারেন 10000সঙ্গে ^;4।

— FryAmTheEggman

2

;এই ক্ষেত্রে 10 সর্বদা বিশ্বব্যাপী প্রেক্ষাপটে পুনরাবৃত্তকরণের পরিবর্তনশীলটির মান থাকে 10 তাই ^;4আপনি যা খুঁজছেন তা তাই ।

— isaacg

1

20 বাইট: fq^;4sT*FmvsmXLkdThl। ( পাইথ জেলিকে মারধর করছেন? ও ও

— হুরয়

4

পার্ল 6 , 64 বাইট

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

এটি অনলাইন চেষ্টা করুন!

নম্বরগুলি বৈধ কিনা তা পরীক্ষা করতে এটি একটি রেজেেক্স ব্যবহার করে জিবি-র উত্তরের একটি বন্দর । এটি পোর্ট করার জন্য nwellnhof ধন্যবাদ ।

পুরানো উত্তর, 127 110 , 88 বাইট

-২২ বাইটস নোহেলহোফকে ধন্যবাদ!

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

এটি অনলাইন চেষ্টা করুন!

নামবিহীন কোড ব্লক যা দুটি সংখ্যার একটি তালিকা নেয় এবং সংখ্যার জোড়ের একটি তালিকা প্রদান করে।

এর মধ্যে অঙ্কগুলি সন্নিবেশ করানোর বিষয়ে ঝাঁকুনির পরিবর্তে এই সমাধানটি সংখ্যার প্রতিটি সংমিশ্রণ যা 10000 এর সমষ্টি এবং এটি ফিল্টার করে যে প্রদত্ত সংখ্যাগুলি জোড়ের অংশ are

ব্যাখ্যা:

->\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
         }
}

— জো কিং
সূত্র

কেবল কৌতূহল: আপনি কি এই সত্যটি ব্যবহার করতে পারবেন না যে (i,1e4-i)জোড়গুলি প্রত্যেকের উপরে পুনরুক্তি (i,j)এবং ফিল্টারিংয়ের পরিবর্তে লেখা যেতে পারে ?

— এরিক ডুমিনিল

3

আর , 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}

এটি অনলাইন চেষ্টা করুন!

@ জয়সি এবং @ জিউজ্পে 35 টি বাইট সংরক্ষণ করেছেন saved

ব্যাখ্যা

সহায়ক ফাংশন জি সমস্ত সম্ভাব্য সন্নিবেশ পান।

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!

আমি লক্ষ্য করেছি যে এটি মূলত পাইথ উত্তর হিসাবে একই যুক্তিযুক্ত ।

— NGM
সূত্র

স্ট্রিং আউটপুট ব্যবহার করে 10 বাইট সাশ্রয় হয়: টিআইও

— জাইসি

@ জাসি 10 টিরও বেশি বাইট সঞ্চয় করে! প্রতিলিপি চ্যালেঞ্জ কোডের বাইরে হওয়ার অনুমতি দেওয়া হয়েছে।

— এনজিএম

-11 বাইট ব্যবহার করে Fএবং%*%

— জিউস্পে

আসুন আরও কিছু বাইট মেরে

— ফেলি

আমি মনে করি আমরা এটিতে একটি কাঁটাচামচ লাগানোর কাছাকাছি!

— এনজিএম

3

রুবি , 93 91 বাইট

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

এটি অনলাইন চেষ্টা করুন!

প্রতিটি একক সংখ্যা 10000 পর্যন্ত চেষ্টা করে দেখুন এবং সংখ্যাটি মিলছে কিনা তা পরীক্ষা করার জন্য রেজেক্স ব্যবহার করুন।

— গিগাবাইট
সূত্র

2

জেলি , 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.

— লিন
সূত্র

2

পিএইচপি, 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>বা অনলাইনে চেষ্টা করুন ।

— তিতাস
সূত্র

2

পাইথ, 18 বাইট

fqsT^;4*FsMvXLRRTT

বিক্ষোভ , পরীক্ষা স্যুট (পরীক্ষার স্যুটটি শীর্ষস্থানীয় সহ প্রতিলিপি দেওয়া হয় {)।

ইনপুট দুটি স্ট্রিংয়ের তালিকার আকারে।

XLRRTT: এল এবং আর নেস্টেড মানচিত্র সম্পাদন করে। যেহেতু তাদের মধ্যে 3 জন রয়েছে, তাই আমরা Xফাংশনের একটি ট্রিপলি নেস্টেড ম্যাপটি সম্পাদন করব। এই ক্ষেত্রে, Xফাংশন একটি স্ট্রিংতে একটি মনোনীত অবস্থানে একটি অক্ষর willোকাবে।

স্ট্রিংটি ইনপুট, যা অন্তর্ভুক্ত এবং প্রথম দ্বারা স্থাপন করা হয় R। চরিত্রটি সীমাবদ্ধ 0 ... 9, সুতরাং আমাদের সমস্ত সম্ভাব্য inোকানো সংখ্যা রয়েছে এবং এটি দ্বারা স্থাপন করা হয়েছে L। পরিসীমা দ্বারা প্রদত্ত T, যা নিখুঁতভাবে সেট করা হয় 10, যা স্পষ্টভাবে হিসাবে বিবেচিত হয় [0 ... 9]। অবস্থানটি সীমাবদ্ধ 0 ... 9, যা যথেষ্ট, কারণ দশম অবস্থানের পরে একটি সংখ্যা সন্নিবেশ করা কখনই কার্যকর হবে না। সদৃশ ফলাফল ঠিক আছে। পরিসরটি দ্বিতীয় দ্বারা স্থাপন করা হয় এবং দ্বিতীয় Rদ্বারা দেওয়া হয় T।

v: অন্তর্নিহিত কাস্ট স্ট্রিং।

sM: প্রতিটি ইনপুট সংখ্যার জন্য ডিজিট সন্নিবেশের পরে সমস্ত সম্ভাব্য সংখ্যার একটি তালিকা রেখে আমাদের দ্বিতীয় স্তরের তালিকাগুলি সমতল করুন।

*F: সম্ভাব্য সংখ্যার দুটি তালিকার কার্টেসিয়ান পণ্যটি নিন।

fqsT^;4: যার জুড়িগুলিতে ফিল্টার করুন 10000। ;মান লাগে 10এখানে, যেমন Tফিল্টার পরিবর্তনশীল হিসেবে ব্যবহারের মধ্যে আছে, এবং ;পরিবর্তনশীল যা ব্যবহার করা হচ্ছে এর মান হিসাবে সবসময়।

— isaacg
সূত্র

2

জাপট , 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

— রোমশ
সূত্র

2

জাভাস্ক্রিপ্ট (নোড) - 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-ab হয় তখন এটি স্ট্রিং হিসাবে ইনপুট নেয়।

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

— Asleepace
সূত্র

এখানে কিছু দ্রুত জয় রয়েছে । এটি মুলত ( 'গলফ-অনাত্মীয়' বিবৃতি ছাড়া একই কোড String.prototype, function, let, this) এবং কয়েক অন্যান্য অপ্টিমাইজেশন সঙ্গে।

— আর্নল্ড

সেখান থেকে, আপনি সংরক্ষণ করতে পারবেন আরো 4 বাইট একটি ব্যবহার করে map()বাইরের পরিবর্তে forলুপ। এনবি: আমরা jকলব্যাক ফাংশনের 1 ম পরামিতি হিসাবে ব্যবহার করার একমাত্র কারণ হ'ল আমরা চাই যে এটি এই সুযোগে সংজ্ঞায়িত করা হোক।

— আর্নল্ড

@ আরনাউল্ড ধন্যবাদ আমি সত্যিই এটির প্রশংসা করি, আপনি একজন কিংবদন্তি মানুষ। আপনার উত্তর পোস্ট করুন, আমি আপনার নিতে চাই না, আমি এটি মজাদার জন্য করছি।

— স্লিপেসেস

1

আমি আমার নিজের চ্যালেঞ্জের জবাব দেব না এবং এই কোডটি আপনার কেবল একটি পরিবর্তন, সুতরাং এটি ব্যবহার করতে নির্দ্বিধায়। কোন চিন্তা করো না!

— আর্নল্ড

@ আরনৌল্ডের পরামর্শগুলি 123 বাইটে

— শেগি

1

জেলি , 23 বাইট

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

অঙ্কের তালিকার একটি তালিকা গ্রহণ করে একটি মোনাডিক লিঙ্ক
(উদাহরণস্বরূপ 923 এবং 72 এর ইনপুটটি [[9,2,3],[7,2]])

এটি অনলাইন চেষ্টা করুন! (পাদলেখ এটি তৈরি করে যাতে I / O দুটি সংখ্যার এক জোড়া এবং একটি [ফর্ম্যাটেড] জোড় সংখ্যার জোড়ের তালিকা থাকে)

অথবা পরীক্ষা-স্যুটটি দেখুন ।

কিভাবে?

"সংখ্যার" সমস্ত সংখ্যার (অঙ্কগুলির তালিকা) যাচাই করে যা "numbers সংখ্যা" থেকে অর্ডার বজায় রাখার জন্য এন -1 সংখ্যা বেছে নেওয়ার সমস্ত উপায় গঠন করে বৈধতার জন্য 10000 এর সমষ্টি; এবং যা বৈধ তাদের রাখে (যেখানে বৈধতা পরীক্ষার অধীনে "সংখ্যা "টিকে মূল" সংখ্যার "সমান হতে দেয়)।

œ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)

— জোনাথন অ্যালান
সূত্র

1

স্ট্যাক্স , 24 বাইট

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

এটি চালান এবং এটি ডিবাগ করুন

এই প্রোগ্রামটি এর মতো দুটি স্ট্রিংয়ের অ্যারে হিসাবে এটি গ্রহণ করে।

["934", "654"]

— রিকার্সিভ
সূত্র

1

কাঠকয়লা , 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 টি অক্ষর মুছে ফেলার ফলাফলের সাথে প্রতিটি ইনপুট কতবার মেলে তা গণনা করে। যদি সর্বনিম্ন গণনাটি নানজারো হয় তবে উভয় ইনপুট মেলে এবং এটি একটি সম্ভাব্য সমাধান।

— নিল
সূত্র

1

পাইথন 3, 165 160 153 125 117 বাইট

setআউটপুটে ডুপ্লিকেট থাকতে পারে বলে রিটার্ন মান থেকে অপসারণ করার জন্য @ জ্যাকব্রোসস্টেইন পরামর্শের জন্য 5 বাইট সংরক্ষণ করা হয়েছে ।
প্রতিস্থাপন সংরক্ষিত 7 range(len(s))সঙ্গে range(5)।
itertoolsনেস্টেড তালিকা বোঝার (এবং একটি স্থান অপসারণ) এর সাথে প্রতিস্থাপনের জন্য @ এরিক ডুমিনিলের পরামর্শের জন্য 23 বাইট সংরক্ষণিত
একক লুপ এবং মডুলাস অপারেটরের সাথে নেস্টেড তালিকা বোঝার প্রতিস্থাপন করার জন্য @ জো কিং এর পরামর্শের জন্য 8 টি সংরক্ষিত হয়েছে

~~ব্যবহার 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}

— user2699
সূত্র

1

আউটপুটে সদৃশগুলি অন্তর্ভুক্ত থাকতে পারে, আপনাকে set-5 বাইটের জন্য শেষ লাইনে কল করার দরকার নেই ।

— জ্যাক ব্রাউনস্টেইন

@ জ্যাকব্রাউনস্টাইন, ধন্যবাদ আমি নিয়মের সেই অংশটি মিস করেছি missed

— ব্যবহারকারী 2699

@ এরিকডুমিনিল, ধন্যবাদ সেট বোধগম্যতা সম্পর্কে আমি জানতাম না, এটি একটি ঝরঝরে কৌশল।

— ব্যবহারকারী2699

1

117 বাইট

— জো কিং

1

@ জোকিং চালাক এই সমস্ত পরামর্শের পরে সমাধানটি সবে সাদৃশ্যপূর্ণ যা আমি শুরু করেছি।

— ব্যবহারকারী2699

1

রুবি , ১১০ বাইট

স্ট্রিংগুলি ইনপুট হিসাবে গ্রহণ করে, পূর্ণসংখ্যার অ্যারের অ্যারে দেয়।

পাইথন সংস্করণের উপর ভিত্তি করে । প্রদত্ত পূর্ণসংখ্যার জন্য, 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}}

এটি অনলাইন চেষ্টা করুন!

— এরিক ডুমিনিল
সূত্র

1

05 এ বি 1 ই (উত্তরাধিকার) , 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

— কেভিন ক্রুইজসেন
সূত্র

0

জেলি , 25 বাইট

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

এটি অনলাইন চেষ্টা করুন!

এখানে সংক্ষিপ্ততম জেলি সমাধান নয় তবে সম্ভবত কেউ এইটি গল্ফ করতে পারে? আমি স্ট্যাম্পড

— dylnan
সূত্র

তাদের 10,000 করে যোগ করুন

ইনপুট

কার্য

আউটপুট

বিধি

পরীক্ষার মামলা

হাস্কেল , 99 97 82 81 বাইট

আর , 96 বাইট

ব্যাখ্যা (অবরুদ্ধ)

পাইথ, 28 27 25 24 22 20 বাইট

পার্ল 6 , 64 বাইট

পুরানো উত্তর, 127 110 , 88 বাইট

ব্যাখ্যা:

আর , 179 161 150 144 বাইট

ব্যাখ্যা

রুবি , 93 91 বাইট

জেলি , 30 বাইট

ব্যাখ্যা

পিএইচপি, 162 159 বাইট

পাইথ, 18 বাইট

জাপট , 30 29 25 23 বাইট

ব্যাখ্যা

জাভাস্ক্রিপ্ট (নোড) - 183 136 123 বাইট

জেলি , 23 বাইট

কিভাবে?

স্ট্যাক্স , 24 বাইট

কাঠকয়লা , 33 বাইট

পাইথন 3, 165 160 153 125 117 বাইট

রুবি , ১১০ বাইট

05 এ বি 1 ই (উত্তরাধিকার) , 36 বাইট

জেলি , 25 বাইট