Recientemente hemos alcanzado el umbral de 10,000 preguntas sobre PPCG. ¡Hurra! Celebremos esto con un simple desafío.

Entrada

Dos enteros $A$ y $B$ , ambos en $[1..9999]$ , de modo que $A+B<10000$ .

Tarea

Su tarea es agregar un solo dígito a uno de estos enteros o un solo dígito a ambos de manera que $A+B=10000$ . Si agrega un dígito a $A$ y $B$ , no necesariamente tiene que ser el mismo dígito.

El nuevo dígito se puede agregar al principio, al final o en cualquier lugar en el medio del entero original. Sin embargo, no puede agregar un cero a la izquierda.

Ejemplo:

Para $A=923$ , las siguientes transformaciones son válidas:

Pero estos no son válidos :

Dado $A=923$ y $B=72$ , hay dos posibles soluciones:

Salida

Debe imprimir o generar una lista de todas las soluciones posibles.

Para el ejemplo anterior, el resultado esperado sería [[9238,762],[9273,727]].

Reglas

• Las E / S se pueden procesar en cualquier formato razonable y sin ambigüedades. Puede usar cadenas, listas de dígitos, etc. en lugar de enteros.
• Se garantiza que la entrada tenga al menos una solución.
• Se le permite no deduplicar la salida. Sin embargo, se agradecería que el código de prueba lo esté deduplicando con algún procesamiento posterior, por ejemplo, en la sección de pie de página de TIO.
• Este es un desafío de código de golf .

Casos de prueba

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 gracias a Delfad0r (tomando entradas como una lista, usando el abuso que no necesitamos deduplicar -> n siempre puede estar en [0,4] y usando una combinación inteligente de formato de entrada y ap).}

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

Pruébalo en línea!

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

Pruébalo en línea!

Explicación (sin golf)

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

Asignamos ?a paste. Eso nos permite hacer algo genial: a<-b?c<-dhace asignaciones en línea dentro de la pastellamada, lo que no podríamos hacer con ningún otro operador que ?, ya que tiene una prioridad menor que <-.

Ahora, como señaló amablemente @JoKing, puede haber casos 900 10en los que podrían tener lugar dos inserciones como 9100 8100. Por lo tanto, filtramos las coincidencias donde el número de caracteres en cualquiera de los números ha aumentado en más de 1. La forma rápida de hacerlo es con la distancia de edición de Levenshtein a la adist que nos unimos +.

Pyth, 28 27 25 24 22 20 bytes

fq^;4sT*FmvsmXLkdThl

Pruébelo en línea aquí , o verifique todos los casos de prueba aquí : el conjunto de pruebas deduplica el resultado anteponiendo a {.

La entrada es como una lista de cadenas.

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)

Edición 4: guardó otros 2 bytes, gracias a Mr Xcoder: se vvectoriza de forma predeterminada y se Lusa mdebajo, por lo que la asignación sobre el rango está implícita, lo que hace Uinnecesario también

Edición 3: Introducción al uso global del ;operador para conservar el acceso a 10 para guardar 2 bytes, gracias a FryAmTheEggman e issacg:

fq^T4sT*FmvMsmXLkdUThl

Edición 2: Olvidé que existe el operador de suma, qué embarazoso ...

Edición 1: la versión anterior aceptó una lista de enteros como entrada, realizando conversiones de cadenas manualmente, para 27 bytes:

fq10000+FT*FmvMsmXLk`dUThl`

Perl 6 , 64 bytes

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

Pruébalo en línea!

Este es un puerto de respuesta de GB usando una expresión regular para verificar si los números son válidos. Gracias a nwellnhof por portarlo.

Respuesta anterior, 127 110 , 88 bytes

-22 bytes gracias a nwellnhof!

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

Pruébalo en línea!

Bloque de código anónimo que toma una lista de dos números y devuelve una lista de pares de números.

En lugar de jugar con la inserción de los dígitos, esta solución verifica cada combinación de números que suman 10000 y filtra que los números dados son parte del par.

Explicación:

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

Pruébalo en línea!

35 bytes guardados por @JayCe y @Giuseppe.

Explicación

La función auxiliar g obtiene todas las inserciones posibles.

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
}

Función principal.

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!

Después del hecho, he notado que esta es esencialmente la misma lógica que la respuesta de Pyth .

Ruby , 93 91 bytes

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

Pruébalo en línea!

Pruebe cada número hasta el 10000 y use la expresión regular para verificar si los números coinciden.

Jalea , 30 bytes

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

Pruébalo en línea!

Un poco torpe porque Jelly no tiene inserción.

Explicación

                                   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 bytes

hermoso ejemplo para una función de generador!

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

toma datos de los argumentos de la línea de comandos; Imprime duplicados. Ejecutar -nr '<code>o probarlo en línea .

