Défi

En donnant une somme arithmétique valide avec quelques nombres manquants, affichez l'expression complète.

Exemple:

    1#3                 123
+   45#     =>     +    456
--------            --------
    579                 579

Contribution

• Le format d'expression peut être un tableau ["1#3", "45#", "579"], une chaîne "1#3+45#=579"ou 3 entréesf("1#3","45#","579")

Production

• Identique à l'entrée
• Vous n'avez pas besoin de sortir le résultat

Remarques

• Les nombres manquants seront représentés à l'aide de #ou tout autre caractère non numérique constant que vous souhaitez
• Supposons que le résultat n'aura pas de numéro manquant
• Supposons que les entrées / sorties consistent en 2 termes et un résultat final
• Supposons à la fois terme> 0 et résultat> = 2
• Il peut y avoir plusieurs solutions. Vous pouvez sortir n'importe qui tant que le résultat de la somme correspond

Cas de test avec éventuellement des sorties (joli format)

    #79                     879
+   44#         =>      +   444
--------                --------
    1323                   1323

    5#5                     555
+   3#3         =>      +   343
--------                --------
    898                     898

      #                       1
+     #         =>      +     1
--------                --------
      2                       2

    ###                     998
+   ###         =>      +     1     PD: there are a lot of possible outputs for this one
--------                --------
    999                     999


    123                     123
+     #         =>      +     1
--------                --------
    124                     124


      9                       9
+    #6         =>      +    46
--------                --------
     55                      55


    #123651                     1123651
+      #98#         =>      +      7981
------------                -----------
    1131632                     1131632

Les règles de code-golf standard s'appliquent

Brachylog , 22 16 octets

{Ṣ∧Ị∋|}ᵐ²ịᵐ.k+~t

Essayez-le en ligne!

-6 octets grâce à @Fatelize

Explication

{Ṣ∧Ị∋|}ᵐ²ịᵐ.k+~t
{     }ᵐ²                   #   for each letter in each string
 Ṣ∧Ị∋                       #       if " " return a digit; else input
     |                      #
         ịᵐ                 #   cast each string to number
            k+              #   the sum of all but the last one
              ~t            #       is equal to the last one
           .                #   output that list

JavaScript (ES6), 74 57 octets

Prend l'entrée comme (a)(b)(result) , où a et b sont des chaînes avec .des chiffres inconnus et le résultat est un entier. Renvoie un tableau de 2 entiers.

a=>b=>F=(c,n)=>`${r=[c,n]}`.match(`^`+[a,b])?r:F(c-1,-~n)

Essayez-le en ligne!

Commenté

a => b =>                // a, b = term patterns (e.g. a = ".79", b = "44.")
  F = (c,                // c = expected result (e.g. 1323)
          n) =>          // n = guessed value of b, initially undefined
    `${r = [c, n]}`      // we coerce r = [c, n] to a string (e.g. "879,444")
                         // if n is still undefined, this gives just c followed by a comma
    .match(`^` + [a, b]) // we coerce [a, b] to a string, prefixed with "^" (e.g. "^.79,44.")
    ?                    // this is implicitly turned into a regular expression; if matching:
      r                  //   return r
    :                    // else:
      F(c - 1, -~n)      //   decrement c, increment n and do a recursive call

Matlab, 143 134 132 119 115 octets

function[m]=f(x,y,r),p=@(v)str2num(strrep(v,'#',char(randi([48,57]))));m=[1,1];while sum(m)-r,m=[p(x),p(y)];end;end

-4 octets grâce à @Luismendo

Essayez-le en ligne

Assez gros et assez stupide. Il remplace simplement tout #par des chiffres aléatoires jusqu'à ce qu'il trouve les bons.

R , 67 51 octets

Rock simple et échelles horriblement, juste grep toutes les combinaisons de somme. Utilisation "." pour les chiffres inconnus. Il ne trouvera pas la même réponse que le cas de test numéro 4, mais il donnera une réponse possible, qui suit la lettre des règles donnée.

-16 octets par grepping après avoir formé la sortie et remplacé pastepar l' ?opérateur.

