Ingresso

Un array non vuoto di numeri interi positivi.

Compito

Converti ogni numero intero in binario, ottale, decimale o esadecimale in modo tale che ogni cifra (da 0 a F ) venga utilizzata al massimo una volta.

Produzione

L'elenco delle basi utilizzate per risolvere il puzzle.

Esempio dettagliato

L'output previsto per [16, 17] è [ottale, decimale] .

Ecco perché:

• Non possiamo semplicemente usare il decimale per entrambi i numeri, perché entrambi contengono un 1 .
• 16 non può essere convertito in binario, poiché la sua rappresentazione in questa base ( 10000 ) contiene diversi 0 .
• Nemmeno il 17 può essere convertito in binario, poiché la sua rappresentazione in questa base ( 10001 ) contiene diversi 0 e diversi 1 .
• 17 non può essere convertito in esadecimale, perché la sua rappresentazione in questa base ( 11 ) è composta da due 1 '.

• Consideriamo tutte le possibilità rimanenti:

                 +---------+---------+--------+
                 | oct(16) | dec(16) | hex(16)|
                 | = 20    | = 16    | = 10   |
  +--------------+---------+---------+--------+
  | oct(17) = 21 | 20,21   | 16,21   | 10,21  |
  | dec(17) = 17 | 20,17   | 16,17   | 10,17  |
  +--------------+---------+---------+--------+
  

  L'unica soluzione possibile è convertire 16 in ottale ( 20 ) e mantenere 17 in decimale ( 17 ). In questo modo, le cifre 0 , 1 , 2 e 7 vengono utilizzate esattamente una volta.

Chiarimenti e regole

• L'input garantisce una soluzione unica. Il codice non dovrebbe supportare array che offrono diverse soluzioni o nessuna soluzione.
• Puoi generare le basi in qualsiasi formato ragionevole, come ["bin", "oct", "dec", "hex"] , ['b', 'o', 'd', 'h'] , "BODH " , [2,8,10,16] , [0,1,2,3] ecc. Ma dovrebbe essere chiaramente spiegato nella tua risposta.
• L'ordine delle basi nell'output deve corrispondere all'ordine degli interi di input.
• Se ciò aiuta, puoi supporre che l'input sia ordinato dal più basso al più alto o dal più alto al più basso.
• Questo è code-golf , quindi vince la risposta più breve in byte!

Casi test

Non è necessario produrre i risultati della conversione elencati di seguito. Sono puramente informativi.

Input                                  | Output          | Conversion result
---------------------------------------+-----------------+------------------------
[ 119 ]                                | O               | 167
[ 170 ]                                | D               | 170
[ 64222 ]                              | H               | FADE
[ 16, 17 ]                             | O/D             | 20/17
[ 14, 64, 96 ]                         | H/H/D           | E/40/96
[ 34, 37, 94 ]                         | O/D/H           | 42/37/5E
[ 2, 68, 82 ]                          | B/D/H           | 10/68/52
[ 22, 43, 96 ]                         | O/O/O           | 26/53/140
[ 3639, 19086, 57162 ]                 | H/D/H           | E37/19086/DF4A
[ 190, 229, 771 ]                      | O/H/O           | 276/E5/1403
[ 2, 44, 69, 99 ]                      | B/H/H/H         | 10/2C/45/63
[ 75, 207, 218, 357, 385 ]             | H/H/H/D/O       | 4B/CF/DA/357/601
[ 12, 28, 46, 78, 154, 188, 222, 240 ] | D/O/O/D/H/H/H/H | 12/34/56/78/9A/BC/DE/F0

L'elenco di input non elaborati è disponibile qui .

JavaScript (Node.js) , 192.155.154.152.151.145.136.113,99,92 90 byte

• grazie a @Arnauld per avermi ricordato che posso restituire [0,1,2,3] -> che è [2,8,10,16] salva 8 byte e per la brillante idea (che aiuta a ridurre di 23+ byte)
• grazie a @Kevin Cruijssen per la riduzione di 1 byte

f=([c,...a],t="")=>c?[1,4,5,8].find(b=>T=!/(.).*\1/.test(n=t+c.toString(b*2))&&f(a,n))+T:a

Provalo online!

Spiegazione:

