Objectif

Étant donné une liste d'entrée de 6chiffres distincts, trouvez 3 nombres a, bet ctels que a × b = c, avec a2 chiffres, b1 chiffre et c3 chiffres. De manière plus visuelle, votre programme doit disposer ces 6 chiffres dans les cases de cette image:

S'il existe plusieurs solutions, vous pouvez en générer une.

Contribution

6 chiffres distincts. Vous pouvez les prendre de toute manière raisonnable pour votre langue.

Sortie

Les 3 chiffres a, bet c. Le format de sortie est relativement libre, tant que les 3 nombres sont séparés et sont toujours imprimés dans le même ordre (mais pas nécessairement dans l'ordre a, b, c).

Cas de test

1, 2, 3, 4, 5, 6 -> 54,3,162  
2, 3, 4, 5, 6, 7 -> 57,6,342 or 52,7,364

Notation

Le code le plus court en octets gagne.

Brachylog (2), 10 octets

p~c₃o.k×~t

Essayez-le en ligne!

Beaucoup trop lent pour s'exécuter dans un laps de temps raisonnable (l'interpréteur Brachylog passe beaucoup de temps à faire des multiplications sur des chaînes vides, des nombres à 4 chiffres, des nombres négatifs, etc. en utilisant un solveur de contraintes très lent). Le lien TIO utilise une entrée avec seulement 3 chiffres (ce programme peut gérer l'entrée avec n'importe quel nombre de chiffres). Il s'agit d'une fonction dont l'entrée est un nombre contenant tous les chiffres requis (par exemple 234567) - le manque de doublons dans l'entrée signifie que vous pouvez toujours simplement en mettre un 0à la fin pour éviter un zéro de tête - et dont la sortie est une liste dans le ordre [b, a, c](par exemple [6, 57, 342]).

Explication

p~c₃o.k×~t
p           Permute the digits of the input
 ~c₃        Split them into three groups
    o       Sort the three groups
     .      to produce the output, which must have the following property:
      k     all but the last group
       ×    when multiplied together
        ~t  produces the last group

Où est donc passée l'obligation pour les groupes d'avoir 2, 1 et 3 chiffres? Eh bien, nous savons qu'il y a 6 chiffres dans l'entrée, et les groupes sont classés par ordre. Les seules tailles possibles qu'ils peuvent avoir sont donc [1, 1, 4], [1, 2, 3] ou [2, 2, 2]. Le premier cas est impossible (vous ne pouvez pas multiplier deux nombres à 1 chiffre pour produire un nombre à 4 chiffres, car 9 × 9 n'est que de 81), tout comme le dernier cas (vous ne pouvez pas multiplier deux nombres à 2 chiffres pour produire un nombre à 2 chiffres, car même 10 × 10 produit 100). Ainsi, les valeurs de retour [b, a, c]doivent être longues de 1, 2 et 3 chiffres dans cet ordre, donc a2 chiffres, b1 chiffre et c3 chiffres, comme demandé.

JavaScript (ES6), 90 88 octets

Prend l'entrée comme un tableau de 6 chiffres. Renvoie une chaîne décrivant une solution possible (telle que '54*3==162') ou se termine avec une erreur «trop de récursivité» si (et seulement si) il n'y a pas de solution.

f=(a,k=1)=>eval(s='01*2==345'.replace(/\d/g,n=>a[n],a.sort(_=>(k=k*2%3779)&2)))?s:f(a,k)

Comment ça marche

Il s'agit d'un algorithme déterministe.

Les nombres premiers P=2et Q=3779ont été choisis de telle manière que le rappel de tri (k = k * P % Q) & 2soit garanti pour générer les 720 permutations possibles du tableau d'entrée au fil du temps. Plus précisément, toutes les permutations sont couvertes après 2798 tris - ce qui devrait être dans la limite de récursivité de tous les navigateurs.

Nous injectons chaque permutation dans l'expression 01*2==345en mappant les chiffres aux entrées correspondantes dans le tableau.

Nous évaluons cette expression et faisons des appels récursifs jusqu'à ce qu'elle soit vraie.

Tester

f=(a,k=1)=>eval(s='01*2==345'.replace(/\d/g,n=>a[n],a.sort(_=>(k=k*2%3779)&2)))?s:f(a,k)

console.log(f([1,2,3,4,5,6])); // 54*3==162
console.log(f([2,3,4,5,6,7])); // 52*7==364
console.log(f([1,2,3,4,6,7])); // 73*2==146

Brachylog , 17 octets

p~c[Ċ,I,Ṫ]cᵐ.k×~t

Essayez-le en ligne!

Explication

p                   Try a permutation of the Input
 ~c[Ċ,I,Ṫ]          Deconcatenate it; the result must be a list of the form [[_,_],_,[_,_,_]]
          cᵐ.       Output is the list of integers you get when mapping concatenate on the
                      previous list
             k×~t   The first two ints of the Output, when multiplied, result in the third
                      int of the Output

05AB1E , 15 13 octets

Enregistré deux octets grâce à Emigna !

œJvy3L£Â`*Qi,

Utilise l' encodage CP-1252 . Essayez-le en ligne!

Explication:

œ                 # Get all permutations of the input
 J                # Join them to get the numbers
  vy              # For each element in the list..
    3L            #   Push the list [1, 2, 3]
      £           #   Pops a and pushes [a[0:1], a[1:3], a[3:6]]
       Â`         #   Bifurcate and flatten
         *        #   Multiply the top two elements in the stack
          Qi      #   If equal to the third element..
            ,     #     Print the array

