一些正整数的除数确实很讨厌彼此，并且他们不喜欢共享一个或多个公共数字。

这些整数称为敌对数数（HDN）

例子

Number 9566有4除数：（1, 2, 4783 and 9566
如您所见，其中没有两个共享相同的数字）。
因此，9566是一个ħ ostile d ivisor Ñ棕土

号码9567是不是HDN，因为它的除数（1, 3, 9, 1063, 3189, 9567）具有一些共同的数字。

这是前几个HDN

1,2,3,4,5,6,7,8,9,23,27,29,37,43,47,49,53,59,67,73,79,83,86,87,89,97,223,227,229,233,239,257,263,267,269,277,283,293,307,337...       

任务

上面的列表继续，您的任务是找到第n个 HDN

输入值

n从1到的正整数4000

输出量

该nth HDN

测试用例

这是一些1索引测试用例。
请说明您在答案中使用的索引系统，以避免造成混淆。

input -> output     
 1        1     
 10       23       
 101      853     
 1012     26053     
 3098     66686      
 4000     85009      

这是代码高尔夫球，因此以字节为单位的最低分数获胜。

编辑

好消息！我已将序列提交给OEIS，并且...
敌对因子数现在为OEIS A307636

05AB1E，12 10 字节

µNNÑ€ÙSDÙQ

-2个字节，感谢@Emigna。

1索引

在线尝试或验证大多数测试用例（由于超时，将省略最后两个测试用例）。

说明：

µ           # Loop while the counter_variable is not equal to the (implicit) input yet:
 N          #  Push the 0-based index of the loop to the stack
  NÑ        #  Get the divisors of the 0-based index as well
            #   i.e. N=9566 → [1,2,4783,9566]
            #   i.e. N=9567 → [1,3,9,1063,3189,9567]
    €Ù      #  Uniquify the digits of each divisor
            #   → ["1","2","4783","956"]
            #   → ["1","3","9","1063","3189","9567"]
      S     #  Convert it to a flattened list of digits
            #   → ["1","2","4","7","8","3","9","5","6"]
            #   → ["1","3","9","1","0","6","3","3","1","8","9","9","5","6","7"]
       D    #  Duplicate this list
        Ù   #  Unique the digits
            #   → ["1","2","4","7","8","3","9","5","6"]
            #   → ["1","3","9","0","6","8","5","7"]
         Q  #  And check if it is still equal to the duplicated list
            #   → 1 (truthy)
            #   → 0 (falsey)
            #  And if it's truthy: implicitly increase the counter_variable by 1
            # (After the loop: implicitly output the top of the stack,
            #  which is the pushed index)

Python 2，104个字节

n=input()
x=1
while n: 
 x=i=x+1;d={0};c=1
 while i:m=set(`i`*(x%i<1));c*=d-m==d;d|=m;i-=1
 n-=c
print x

在线尝试！

0索引。

JavaScript（ES6），78个字节

1个索引。

n=>eval("for(k=0;n;n-=!d)for(s=d=++k+'';k%--d||d*!s.match(`[${s+=d,d}]`););k")

在线尝试！

更快的版本，79字节

n=>{for(k=0;n;n-=!d)for(s=d=++k+'';k%--d||d*!s.match(`[${s+=d,d}]`););return k}

在线尝试！

怎么样？

给定整数$k>0$，我们将字符串$s$构建为$k$的所有除数的串联。

由于$k$始终是其自身的除数，因此$s$初始化为$k$（强制为字符串），而我们尝试的第一个除数为$d=k-1$。

对于每一个除数$d$的$k$，我们测试是否任位$d$中可以找到$s$通过转动$d$成字符集正则表达式。

例子

• $s=\text{"}956647832\text{"}$，$d=1$ →"956647832".match(/[1]/)是虚假的
• $s=\text{"}9567\text{"}$，$d=3189$ →"9567".match(/[3189]/)是真实的

已评论

这是不带的版本eval()，以提高可读性

