输入值

一个非空的正整数数组。

任务

将每个整数转换为二进制，八进制，十进制或十六进制，以使每个数字（0至F）最多使用一次。

输出量

用于解决难题的基础列表。

详细的例子

对于预期的输出[16，17]是[八进制，十进制]。

原因如下：

• 我们不能简单地对两个数字都使用十进制，因为它们都包含1。
• 16无法转换为二进制，因为它在此基数（10000）中的表示包含多个0。
• 17也不能转换为二进制，因为它在此基数（10001）中的表示包含几个0和几个1。
• 17不能转换为十六进制，因为它在此基数（11）中的表示由两个1组成。

• 让我们考虑所有剩余的可能性：

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

  唯一可能的解决方案是将16转换为八进制（20），将17保留为十进制（17）。这种方式，数字0，1，2和7被精确地使用一次。

澄清和规则

• 输入保证可以导致独特的解决方案。您的代码不应支持提供多个解决方案或根本没有解决方案的阵列。
• 您可以以任何合理的格式输出基数，例如[“ bin”，“ oct”，“ dec”，“ hex”]，['b'，'o'，'d'，'h']，“ BODH “，[2,8,10,16]，[0,1,2,3]等。但是您的答案中应明确说明。
• 输出中基数的顺序必须与输入整数的顺序匹配。
• 如果有帮助，您可以假设输入从最低到最高，或者从最高到最低排序。
• 这是代码高尔夫球，因此最短答案以字节为单位！

测试用例

您不必输出下面列出的转换结果。它们纯粹是信息性的。

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

原始输入列表在此处可用。

JavaScript（Node.js），192,155,154,152,151,145,136,113,99,92 90字节

• 感谢@Arnauld提醒我，我可以返回[0,1,2,3]-> [2,8,10,16]可以节省8个字节，并且是个绝妙的主意（有助于减少23+个字节）
• 感谢@Kevin Cruijssen减少了1个字节

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

在线尝试！

说明：

[c,...a]-@一次一次拿一件商品的Arnauld技巧 c?***:" "->如果c未定义，我们设法达到最终结果-[]-如果我将“”放到发现的范围内，则不会认为这是合法的。（[] + 5 =“ 5” JS FTW） [1,4,5,8].find每次我们找到正确的基础（输出将是其合法性的此数组（1,4,5,8）->（2,8,10,16）。现在查找的工作原理->如果找到了它，则返回元素（1-8），然后我添加内部解决方案的结果。如果找不到，则返回undefined + T现在为false-> NaN父级通话将被视为错误

!/(.).*\1/.test(n=t+b) 确定字符串是否重复，如果存在：

f(a,n)) 只需转到带有新字符串（n）的下一个数字（现在是array.slice（1））

我们将结果分配给结果的T（temp），因为在找到时停止查找，因此我们知道最后一个结果将是f（），即结果B

Perl -alp 5、55个字节

用途%x为十六进制，%d十进制，%o八进制和%b二进制

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

在线尝试！

红宝石， 72 71字节

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

输出格式是某种反向S表达式的怪诞形式：

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

斜杠分隔将花费3个字节（附加*?/）。

这种格式来自循环结构，比更惯用的循环结构略短repeated_combination(a.size)，后者会生成字符数组，然后通过叉积函数将其减少。

编辑：感谢Lynn，节省了1个字节。

Pyth，21 20字节

f{Is.bjYNTQ^[8T2y8)l

返回所有可能的碱基列表（始终为1）的列表。
在这里尝试

说明

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语言（Mathematica），71个字节

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

返回碱基列表。

在线尝试！

果冻，17 16字节

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

在线尝试！

返回碱基列表。

 ==说明==
⁴⁽％ʠḃṗL³bF⁼Q$Ʋf主链接。
 ⁽％ʠ一个数字。
    ḃ将其转换为双射基数...
⁴16.结果为[2,8,10,16]。
     ṗL笛卡尔幂乘以输入长度。
             Filterf过滤器，保留那些满足...
       ³输入
        b转换为该基数
         F展平时（请连入\的所有数字
                      不同的数字在一起）
          ⁼Q$等于本身的唯一性。

Python 2，128个字节

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

在线尝试！

05AB1E，17个字节

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

在线尝试！

Python 2中，121个 117 113 111字节

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

在线尝试！

尖帽子的林恩的format，我已经忘了！

外壳，19个字节

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

在线尝试！

返回碱基列表

说明

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