Gần đây chúng tôi đã đạt đến ngưỡng 10.000 câu hỏi về PPCG. Hoan hô! Hãy ăn mừng điều này với một thử thách đơn giản.

Đầu vào

Hai số nguyên và , cả hai trong , sao cho .$A$$B$$[1..9999]$$A+B<10000$

Bài tập

Nhiệm vụ của bạn là thêm một chữ số vào một trong các số nguyên này hoặc một chữ số đơn cho cả hai số đó sao cho . Nếu thêm một chữ số cho cả và , nó không nhất thiết phải là cùng một chữ số.$A+B=10000$$A$$B$

Chữ số mới có thể được thêm vào đầu, cuối hoặc bất cứ nơi nào ở giữa số nguyên ban đầu. Tuy nhiên, bạn không thể thêm số 0 đứng đầu.

Thí dụ:

Với , các phép biến đổi sau là hợp lệ:$A=923$

Nhưng những cái này không hợp lệ :

Cho và , có hai giải pháp khả thi:$A=923$$B=72$

Đầu ra

Bạn phải in hoặc xuất danh sách tất cả các giải pháp có thể.

Đối với ví dụ trên, đầu ra dự kiến ​​sẽ là [[9238,762],[9273,727]].

Quy tắc

• I / O có thể được xử lý ở bất kỳ định dạng hợp lý, rõ ràng nào. Bạn có thể sử dụng chuỗi, danh sách các chữ số, vv thay vì số nguyên.
• Đầu vào được đảm bảo có ít nhất một giải pháp.
• Bạn được phép không lặp lại đầu ra. Tuy nhiên, nó sẽ được đánh giá cao nếu mã kiểm tra được sao chép lại với một số xử lý hậu kỳ, ví dụ như trong phần chân trang của TIO.
• Đây là một thách thức mã golf .

Các trường hợp thử nghiệm

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 byte nhờ Delfad0r (lấy đầu vào làm danh sách, sử dụng lạm dụng mà chúng ta không cần phải lặp lại -> n luôn có thể ở [0,4] và sử dụng kết hợp thông minh định dạng đầu vào và ap)!}

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

Hãy thử trực tuyến!

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

Hãy thử trực tuyến!

Giải thích (vô danh)

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

Chúng tôi giao ?cho paste. Điều đó cho phép chúng tôi thực hiện một điều thú vị: a<-b?c<-dthực hiện các nhiệm vụ nội tuyến trong pastecuộc gọi, điều mà chúng tôi không thể thực hiện với bất kỳ nhà điều hành nào khác ?, vì nó có mức độ ưu tiên thấp hơn <-.

Bây giờ như @JoKing vui lòng chỉ ra, có thể có những trường hợp như 900 10hai lần chèn có thể diễn ra như 9100 8100. Vì vậy, chúng tôi lọc ra các kết quả khớp với số lượng ký tự trong một trong hai số đã tăng hơn 1. Cách nhanh chóng để thực hiện điều này là với khoảng cách chỉnh sửa Levenshtein adist mà chúng tôi liên kết +.

Pyth, 28 27 25 24 22 20 byte

fq^;4sT*FmvsmXLkdThl

Dùng thử trực tuyến tại đây hoặc xác minh tất cả các trường hợp thử nghiệm tại đây - bộ thử nghiệm lặp lại kết quả bằng cách trả trước a {.

Đầu vào là một danh sách các chuỗi.

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)

Chỉnh sửa 4: Đã lưu thêm 2 byte, nhờ Mr vXcoder - mặc định các vectơ và Lsử dụng mbên dưới, do đó ánh xạ trên phạm vi được ngụ ý, làm cho Uquá không cần thiết

Chỉnh sửa 3: Được giới thiệu sử dụng ;toán tử toàn cầu để duy trì quyền truy cập vào 10 để tiết kiệm 2 byte, nhờ FryAmTheEggman và hiệnacg:

fq^T4sT*FmvMsmXLkdUThl

