Entrada

Uma matriz não vazia de números inteiros positivos.

Tarefa

Converta cada número inteiro em binário, octal, decimal ou hexadecimal de forma que cada dígito ( 0 a F ) seja usado no máximo uma vez.

Resultado

A lista de bases que foram usadas para resolver o quebra-cabeça.

Exemplo detalhado

A saída esperada para [16, 17] é [octal, decimal] .

Aqui está o porquê:

• Não podemos simplesmente usar decimal para ambos os números, porque ambos contêm um 1 .
• 16 não pode ser convertido em binário, porque sua representação nesta base ( 10000 ) contém vários 0 's.
• 17 também não pode ser convertido em binário, porque sua representação nesta base ( 10001 ) contém vários 0 e vários 1 .
• 17 não pode ser convertido em hexadecimal, porque sua representação nesta base ( 11 ) consiste em dois 1 's.

• Vamos considerar todas as possibilidades restantes:

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

  A única solução possível é converter 16 em octal ( 20 ) e manter 17 em decimal ( 17 ). Dessa forma, os dígitos 0 , 1 , 2 e 7 são usados ​​exatamente uma vez.

Esclarecimentos e regras

• A entrada é garantida para levar a uma solução única. Seu código não deve oferecer suporte a matrizes que oferecem várias soluções ou nenhuma solução.
• Você pode emitir as bases em qualquer formato razoável, como ["bin", "oct", "dec", "hex"] , ['b', 'o', 'd', 'h'] , "BODH " , [2,8,10,16] , [0,1,2,3] etc. Mas deve ser claramente explicado na sua resposta.
• A ordem das bases na saída deve corresponder à ordem dos números inteiros de entrada.
• Se isso ajudar, você pode assumir que a entrada é classificada da mais baixa para a mais alta ou da mais alta para a mais baixa.
• Isso é código-golfe , então a resposta mais curta em bytes vence!

Casos de teste

Você não precisa exibir os resultados da conversão listados abaixo. Eles são puramente informativos.

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

A lista de entradas brutas está disponível aqui .

JavaScript (Node.js) , 192,155,154,152,151,145,136,113,99,92 90 bytes

• obrigado a @Arnauld por me lembrar que eu posso retornar [0,1,2,3] -> que é [2,8,10,16] economiza 8 bytes e pela brilhante idéia (que ajuda a reduzir em mais de 23 bytes)
• graças a @Kevin Cruijssen por reduzir em 1 bytes

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

Experimente online!

Explicação:

[c,...a]- truque @Arnauld para pegar um item de cada vez c?***:" "-> se c é indefinido, conseguimos chegar ao resultado final- [] - se eu colocasse "" do que a descoberta não consideraria isso legítimo. ([] + 5 = "5" JS FTW) [1,4,5,8].findtoda vez que encontrarmos a base correta (a saída será dessa matriz (1,4,5,8) -> (2,8,10,16) sua legit. Agora, como a descoberta funciona -> se encontrar algo, ele retorna o elemento (1-8) e, em seguida, adiciono o resultado da solução interna.Se não encontrar, retorna indefinido + T agora é falso -> NaN, que no chamada pai será considerada falsa

!/(.).*\1/.test(n=t+b) determine se a sequência possui duplicatas, se houver:

f(a,n)) basta ir para o próximo número (a agora é array.slice (1)) com a nova string (n)

atribuímos o resultado a T (temp) do resultado porque find pára quando é encontrado e, portanto, sabemos que o último resultado será f (), que é o resultado B

Perl 5 -alp , 55 bytes

Usa %xpara hexadecimal, %ddecimal, %ooctal e %bbinário

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

Experimente online!

Rubi, 72 71 bytes

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

O formato de saída é algum tipo de monstruosidade de expressão S reversa:

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

Separá-la com uma barra custaria mais 3 bytes (anexando *?/).

Esse formato vem da estrutura do loop, um pouco menor que a mais idiomática repeated_combination(a.size) , que gera uma matriz de matrizes de caracteres e a reduz pela função entre produtos.

Editar: salvou 1 byte graças a Lynn.

Pitão, 21 20 bytes

f{Is.bjYNTQ^[8T2y8)l

Retorna uma lista de todas as listas possíveis de bases (que sempre têm o comprimento 1).
Experimente aqui

Explicação

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 bytes

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

Retorne uma lista de bases.

Experimente online!

Geléia , 17 16 bytes

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

Experimente online!

Retorne uma lista de bases.

 == Explicação ==
⁴⁽% ʠḃṗL³bF⁼Q $ ƲÐf Link principal.
 ⁽% ʠ Um número.
    ḃ converta-o em base bijetiva ...
16. O resultado é [2,8,10,16].
     ṗL potência cartesiana pelo comprimento de entrada.
             Se filtro, mantenha aqueles que satisfazem ...
       ³ a entrada
        b converter para essa base
         F quando achatar (junte todos os dígitos de \
                      números diferentes juntos)
          $Q $ é igual a si próprio.

Python 2 , 128 bytes

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

Experimente online!

05AB1E , 17 bytes

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

Experimente online!

Python 2 , 121 117 113 111 bytes

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

Experimente online!

Ponta do chapéu para Lynn para formatque eu tinha esquecido!

Casca , 19 bytes

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

Experimente online!

Retorna listas de bases

Explicação

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