Wir haben kürzlich die Schwelle von 10.000 Fragen zu PPCG erreicht. Hurra! Feiern wir dies mit einer einfachen Herausforderung.

Eingang

Zwei ganze Zahlen $A$ und $B$ , beide in $[1..9999]$ , so dass $A+B<10000$ .

Aufgabe

Ihre Aufgabe ist es, einer dieser ganzen Zahlen eine einzelne Ziffer oder beiden eine einzelne Ziffer hinzuzufügen, sodass $A+B=10000$ . Wenn Sie $A$ und eine Ziffer hinzufügen , muss dies nicht unbedingt dieselbe Ziffer sein.$B$

Die neue Ziffer kann am Anfang, am Ende oder irgendwo in der Mitte der ursprünglichen Ganzzahl eingefügt werden. Sie können jedoch keine führende Null hinzufügen.

Beispiel:

Für folgende Transformationen:$A=923$

Aber diese sind ungültig :

Bei und gibt es zwei mögliche Lösungen:$A=923$$B=72$

Ausgabe

Sie müssen eine Liste aller möglichen Lösungen drucken oder ausgeben.

Für das obige Beispiel wäre die erwartete Ausgabe [[9238,762],[9273,727]].

Regeln

• I / O kann in jedem vernünftigen, eindeutigen Format verarbeitet werden. Sie können Zeichenfolgen, Ziffernlisten usw. anstelle von ganzen Zahlen verwenden.
• Die Eingabe hat garantiert mindestens eine Lösung.
• Sie dürfen die Ausgabe nicht deduplizieren. Es wäre jedoch wünschenswert, wenn der Testcode ihn mit einer gewissen Nachbearbeitung deduplizieren würde, beispielsweise in der Fußzeile von TIO.
• Dies ist eine Code-Golf- Herausforderung.

Testfälle

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 Bytes

^{-16 Bytes dank Delfad0r (Eingaben als Liste nehmen, Missbrauch verwenden, den wir nicht deduplizieren müssen -> n kann immer in [0,4] sein und eine clevere Kombination aus Eingabeformat und verwenden ap)!}

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

Probieren Sie es online!

R , 96 Bytes

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

Probieren Sie es online!

Erklärung (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 
  ]
}

Wir weisen ?zu paste. Dadurch können wir etwas Cooles tun: a<-b?c<-dInline-Zuweisungen innerhalb des pasteAnrufs, die wir mit keinem anderen Operator als durchführen können ?, da sie eine niedrigere Priorität als haben <-.

Nun, wie @JoKing freundlicherweise hervorhob, kann es Fälle geben, in 900 10denen zwei Einfügungen stattfinden könnten, wie z 9100 8100. Aus diesem Grund filtern wir Übereinstimmungen heraus, bei denen die Anzahl der Zeichen in einer der beiden Zahlen um mehr als 1 zugenommen hat. Der schnellste Weg dazu ist der Levenshtein-Bearbeitungsabstand, an adist den wir binden +.

Pyth, 28 27 25 24 22 20 Bytes

fq^;4sT*FmvsmXLkdThl

Probieren Sie es hier online aus oder überprüfen Sie alle Testfälle hier - die Testsuite dedupliziert das Ergebnis, indem Sie a voranstellen {.

Die Eingabe erfolgt als Liste von Zeichenfolgen.

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)

Bearbeiten 4: Saved weitere 2 Bytes, dank Herrn Xcoder - vvectorises standardmäßig und LVerwendungen mdarunter, so Mapping über Bereich impliziert ist, so dass die Uunneccesary zu

Edit 3: Einführung in die globale Verwendung des ;Operators, um dank FryAmTheEggman und issacg den Zugriff auf 10 zu behalten und 2 Bytes zu sparen:

fq^T4sT*FmvMsmXLkdUThl

Edit 2: Ich habe vergessen, dass der Summenoperator existiert, wie peinlich ...

Bearbeiten 1: In der Vorgängerversion wurde eine Liste von Ganzzahlen als Eingabe akzeptiert, wobei die Zeichenfolgenkonvertierungen für 27 Byte manuell durchgeführt wurden:

