Eingang

Ein nicht leeres Array positiver Ganzzahlen.

Aufgabe

Konvertieren Sie jede Ganzzahl entweder in binär, oktal, dezimal oder hexadezimal, sodass jede Ziffer ( 0 bis F ) höchstens einmal verwendet wird.

Ausgabe

Die Liste der Basen, die zur Lösung des Rätsels verwendet wurden.

Ausführliches Beispiel

Die erwartete Ausgabe für [16, 17] ist [oktal, dezimal] .

Hier ist warum:

• Wir können nicht einfach eine Dezimalzahl für beide Zahlen verwenden, da beide eine 1 enthalten .
• 16 kann nicht auf binär umgewandelt werden, da seine Darstellung in dieser Basis ( 10000 ) enthält mehrere 0 ‚s.
• 17 kann nicht auf binäre entweder, umgewandelt werden , da seine Darstellung in dieser Basis ( 10001 ) enthält mehrere 0 ‚s und mehrere 1 ‘ s.
• 17 kann nicht auf hexadezimale umgewandelt werden, da seine Darstellung in dieser Basis ( 11 ) besteht aus zwei 1 ‚s.

• Betrachten wir alle verbleibenden Möglichkeiten:

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

  Die einzig mögliche Lösung besteht darin, 16 in Oktal ( 20 ) umzuwandeln und 17 in Dezimal ( 17 ) zu belassen . Auf diese Weise werden die Ziffern 0 , 1 , 2 und 7 genau einmal verwendet.

Erläuterungen und Regeln

• Der Input führt garantiert zu einer einzigartigen Lösung. Ihr Code sollte keine Arrays unterstützen, die mehrere oder gar keine Lösungen bieten.
• Sie können die Basen in jedem vernünftigen Format ausgeben, z. B. ["bin", "oct", "dec", "hex"] , ["b", "o", "d", "h"] , "BODH" " , [2,8,10,16] , [0,1,2,3] usw. Aber es sollte in Ihrer Antwort klar erklärt werden.
• Die Reihenfolge der Basen in der Ausgabe muss mit der Reihenfolge der Eingabe-Ganzzahlen übereinstimmen.
• In diesem Fall können Sie davon ausgehen, dass die Eingabe vom niedrigsten zum höchsten oder vom höchsten zum niedrigsten Wert sortiert ist.
• Das ist Code-Golf , also gewinnt die kürzeste Antwort in Bytes!

Testfälle

Sie müssen die unten aufgeführten Konvertierungsergebnisse nicht ausgeben. Sie dienen lediglich der Information.

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

Die Rohdatenliste finden Sie hier .

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

• Vielen Dank an @Arnauld, der mich daran erinnert hat, dass ich [0,1,2,3] zurückgeben kann -> was [2,8,10,16] 8 Bytes spart und für die brillante Idee (die dazu beiträgt, um 23+ zu reduzieren) Bytes)
• danke an @Kevin Cruijssen für die Reduzierung um 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

Probieren Sie es online!

Erläuterung:

[c,...a]- @Arnauld-Trick, um jeweils einen Gegenstand zu nehmen c?***:" "-> wenn c undefiniert ist, haben wir es geschafft, zum Endergebnis zu gelangen- [] - wenn ich "" setzen würde, würde der Fund nicht als legitim angesehen. ([] + 5 = "5" JS FTW) [1,4,5,8].findjedes Mal, wenn wir die richtige Basis finden (die Ausgabe wird von diesem Array (1,4,5,8) -> (2,8,10,16) sein legitimes. jetzt wie der find funktioniert -> wenn es etwas findet gibt es das element zurück (1-8) und dann addiere ich das ergebnis der inneren lösung. wenn es nicht findet dann gibt es undefined zurück + T ist jetzt false -> naN was in der Elternruf wird als falsch gewertet

!/(.).*\1/.test(n=t+b) Bestimmen Sie, ob die Zeichenfolge Duplikate enthält.

f(a,n)) gehe einfach zur nächsten Zahl (a ist jetzt array.slice (1)) mit der neuen Zeichenkette (n)

Wir weisen das Ergebnis T (temp) des Ergebnisses zu, da find stoppt, wenn es findet, und wir wissen, dass das letzte Ergebnis f () ist, das Ergebnis B ist

Perl 5 -alp , 55 Bytes

Verwendet %xfür hex, %dfür dezimal, %ofür oktal und %bfür binär

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

Probieren Sie es online!

Ruby, 72 71 Bytes

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

Das Ausgabeformat ist eine Art umgekehrte Monstrosität des S-Ausdrucks:

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

Das Trennen mit Schrägstrichen würde stattdessen 3 weitere Bytes kosten (anhängen *?/).

Dieses Format stammt aus der Schleifenstruktur, die etwas kürzer ist als die idiomatischere Struktur, repeated_combination(a.size)die ein Array von Arrays von Zeichen generiert und es dann über die produktübergreifende Funktion reduziert.

Bearbeiten: 1 Byte dank Lynn gespeichert.

Pyth, 21 bis 20 Bytes

f{Is.bjYNTQ^[8T2y8)l

Gibt eine Liste aller möglichen Listen von Basen zurück (die immer die Länge 1 haben).
Probieren Sie es hier aus

Erläuterung

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

Gibt eine Liste der Basen zurück.

Probieren Sie es online!

Jelly , 17 16 Bytes

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

Probieren Sie es online!

Gibt eine Liste der Basen zurück.

 == Erklärung ==
⁴⁽% ʠḃṗL³bF⁼Q $ ƲÐf Hauptlink.
 ⁽% ʠ Eine Zahl.
    ḃ konvertiere es in eine bijektive Basis ...
⁴ 16. Das Ergebnis ist [2,8,10,16].
     ṗL Kartesische Potenz durch die Eingangslänge.
             ƲÐ Behalten Sie beim Filtern diejenigen bei, die ...
       ³ die Eingabe
        b zu dieser Basis konvertieren
         F beim Abflachen (alle Ziffern von \ verbinden
                      verschiedene Zahlen zusammen)
          ⁼Q $ gleich sich selbst eindeutig.

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

Probieren Sie es online!

05AB1E , 17 Bytes

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

Probieren Sie es 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

Probieren Sie es online!

Spitze des Hutes zu Lynn für format, die ich vergessen hatte!

Schale , 19 Bytes

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

Probieren Sie es online!

Gibt eine Liste der Basen zurück

Erläuterung

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