Nous avons récemment atteint le seuil de 10 000 questions sur PPCG. Hourra! Célébrons cela avec un simple défi.

Contribution

Deux entiers et , tous deux dans , tels que .$A$$B$$[1..9999]$$A+B<10000$

Tâche

Votre tâche consiste à ajouter un seul chiffre à l'un de ces nombres entiers ou un seul chiffre aux deux, de sorte que . Si vous ajoutez un chiffre à la fois et , il ne doit pas nécessairement être le même chiffre.$A+B=10000$$A$$B$

Le nouveau chiffre peut être ajouté au début, à la fin ou n'importe où au milieu de l'entier d'origine. Cependant, vous ne pouvez pas ajouter un zéro non significatif.

Exemple:

Pour , les transformations suivantes sont valides:$A=923$

Mais ceux-ci ne sont pas valides :

Étant donné et , il existe deux solutions possibles:$A=923$$B=72$

Sortie

Vous devez imprimer ou imprimer une liste de toutes les solutions possibles.

Pour l'exemple ci-dessus, la sortie attendue serait [[9238,762],[9273,727]].

Règles

• Les E / S peuvent être traitées dans n'importe quel format raisonnable et sans ambiguïté. Vous pouvez utiliser des chaînes, des listes de chiffres, etc. au lieu d'entiers.
• L'entrée est garantie d'avoir au moins une solution.
• Vous êtes autorisé à ne pas dédupliquer la sortie. Cependant, il serait apprécié que le code de test le déduplique avec un certain post-traitement, par exemple dans la section de pied de page de TIO.
• Il s'agit d'un défi de code-golf .

Cas de 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 octets

^{-16 octets grâce à Delfad0r (en prenant les entrées comme une liste, en utilisant des abus que nous n'avons pas besoin de dédupliquer -> n peut toujours être en [0,4] & en utilisant une combinaison intelligente de format d'entrée et ap)!}

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

Essayez-le en ligne!

R , 96 octets

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

Essayez-le en ligne!

Explication (non golfée)

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

Nous attribuons ?à paste. Cela nous permet de faire quelque chose de cool: a<-b?c<-dfait des affectations en ligne dans l' pasteappel, ce que nous ne pouvions pas faire avec un autre opérateur que ?, car il a une priorité inférieure à <-.

Maintenant, comme @JoKing l'a gentiment souligné, il peut y avoir des cas comme 900 10où deux insertions pourraient avoir lieu, comme 9100 8100. Nous filtrons donc les correspondances où le nombre de caractères dans l'un ou l'autre nombre a augmenté de plus de 1. La façon rapide de le faire est avec la distance d'édition de Levenshtein à adist laquelle nous nous lions +.

Pyth, 28 27 25 24 22 20 octets

fq^;4sT*FmvsmXLkdThl

Essayez-le en ligne ici , ou vérifiez tous les cas de test ici - la suite de tests déduplique le résultat en ajoutant a {.

L'entrée est une liste de chaînes.

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)

Edit 4: sauvé encore 2 octets, grâce à Mr Xcoder - vvectorise par défaut, et Lutilise en mdessous, donc la cartographie sur la plage est implicite, ce qui rend l' Uinutile aussi

Edit 3: Introduction à l'utilisation globale de l' ;opérateur pour conserver l'accès à 10 pour économiser 2 octets, grâce à FryAmTheEggman et issacg:

fq^T4sT*FmvMsmXLkdUThl

Edit 2: J'ai oublié que l'opérateur de somme existe, combien embarrassant ...

Édition 1: la version précédente acceptait une liste d'entiers en entrée, effectuant des conversions de chaînes manuellement, pour 27 octets:

fq10000+FT*FmvMsmXLk`dUThl`

Perl 6 , 64 octets

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

Essayez-le en ligne!

Il s'agit d'un port de réponse de GB utilisant une expression régulière pour vérifier si les numéros sont valides. Merci à nwellnhof de l' avoir porté .

Ancienne réponse, 127 110 , 88 octets

-22 octets grâce à nwellnhof!

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

Essayez-le en ligne!

Bloc de code anonyme qui prend une liste de deux nombres et renvoie une liste de paires de nombres.

Plutôt que de jouer avec l'insertion des chiffres, cette solution vérifie chaque combinaison de nombres qui totalisent 10000 et filtre que les nombres donnés font partie de la paire.

Explication:

->\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 150 144 octets

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}

Essayez-le en ligne!

35 octets enregistrés par @JayCe et @Giuseppe.

Explication

La fonction d'assistance g obtient toutes les insertions possibles.

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
}

Fonction 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!

J'ai remarqué après le fait que c'est essentiellement la même logique que la réponse Pyth .

Rubis , 93 91 octets

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

Essayez-le en ligne!

Essayez chaque numéro jusqu'à 10000 et utilisez l'expression régulière pour vérifier si les numéros correspondent.

Gelée , 30 octets

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

Essayez-le en ligne!

Un peu maladroit car Jelly n'a pas d'insertion.

Explication

                                   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 octets

bel exemple pour une fonction de générateur!

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

