Objetivo

Dada una lista de entrada de 6dígitos distintos, encuentre 3 números a, by ctal que a × b = c, con atener 2 dígitos, btener 1 dígito y ctener 3 dígitos. De una manera más visual, su programa debe organizar esos 6 dígitos en los cuadros de esta imagen:

Si existe más de una solución, puede generar cualquiera de ellas.

Entrada

6 dígitos distintos. Puede tomarlos de cualquier manera razonable para su idioma.

Salida

Los 3 números a, by c. El formato de salida es relativamente libre, siempre y cuando los 3 números estén separados y siempre se impriman en el mismo orden (pero no necesariamente en el orden a, b, c).

Casos de prueba

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

Tanteo

El código más corto en bytes gana.

Brachylog (2), 10 bytes

p~c₃o.k×~t

Pruébalo en línea!

Demasiado lento para ejecutarse en un período de tiempo razonable (el intérprete de Brachylog pasa mucho tiempo haciendo multiplicaciones en cadenas vacías, números de 4 dígitos, números negativos, etc., usando un solucionador de restricciones muy lento). El enlace TIO utiliza una entrada con solo 3 dígitos (este programa puede manejar entradas con cualquier número de dígitos). Esta es una función cuya entrada es un número que contiene todos los dígitos requeridos (por ejemplo 234567, la falta de duplicados en la entrada significa que siempre puede poner cualquiera 0al final para evitar un cero inicial) y cuya salida es una lista en el orden [b, a, c](por ejemplo [6, 57, 342]).

Explicación

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

Entonces, ¿a dónde se fue el requisito de que los grupos tengan 2, 1 y 3 dígitos? Bueno, sabemos que hay 6 dígitos en la entrada, y los grupos están ordenados. Los únicos tamaños posibles que pueden tener, por lo tanto, son [1, 1, 4], [1, 2, 3] o [2, 2, 2]. El primer caso es imposible (no puede multiplicar dos números de 1 dígito para producir un número de 4 dígitos, ya que 9 × 9 es solo 81), como es el último caso (no puede multiplicar dos números de 2 dígitos para producir un número de 2 dígitos, ya que incluso 10 × 10 produce 100). Por lo tanto, los valores de retorno [b, a, c]deben tener 1, 2 y 3 dígitos de largo en ese orden, por lo que ason 2 dígitos, b1 dígito y c3 dígitos, según se solicite.

JavaScript (ES6), 90 88 bytes

Toma la entrada como una matriz de 6 dígitos. Devuelve una cadena que describe una posible solución (como '54*3==162') o sale con un error de 'demasiada recursividad' si (y solo si) no hay solución.

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)

Cómo funciona

Este es un algoritmo determinista.

Los números primos P=2y Q=3779fueron elegidos de tal manera que la devolución de llamada de clasificación (k = k * P % Q) & 2garantice generar las 720 permutaciones posibles de la matriz de entrada a lo largo del tiempo. Más precisamente, todas las permutaciones están cubiertas después de 2798 géneros, lo que debería estar dentro del límite de recurrencia de todos los navegadores.

Inyectamos cada permutación en la expresión 01*2==345mapeando los dígitos a las entradas correspondientes en la matriz.

Evaluamos esta expresión y hacemos llamadas recursivas hasta que sea verdad.

Prueba

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 bytes

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

Pruébalo en línea!

Explicación

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 bytes

¡ Ahorré dos bytes gracias a Emigna !

œJvy3L£Â`*Qi,

Utiliza la codificación CP-1252 . Pruébalo en línea!

Explicación:

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

No hay una forma particularmente fácil de generar todas las permutaciones. En cambio, genere permutaciones al azar y calcule hasta que encontremos una buena.

La salida tiene la forma A*B-C, es decir, la expresión que se evaluará a cero cuando tengamos la permutación correcta.

Pruébalo en línea .

CJam , 23 bytes

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

Pruébalo en línea!

Python 2 , 105 bytes

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*

Pruébalo en línea!

Solución de 88 bytes con una salida más flexible

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

Pruébalo en línea!
donde la salida sería ['6', '5', '7', '3', '4', '2'] en lugar de '6', '57', '342'

PHP, 110 bytes

Llegará allí ... eventualmente ...

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

Sin 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 bytes

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

Toma la entrada como una cadena.

ES6 (Javascript), 85, 8279 bytes

Acepta una matriz de dígitos (cadenas), devuelve una matriz de 3 elementos [A,B,C]=> C=A*B

Golfed

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

EDICIONES:

• Ahorré 3 bytes más al reutilizar dy adeshacerme ==(¡Gracias @Arnauld!)
• Guardado 3 bytes usando la asignación de desestructuración

Intentalo !

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 bytes

17 bytes de código, +1 para -Sbandera.

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

Toma datos como una cadena de dígitos a través del argumento de la línea de comandos. La salida está en el orden c, b, a. Pruébalo en línea!

Este código genera todas las soluciones si existen múltiples. Si es necesario que solo muestre una solución, agregue tres bytes y ajuste el programa en(...0) .

Explicación

                   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)

Rubí, 60 bytes.

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

Imprime todas las soluciones como "a * b == c"

Ejemplo:

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

Lote, 305 bytes.

@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%%

Toma la entrada en STDIN como una cadena [1-9]{6}y emite todas las soluciones en dd*d-dddformato. Batch no es muy bueno en la manipulación de cadenas, por lo que generar 720 permutaciones es un poco incómodo.