[c,...a]- @Arnauld trucco per prendere un oggetto alla volta c?***:" "-> se c è indefinito, siamo riusciti a ottenere il risultato finale- [] - se inserissi "" di quello che la ricerca non considererebbe così legittimo. ([] + 5 = "5" JS FTW) [1,4,5,8].findogni volta che troviamo la base corretta (l'output sarà di questo array (1,4,5,8) -> (2,8,10,16) è legittimo. ora come funziona la ricerca -> se trova qualcosa restituisce l'elemento (1-8) e quindi aggiungo il risultato della soluzione interna. Se non trova, restituisce un valore indefinito + T ora è falso -> NaN che nel la chiamata del genitore sarà considerata falsa

!/(.).*\1/.test(n=t+b) determinare se la stringa ha duplicati, in tal caso:

f(a,n)) basta andare al numero successivo (a ora è array.slice (1)) con la nuova stringa (n)

assegniamo il risultato a T (temp) del risultato perché find si ferma quando trova e quindi sappiamo che l'ultimo risultato sarà f () che è il risultato B

Perl 5 -alp , 55 byte

Utilizza %xper esadecimale, %dper decimale, %oper ottale e %bper binario

#!/usr/bin/perl -alp
($_)=grep{sprintf($_,@F)!~/(.).*\1/}glob"%{d,o,b,x}"x@F

Provalo online!

Rubino, 72 71 byte

->a{a.map{%w[b o d x]}.inject(&:product).find{|c|/(.).*\1/!~[p,c]*?%%a}}

Il formato di output è una sorta di mostruosità inversa dell'espressione S:

f[[12, 28, 46, 78, 154, 188, 222, 240]]
=> [[[[[[["d", "o"], "o"], "d"], "x"], "x"], "x"], "x"]

Separare la barra invece costerebbe altri 3 byte (aggiungendo *?/).

Questo formato deriva dalla struttura ad anello, leggermente più corta di quella più idiomatica repeated_combination(a.size), che genera una matrice di matrici di caratteri e quindi la riduce sulla funzione tra prodotti.

Modifica: salvato 1 byte grazie a Lynn.

Pyth, 21 20 byte

f{Is.bjYNTQ^[8T2y8)l

Restituisce un elenco di tutti i possibili elenchi di basi (che ha sempre la lunghezza 1).
Provalo qui

Spiegazione

f{Is.bjYNTQ^[8T2y8)l
           ^[8T2y8)lQ  Get the tuples of bases of the same length as the input.
f                      Filter to get those...
    .bjYNTQ            ... where converting bases elementwise...
   s                   ... and joining together...
 {I                    ... has no repeats.

Wolfram Language (Mathematica) , 71 byte

Cases[2{1,4,5,8}~Tuples~Tr[1^#],b_/;UnsameQ@@Join@@IntegerDigits[#,b]]&

Restituisce un elenco di basi.

Provalo online!

Gelatina , 17 16 byte

⁴⁽%ʠḃṗL³bF⁼Q$ƲÐf

Provalo online!

Restituisce un elenco di basi.

 == Spiegazione ==
⁴⁽% ʠḃṗL³bF⁼Q $ ƲÐf Link principale.
 ⁽% ʠ Un numero.
    ḃ convertilo in base biiettiva ...
⁴ 16. Il risultato è [2,8,10,16].
     ṗL Potenza cartesiana per lunghezza di input.
             FilterÐf Filtro, mantieni quelli che soddisfano ...
       ³ l'ingresso
        b converti in quella base
         F quando appiattito (unisci tutte le cifre di \
                      numeri diversi insieme)
          $Q $ uguale a se stesso unificato.

Python 2 , 128 byte

from itertools import*
a=input()
for b in product(*['bdxo']*len(a)):
 s=''.join(map(format,a,b))
 if len(s)==len(set(s)):print b

Provalo online!

05AB1E , 17 byte

2žv8T)sgãʒIsв˜DÙQ

Provalo online!

Python 2 , 121 117 113 111 byte

def f(a,d='',s=''):
 if a:
	for c in'bodx':t=format(a[0],c)+s;len(t)-len(set(t))or f(a[1:],d+c,t)
 else:print d

Provalo online!

Punta del cappello a Lynn per format, che avevo dimenticato!

Buccia , 19 byte

fȯS=UΣz`B¹πmDd1458L

Provalo online!

Restituisce elenchi di basi

Spiegazione

fȯS=UΣz`B¹πmDd1458L  Implicit input
                  L  Length of input
          π          Cartesian power of
             d1458     The digits of 1458  [1,4,5,8]
           mD          Double the digits   [2,8,10,16]
fȯ                   Filter by
      z`B¹             Zip with input by converting to its base
     Σ                 Concatenate
  S=U                  Equal to itself with unique elements