Di recente abbiamo raggiunto la soglia di 10.000 domande su PPCG. Evviva! Celebriamo questo con una semplice sfida.

Ingresso

Due numeri interi e , entrambi in , in modo che .$A$$B$$[1..9999]$$A+B<10000$

Compito

Il tuo compito è quello di aggiungere una singola cifra a uno di questi numeri interi o una singola cifra ad entrambi in modo tale che . Se si aggiunge una cifra a e , non è necessario che sia necessariamente la stessa cifra.$A+B=10000$$A$$B$

La nuova cifra può essere aggiunta all'inizio, alla fine o ovunque nel mezzo dell'intero originale. Tuttavia, non è possibile aggiungere uno zero iniziale.

Esempio:

Per , sono valide le seguenti trasformazioni:$A=923$

Ma questi non sono validi :

Dato e , ci sono due possibili soluzioni:$A=923$$B=72$

Produzione

È necessario stampare o stampare un elenco di tutte le possibili soluzioni.

Per l'esempio sopra, l'output previsto sarebbe [[9238,762],[9273,727]].

Regole

• L'I / O può essere elaborato in qualsiasi formato ragionevole e inequivocabile. È possibile utilizzare stringhe, elenchi di cifre, ecc. Anziché numeri interi.
• È garantito che l'input abbia almeno una soluzione.
• È consentito non deduplicare l'output. Tuttavia, sarebbe apprezzato se il codice di test lo deduplica con qualche post-elaborazione, ad esempio nella sezione piè di pagina di TIO.
• Questa è una sfida di code-golf .

Casi test

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 grazie a Delfad0r (prendendo input come elenco, usando abusi che non abbiamo bisogno di deduplicare -> n può sempre essere in [0,4] e usare una combinazione intelligente di input-format e ap)!}

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

Provalo 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

Provalo online!

Spiegazione (non golfizzato)

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

Assegniamo ?a paste. Questo ci consente di fare qualcosa di interessante: a<-b?c<-dsvolge compiti in linea all'interno della pastechiamata, cosa che non potremmo fare con nessun altro operatore rispetto a ?, poiché ha una precedenza inferiore a <-.

Ora, come ha gentilmente sottolineato @JoKing, ci possono essere casi come in 900 10cui potrebbero avvenire due inserzioni come 9100 8100. Quindi filtriamo le partite in cui il numero di caratteri in entrambi i numeri è aumentato di più di 1. Il modo rapido per farlo è con la distanza di modifica di Levenshtein alla adist quale ci leghiamo +.

Pyth, 28 27 25 24 22 20 byte

fq^;4sT*FmvsmXLkdThl

Provalo online qui o verifica tutti i casi di test qui : la suite di test deduplica il risultato anteponendo a {.

L'input è come un elenco di stringhe.

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)

Modifica 4: salvato altri 2 byte, grazie a Mr Xcoder - vvettorializza di default, e Lusa msotto, quindi è implicita la mappatura su range, rendendo anche il non- Uobbligatorio

Modifica 3: introdotto per l'uso globale ;dell'operatore per mantenere l'accesso a 10 per salvare 2 byte, grazie a FryAmTheEggman e issacg:

fq^T4sT*FmvMsmXLkdUThl

Modifica 2: Ho dimenticato che esiste l'operatore somma, quanto imbarazzante ...

Modifica 1: la versione precedente accettava un elenco di numeri interi come input, eseguendo manualmente le conversioni di stringa, per 27 byte:

fq10000+FT*FmvMsmXLk`dUThl`

Perl 6 , 64 byte

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

Provalo online!

Questa è una porta della risposta di GB che utilizza una regex per verificare se i numeri sono validi. Grazie a nwellnhof per il porting.

Vecchia risposta, 127 110 , 88 byte

-22 byte grazie a nwellnhof!

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

Provalo online!

Blocco di codice anonimo che contiene un elenco di due numeri e restituisce un elenco di coppie di numeri.

Invece di giocherellare con l'inserimento delle cifre, questa soluzione controlla ogni combinazione di numeri che si sommano a 10000 e filtra che i numeri indicati facciano parte della coppia.

Spiegazione:

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

Provalo online!

35 byte salvati da @JayCe e @Giuseppe.

Spiegazione

La funzione di aiuto g ottiene tutti gli inserimenti possibili.

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
}

Funzione principale.

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!

Ho notato dopo che questa è essenzialmente la stessa logica della risposta Pyth .

Rubino , 93 91 byte

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

Provalo online!

Prova ogni singolo numero fino a 10000 e usa regex per verificare se i numeri corrispondono.

Gelatina , 30 byte

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

Provalo online!

Un po 'goffo perché Jelly non ha inserimenti.

Spiegazione

                                   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

bell'esempio per una funzione di generatore!

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

accetta input dagli argomenti della riga di comando; stampa duplicati. Corri con -nr '<code>o provalo online .

