Objetivo

Dada uma lista de entrada de 6dígitos distintas, encontrar números 3 a, be cde tal modo que a × b = c, com ater 2 dígitos, btendo um dígito e ctendo de 3 dígitos. De uma maneira mais visual, seu programa deve organizar esses 6 dígitos nas caixas desta imagem:

Se existir mais de uma solução, você poderá gerar uma delas.

Entrada

6 dígitos distintos. Você pode aceitá-los de qualquer maneira razoável para o seu idioma.

Saída

Os números 3 a, be c. O formato de saída é relativamente livre, desde que os três números sejam separados e sempre sejam impressos na mesma ordem (mas não necessariamente na ordem a, b, c).

Casos de teste

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

Pontuação

O código mais curto em bytes vence.

Braquilog (2), 10 bytes

p~c₃o.k×~t

Experimente online!

Muito lento para ser executado em um período de tempo razoável (o intérprete Brachylog passa muito tempo fazendo multiplicações em cadeias vazias, números de 4 dígitos, números negativos etc. usando um solucionador de restrições muito lento). O link TIO usa uma entrada com apenas 3 dígitos (este programa pode manipular a entrada com qualquer número de dígitos). Essa é uma função cuja entrada é um número que contém todos os dígitos necessários (por exemplo 234567) - a falta de duplicatas na entrada significa que você sempre pode colocar alguma 0no final para evitar um zero à esquerda - e cuja saída é uma lista no pedido [b, a, c](por exemplo [6, 57, 342]).

Explicação

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

Então, para onde foi o requisito dos grupos de 2, 1 e 3 dígitos? Bem, sabemos que existem 6 dígitos na entrada e os grupos estão em ordens ordenadas. Os únicos tamanhos possíveis que eles podem ter, portanto, são [1, 1, 4], [1, 2, 3] ou [2, 2, 2]. O primeiro caso é impossível (você não pode multiplicar dois números de 1 dígito para produzir um número de 4 dígitos, pois 9 × 9 é apenas 81), como é o último caso (você não pode multiplicar dois números de 2 dígitos para produza um número de 2 dígitos, pois mesmo 10 × 10 produz 100). Portanto, os valores de retorno [b, a, c]devem ter 1, 2 e 3 dígitos nessa ordem, assim acomo 2 dígitos, b1 dígito e c3 dígitos, conforme solicitado.

JavaScript (ES6), 90 88 bytes

Recebe a entrada como uma matriz de 6 dígitos. Retorna uma string descrevendo uma possível solução (como '54*3==162') ou sai com um erro 'muita recursão' se (e somente se) não houver solução.

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)

Como funciona

Este é um algoritmo determinístico.

Os números primos P=2e Q=3779foram escolhidos de forma a (k = k * P % Q) & 2garantir que o retorno de chamada de classificação gere todas as 720 permutações possíveis da matriz de entrada ao longo do tempo. Mais precisamente, todas as permutações são cobertas após as classificações de 2798 - que devem estar dentro do limite de recursão de todos os navegadores.

Injetamos cada permutação na expressão 01*2==345mapeando os dígitos para as entradas correspondentes na matriz.

Avaliamos essa expressão e fazemos chamadas recursivas até que seja verdadeira.

Teste

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

Braquilog , 17 bytes

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

Experimente online!

Explicação

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

Economizou dois bytes graças a Emigna !

œJvy3L£Â`*Qi,

Usa a codificação CP-1252 . Experimente online!

Explicação:

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

Não é uma maneira particularmente fácil de gerar todas as permutações. Em vez disso, gere permutações aleatoriamente e calcule até encontrarmos uma boa.

A saída está na forma A*B-C- ou seja, a expressão que será avaliada como zero quando tivermos a permutação correta.

Experimente online .

CJam , 23 bytes

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

Experimente online!

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*

Experimente online!

Solução de 88 bytes com uma saída mais flexível

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

Experimente online!
onde a saída seria ['6', '5', '7', '3', '4', '2'] em vez de '6', '57', '342'

PHP, 110 bytes

Chegará lá ... 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";

Ungolfed:

<?
$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])));

Recebe a entrada como uma sequência.

ES6 (Javascript), 85, 82, 79 bytes

Aceita uma matriz de dígitos (strings), retorna uma matriz de 3 elementos [A,B,C]=> C=A*B

Golfe

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

EDITAS:

• Economizou mais 3 bytes reutilizando de a, e se livrando de ==(Obrigado @Arnauld!)
• 3 bytes salvos usando a atribuição de desestruturação

Tente !

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

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

Recebe a entrada como uma sequência de dígitos via argumento da linha de comando. A saída está na ordem c, b, a. Experimente online!

Esse código gera todas as soluções, se existirem várias. Se for necessário gerar apenas uma solução, adicione três bytes e envolva o programa (...0).

Explicação

                   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)

Ruby, 60 bytes

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

Imprime todas as soluções como "a * b == c"

Exemplo:

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

Aceita STDIN como uma string [1-9]{6}e gera todas as soluções em dd*d-dddformato. Lote não é muito bom em manipulação de cordas, portanto, gerar as permutações 720 é um pouco estranho.