function(x,y,z,`?`=paste)grep(x?y,1:z?z:1-1,v=T)[1]

Essayez-le en ligne!

Fusain , 32 octets

Ｆ²⊞υ0Ｗ⁻ζΣＩυ≔Ｅ⟦θη⟧⭆κ⎇⁼μ#‽χμυ←Ｅυ⮌ι

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

Ｆ²⊞υ0

Poussez deux chaînes 0vers la liste vide prédéfinie upour lancer la boucle while.

Ｗ⁻ζΣＩυ

Répétez pendant que la somme de la conversion des valeurs en uentier n'est pas égale au résultat souhaité.

≔Ｅ⟦θη⟧

Créez un tableau des deux entrées et mappez dessus.

⭆κ⎇⁼μ#‽χμυ

Remplacez chacun #par un chiffre aléatoire et attribuez le résultat à u.

←Ｅυ⮌ι

Imprimer le résultat justifié à droite. (Justifié à gauche serait juste υpour une sauvegarde de 4 octets.)

Gelée , 20 octets

ØDṛċ¡V€)ŒpḌð€ŒpS⁼¥ƇḢ

Essayez-le en ligne!

05AB1E (hérité), 23 20 octets

[²³«εð9ÝΩ:}²gôJDO¹Q#

-3 octets grâce à @Emigna .

Les chiffres inconnus sont des espaces ( ). L'ordre d'entrée doit être: résultat attendu; chaîne la plus longue; chaîne la plus courte.

Essayez-le en ligne .

Explication:

[                 # Start an infinite loop
 ²³«              #  Take the second and third inputs, and merge them together
               #   i.e. " 79" and " 4 " → " 79 4 "
    ε     }    #  Map each character to:
     ð   :     #   Replace a space with:
      9ÝΩ      #   A random digit in the range [0,9]
               #    i.e. " 79 4 " → ['3','7','9','2','4','3']
               #    i.e. " 79 4 " → ['5','7','9','7','4','4']
²g             #  Get the length of the second input
               #   i.e. " 79" → 3
  ô            #  And split it into two numbers again
               #   i.e. ['3','7','9','2','4','3'] and 3 → [['3','7','9'],['2','4','3']]
               #   i.e. ['5','7','9','7','4','4'] and 3 → [['5','7','9'],['7','4','4']]
   J           #  Join each list together to a single number
               #   i.e. [['3','7','9'],['2','4','3']] → [379,243]
               #   i.e. [['5','7','9'],['7','4','4']] → [579,744]
    D          #  Duplicate this list
     O         #  Sum the list
               #   i.e. [379,243] → 622
               #   i.e. [579,744] → 1323
      ¹Q#      #  If it's equal to the first input: stop the infinite loop
               #  (and output the duplicate list implicitly)
               #   i.e. 1323 and 622 → 0 (falsey) → continue the loop
               #   i.e. 1323 and 1323 → 1 (truthy) → stop the loop and output [579,744]

Perl 6 , 81 74 octets

-7 octets grâce à nwellnhof!