n => {                   // n = input
  for(                   // for() loop:
    k = 0;               //   start with k = 0
    n;                   //   go on until n = 0
    n -= !d              //   decrement n if the last iteration resulted in d = 0
  )                      //
    for(                 //   for() loop:
      s =                //     start by incrementing k and
      d = ++k + '';      //     setting both s and d to k, coerced to a string
      k % --d ||         //     decrement d; always go on if d is not a divisor of k
      d *                //     stop if d = 0
      !s.match(          //     stop if any digit of d can be found in s
        `[${s += d, d}]` //     append d to s
      );                 //
    );                   //   implicit end of inner for() loop
                         // implicit end of outer for() loop
  return k               // return k
}                        //

果冻，10字节

ÆDQ€FQƑµ#Ṫ

在线尝试！

-1字节感谢ErikTheOutgolfer

接收来自STDIN的输入，这对于Jelly是不常见的，但在nfind使用该位置时是正常的。

ÆDQ€FQƑµ#Ṫ  Main link
         Ṫ  Get the last element of
        #   The first <input> elements that pass the filter:
ÆD          Get the divisors
  Q€        Uniquify each (implicitly converts a number to its digits)
    F       Flatten the list
     QƑ     Does that list equal itself when deduplicated?

2索引

Perl 6 6、53字节

{(grep {/(.).*$0/R!~~[~] grep $_%%*,1..$_},^∞)[$_]}

在线尝试！

1个索引。

/(.).*$0/ 匹配具有重复数字的任何数字。

grep $_ %% *, 1 .. $_ 返回数字的所有除数的列表 $_当前正在检查列表中成员资格的列表。

[~]将所有这些数字连接在一起，然后R!~~将右侧的字符串与左侧的模式匹配。（~~是通常的match运算符，!~~是该运算符的取反，并且R是交换的参数的元运算符!~~。）

Python 2（PyPy），117 114字节

使用1索引

k=input();n=0;r=range
while k:n+=1;k-=1-any(set(`a`)&set(`b`)for a in r(1,n+1)for b in r(1,a)if n%a<1>n%b)
print n

在线尝试！

Wolfram语言103字节

使用1索引。我很惊讶它需要那么多代码。

