Obbiettivo

Dato un elenco di input di 6cifre distinte, per 3 numeri a, be ctali che a × b = c, con aavendo 2 cifre, bavente da 1 cifra e cavente 3 cifre. In un modo più visivo, il tuo programma deve disporre quelle 6 cifre nelle caselle di questa immagine:

Se esiste più di una soluzione, è possibile produrne una qualsiasi.

Ingresso

6 cifre distinte. Puoi prenderli in qualsiasi modo ragionevole per la tua lingua.

Produzione

I 3 numeri a, be c. Il formato di output è relativamente libero, purché i 3 numeri siano separati e siano sempre stampati nello stesso ordine (ma non necessariamente nell'ordine a, b, c).

Casi test

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

punteggio

Vince il codice più breve in byte.

Brachylog (2), 10 byte

p~c₃o.k×~t

Provalo online!

Troppo lento per funzionare in un ragionevole lasso di tempo (l'interprete Brachylog passa molto tempo a fare moltiplicazioni su stringhe vuote, numeri a 4 cifre, numeri negativi ecc. Usando un risolutore di vincoli molto lento). Il collegamento TIO utilizza un input con solo 3 cifre (questo programma può gestire input con qualsiasi numero di cifre). Questa è una funzione il cui input è un numero contenente tutte le cifre richieste (ad es. 234567) - la mancanza di duplicati nell'input significa che puoi sempre metterne uno qualsiasi 0alla fine per evitare uno zero iniziale - e il cui output è un elenco nella ordine [b, a, c](ad es [6, 57, 342].).

Spiegazione

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

Quindi dove sono finiti i requisiti per i gruppi di 2, 1 e 3 cifre? Bene, sappiamo che ci sono 6 cifre nell'input e che i gruppi sono ordinati. Le uniche dimensioni possibili che possono avere, quindi, sono [1, 1, 4], [1, 2, 3] o [2, 2, 2]. Il primo caso è impossibile (non è possibile moltiplicare due numeri a 1 cifra per produrre un numero a 4 cifre, poiché 9 × 9 è solo 81), così come l'ultimo caso (non è possibile moltiplicare due numeri a 2 cifre per produce un numero di 2 cifre, poiché anche 10 × 10 produce 100). Pertanto, i valori restituiti [b, a, c]devono essere lunghi 1, 2 e 3 cifre in quell'ordine, quindi asono 2 cifre, b1 cifra e c3 cifre, come richiesto.

JavaScript (ES6), 90 88 byte

Accetta input come una matrice di 6 cifre. Restituisce una stringa che descrive una possibile soluzione (come '54*3==162') o esce con un errore "troppa ricorsione" se (e solo se) non c'è soluzione.

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)

Come funziona

Questo è un algoritmo deterministico.

I numeri primi P=2e Q=3779sono stati scelti in modo tale da (k = k * P % Q) & 2garantire che il callback di ordinamento generi nel tempo tutte le 720 possibili permutazioni dell'array di input. Più precisamente, tutte le permutazioni sono coperte dopo 2798 ordinamenti, che dovrebbero rientrare nel limite di ricorsione di tutti i browser.

Iniettiamo ogni permutazione nell'espressione 01*2==345mappando le cifre alle voci corrispondenti nella matrice.

Valutiamo questa espressione e facciamo chiamate ricorsive fino a quando non è vera.

Test

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 byte

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

Provalo online!

Spiegazione

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 byte

Due byte salvati grazie a Emigna !

œJvy3L£Â`*Qi,

Utilizza la codifica CP-1252 . Provalo online!

Spiegazione:

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

Nessun modo particolarmente semplice per generare tutte le permutazioni. Invece genera casualmente permutazioni e calcola fino a quando non ne troviamo una buona.

L'output è nella forma A*B-C, ovvero l'espressione che valuterà a zero quando avremo la permutazione corretta.

Provalo online .

CJam , 23 byte

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

Provalo online!

Python 2 , 105 byte

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*

Provalo online!

88 byte di soluzione con un output più flessibile

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

Provalo online!
dove l'output sarebbe ['6', '5', '7', '3', '4', '2'] invece '6', '57', '342'

PHP, 110 byte

Ci arriverà ... alla fine ...

<?$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 byte

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

Accetta l'input come stringa.

ES6 (Javascript), 85, 82, 79 byte

Accetta una matrice di cifre (stringhe), restituisce una matrice a 3 elementi [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]

Modifiche:

• Hai salvato altri 3 byte riutilizzandoli de aliberandoti di ==(Grazie @Arnauld!)
• 3 byte salvati usando un compito di destrutturazione

Provalo !

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 byte

17 byte di codice, +1 per la -Sbandiera.

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

Accetta l'input come una stringa di cifre tramite l'argomento della riga di comando. L'output è nell'ordine c, b, a. Provalo online!

Questo codice genera tutte le soluzioni se ne esistono più. Se è necessario produrre solo una soluzione, aggiungere tre byte e inserire il programma (...0).

Spiegazione

                   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)

Rubino, 60 byte

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

Stampa tutte le soluzioni come "a * b == c"

Esempio:

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

Lotto, 305 byte

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

Prende input su STDIN come stringa [1-9]{6}e restituisce tutte le soluzioni in dd*d-dddformato. Il batch non è molto bravo nella manipolazione delle stringhe, quindi generare le 720 permutazioni è un po 'imbarazzante.