최근 PPCG에 대한 10,000 개 문항의 임계 값에 도달했습니다. 만세! 간단한 도전으로 이것을 축하합시다.

입력

두 정수 와 둘 다에서 등이 .$A$$B$$[1..9999]$$A+B<10000$

태스크

당신의 임무는이 정수 중 하나에 하나의 숫자를 추가하거나 되도록 두 숫자에 하나의 숫자를 추가하는 것입니다 . 와 숫자를 추가하는 경우 반드시 같은 숫자 일 필요는 없습니다.$A+B=10000$$A$$B$

새로운 숫자는 처음, 끝 또는 원래 정수 중간에 추가 할 수 있습니다. 그러나 앞에 0을 추가 할 수 없습니다.

예:

들어 , 다음과 같은 변환이 유효합니다 :$A=923$

그러나 이것들은 유효하지 않습니다 :

및 주어지면 두 가지 가능한 솔루션이 있습니다.$A=923$$B=72$

산출

가능한 모든 솔루션 목록을 인쇄하거나 출력해야합니다.

위의 예에서 예상되는 출력은입니다 [[9238,762],[9273,727]].

규칙

• I / O는 합리적이고 명확한 형식으로 처리 될 수 있습니다. 정수 대신 문자열, 숫자 목록 등을 사용할 수 있습니다.
• 입력 값에는 하나 이상의 솔루션이 보장됩니다.
• 출력을 중복 제거 할 수 없습니다. 그러나 테스트 코드가 TIO 의 바닥 글 섹션 과 같은 일부 사후 처리로 코드를 중복 제거하는 것이 좋습니다.
• 이것은 코드 골프 도전입니다.

테스트 사례

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

하스켈 , 99 97 82 81 바이트

^{Delfad0r 덕분에 -16 바이트 (입력을 중복 제거 할 필요가없는 학대를 사용하여 입력으로 가져 오기 -> n은 항상 [0,4]에 있을 수 있고 입력 형식과 영리한 조합을 사용하여 ap)!}

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

온라인으로 사용해보십시오!

R , 96 바이트

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

온라인으로 사용해보십시오!

설명 (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 
  ]
}

에 할당 ?합니다 paste. 호출에서 a<-b?c<-d인라인 할당을 수행합니다. 이 paste연산자 ?는 우선 순위 가 <-. 이므로 다른 연산자로는 수행 할 수 없습니다 .

@JoKing이 친절하게 지적했듯이와 같이 900 10두 개의 삽입이 발생할 수있는 경우가 있습니다 9100 8100. 따라서 우리는 두 숫자 중 하나의 문자 수가 1 이상 증가한 일치 항목을 필터링합니다.이를 수행하는 가장 빠른 방법은 바인딩 할 Levenshtein 편집 거리를 사용 adist 하는 것 +입니다.

Pyth, 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 : Mr Xcoder 덕분에 2 바이트를 더 절약 v했습니다. 기본적으로 벡터화되고 그 아래를 L사용 m하므로 범위에 대한 매핑이 암시되어 U불필요한 것도 아닙니다

편집 3 : ;FryAmTheEggman과 issacg 덕분에 2 바이트를 절약하기 위해 10에 대한 액세스 권한을 유지하기 위해 연산자의 전역 사용을 소개했습니다 .

fq^T4sT*FmvMsmXLkdUThl

편집 2 : 합계 연산자가 존재하는 것을 잊어 버렸습니다.

편집 1 : 이전 버전은 27 바이트에 대해 문자열 변환을 수동으로 수행하여 정수 목록을 입력으로 허용했습니다.

fq10000+FT*FmvMsmXLk`dUThl`

펄 6 , 64 바이트

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

온라인으로 사용해보십시오!

이것은 숫자가 유효한지 확인하기 위해 정규 표현식을 사용하여 GB의 답변 포트입니다 . 그것을 포팅 한 nwellnhof 에게 감사드립니다 .

이전 답변, 127110 , 88 바이트

nwellnhof 덕분에 -22 바이트!

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

R , 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는 가능한 모든 삽입을 가져옵니다.

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!

필자는 이것이 본질적으로 Pyth 답변 과 동일한 논리라는 것을 알았습니다 .

루비 , 93 91 바이트

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

온라인으로 사용해보십시오!