Pyth, 18 byte

fqsT^;4*FsMvXLRRTT

Dimostrazione , suite di test (la suite di test è deduplicata con il leader {).

L'input ha la forma di un elenco di due stringhe.

XLRRTT: L e R eseguono mappe nidificate. Poiché ce ne sono 3, eseguiremo una mappa annidata triplicata della Xfunzione. In questo caso, la Xfunzione inserirà un carattere in una posizione designata in una stringa.

La stringa è l'input, che è implicito e inserito dal primo R. Il carattere si estende 0 ... 9, quindi abbiamo tutte le possibili cifre inserite e viene inserito dal L. L'intervallo è dato da T, che è implicitamente impostato su 10, che è implicitamente trattato come [0 ... 9]. La posizione varia 0 ... 9, il che è sufficiente, perché l'inserimento di un numero dopo la decima posizione non sarà mai utile. I risultati duplicati vanno bene. L'intervallo è posizionato dal secondo Re dato dal secondo T.

v: Stringhe di cast nidificate in ints.

sM: Appiattisce il secondo livello di elenchi, lasciandoci con un elenco di tutti i possibili numeri dopo l'inserimento delle cifre, per ciascuno dei numeri di input.

*F: Prendi il prodotto cartesiano delle due liste di possibili numeri.

fqsT^;4: Filtra le coppie il cui prodotto è 10000. ;prende il valore di 10qui, poiché Tè in uso come variabile di filtro e ;sempre come valore della variabile in uso.

Japt , 30 29 25 23 byte

Prende l'input come una matrice di stringhe, genera una matrice di array di stringhe.

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

Provalo

Spiegazione

£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 (nodo) - 183 136 123 byte

123 byte grazie a 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 grazie ad 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

Vecchio codice

Non ne sono orgoglioso, ma ho pensato che avrei presentato comunque. Crea una funzione prototipo di stringa simile alla mappa che occupa la maggior parte dei byte. La funzione scorre solo attraverso entrambe le permutazioni e trova quando 1000-ab è 0. Accetta input come stringhe.

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

Provalo 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

Gelatina , 23 byte

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

Un collegamento monadico che accetta un elenco di elenchi di cifre
(ad esempio, per l'esempio di 923 e 72, l'input è [[9,2,3],[7,2]])

Provalo online! (footer lo rende in modo che l'I / O sia una coppia di due numeri interi in e un elenco [formattato] di coppie di numeri interi in uscita)

Oppure vedi la suite di test .

Come?

Controlla tutte le coppie di "numeri" (elenchi di cifre) che si sommano a 10000 per validità formando tutti i modi per scegliere n-1 cifre da quei "numeri" mantenendo l'ordine; e mantiene quelli che sono validi (dove la validità consente anche che il "numero" sotto test sia uguale al "numero" originale).

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

Esegui ed esegui il debug

Quel programma prende i suoi due input come una matrice di stringhe, come questa.

["934", "654"]

Carbone , 33 byte

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

Provalo online! Il collegamento è alla versione dettagliata del codice. Spiegazione:

   χ                                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

Nel caso non lo capissi, scorre tutte le coppie di valori che si aggiungono a 10000 (come stringhe), quindi conta quante volte ciascun input corrisponde al risultato dell'eliminazione di 1 carattere dal rispettivo valore. Se il conteggio minimo è diverso da zero, entrambi gli input corrispondono e questa è una possibile soluzione.

Python 3, 165 160 153 125 117 byte

• Salvato 5 byte grazie al suggerimento di @JackBrounstein per rimuovere setdal valore restituito, poiché l'output può contenere duplicati.
• Salvato 7 sostituendo range(len(s))con range(5).
• Risparmiato 23 byte grazie al suggerimento di @Eric Duminil di sostituire itertoolscon la comprensione dell'elenco nidificato (e la rimozione di uno spazio).
• Salvato 8 grazie al suggerimento di @Jo King di sostituire la comprensione della lista nidificata con un singolo operatore di loop e modulo.

Utilizzo itertoolse una semplice funzione di supporto. Accetta le stringhe come input, restituisce un set di ints come 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}

Rubino , 110 byte

Accetta stringhe come input, restituisce un array di array di numeri interi.

Basato sulla versione di Python . Per un dato numero intero, Ccrea una matrice di numeri che è possibile creare aggiungendo una cifra.

La lambda scorre su ogni possibile coppia e seleziona quella la cui somma è 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}}

Provalo online!

05AB1E (legacy) , 36 byte

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

Senza dubbio si può giocare a golf in modo sostanziale. In particolare inserendo le cifre, inclusa una prima o una successiva.

Provalo online o verifica tutti i casi di test ( ênel piè di pagina c'è Uniquify & Sort).

Spiegazione:

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

Gelatina , 25 byte

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

Provalo online!

Non è la soluzione Jelly più breve qui, ma forse qualcuno può giocare a golf? Sono perplesso