Chỉnh sửa 2: Tôi quên toán tử tổng tồn tại, làm thế nào xấu hổ ...

Chỉnh sửa 1: Phiên bản trước chấp nhận danh sách các số nguyên làm đầu vào, thực hiện chuyển đổi chuỗi theo cách thủ công, với 27 byte:

fq10000+FT*FmvMsmXLk`dUThl`

Perl 6 , 64 byte

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

Hãy thử trực tuyến!

Đây là một câu trả lời của GB bằng cách sử dụng biểu thức chính quy để kiểm tra xem các số có hợp lệ không. Cảm ơn nwellnhof đã chuyển nó.

Câu trả lời cũ, 127 110 , 88 byte

-22 byte nhờ nwellnhof!

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

Hãy thử trực tuyến!

Khối mã ẩn danh nhận danh sách hai số và trả về danh sách các cặp số.

Thay vì miệt mài với việc chèn các chữ số vào, giải pháp này kiểm tra mọi tổ hợp số có tổng bằng 10000 và các bộ lọc mà các số đã cho là một phần của cặp.

Giải trình:

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

Hãy thử trực tuyến!

35 byte được lưu bởi @JayCe và @Giuseppe.

Giải trình

Hàm trợ giúp g được tất cả các phần chèn thêm có thể.

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
}

Chức năng chính.

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!

Tôi đã nhận thấy sau khi thực tế rằng điều này về cơ bản là logic giống như câu trả lời của 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]}

Hãy thử trực tuyến!

Hãy thử mọi số đơn lẻ lên tới 10000 và sử dụng biểu thức chính quy để kiểm tra xem các số có khớp không.

Thạch , 30 byte

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

Hãy thử trực tuyến!

Loại vụng về vì Jelly không có chèn.

Giải trình

                                   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

ví dụ đáng yêu cho một chức năng máy phát điện!

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

lấy đầu vào từ các đối số dòng lệnh; in trùng lặp. Chạy với -nr '<code>hoặc thử trực tuyến .

Bình thường, 18 byte

fqsT^;4*FsMvXLRRTT