(k=1;u=Union;n=2;l=Length;While[k<#,If[l[a=Join@@u/@IntegerDigits@Divisors@#]==l@u@a&@n,k++];n++];n-1)&

电源外壳，112字节

for($a=$args[0];$a-gt0){$z=,0*10;1..++$n|?{!($n%$_)}|%{"$_"|% t*y|sort -u|%{$z[+"$_"]++}};$a-=!($z|?{$_-ge2})}$n

在线尝试！

接受1索引的输入$args[0]，将其存储到$a，循环直到命中0。每次迭代，我们将一个10元素的数组归零$z（用于保存我们的数字计数）。然后，使用构造除数列表1..++$n|?{!($n%$_)}。对于每个除数，我们将其强制转换为字符串"$_"，将其t强制转换为oCharArra y，并sort使用-unique标志将这些数字强制转换（因为我们不在乎除数本身是否具有重复的数字）。然后，我们在中增加适当的位数$z。然后，$a仅当$z包含0s和1s时我们才递减（即，我们找到了HDN）。如果我们完成了for循环，则意味着我们找到了适当数量的HDN，因此我们$n继续执行管道，并且输出是隐式的。

Python 3，115字节

1索引

f=lambda n,x=1,s="",l="",d=1:n and(d>x+1and f(n-1,x+1)or{*s}&{*l}and f(n,x+1)or f(n,x,s+l,(1-x%d)*str(d),d+1))or~-x

在线尝试！

这需要大量的递归。即使增加了递归限制，它也无法做到f(30)。我认为它可能更适合打高尔夫球，因此我尝试寻找一些替代品(1-x%d)，但无法提出任何建议（-~-x%d优先顺序错误）。可以剃除的任何字节都将受到极大的赞赏。

怎么运行的

# n: HDNs to go
# x: Currently tested number
# s: String of currently seen divisor digits
# l: String of digits of last tried divisor if it was a divisor, empty string otherwise
# d: Currently tested divisor

f=lambda n,x=1,s="",l="",d=1:n and(                    # If there are still numbers to go
                             d>x+1and f(n-1,x+1)or     # If the divisors have been
                                                       #  exhausted, a HDN has been found
                             {*s}&{*l}and f(n,x+1)or   # If there were illegal digits in
                                                       #  the last divisor, x isn't a HDN
                             f(n,x,s+l,(1-x%d)*str(d),d+1)
                                                       # Else, try the next divisor, and
                                                       #  check this divisor's digits (if
                                                       #  if is one) in the next call
                             )or~-x                    # Else, return the answer

Brachylog（v2），14个字节

;A{ℕfdᵐc≠&}ᶠ⁽t

在线尝试！

功能提交；从左边输入，到右边输出。（TIO链接包含一个命令行参数，可以像运行完整程序一样运行函数。）

说明

“这是一个敌对的除数吗？” 决策问题代码：

ℕfdᵐc≠
ℕ       number is ≥0 (required to match the question's definition of "nth solution")
 f      list of all factors of the number
   ᵐ    for each factor
  d       deduplicate its digits
    c   concatenate all the deduplications with each other
     ≠  the resulting number has no repeated digits

尽管我是独立编写的，但这与@UnrelatedString的基本相同。

“ 决策问题的第n个解决方案”包装器：

;A{…&}ᶠ⁽t
    &      output the successful input to
  {  }ᶠ    the first n solutions of the problem
       ⁽   taking <n, input> as a pair
;A         form a pair of user input and a "no constraints" value
        t  take the last solution (of those first n)

这是其中产生第n个输出所需的包装程序明显长于依次测试每个输出所需的代码的情况之一：-)

我独立于@UnrelatedString提出了这个包装器。它的长度相同，工作原理相同，但是最终以不同的方式书写。它确实有更大的改进空间，因为我们可以通过用A一些约束变量替换来免费添加我们正在寻找的值的约束，但是任何可能的约束变量都不保存字节。（如果有一个“负整数”约束变量，可以用替换A它，然后通过使ℕ不必要的字节来保存一个字节。）

爪哇10，149个 139 138 126 125 120 119字节

n->{int r=0,i,d;for(;n>0;n-=d){var s="1";for(r+=d=i=1;i++<r;)if(r%i<1){d=s.matches(".*["+i+"].*")?0:d;s+=i;}}return r;}

受@Arnauld的JavaScript答案启发，通过使用-10个字节.matches代替.contains每个数字。 -5字节感谢@ValueInk -1感谢字节@ceilingcat

1索引

在线尝试。

说明：

n->{                 // Method with integer as both parameter and return-type
  int r=0,           //  Result-integer, starting at 0
      i,             //  Index integer
      d;             //  Decrement integer
  for(;n>0;          //  Loop until the input `n` is 0:
      n-=d){         //    After every iteration: decrease `n` by the decrement integer `d`
    var s="1";       //   Create a String `s`, starting at "1"
    for(r+=d=i=1;    //   (Re)set the decrement and index integers to 1,
                     //   and increase the result by 1 as well
        i++<r;)      //   Inner loop `i` in the range [2, r]:
      if(r%i<1){     //    If `r` is divisible by `i`:
        d=s.matches(".*["+i+"].*")?
                     //     If string `s` contains any digits also found in integer `i`:
           0         //      Set the decrement integer `d` to 0
          :d;        //     Else: leave `d` unchanged
        s+=i;}}      //     And then append `i` to the String `s`
  return r;}         //  After the loops, return the result `r`

Brachylog，16个字节

g{∧0<.fdᵐc≠∧}ᵘ⁾t

在线尝试！

非常慢，是决策问题的两倍。1个索引。

                    The output
               t    is the last
             ᵘ⁾     of a number of unique outputs,
g                   where that number is the input,
 {          }       from the predicate declaring that:
     .              the output
    <               which is greater than
   0                zero
  ∧                 (which is not the empty list)
      f             factorized
        ᵐ           with each factor individually
       d            having duplicate digits removed
          ≠         has no duplicate digits in
         c          the concatenation of the factors
           ∧        (which is not the output).

Wolfram语言（Mathematica），74字节

Nest[1+#//.a_/;!Unequal@@Join@@Union/@IntegerDigits@Divisors@a:>a+1&,0,#]&

在线尝试！

Japt v2.0a0，17个字节

_=â ®sâìUµZ¶â}f1

试试吧

这个Brachylog答案的端口。

信用：感谢Shaggy总共节省了4个字节，他还提出了一种更好的解决方案，可以产生更多的字节:)

原始答案28字节的方法：

Èâ¬rÈ«è"[{Y}]" ©X+Y}Xs)«U´Ãa

