양의 정수를 나누는 제수는 실제로 서로를 미워하며 하나 이상의 공통 숫자를 공유하는 것을 좋아하지 않습니다.

이러한 정수를 적대적 제수 ( HDN )라고합니다.

예

숫자 9566는 4제수를가집니다 : 1, 2, 4783 and 9566
보시 다시피 , 두 숫자가 같은 숫자를 공유하지 않습니다 .
따라서, 9566는 A는 H의 ostile의 D ivisor N의 엄버

제수 ( )가 일부 공통 자릿수를 공유 하므로 Number 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      

이것은 code-golf 이므로 바이트 단위의 최저 점수가 이깁니다.

편집하다

좋은 소식! 나는 OEIS에 내 시퀀스를 제출했고 ...
적대적인 제수는 이제 OEIS A307636입니다.

05AB1E , 12 10 바이트

µNNÑ€ÙSDÙQ

@Emigna 덕분에 -2 바이트 .

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)

파이썬 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입니다.

자바 스크립트 (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Ƒµ#Ṫ

온라인으로 사용해보십시오!

ErikTheOutgolfer 덕분에 -1 바이트

STDIN에서 입력을 가져옵니다. 이는 젤리에서는 드문 일이지만 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- 색인

펄 6 , 53 바이트

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

온라인으로 사용해보십시오!

1- 색인.

/(.).*$0/ 숫자가 반복되는 숫자와 일치합니다.

grep $_ %% *, 1 .. $_$_현재 목록에서 멤버쉽을 확인중인 숫자의 모든 제수 목록을 리턴 합니다.

[~]해당 숫자를 모두 연결 한 다음 R!~~오른쪽의 문자열을 왼쪽의 패턴과 일치시킵니다. ( ~~일반적인 일치 연산자이고 !~~해당 연산자의 부정이며 R의 인수를 바꾸는 메타 연산자 입니다 !~~.)

파이썬 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)&

PowerShell , 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%$_)}. 각 제수에 대해 문자열로 캐스트합니다."$_" 로 캐스트하고 toCharArra y, nique 플래그로 sort숫자를 캐스트합니다 -u(제수 자체에 중복 숫자가 있는지는 신경 쓰지 않기 때문에). 그런 다음에 적절한 자리수를 증가시킵니다 $z. 그런 다음 s 및 s $a가 $z포함 된 경우에만 감소 합니다 (즉, HDN을 찾았습니다). 루프를 마치면 적절한 수의 HDN을 찾았으므로 파이프 라인 을 그대로두고 출력은 암시 적입니다.01for$n

파이썬 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과 동일합니다.

" 의사 결정 문제 에 대한 두 번째 해결책 "래퍼 :

;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 답변 에서 영감을 얻은 자릿수 .matches대신 -10 바이트 . -5 덕분 바이트 @ValueInk -1 바이트 덕분 @ceilingcat을.contains

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 Language (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- 색인. 큰 입력의 경우에는 실제로 느립니다.

펄 6 , 74 바이트

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

인덱스가 0입니다. 나머지 세 개를 테스트하기에는 너무 느리기 때문에 처음 세 가지 사례 만 TIO에 나열됩니다.

온라인으로 사용해보십시오!

루비 , 110 97 92 84 바이트

@Arnauld의 JavaScript 정규식 검사 를 활용하여 -13 바이트 .

스왑 아웃을위한 -5 바이트 times decrementer 및 위해 루프 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}

온라인으로 사용해보십시오!

펄 5 -p , 66 바이트

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

온라인으로 사용해보십시오!

1 색인

J , ⁸⁷ 59 바이트

FrownFrog 덕분에 -28 바이트

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

온라인으로 사용해보십시오!

기발한

J , 87 바이트

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

온라인으로 사용해보십시오!

Yikes.

이것은 J에게는 엄청나게 길지만, 그것을 없애는 좋은 방법을 찾지 못했습니다.

설명

무슨 일이 일어나고 있는지 확인하기 위해 몇 가지 도우미 동사를 소개하는 데 도움이됩니다.

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

• d 인수의 모든 제수 목록을 리턴합니다.
• h그런 목록이 적대적이라고 알려줍니다. 각 숫자를 ~.@":"0문자열 화하고 중복 제거 하여 짧은 숫자가 공백으로 채워지는 정사각 행렬을 반환합니다. -.&' '@,/행렬을 평탄화하고 공백을 제거하고 마지막으로 해당 숫자가 반복 (-:~.)되는지 여부 를 알려줍니다 .

이 두 조력자들과 함께 우리의 전체 골퍼가 아닌 동사는 다음과 같습니다.

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

여기서 우리는 "현재 후보"(1로 시작)이고 그 꼬리가 지금까지 발견 된 적대적인 숫자 인 목록을 유지합니다.

우리는 >:@[각 반복 에서 목록의 헤드를 증가시키고 적대적인 경우에만 "현재 후보"를 추가합니다 h@d@[ # [. 우리는리스트 길이가 1 + n :에 도달 할 때까지 이것을 계속 ^:(#@] < 1 + [)^:_합니다.

마지막으로, 우리가 끝나면, [: {:이리 스트의 마지막 숫자 인 n 번째 적대 수를 반환합니다 .