Bash + coreutils, 70

for((b=1;b;));{
a=`shuf -ze $@`
b=${a:0:2}*${a:2:1}-${a:3:3}
}
echo $b

Pas de moyen particulièrement simple de générer toutes les permutations. Au lieu de cela, générez des permutations au hasard et calculez jusqu'à ce que nous en trouvions une bonne.

La sortie est sous la forme A*B-C- c'est-à-dire l'expression qui sera évaluée à zéro lorsque nous aurons la permutation correcte.

Essayez-le en ligne .

CJam , 23 octets

qm!{3/)2/+:i}%{(\:*=}=p

Essayez-le en ligne!

Python 2 , 105 octets

lambda s:[(x[0],x[1:3],x[3:])for x in permutations(s)if eval('%s*%s%s==%s%s%s'%x)]
from itertools import*

Essayez-le en ligne!

Solution de 88 octets avec une sortie plus flexible

lambda s:[x for x in permutations(s)if eval('%s*%s%s==%s%s%s'%x)]
from itertools import*

Essayez-le en ligne!
où la sortie serait ['6', '5', '7', '3', '4', '2'] au lieu de '6', '57', '342'

PHP, 110 octets

Il y arrivera ... finalement ...

<?$v=$argv;unset($v[0]);do shuffle($v)&[$a,$b,$c,$d,$e,$f]=$v;while("$a$b"*$c!="$d$e$f");echo"$a$b $c $d$e$f";

Non golfé:

<?
$v=$argv;
unset($v[0]);
do
  shuffle($v);
  [$a,$b,$c,$d,$e,$f]=$v;
while("$a$b"*$c!="$d$e$f");
echo"$a$b $c $d$e$f";

PHP, 77 octets

for(;;)eval(strtr('0.*1-"428"||die("0.,1,428");',1/7,str_shuffle($argv[1])));

Prend l'entrée sous forme de chaîne.

ES6 (Javascript), 85, 82, 79 octets

Accepte un tableau de chiffres (chaînes), retourne un tableau à 3 éléments [A,B,C]=> C=A*B

Golfé

R=(w,[a,b,c,d,e,f]=w)=>f*(d+=e)^(a+=b+c)?R(w.sort(_=>Math.random()-.5)):[a,d,f]

MODIFICATIONS:

• Enregistré 3 octets de plus en réutilisant det en ase débarrassant de ==(Merci @Arnauld!)
• Enregistré 3 octets en utilisant l'affectation de déstructuration

Essayez-le!

R=(w,[a,b,c,d,e,f]=w)=>f*(d+=e)^(a+=b+c)?R(w.sort(_=>Math.random()-.5)):[a,d,f];

function generate(A) {
   console.log(R([...A]));
}

<input type="text" id="A" value="123456"/><button onclick="generate(A.value)">GENERATE</button>

Pip , 18 octets

17 octets de code, +1 pour l' -Sindicateur.

$/_=1FI_^@3,5MPMa

Prend l'entrée sous la forme d'une chaîne de chiffres via un argument de ligne de commande. La sortie est dans l'ordre c, b, a. Essayez-le en ligne!

Ce code génère toutes les solutions si plusieurs existent. S'il est nécessaire de générer une seule solution, ajoutez trois octets et encapsulez le programme (...0).

Explication

                   a is 1st cmdline arg (implicit)
              PMa  Compute all permutations of a
             M     To each, map this function:
          3,5       Range(3,5)--contains values 3 and 4
       _^@          Split the function argument at those indices
                    This transforms a string like 342657 into a list [342; 6; 57]
     FI            Now filter the list of split permutations on this function:
$/_                 Fold on division: takes 1st element and divides it by the rest
   =1               Compare the quotient with 1
                    This keeps only the permutations where the first number is the product
                    of the other two
                   Autoprint the list (implicit), with each sublist on a separate line
                   and space-separated (-S flag)

Rubis, 60 octets

->x{x.permutation{|a|(eval a="%d%d*%d==%d%d%d"%a)&&puts(a)}}

Imprime toutes les solutions sous la forme "a * b == c"

Exemple:

->x{x.permutation{|a|(eval a="%d%d*%d==%d%d%d"%a)&&puts(a)}}[[1,2,3,4,5,6]]
54*3==162

->x{x.permutation{|a|(eval a="%d%d*%d==%d%d%d"%a)&&puts(a)}}[[2,3,4,5,6,7]]
52*7==364
57*6==342

Lot, 305 octets

@echo off
set/pd=
for /l %%i in (0,1,719)do set n=%%i&call:c
exit/b
:c
set t=%d%
set s=
for /l %%j in (6,-1,1)do set/ap=n%%%%j,n/=%%j&call:l
set s=%s:~0,2%*%s:~2,1%-%s:~3%
set/an=%s%
if %n%==0 echo %s%
exit/b
:l
call set u=%%t:~%p%%%
call set s=%%s%%%%u:~,1%%
call set t=%%t:~,%p%%%%%u:~1%%

Prend l'entrée sur STDIN sous forme de chaîne [1-9]{6}et affiche toutes les solutions au dd*d-dddformat. Batch n'est pas très bon pour la manipulation de chaînes, donc générer les permutations 720 est un peu gênant.