Pyth, 18 bytes

fqsT^;4*FsMvXLRRTT

Demostración , conjunto de pruebas (el conjunto de pruebas se deduplica con{ )

La entrada tiene la forma de una lista de dos cadenas.

XLRRTT: L y R realizan mapas anidados. Como hay 3 de ellos, realizaremos un mapa triplemente anidado de la Xfunción. En este caso, elX función insertará un carácter en una posición designada en una cadena.

La cadena es la entrada, que está implícita y colocada por el primero R. El carácter varía 0 ... 9, por lo que tenemos todos los dígitos insertados posibles, y se coloca con el L. El rango viene dado por T, que se establece implícitamente en 10, que se trata implícitamente como [0 ... 9]. La posición varía 0 ... 9, lo cual es suficiente, porque insertar un número después de la décima posición nunca será útil. Los resultados duplicados están bien. El rango es colocado por el segundo R, y dado por el segundo T.

v: Cadenas anidadas de fundición a int.

sM: Aplanar el segundo nivel de listas, dejándonos con una lista de todos los números posibles después de la inserción de dígitos, para cada uno de los números de entrada.

*F: Tome el producto cartesiano de las dos listas de números posibles.

fqsT^;4: Filtra en los pares cuyo producto es 10000. ;toma el valor de 10aquí, como Testá en uso como la variable de filtro, y ;siempre como el valor de la variable que está en uso.

Japt , 30 29 25 23 bytes

Toma la entrada como una matriz de cadenas, emite una matriz de matrices de cadenas.

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

Intentalo

Explicación

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

123 Bytes gracias 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 Bytes gracias a 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

Código antiguo

No me enorgullezco de ello, pero pensé que me enviaría de todos modos. Crea una función de prototipo de cadena similar al mapa que ocupa la mayor parte de los bytes. La función simplemente itera a través de ambas permutaciones y encuentra cuándo 1000-ab es 0. Toma la entrada como cadenas.

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

Pruébalo en línea!

Sin golf

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

Jalea , 23 bytes

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

Un enlace monádico que acepta una lista de listas de dígitos
(por ejemplo, para el ejemplo de 923 y 72, la entrada es [[9,2,3],[7,2]])

Pruébalo en línea!(el pie de página hace que la E / S sea un par de dos enteros y una lista [formateada] de pares de enteros)

O ver el conjunto de pruebas .

¿Cómo?

Verifica todos los pares de "números" (listas de dígitos) que suman 10000 para validez al formar todas las formas de elegir n-1 dígitos de esos "números" manteniendo el orden; y mantiene aquellos que son válidos (donde la validez también permite que el "número" bajo prueba sea igual al "número" original).

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

Ejecutar y depurarlo

Esos programas toman sus dos entradas como una matriz de cadenas, como esta.

["934", "654"]

Carbón , 33 bytes

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

Pruébalo en línea! El enlace es a la versión detallada del código. Explicación:

   χ                                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

En caso de que no lo haya entendido, se ejecuta a través de todos los pares de valores que se suman a 10000 (como cadenas), luego cuenta cuántas veces cada entrada coincide con el resultado de eliminar hasta 1 carácter del valor respectivo. Si el recuento mínimo no es cero, ambas entradas coinciden y esta es una posible solución.

Python 3, 165160153125117 bytes

• Guardado 5 bytes gracias a la sugerencia de @JackBrounstein para eliminar set del valor de retorno, ya que la salida puede contener duplicados.
• Se salvó 7 al reemplazar range(len(s)) conrange(5) .
• Ahorró 23 bytes gracias a la sugerencia de @Eric Duminil de reemplazar itertools con comprensiones de listas anidadas (y eliminar un espacio).
• Guardado 8 gracias a la sugerencia de @Jo King de reemplazar la comprensión de la lista anidada con un solo operador de bucle y módulo.

Uso itertoolsy una función auxiliar simple. Acepta cadenas como entrada, devuelve un conjunto de entradas como salida.

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}

Rubí , 110 bytes

Acepta cadenas como entrada, devuelve una matriz de matriz de enteros.

Basado en la versión de Python . Para un entero dado,C crea una matriz de números que se pueden crear agregando un dígito.

La lambda itera sobre cada par posible y selecciona el cuya suma es 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}}

Pruébalo en línea!

05AB1E (legado) , 36 bytes

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

Sin duda, se puede jugar al golf sustancialmente. Especialmente insertando los dígitos, incluido uno inicial / final.

Pruébelo en línea o verifique todos los casos de prueba ( êen el pie de página hay Uniquify & Sort).

Explicación:

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

Jalea , 25 bytes

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

Pruébalo en línea!

No es la solución Jelly más corta aquí, ¿pero tal vez alguien pueda jugar golf? Estoy perplejo