prend l'entrée des arguments de la ligne de commande; imprime les doublons. Courez avec -nr '<code>ou essayez-le en ligne .

Pyth, 18 octets

fqsT^;4*FsMvXLRRTT

Démonstration , suite de tests (la suite de tests est dédupliquée avec le leader {).

L'entrée se présente sous la forme d'une liste de deux chaînes.

XLRRTT: L et R effectuent des cartes imbriquées. Puisqu'il y en a 3, nous allons effectuer une carte triplement imbriquée de la Xfonction. Dans ce cas, la Xfonction insérera un caractère à une position désignée dans une chaîne.

La chaîne est l'entrée, qui est implicite et placée par la première R. Le caractère s'étend sur 0 ... 9, nous avons donc tous les chiffres insérés possibles, et est placé par le L. La plage est donnée par T, qui est implicitement définie sur 10, qui est implicitement traitée comme [0 ... 9]. La position s'étend 0 ... 9, ce qui est suffisant, car l'insertion d'un nombre après la 10e position ne sera jamais utile. Les résultats en double sont corrects. La plage est placée par la seconde Ret donnée par la seconde T.

v: Chaînes de distribution imbriquées en pouces.

sM: Aplatissez le deuxième niveau de listes, nous laissant avec une liste de tous les nombres possibles après insertion de chiffres, pour chacun des nombres saisis.

*F: Prenez le produit cartésien des deux listes de nombres possibles.

fqsT^;4: Filtrer sur les paires dont le produit est 10000. ;prend la valeur d' 10ici, telle qu'elle Test utilisée comme variable de filtre, et ;toujours comme la valeur de la variable qui est utilisée.

Japt , 30 29 25 23 octets

Prend l'entrée comme un tableau de chaînes, génère un tableau de tableaux de chaînes.

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

Essayez-le

Explication

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

123 octets grâce à 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 octets grâce à 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

Ancien code

Pas fier de ça, mais j'ai pensé que je soumettrais quand même. Crée une fonction de prototype de chaîne semblable à la carte qui prend la majeure partie des octets. La fonction parcourt simplement les deux permutations et trouve lorsque 1000-ab est égal à 0. Prend l'entrée en tant que chaînes.

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

Essayez-le en ligne!

Non 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

Gelée , 23 octets

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

Un lien monadique acceptant une liste de listes de chiffres
(par exemple pour l'exemple de 923 et 72 l'entrée est [[9,2,3],[7,2]])

Essayez-le en ligne! (le pied de page fait que les E / S sont une paire de deux entiers entrants et une liste [formatée] de paires d'entiers sortants)

Ou consultez la suite de tests .

Comment?

Vérifie toutes les paires de "nombres" (listes de chiffres) qui totalisent 10000 pour la validité en formant toutes les façons de choisir n-1 chiffres parmi ces "nombres" en maintenant l'ordre; et conserve ceux qui sont valides (où la validité permet également que le "nombre" testé soit égal au "nombre" d'origine).

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

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

Exécuter et déboguer

Ce programme prend ses deux entrées comme un tableau de chaînes, comme ceci.

["934", "654"]

Fusain , 33 octets

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

Essayez-le en ligne! Le lien est vers la version détaillée du code. Explication:

   χ                                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

Au cas où vous ne l'auriez pas compris, il parcourt toutes les paires de valeurs qui s'ajoutent à 10000 (sous forme de chaînes), puis compte le nombre de fois que chaque entrée correspond au résultat de la suppression jusqu'à 1 caractère de la valeur respective. Si le nombre minimum est différent de zéro, les deux entrées correspondent et c'est une solution possible.

Python 3, 165160153125117 octets

• 5 octets enregistrés grâce à la suggestion de @JackBrounstein de supprimer setde la valeur de retour, car la sortie peut contenir des doublons.
• Enregistré 7 en remplaçant range(len(s)) par range(5).
• Économie de 23 octets grâce à la suggestion de @Eric Duminil de remplacer itertools par des listes de listes imbriquées (et en supprimant un espace).
• Enregistré 8 grâce à la suggestion de @Jo King de remplacer la compréhension de la liste imbriquée par un opérateur de boucle et de module unique.

Utilisation itertoolset une fonction d'assistance simple. Accepte les chaînes en entrée, renvoie un ensemble d'entiers en sortie.

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}

Rubis , 110 octets

Accepte les chaînes en entrée, renvoie un tableau de tableau d'entiers.

Basé sur version python . Pour un entier donné,C crée un tableau de nombres qui peut être créé en ajoutant un chiffre.

Le lambda parcourt chaque paire possible et sélectionne celle dont la somme est de 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}}

Essayez-le en ligne!

05AB1E (hérité) , 36 octets

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

Peut sans aucun doute être joué au golf de manière substantielle.

Essayez-le en ligne ou vérifiez tous les cas de test ( êdans le pied de page se trouve Uniquify & Sort).

Explication:

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

Gelée , 25 octets

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

Essayez-le en ligne!

Ce n'est pas la solution de gelée la plus courte ici, mais peut-être que quelqu'un peut jouer au golf? Je suis perplexe