试试吧

此JavaScript回答的端口。

图标，123字节

procedure f(n)
k:=m:=0
while m<n do{
k+:=1
r:=0
s:=""
every k%(i:=1 to k)=0&(upto(i,s)&r:=1)|s++:=i
r=0&m+:=1}
return k
end

在线尝试！

1个索引。对于大的输入来说真的很慢。

Perl 6，74个字节

{(grep {!grep *>1,values [(+)] map *.comb.Set,grep $_%%*,1..$_},1..*)[$_]}

0索引。TIO仅列出前三个案例，因为它太慢，无法测试其余案例。

在线尝试！

Ruby，110 97 92 84字节

通过@Arnauld的JavaScript regex check来获得-13个字节。

-5个字节，用于换出times一个递减器和一个循环while。

放弃combination其他答案，可以放弃-8个字节。

->n{x=0;n-=1if(s='';1..x+=1).all?{|a|x%a>0||(e=/[#{a}]/!~s;s+=a.to_s;e)}while n>0;x}

在线尝试！

Perl -p 5，66个字节

map{1while(join$",map{$\%$_==0&&$_}1..++$\)=~/(\d).* .*\1/}1..$_}{

在线尝试！

1个索引

J，⁸⁷ 59字节

-28字节归功于FrownFrog

0{(+1,1(-:~.)@;@(~.@":&.>@,i.#~0=i.|])@+{.)@]^:(>{:)^:_&0 0

在线尝试！

原版的

J，87字节

[:{:({.@](>:@[,],([:(-:~.)[:-.&' '@,/~.@":"0)@((]#~0=|~)1+i.)@[#[)}.@])^:(#@]<1+[)^:_&1

在线尝试！

kes。

对于J来说，这已经很残酷了，但是我没有找到降低它的好方法。

说明

引入几个辅助动词以查看正在发生的情况将有所帮助：

d=.(]#~0=|~)1+i.
h=. [: (-:~.) [: -.&' '@,/ ~.@":"0

• d 返回其参数的所有除数的列表
• h告诉您这样的列表是敌对的。它对每个数字进行字符串化和重复数据删除~.@":"0，然后返回一个方矩阵，其中较短的数字用空格填充。-.&' '@,/展平矩阵并删除空格，最后(-:~.)告诉您该数字是否重复。

有了这两个帮助器，我们整体的，没有助词的动词变为：

[: {: ({.@] (>:@[ , ] , h@d@[ # [) }.@])^:(#@] < 1 + [)^:_&1

在这里，我们维护一个列表，其头是我们的“当前候选者”（从1开始），而尾巴是到目前为止发现的所有敌对数字。

我们>:@[在每次迭代中增加列表的开头，并且仅在“当前候选者”是敌对时附加“当前候选者” h@d@[ # [。我们一直这样做，直到列表长度达到1 + n：^:(#@] < 1 + [)^:_。

最后，完成后，我们返回此列表的最后一个数字，[: {:即第n个敌对数字。