fq10000+FT*FmvMsmXLk`dUThl`

Perl 6 , 64 Bytes

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

Probieren Sie es online!

Dies ist ein Port der Antwort von GB, in dem mithilfe eines regulären Ausdrucks überprüft wird, ob die Nummern gültig sind. Danke an nwellnhof für die Portierung.

Alte Antwort, 127 110 , 88 Bytes

-22 bytes dank nwellnhof!

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

Probieren Sie es online!

Anonymer Codeblock, der eine Liste mit zwei Zahlen aufnimmt und eine Liste mit Zahlenpaaren zurückgibt.

Anstatt mit dem Einfügen der Ziffern herumzuspielen, überprüft diese Lösung jede Zahlenkombination, die sich auf 10000 summiert, und filtert, dass die angegebenen Zahlen Teil des Paars sind.

Erläuterung:

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

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}

Probieren Sie es online!

35 Bytes, die von @JayCe und @Giuseppe gespeichert wurden.

Erläuterung

Die Hilfsfunktion g holt sich alle möglichen Einfügungen.

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
}

Hauptfunktion.

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!

Ich habe nach der Tatsache bemerkt, dass dies im Wesentlichen die gleiche Logik wie die Pyth- Antwort ist.

Ruby , 93 91 Bytes

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

Probieren Sie es online!

Probieren Sie jede einzelne Zahl bis zu 10000 aus und verwenden Sie den regulären Ausdruck, um zu überprüfen, ob die Zahlen übereinstimmen.

Gelee , 30 Bytes

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

Probieren Sie es online!

Ein bisschen ungeschickt, weil Jelly keine Einfügung hat.

Erläuterung

                                   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 Bytes

schönes Beispiel für eine Generatorfunktion!

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

Nimmt Eingaben von Befehlszeilenargumenten entgegen. druckt Duplikate. Laufen Sie mit -nr '<code>oder versuchen Sie es online .

Pyth, 18 Bytes

fqsT^;4*FsMvXLRRTT

