Contribution

Un tableau non vide d'entiers positifs.

Tâche

Convertissez chaque entier en binaire, octal, décimal ou hexadécimal de manière à ce que chaque chiffre ( 0 à F ) soit utilisé au plus une fois.

Production

La liste des bases utilisées pour résoudre le puzzle.

Exemple détaillé

La sortie attendue pour [16, 17] est [octal, décimal] .

Voici pourquoi:

• Nous ne pouvons pas simplement utiliser décimal pour les deux nombres, car ils contiennent tous les deux un 1 .
• 16 ne peut pas être converti en binaire, car sa représentation dans cette base ( 10000 ) contient plusieurs 0 .
• 17 ne peut pas non plus être converti en binaire, car sa représentation dans cette base ( 10001 ) contient plusieurs 0 et plusieurs 1 .
• 17 ne peut pas être converti en hexadécimal, car sa représentation dans cette base ( 11 ) consiste en deux 1 .

• Examinons toutes les possibilités 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  |
  +--------------+---------+---------+--------+
  

  La seule solution possible est de convertir 16 en octal ( 20 ) et de garder 17 en décimal ( 17 ). De cette façon, les chiffres 0 , 1 , 2 et 7 sont utilisés exactement une fois.

Clarifications et règles

• L'entrée est garantie de conduire à une solution unique. Votre code n'est pas censé prendre en charge les tableaux qui donnent plusieurs solutions ou aucune solution du tout.
• Vous pouvez afficher les bases dans n'importe quel format raisonnable, comme ["bin", "oct", "dec", "hex"] , ['b', 'o', 'd', 'h'] , "BODH " , [2,8,10,16] , [0,1,2,3] etc. Mais cela devrait être clairement expliqué dans votre réponse.
• L'ordre des bases dans la sortie doit correspondre à l'ordre des entiers d'entrée.
• Si cela vous aide, vous pouvez supposer que l'entrée est triée du plus bas au plus élevé, ou du plus haut au plus bas.
• C'est le code-golf , donc la réponse la plus courte en octets l'emporte!

Cas de test

Il n'est pas nécessaire de générer les résultats de conversion répertoriés ci-dessous. Ils sont purement informatifs.

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

La liste des entrées brutes est disponible ici .

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

• merci à @Arnauld de m'avoir rappelé que je peux retourner [0,1,2,3] -> qui est [2,8,10,16] économise 8 octets, et pour l'idée géniale (qui aide à réduire de 23+ octets)
• merci à @Kevin Cruijssen pour avoir réduit de 1 octet

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

Essayez-le en ligne!

Explication:

[c,...a]- Astuce @Arnauld pour prendre un élément à la fois c?***:" "-> si c n'est pas défini, nous avons réussi à arriver au résultat final - [] - si je mettais "" que la recherche ne serait pas considérée comme légitime. ([] + 5 = "5" JS FTW) [1,4,5,8].findchaque fois que nous trouvons la base correcte (la sortie sera de ce tableau (1,4,5,8) -> (2,8,10,16) sa légitimité. maintenant comment fonctionne la recherche -> s'il trouve quelque chose, il renvoie l'élément (1-8) et que j'ajoute le résultat de la solution interne. s'il ne le trouve pas, il renvoie undefined + T est maintenant faux -> NaN qui dans le l'appel des parents sera considéré comme faux

!/(.).*\1/.test(n=t+b) déterminer si la chaîne a des doublons, si oui:

f(a,n)) il suffit de passer au numéro suivant (a est maintenant array.slice (1)) avec la nouvelle chaîne (n)

nous attribuons le résultat à T (temp) du résultat parce que find s'arrête quand il trouve et donc nous savons que le dernier résultat sera f () qui est le résultat B

Perl 5 -alp , 55 octets

Utilise %xhexadécimal, %ddécimal, %ooctal et %bbinaire

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

Essayez-le en ligne!

Rubis, 72 71 octets

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

Le format de sortie est une sorte de monstruosité d'expression S inverse:

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

Séparez-le à la place coûterait 3 octets de plus (en annexe *?/).

Ce format provient de la structure de la boucle, légèrement plus courte que la plus idiomatique repeated_combination(a.size), qui génère un tableau de tableaux de caractères et le réduit ensuite sur la fonction inter-produits.

Edit: sauvé 1 octet grâce à Lynn.

Pyth, 21 20 octets

f{Is.bjYNTQ^[8T2y8)l

Renvoie une liste de toutes les listes de bases possibles (qui a toujours la longueur 1).
Essayez-le ici

Explication

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 octets

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

Renvoyez une liste de bases.

Essayez-le en ligne!

Gelée , 17 16 octets

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

Essayez-le en ligne!

Renvoyez une liste de bases.

 == Explication ==
⁴⁽% ʠḃṗL³bF⁼Q $ ƲÐf Lien principal.
 ⁽% ʠ Un nombre.
    ḃ le convertir en base bijective ...
⁴ 16. Le résultat est [2,8,10,16].
     ṗL Puissance cartésienne par la longueur d'entrée.
             ƲÐf Filtrez, conservez ceux qui satisfont ...
       ³ l'entrée
        b convertir à cette base
         F une fois aplati (joindre tous les chiffres de \
                      différents numéros ensemble)
          ⁼Q $ égal à lui-même non unique.

Python 2 , 128 octets

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

Essayez-le en ligne!

05AB1E , 17 octets

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

Essayez-le en ligne!

Python 2 , 121 117 113 111 111 octets

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

Essayez-le en ligne!

Pointe du chapeau à Lynn pour formatlaquelle j'avais oublié!

Husk , 19 octets

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

Essayez-le en ligne!

Retourne les listes de bases

Explication

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