Encuentra los números y calcula la salida

22

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:

ingrese la descripción de la imagen aquí

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.

HABJAN
fuente
1
Eso fue lo primero que pensé cuando vi el desafío también @Dada ... Sugiero ponerlo en el sandbox para obtener algunos comentarios antes de publicarlo :-)
Stewie Griffin
1
¿Se garantiza que la entrada dará como resultado una solución?
AdmBorkBork
1
He editado bastante la redacción de su desafío para que quede claro (en mi opinión). Asegúrate de no haber cambiado el objetivo del desafío.
Fatalize
1
También creo que el desafío necesita un título más explícito, pero no tengo ideas en este momento.
Fatalize
1
Debe una entrada de 0,1,2,3,4,5resultado en 13,4,052; sin solución; ¿o está bien algún comportamiento?
Jonathan Allan

Respuestas:

8

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.


fuente
2
Bueno ... me rindo
Fatalize
8

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

Arnauld
fuente
Suponiendo que el formato de salida sigue siendo válido, use en -lugar de ==(e invierta el ?:) para guardar un byte.
Neil
1
@Neil En realidad, hice la misma sugerencia para zeppelin. Probablemente también debería jugar un poco más, pero debo admitir que me gusta el formato de salida actual.
Arnauld
¿Forzó la fuerza bruta para encontrar 3379 o utilizó el razonamiento matemático? Si es así, ¿podría proporcionar su forma de encontrarlo? :)
Yytsi
@ TuukkaX Nada realmente elegante aquí. Simplemente lo forcé, mi criterio es 1) la menor cantidad de dígitos posible para P y Q y 2) la menor cantidad de iteraciones posibles.
Arnauld
6

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
Fatalizar
fuente
3

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
Adnan
fuente
Se puede reemplazar 213Scon 3Lque el orden no tiene que ser 2,1,3de acuerdo con las especificaciones.
Emigna
Es bueno saber que se £vectoriza acumulativamente ... Si esa es la forma correcta de decir eso.
Urna de pulpo mágico
3

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 .

Trauma digital
fuente
2

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'

Barra
fuente
2
No pusiste tu importen la parte superior ... sacude la cabeza
mbomb007
@ mbomb007 tiene que trabajar en TIO ¯ \ _ (ツ) _ / ¯
Rod
Eres la primera persona que he visto que realmente puso f=el encabezado. No es gran cosa.
mbomb007
2

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";
Alex Howansky
fuente
2

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.

usuario63956
fuente
1

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>

zepelín
fuente
¿Puedes garantizar que tu ordenación aleatoria realmente cubrirá todas las permutaciones?
Neil
@Neil, si está buscando una prueba formal estricta, no creo que pueda proporcionarle una, pero empíricamente resulta en una distribución bastante uniforme de permutaciones.
zeppelin
1

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)
DLosc
fuente
1

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
GB
fuente
1

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.

Neil
fuente