Demonstration , Testsuite (Testsuite wird mit Leading dedupliziert {).

Die Eingabe erfolgt in Form einer Liste mit zwei Zeichenfolgen.

XLRRTT: L und R führen verschachtelte Maps aus. Da es 3 davon gibt, führen wir eine dreifach verschachtelte Karte der XFunktion durch. In diesem Fall Xfügt die Funktion ein Zeichen an einer bestimmten Position in eine Zeichenfolge ein.

Die Zeichenfolge ist die Eingabe, die implizit und von der ersten platziert wird R. Das Zeichen erstreckt sich über 0 ... 9, so dass wir alle möglichen eingegebenen Ziffern haben, und wird durch das platziert L. Der Bereich ist gegeben durch T, der implizit gesetzt ist 10, der implizit behandelt wird als [0 ... 9]. Die Position reicht über 0 ... 9, was ausreichend ist, da das Einfügen einer Zahl nach der 10. Position niemals nützlich sein wird. Doppelte Ergebnisse sind in Ordnung. Der Bereich wird sekundengenau platziert Rund sekundengenau angegeben T.

v: Verschachtelte Besetzungszeichenfolgen in Ints.

sM: Reduzieren Sie die zweite Ebene der Listen, und geben Sie nach dem Einfügen der Ziffern für jede eingegebene Nummer eine Liste aller möglichen Zahlen ein.

*F: Nehmen Sie das kartesische Produkt der beiden Listen möglicher Zahlen.

fqsT^;4: Filtern Sie nach den Paaren, deren Produkt ist 10000. ;Nimmt den Wert von 10hier, wie er Tals Filtervariable verwendet wird, und ;immer den Wert der Variablen, die verwendet wird.

Japt , 30 29 25 23 Bytes

Nimmt Eingaben als ein Array von Zeichenfolgen und gibt ein Array von Zeichenfolgen aus.

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

Versuch es

Erläuterung

£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 dank 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 danke an 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

Alter Code

Nicht stolz darauf, aber ich dachte, ich würde sowieso einreichen. Erstellt eine Zeichenfolgeprototypfunktion, die der Zuordnung ähnelt und die den Großteil der Bytes einnimmt. Die Funktion durchläuft nur beide Permutationen und findet, wenn 1000-ab 0 ist. Übernimmt die Eingabe als Zeichenfolge.

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

Probieren Sie es online!

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

Jelly , 23 Bytes

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

Ein monadischer Link, der eine Liste von Ziffernlisten akzeptiert
(zB für das Beispiel von 923 und 72 ist die Eingabe[[9,2,3],[7,2]] )

Probieren Sie es online!(Fußzeile macht es so, dass E / A ein Paar von zwei Ganzzahlen ist und eine [formatierte] Liste von Ganzzahlenpaaren aus.)

Oder sehen Sie die Testsuite an .

Wie?

Überprüft alle Paare von "Zahlen" (Ziffernlisten), die sich auf 10000 summieren, auf Gültigkeit, indem alle Möglichkeiten zur Auswahl von n-1 Ziffern aus diesen "Zahlen" unter Beibehaltung der Reihenfolge gebildet werden; und behält diejenigen bei, die gültig sind (wobei die Gültigkeit auch zulässt, dass die zu prüfende "Nummer" der ursprünglichen "Nummer" entspricht).

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

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

Führen Sie es aus und debuggen Sie es

Diese Programme nehmen die beiden Eingänge wie folgt als Array von Zeichenfolgen.

["934", "654"]

Holzkohle , 33 Bytes

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

Probieren Sie es online! Link ist eine ausführliche Version des Codes. Erläuterung:

   χ                                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

Falls Sie das nicht verstanden haben, werden alle Wertepaare durchlaufen, die sich zu 10000 addieren (als Zeichenfolgen). Anschließend wird gezählt, wie oft jede Eingabe mit dem Ergebnis des Löschens von bis zu 1 Zeichen aus dem jeweiligen Wert übereinstimmt. Wenn die Mindestanzahl ungleich Null ist, stimmen beide Eingaben überein, und dies ist eine mögliche Lösung.

Python 3, 165 160 153 125 117 Bytes

• Dank des @ JackBrounstein-Vorschlags, setaus dem Rückgabewert zu entfernen, 5 Byte gespart , da die Ausgabe Duplikate enthalten kann.
• Gespeichert 7 durch Ersetzen range(len(s))durch range(5).
• 23 Bytes gespart dank des Vorschlags von @Eric Duminil, durch itertoolsverschachtelte Listenverständnisse zu ersetzen (und ein Leerzeichen zu entfernen).
• 8 Dank des Vorschlags von @Jo King, das Verständnis verschachtelter Listen durch einen einzigen Schleifen- und Moduloperator zu ersetzen, gespart.

Verwenden itertoolsund eine einfache Hilfsfunktion. Akzeptiert Zeichenfolgen als Eingabe und gibt eine Menge von Ints als Ausgabe zurück.

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}

Rubin , 110 Bytes

Akzeptiert Zeichenfolgen als Eingabe und gibt ein Array mit ganzen Zahlen zurück.

Basierend auf der Python Version. Für eine gegebene ganze ZahlCErstellt ein Array von Zahlen, das durch Hinzufügen einer Ziffer erstellt werden kann.

Das Lambda iteriert über jedes mögliche Paar und wählt dasjenige aus, dessen Summe 10000 ist.

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

Probieren Sie es online!

05AB1E (Legacy) , 36 Byte

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

Kann ohne Zweifel im Wesentlichen Golf gespielt werden. Insbesondere das Einfügen der Ziffern, einschließlich einer führenden / nachfolgenden.

Probieren Sie es online aus oder überprüfen Sie alle Testfälle ( êin der Fußzeile steht "Eindeutig machen und sortieren").

Erläuterung:

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

Gelee , 25 Bytes

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

Probieren Sie es online!

Nicht die kürzeste Jelly-Lösung hier, aber vielleicht kann jemand Golf spielen? Ich bin ratlos