{first {try S/\=/==/.EVAL},map {$^a;S:g[\#]=$a[$++]},[X] ^10 xx.comb('#')}

Essayez-le en ligne!

Bloc de code anonyme qui prend l'entrée comme une chaîne contenant une expression arithmétique, par exemple "12 # + 45 # = 579". Remplace chacun #par des permutations possibles de chiffres, remplace le =par ==et trouve le premier résultat valide.

Explication:

{  # Anonymous code block                                                      }
 first   # Find the first of:
                                                               ^10  # The range of 0 to 9
                                                                   xx.comb('#') # Multiplied by the number #s in the code
                                                          ,[X]  # The cross-product of these lists
                          map   # Map each crossproduct to:
                              {$^a;.trans: "#"=>{$a[$++]}}  # The given string with each # translated to each element in the list
      {try S/\=/==/.EVAL}, # Find which of these is true when = are changed to == and it is eval'd

APL (Dyalog Unicode) , 22 octets

{'#'⎕R{⍕?10}t}⍣{⍎⍺}t∘←

Essayez-le en ligne!

Java 10, 203 198 193 octets

(a,b,c)->{int A=0,B=0,l=a.length();for(a+=b,b="";A+B!=c;A=c.valueOf(b.substring(0,l)),B=c.valueOf(b.substring(l)),b="")for(var t:a.getBytes())b+=t<36?(t*=Math.random())%10:t-48;return A+"+"+B;}

Essayez-le en ligne.

Explication:

(a,b,c)->{           // Method with 2 Strings & integer parameters and String return-type
  int A=0,B=0,       //  Result-integers, starting both at 0
      l=a.length();  //  Length of the first String-input
  for(a+=b,          //  Concat the second String-input to the first
      b="";          //  Reuse `b`, and start it as an empty String
      A+B!=c         //  Loop as long as `A+B` isn't equal to the integer-input
      ;              //    After every iteration:
       A=c.valueOf(b.substring(0,l)),
                     //     Set `A` to the first String-part as integer
       B=c.valueOf(n.substring(l)),
                     //     Set `B` to the second String-part as integer
       b="")         //     Reset `b` to an empty String
    for(var t:a.getBytes())
                     //   Inner loop over the characters of the concatted String inputs
      b+=t<36?       //    If the current character is a '#':
          (t*=Math.random())%10
                     //     Append a random digit to `b`
         :           //    Else (it already is a digit):
          t-48;      //     Append this digit to `b`
  return A+"+"+B;}   //  After the loop, return `A` and `B` as result

C (gcc) , 228 213 203 172 170 octets

-15 octets grâce à @ceilingcat . Je n'en ai jamais utilisé indexauparavant.

-10 octets grâce à @Logem . Magie du préprocesseur

appel refactorisé à exit(0)avec met comme paramètre.

char*c,*p[9],k;main(i,v)int**v;{for(i=X[1],35))||X[2],35))?p[k++]=c,main(*c=57,v):k;!c*i--;)47==--*p[i]?*p[i]=57:Y[1])+Y[2])^Y[3])?main(i,v):exit(puts(v[2],puts(v[1])));}

Essayez-le en ligne!

C # .NET, 225 220 196 octets

(a,b,c)=>{int A=0,B=0,l=a.Length;for(a+=b,b="";A+B!=c;A=int.Parse(b.Substring(0,l)),B=int.Parse(b.Substring(l)),b="")foreach(var t in a)b+=(t<36?new System.Random().Next(10):t-48)+"";return(A,B);}

