Kami baru saja mencapai ambang 10.000 pertanyaan tentang PPCG. Hore! Mari kita rayakan ini dengan tantangan sederhana.

Memasukkan

Dua bilangan bulat $A$ dan $B$ , keduanya dalam $[1..9999]$ , sehingga $A+B<10000$ .

Tugas

Tugas Anda adalah menambahkan satu digit tunggal ke salah satu bilangan bulat ini atau satu digit tunggal untuk keduanya sehingga $A+B=10000$ . Jika menambahkan digit ke $A$ dan , tidak harus sama dengan digit.$B$

Digit baru dapat ditambahkan di awal, di akhir atau di mana saja di tengah bilangan bulat asli. Namun, Anda tidak dapat menambahkan nol di depan.

Contoh:

Untuk , transformasi berikut ini valid:$A=923$

Tetapi yang ini tidak valid :

Diberikan dan , ada dua solusi yang mungkin:$A=923$$B=72$

Keluaran

Anda harus mencetak atau mengeluarkan daftar semua solusi yang mungkin.

Untuk contoh di atas, output yang diharapkan adalah [[9238,762],[9273,727]].

Aturan

• I / O dapat diproses dalam format yang masuk akal dan tidak ambigu. Anda dapat menggunakan string, daftar digit, dll. Bukan bilangan bulat.
• Input dijamin memiliki setidaknya satu solusi.
• Anda diizinkan untuk tidak menduplikat output. Namun, akan lebih dihargai jika kode tes dideduplikasi dengan beberapa post-processing, misalnya di bagian footer TIO.
• Ini adalah tantangan kode-golf .

Uji kasus

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

Haskell , 99 97 82 81 byte

^{-16 bytes terima kasih kepada Delfad0r (mengambil input sebagai daftar, menggunakan penyalahgunaan yang tidak perlu kita deduplicate -> n selalu bisa dalam [0,4] & menggunakan kombinasi pandai format input dan ap)!}

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

Cobalah online!

R , 96 byte

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

Cobalah online!

Penjelasan (ungolfed)

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

Kami ditugaskan ?untuk paste. Itu memungkinkan kami melakukan sesuatu yang keren: a<-b?c<-dmelakukan penugasan sebaris dalam pastepanggilan, yang tidak dapat kami lakukan dengan operator lain selain ?, karena memiliki prioritas lebih rendah daripada <-.

Sekarang seperti yang ditunjukkan oleh @JoKing, mungkin ada kasus seperti di 900 10mana dua penyisipan dapat terjadi seperti 9100 8100. Jadi kami menyaring pertandingan yang jumlah karakternya meningkat lebih dari 1. Cara cepat untuk melakukannya adalah dengan jarak edit Levenshtein adist yang kami ikat +.

Pyth, 28 27 25 24 22 20 byte

fq^;4sT*FmvsmXLkdThl

Cobalah secara online di sini , atau verifikasi semua test case di sini - test suite menduplikat hasilnya dengan menambahkan a {.

Input adalah sebagai daftar string.

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)

Sunting 4: Disimpan 2 byte lagi, terima kasih kepada Tuan Xcoder - membuat vvektor secara default, dan Lmenggunakan di mbawahnya, sehingga pemetaan rentang terimplikasi, membuat yang Utidak perlu terlalu

Sunting 3: Diperkenalkan kepada penggunaan global ;operator untuk mempertahankan akses ke 10 untuk menghemat 2 byte, terima kasih kepada FryAmTheEggman dan issacg:

fq^T4sT*FmvMsmXLkdUThl

Sunting 2: Saya lupa operator penjumlahan ada, betapa memalukannya ...

Sunting 1: Versi sebelumnya menerima daftar bilangan bulat sebagai input, melakukan konversi string secara manual, selama 27 byte:

fq10000+FT*FmvMsmXLk`dUThl`

Perl 6 , 64 byte

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

Cobalah online!

Ini adalah port jawaban GB menggunakan regex untuk memeriksa apakah angkanya valid. Terima kasih kepada nwellnhof karena memindahkannya .

Jawaban lama, 127 110 , 88 byte

-22 byte berkat nwellnhof!

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

Cobalah online!

Blok kode anonim yang mengambil daftar dua angka dan mengembalikan daftar pasangan angka.

Daripada bermain-main dengan memasukkan angka, solusi ini memeriksa setiap kombinasi angka yang berjumlah 10.000 dan memfilter bahwa angka yang diberikan adalah bagian dari pasangan.

Penjelasan:

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

R , 179 161 150 144 byte

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}

Cobalah online!

35 byte disimpan oleh @JayCe dan @Giuseppe.

Penjelasan

Fungsi pembantu g mendapatkan semua kemungkinan penyisipan.

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
}

Fungsi utama.

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!

Saya perhatikan setelah fakta bahwa ini pada dasarnya logika yang sama dengan jawaban Pyth .

Ruby , 93 91 byte

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

Cobalah online!

Coba setiap nomor hingga 10.000, dan gunakan regex untuk memeriksa apakah jumlahnya cocok.

Jelly , 30 byte

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

Cobalah online!

Agak canggung karena Jelly tidak memiliki sisipan.

Penjelasan

                                   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.

PHP, 162 159 byte

contoh yang bagus untuk fungsi generator!

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";