Trình diễn , bộ thử nghiệm ( bộ thử nghiệm được lặp lại với hàng đầu {).

Đầu vào ở dạng danh sách hai chuỗi.

XLRRTT: L và R thực hiện các bản đồ lồng nhau. Vì có 3 trong số chúng, chúng tôi sẽ thực hiện một bản đồ ba Xchức năng lồng nhau . Trong trường hợp này, Xhàm sẽ chèn một ký tự tại một vị trí được chỉ định vào một chuỗi.

Chuỗi là đầu vào, được ẩn và đặt đầu tiên R. Ký tự nằm trong phạm vi 0 ... 9, vì vậy chúng ta có tất cả các chữ số được chèn và được đặt bởi L. Phạm vi được đưa ra bởi T, được đặt ngầm định 10, được coi là ngầm định [0 ... 9]. Vị trí nằm trong phạm vi 0 ... 9là đủ, bởi vì chèn một số sau vị trí thứ 10 sẽ không bao giờ hữu ích. Kết quả trùng lặp là tốt. Phạm vi được đặt bởi thứ hai Rvà được đưa ra bởi thứ hai T.

v: Lồng chuỗi lồng vào ints.

sM: Làm phẳng cấp độ danh sách thứ hai, để lại cho chúng tôi danh sách tất cả các số có thể sau khi chèn chữ số, cho mỗi số đầu vào.

*F: Lấy sản phẩm của Cartesian trong hai danh sách các số có thể.

fqsT^;4: Lọc trên các cặp có sản phẩm 10000. ;lấy giá trị 10ở đây, như Tđược sử dụng làm biến bộ lọc và ;luôn luôn là giá trị của biến đang sử dụng.

Japt , 30 29 25 23 byte

Lấy đầu vào là một chuỗi các chuỗi, xuất ra một mảng các chuỗi.

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

Thử nó

Giải trình

£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 (Nút) - 183 136 123 byte

123 Byte nhờ 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 byte nhờ 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

Mã cũ

Không tự hào về điều đó, nhưng hình dung tôi sẽ gửi dù sao đi nữa. Tạo một hàm nguyên mẫu chuỗi gần giống với ánh xạ chiếm phần lớn các byte. Hàm chỉ lặp qua cả hai hoán vị và tìm thấy khi 1000-ab bằng 0. Lấy đầu vào dưới dạng chuỗi.

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

Hãy thử trực tuyến!

Bị đánh cắp

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

Thạch , 23 byte

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

Một liên kết đơn âm chấp nhận danh sách các danh sách các chữ số
(ví dụ: ví dụ về 923 và 72 đầu vào là [[9,2,3],[7,2]])

Hãy thử trực tuyến! (chân trang làm cho nó để I / O là một cặp gồm hai số nguyên và một danh sách [định dạng] các cặp số nguyên ra)

Hoặc xem bộ thử nghiệm .

Làm sao?

Kiểm tra tất cả các cặp "số" (danh sách các chữ số) có giá trị bằng 10000 bằng cách hình thành tất cả các cách để chọn n-1 chữ số từ các "số" duy trì thứ tự đó; và giữ cho những số hợp lệ (trong đó tính hợp lệ cũng cho phép "số" được kiểm tra bằng với "số" ban đầu).

œ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▲∞Ç╫[½π=

Chạy và gỡ lỗi nó

Các chương trình này lấy hai đầu vào của nó là một chuỗi các chuỗi, như thế này.

["934", "654"]

Than , 33 byte

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

Hãy thử trực tuyến! Liên kết là phiên bản dài dòng của mã. Giải trình:

   χ                                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

Trong trường hợp bạn không hiểu điều đó, nó sẽ chạy qua tất cả các cặp giá trị cộng thêm 10000 (dưới dạng chuỗi), sau đó đếm số lần mỗi đầu vào khớp với kết quả xóa tối đa 1 ký tự khỏi giá trị tương ứng. Nếu số lượng tối thiểu là khác không thì cả hai đầu vào đều khớp và đây là một giải pháp khả thi.

Python 3, 165 160 153 125 117 byte

• Đã lưu 5 byte nhờ đề xuất @JackBrounstein để xóa setkhỏi giá trị trả về, vì đầu ra có thể chứa các bản sao.
• Lưu 7 bằng cách thay thế range(len(s))bằng range(5).
• Đã lưu 23 byte nhờ đề xuất của @Eric Duminil để thay thế itertoolsbằng cách hiểu danh sách lồng nhau (và xóa một khoảng trắng ).
• Đã lưu 8 nhờ đề xuất của @Jo King để thay thế việc hiểu danh sách lồng nhau bằng một toán tử vòng lặp và mô đun.

Sử dụng itertoolsvà một chức năng trợ giúp đơn giản. Chấp nhận chuỗi làm đầu vào, trả về một tập hợp int làm đầu ra.

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

Chấp nhận chuỗi làm đầu vào, trả về một mảng các số nguyên.

Dựa trên phiên bản python . Đối với một số nguyên cho trước, Ctạo một mảng các số có thể được tạo bằng cách thêm một chữ số.

Lambda lặp lại trên mỗi cặp có thể và chọn một cặp có tổng là 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}}

Hãy thử trực tuyến!

05AB1E (di sản) , 36 byte

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

Không nghi ngờ gì có thể được đánh golf đáng kể .. Đặc biệt là chèn các chữ số, bao gồm cả một chữ số hàng đầu / dấu.

Dùng thử trực tuyến hoặc xác minh tất cả các trường hợp thử nghiệm ( êtrong phần chân trang là để Uniquify & Sắp xếp).

Giải trình:

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

Thạch , 25 byte

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

Hãy thử trực tuyến!

Không phải là giải pháp Jelly ngắn nhất ở đây nhưng có lẽ ai đó có thể chơi golf này? Tôi bị bối rối