Port de ma réponse Java 10 .
(Je suis très rouillé dans le golf C # .NET, donc je peux certainement y jouer ..)

-3 octets implicitement grâce à @ user82593 et à cette nouvelle astuce C # qu'il a ajoutée .
-29 octets grâce à @hvd .

Essayez-le en ligne.

Explication:

(a,b,c)=>{        // Method with 2 string & int parameters and int-tuple return-type
  int A=0,B=0,    //  Result-integers, starting both at 0
      l=a.Length; //  Length of the first string-input
  for(a+=b,       //  Concat the second string-input to the first
      b="";       //  Reuse `b`, and start it as an empty string
      A+B!=c      //  Loop as long as `A+B` isn't equal to the integer-input
      ;           //    After every iteration:
       A=int.Parse(b.Substring(0,l)),
                  //     Set `A` to the first string-part as integer
       B=int.Parse(b.Substring(l)),
                  //     Set `B` to the second string-part as integer
       b="")      //     Reset `b` to an empty string
    foreach(var t in a)
                  //   Inner loop over the characters of the concatted string inputs
      b+=(t<36?   //    If the current character is a '#':
           new System.Random().Next(10)
                  //     Use a random digit
          :       //    Else (it already is a digit):
           t-48)  //     Use this digit as is
         +"";     //    And convert it to a string so it can be appended to the string
  return(A,B);}   //  After the loop, return `A` and `B` in a tuple as result

Python 3 , 121 155 152 149 149 octets

import re
def f(i,k=0,S=re.sub):s=S('#','%s',i)%(*list('%0*d'%(i.count('#'),k)),);print(s)if eval(S('=','==',S('\\b0*([1-9])','\\1',s)))else f(i,k+1)

Essayez-le en ligne!

+34 Nouvelle solution avec regex pour contourner le fait que python ne prend pas en charge les nombres avec des zéros en tête.

-3 merci à @Jonathan Frech

L'ancienne solution ne fonctionne pas si # est le premier caractère d'un nombre quelconque (car eval n'accepte pas les zéros en tête) et n'est donc pas valide :(

def f(i,k=0):
 s=i.replace('#','%s')%(*list('%0*d'%(i.count('#'),k)),)
 print(s)if eval(s.replace('=','=='))else f(i,k+1)

Essayez-le en ligne!

PHP, 112 octets

solution de force brute boiteuse

for(;$s=$argn;eval(strtr($s,['='=>'==','#'=>0]).'&&die($s);'))for($k=$n++;$k;$k=$k/10|0)$s[strpos($s,35)]=$k%10;

prend la chaîne en entrée, s'arrête à la première solution. Exécuter en tant que pipe avec -nRou l' essayer en ligne .

Powershell, 91 octets

Le script trouve toutes les solutions. Le nombre total d'itérations est de 10 pour le nombre de caractères #. La profondeur de récursivité est égale au nombre de caractères #.

filter f{$h,$t=$_-split'#',2
if($t){0..9|%{"$h$_$t"}|f}elseif($h-replace'=','-eq'|iex){$h}}

Script de test:

filter f{$h,$t=$_-split'#',2
if($t){0..9|%{"$h$_$t"}|f}elseif($h-replace'=','-eq'|iex){$h}}

@(
    ,('1#3+45#=579','123+456=579')
    ,('#79+44#=1323','879+444=1323')
    ,('5#5+3#3=898','505+393=898 515+383=898 525+373=898 535+363=898 545+353=898 555+343=898 565+333=898 575+323=898 585+313=898 595+303=898')
    ,('#+#=2','0+2=2 1+1=2 2+0=2')
    ,('9+#6=55','9+46=55')
    ,('123+##=124','123+01=124')
    ,('#123651+#98#=1131632','1123651+7981=1131632')
    ,('##+##=2','00+02=2 01+01=2 02+00=2')
    ,('##+##=99','00+99=99 01+98=99 02+97=99 03+96=99 04+95=99 05+94=99 06+93=99 07+92=99 08+91=99 09+90=99 10+89=99 11+88=99 12+87=99 13+86=99 14+85=99 15+84=99 16+83=99 17+82=99 18+81=99 19+80=99 20+79=99 21+78=99 22+77=99 23+76=99 24+75=99 25+74=99 26+73=99 27+72=99 28+71=99 29+70=99 30+69=99 31+68=99 32+67=99 33+66=99 34+65=99 35+64=99 36+63=99 37+62=99 38+61=99 39+60=99 40+59=99 41+58=99 42+57=99 43+56=99 44+55=99 45+54=99 46+53=99 47+52=99 48+51=99 49+50=99 50+49=99 51+48=99 52+47=99 53+46=99 54+45=99 55+44=99 56+43=99 57+42=99 58+41=99 59+40=99 60+39=99 61+38=99 62+37=99 63+36=99 64+35=99 65+34=99 66+33=99 67+32=99 68+31=99 69+30=99 70+29=99 71+28=99 72+27=99 73+26=99 74+25=99 75+24=99 76+23=99 77+22=99 78+21=99 79+20=99 80+19=99 81+18=99 82+17=99 83+16=99 84+15=99 85+14=99 86+13=99 87+12=99 88+11=99 89+10=99 90+09=99 91+08=99 92+07=99 93+06=99 94+05=99 95+04=99 96+03=99 97+02=99 98+01=99 99+00=99')
) | % {
    $s,$e = $_
    $r = $s|f
    "$($e-eq$r): $r"
}

Powershell, 'Supposons que les deux termes> 0' soient obligatoires, 110 octets

filter f{$h,$t=$_-split'#',2
if($t){0..9|%{"$h$_$t"}|f}else{$a,$b,$c=$_-split'\D'
$_|?{+$a*+$b*!(+$a+$b-$c)}}}