mengambil input dari argumen baris perintah; mencetak duplikat. Jalankan dengan -nr '<code>atau coba online .

Pyth, 18 byte

fqsT^;4*FsMvXLRRTT

Demonstrasi , test suite (test suite diduplikasi dengan memimpin {).

Inputnya berupa daftar dua string.

XLRRTT: L dan R melakukan peta bersarang. Karena ada 3 dari mereka, kami akan melakukan peta Xfungsi bersarang triply . Dalam hal ini, Xfungsi akan memasukkan karakter pada posisi yang ditentukan ke dalam string.

String adalah input, yang tersirat dan ditempatkan oleh yang pertama R. Karakter berkisar 0 ... 9, jadi kami memiliki semua kemungkinan digit yang dimasukkan, dan ditempatkan oleh L. Rentang diberikan oleh T, yang secara implisit diatur ke 10, yang secara implisit diperlakukan sebagai [0 ... 9]. Posisi berkisar di atas 0 ... 9, yang cukup, karena memasukkan angka setelah posisi 10 tidak akan pernah berguna. Hasil duplikat baik-baik saja. Rentang ditempatkan oleh yang kedua R, dan diberikan oleh yang kedua T.

v: Nasting cast strings ke ints.

sM: Ratakan daftar tingkat kedua, beri kami daftar semua angka yang mungkin setelah penyisipan digit, untuk masing-masing nomor masukan.

*F: Ambil produk Cartesian dari dua daftar angka yang mungkin.

fqsT^;4: Saring pada pasangan yang produknya adalah 10000. ;mengambil nilai di 10sini, seperti Tyang digunakan sebagai variabel filter, dan ;selalu sebagai nilai variabel yang digunakan.

Japt , 30 29 25 23 bytes

Mengambil input sebagai array string, menghasilkan array array string.

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

Cobalah

Penjelasan

£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

Javascript (Node) - 183 136 123 Bytes

123 Bytes berkat Shaggy

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 Bytes berkat Arnauld

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

Kode Lama

Tidak bangga akan hal itu, tetapi kupikir aku akan menyerah. Membuat fungsi prototipe string yang mirip dengan memetakan yang memakan sebagian besar byte. Berfungsi hanya melalui kedua permutasi, dan menemukan saat 1000-ab bernilai 0. Mengambil input sebagai string.

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

Cobalah online!

Tidak disatukan

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

Jelly , 23 byte

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

Tautan monadik yang menerima daftar daftar digit
(misalnya untuk contoh 923 dan 72 inputnya [[9,2,3],[7,2]])

Cobalah online! (footer membuatnya jadi I / O adalah sepasang dari dua bilangan bulat di dalam dan daftar pasangan bilangan bulat yang diformat)

Atau lihat test-suite .

Bagaimana?

Memeriksa semua pasangan "angka" (daftar angka) yang berjumlah 10.000 untuk validitas dengan membentuk semua cara untuk memilih n-1 angka dari "angka" yang mempertahankan pesanan; dan menjaga yang valid (di mana validitas juga memungkinkan "angka" yang diuji sama dengan "angka" asli).

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

Stax , 24 byte

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

Jalankan dan debug itu

Program-program itu mengambil dua inputnya sebagai array string, seperti ini.

["934", "654"]

Arang , 33 byte

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

Cobalah online! Tautan adalah untuk mengucapkan versi kode. Penjelasan:

   χ                                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

Jika Anda tidak mengerti itu, ia menjalankan semua pasangan nilai yang menambah 10.000 (sebagai string), lalu menghitung berapa kali setiap input cocok dengan hasil menghapus hingga 1 karakter dari nilai masing-masing. Jika jumlah minimum bukan nol maka kedua input cocok dan ini adalah solusi yang memungkinkan.

Python 3, 165 160 153 125 117 byte

• Disimpan 5 byte berkat saran @JackBrounstein untuk menghapus setdari nilai kembali, karena output dapat berisi duplikat.
• Disimpan 7 dengan mengganti range(len(s))dengan range(5).
• Disimpan 23 byte berkat saran @Eric Duminil untuk menggantikan itertoolsdengan pemahaman daftar bersarang (dan menghapus spasi).
• Disimpan 8 berkat saran @ Jo King untuk menggantikan pemahaman daftar bersarang dengan satu loop dan operator modulus.

Menggunakan itertoolsdan fungsi pembantu sederhana. Menerima string sebagai input, mengembalikan satu set int sebagai output.

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}

Ruby , 110 byte

Menerima string sebagai input, mengembalikan array array integer.

Berdasarkan versi python . Untuk bilangan bulat yang diberikan, Cbuat array angka yang dapat dibuat dengan menambahkan digit.

Lambda mengulangi setiap kemungkinan pasangan dan memilih pasangan yang jumlahnya 10.000.

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

Cobalah online!

05AB1E (warisan) , 36 byte

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

Dapat tanpa diragukan lagi akan golf secara substansial .. Terutama memasukkan angka, termasuk yang terkemuka / tertinggal.

Cobalah secara online atau verifikasi semua kasus uji ( êcatatan kaki adalah untuk Uniquify & Sortir).

Penjelasan:

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

Jelly , 25 byte

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

Cobalah online!

Bukan solusi Jelly terpendek di sini tapi mungkin seseorang bisa bermain golf ini? Saya bingung