모든 단일 숫자를 최대 10000까지 시도하고 정규식을 사용하여 숫자가 일치하는지 확인하십시오.

젤리 , 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.

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>하거나 사용해보십시오 .

Pyth, 18 바이트

fqsT^;4*FsMvXLRRTT

데모 , 테스트 스위트 (테스트 스위트는 중복 제거됨 {).

입력은 두 개의 문자열 목록 형식입니다.

XLRRTT: L 및 R은 중첩 된 맵을 수행합니다. 이 중 3 개가 있기 때문에 X함수의 중첩 중첩 맵을 수행 합니다. 이 경우 X함수는 지정된 위치의 문자를 문자열에 삽입합니다.

문자열은 입력이며 암시 적이며 첫 번째로 배치됩니다 R. 문자의 범위가을 초과 0 ... 9하므로 가능한 모든 숫자가 삽입되고으로 표시됩니다 L. 범위는 T로 암시 적으로 설정 10되며로 암시 적으로 처리됩니다 [0 ... 9]. 0 ... 910 번째 위치 뒤에 숫자를 삽입하는 것은 결코 유용하지 않기 때문에 위치의 범위 는 충분합니다. 중복 결과가 좋습니다. 범위는 초 단위로 배치되고 초 단위 R로 지정됩니다 T.

v: 캐스트 문자열을 정수로 중첩합니다.

sM: 두 번째 수준의 목록을 평평하게하여 각 입력 숫자에 대해 숫자 삽입 후 가능한 모든 숫자 목록을 남겨 둡니다.

*F: 가능한 두 가지 목록 중 데카르트 곱을 가져옵니다.

fqsT^;4: 제품이 인 쌍을 기준으로 필터링합니다 10000. ;의 값을 취 10으로 여기를 T필터 변수로 사용하고, ;사용되는 변수 값으로 항상.

Japt , 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

자바 스크립트 (노드) - 183 136 123 바이트

Shaggy 덕분에 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

Arnauld 덕분에 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가 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

온라인으로 사용해보십시오!

언 골프

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

젤리 , 23 바이트

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

자릿수 목록을 허용하는 모나드 링크
(예 : 923 및 72의 예의 경우 입력은 [[9,2,3],[7,2]])

온라인으로 사용해보십시오! (footer는 I / O가 두 개의 정수 쌍이되고 [포맷 된] 정수 쌍 목록이되도록합니다)

또는 테스트 스위트를 참조하십시오 .

방법?

순서를 유지하면서 "숫자"에서 n-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)

Stax , 24 바이트

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

실행 및 디버깅

이러한 프로그램은 두 개의 입력을 다음과 같은 문자열 배열로 사용합니다.

["934", "654"]

숯 , 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 문자를 삭제 한 결과와 일치하는 횟수를 계산합니다. 최소 카운트가 0이 아닌 경우 두 입력이 모두 일치하며 가능한 해결책입니다.

파이썬 3, 165160153125117 바이트

• set출력에 중복이 포함될 수 있으므로 @JackBrounstein 제안으로 반환 값에서 제거하도록 5 바이트를 절약했습니다 .
• 으로 교체 range(len(s))하여 7을 저장 했습니다 range(5).
• @Eric Duminil의 제안 itertools으로 중첩 된 목록 이해 로 대체 하고 공백을 제거하여 23 바이트를 절약했습니다 .
• 중첩 된 목록 이해를 단일 루프 및 계수 연산자로 대체하려는 @Jo King의 제안 덕분에 8이 절약되었습니다.

itertools간단한 도우미 기능을 사용 합니다. 문자열을 입력으로 허용하고 int 세트를 출력으로 리턴합니다.

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}

루비 , 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}}

온라인으로 사용해보십시오!

05AB1E (레거시) , 36 바이트

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

의심의 여지없이 골프를 치는 것이 가능합니다. 특히 선행 / 트레일을 포함하여 숫자를 삽입합니다.

온라인으로 시도 하거나 모든 테스트 사례를 확인하십시오 ( ê바닥 글에서 Uniquify & Sort).

설명:

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

젤리 , 25 바이트

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

온라인으로 사용해보십시오!

여기서 가장 짧은 젤리 솔루션은 아니지만 누군가 골프를 할 수 있습니까? 난처 치다