Một số ước của số nguyên dương thực sự ghét nhau và họ không muốn chia sẻ một hoặc nhiều chữ số chung.

Các số nguyên đó được gọi là Số chia số thù địch ( HDN )

Ví dụ

Số 9566có 4ước số: 1, 2, 4783 and 9566
(như bạn có thể thấy, không có hai trong số chúng có cùng chữ số ).
Do đó, 9566 là một H ostile D ivisor N màu nâu đen

Số KHÔNG phải9567 là HDN vì các ước của nó ( ) chia sẻ một số chữ số phổ biến. 1, 3, 9, 1063, 3189, 9567

Dưới đây là một vài HDN đầu tiên

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

Bài tập

Danh sách trên tiếp tục và nhiệm vụ của bạn là tìm HDN thứ n

Đầu vào

Một số nguyên dương ntừ 1đến4000

Đầu ra

các nth HDN

Các trường hợp thử nghiệm

Dưới đây là một số trường hợp kiểm tra 1 chỉ mục .
Vui lòng cho biết hệ thống lập chỉ mục nào bạn sử dụng trong câu trả lời của mình để tránh nhầm lẫn.

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

Đây là môn đánh gôn , vì vậy điểm số thấp nhất tính bằng byte sẽ thắng.

CHỈNH SỬA

Tin tốt! Tôi đã gửi trình tự của mình tới OEIS và ...
Số chia số thù địch hiện là OEIS A307636

05AB1E , 12 10 byte

µNNÑ€ÙSDÙQ

-2 byte nhờ @Emigna .

1 chỉ mục

Dùng thử trực tuyến hoặc xác minh hầu hết các trường hợp thử nghiệm (hai trường hợp thử nghiệm cuối cùng bị bỏ qua, vì chúng hết thời gian).

Giải trình:

µ           # 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 byte

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

Hãy thử trực tuyến!

Chỉ số 0.

JavaScript (ES6), 78 byte

1 chỉ mục.

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

Hãy thử trực tuyến!

Phiên bản nhanh hơn, 79 byte

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

Hãy thử trực tuyến!

Làm sao?

Cho một số nguyên $k>0$ , chúng ta xây dựng chuỗi $s$ là phép nối của tất cả các ước của $k$ .

Vì $k$ luôn là ước của chính nó, $s$ được khởi tạo thành $k$ (bị ép buộc thành một chuỗi) và ước số đầu tiên mà chúng ta thử là $d=k-1$ .

Đối với mỗi ước $d$ của $k$ , chúng tôi kiểm tra xem có bất kỳ chữ số của $d$ có thể được tìm thấy trong $s$ bằng cách biến $d$ thành một bộ ký tự trong một biểu thức chính quy.

Ví dụ

• $s=\text{"}956647832\text{"}$ ,$d=1$ →"956647832".match(/[1]/)là giả
• $s=\text{"}9567\text{"}$ ,$d=3189$ →"9567".match(/[3189]/)là sự thật

Đã bình luận

Đây là phiên bản không có eval(), để dễ đọc

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
}                        //

Thạch , 10 byte

ÆDQ€FQƑµ#Ṫ

Hãy thử trực tuyến!

-1 byte nhờ ErikTheOutgolfer

Lấy đầu vào từ STDIN, điều không bình thường đối với Jelly nhưng bình thường nfindđược sử dụng ở đâu .

Æ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 chỉ mục

Perl 6 , 53 byte

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

Hãy thử trực tuyến!

1 chỉ mục.

/(.).*$0/ khớp với bất kỳ số nào với một chữ số lặp lại.

grep $_ %% *, 1 .. $_trả về một danh sách tất cả các ước của số $_hiện đang được kiểm tra làm thành viên trong danh sách.

[~]nối tất cả các chữ số đó lại với nhau, và sau đó R!~~khớp chuỗi bên phải với mẫu bên trái. ( ~~là toán tử khớp thông thường, !~~là phủ định của toán tử đó và Rlà một toán tử meta thay đổi các đối số của !~~.)

Python 2 (PyPy) , 117 114 byte

Sử dụng 1 chỉ mục

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

Hãy thử trực tuyến!

Ngôn ngữ Wolfram 103 byte

Sử dụng 1 chỉ mục. Tôi ngạc nhiên khi nó yêu cầu rất nhiều mã.

(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 byte

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

Hãy thử trực tuyến!

Đưa đầu vào 1 chỉ mục $args[0], lưu trữ vào $a, vòng lặp cho đến khi lần truy cập đó 0. Mỗi lần lặp, chúng tôi bỏ ra một mảng mười phần tử $z(được sử dụng để giữ số lượng chữ số của chúng tôi). Sau đó, chúng tôi xây dựng danh sách các ước của chúng tôi với 1..++$n|?{!($n%$_)}. Đối với mỗi ước số, chúng tôi chuyển nó thành một chuỗi "$_", đúc nó toCharArra yvà sortcác chữ số đó với -ucờ nique (vì chúng tôi không quan tâm nếu chính số chia đó có các chữ số trùng lặp). Chúng tôi sau đó tăng số lượng chữ số thích hợp trong $z. Sau đó, chúng tôi $achỉ giảm nếu $zcó 0s và 1s (nghĩa là chúng tôi đã tìm thấy HDN). Nếu chúng tôi đã hoàn thành forvòng lặp của mình, điều đó có nghĩa là chúng tôi đã tìm thấy số lượng HDN phù hợp, vì vậy chúng tôi để lại $ntrên đường ống dẫn và đầu ra là ẩn.

Python 3 , 115 byte

1 chỉ mục

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

Hãy thử trực tuyến!

Điều này sử dụng rất nhiều đệ quy; ngay cả với giới hạn đệ quy tăng, nó cũng không thể làm được f(30). Tôi nghĩ rằng nó có thể chơi được hơn nữa và tôi đã cố gắng tìm thứ gì đó để thay thế (1-x%d), nhưng không thể đưa ra bất cứ điều gì ( -~-x%dcó quyền ưu tiên sai). Bất kỳ byte nào có thể được loại bỏ được đánh giá rất cao.

Làm thế nào nó hoạt động

# 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 byte

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

Hãy thử trực tuyến!

Chức năng trình; đầu vào từ bên trái, đầu ra bên phải. (Liên kết TIO chứa đối số dòng lệnh để chạy một hàm như thể nó là một chương trình đầy đủ.)

Giải trình

"Đây có phải là một số chia ước thù không?" mã quyết định vấn đề :

ℕ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

Điều này về cơ bản giống như @ UnrelatedString, mặc dù tôi đã viết nó một cách độc lập.

Gói giải pháp "thứ n cho vấn đề quyết định ":

;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)

Đây là một trong những trường hợp trong đó trình bao bọc được yêu cầu để tạo đầu ra thứ n dài hơn đáng kể so với mã được yêu cầu để kiểm tra lần lượt từng đầu ra :-)

Tôi đã đưa ra trình bao bọc này một cách độc lập với @ UnrelatedString's. Nó có cùng độ dài và hoạt động theo cùng một nguyên tắc, nhưng bằng cách nào đó cuối cùng lại được viết khá khác nhau. Nó có phạm vi tiềm năng hơn để cải thiện, vì chúng ta có thể thêm các ràng buộc về các giá trị mà chúng ta đang tìm kiếm miễn phí thông qua việc thay thế Abằng một số biến ràng buộc, nhưng không có biến ràng buộc nào có thể lưu byte. (Nếu có một biến ràng buộc "số nguyên không âm", bạn có thể thay thế Abằng biến đó và sau đó lưu một byte thông qua việc ℕkhông cần thiết.)

Java 10, 149 139 138 126 125 120 119 byte

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;}

-10 byte bằng cách sử dụng .matchesthay vì .containsmỗi chữ số, lấy cảm hứng từ câu trả lời JavaScript của @Arnauld .
-5 byte nhờ @ValueInk
-1 byte nhờ @ceilingcat

1 chỉ mục

Hãy thử trực tuyến.

Giải trình:

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 byte

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

Hãy thử trực tuyến!

Rất chậm, và lâu gấp đôi nếu nó là một vấn đề quyết định . 1 chỉ mục.

                    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).

Ngôn ngữ Wolfram (Mathicala) , 74 byte

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

Hãy thử trực tuyến!

Japt v2.0a0, 17 byte

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

Thử nó

Cổng của câu trả lời Brachylog này .

Tín dụng: Tổng số tiết kiệm 4 byte nhờ Shaggy, người cũng cho rằng có một giải pháp tốt hơn dẫn đến nhiều byte hơn :)

Câu trả lời gốc Cách tiếp cận 28 byte:

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

Thử nó

Cổng của câu trả lời JavaScript này .

Biểu tượng , 123 byte

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

Hãy thử trực tuyến!

1 chỉ mục. Thực sự chậm cho đầu vào lớn.

Perl 6 , 74 byte

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

Chỉ số 0. Chỉ có ba trường hợp đầu tiên được liệt kê trên TIO vì quá chậm để kiểm tra phần còn lại.

Hãy thử trực tuyến!

Ruby , 110 97 92 84 byte

-13 byte bằng cách tận dụng kiểm tra regex JavaScript của @ Arnauld .

-5 byte để hoán đổi timesvòng lặp cho bộ giảm dần và a while.

-8 byte bằng cách bỏ combinationđi một cái gì đó giống như các câu trả lời khác.

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

Hãy thử trực tuyến!

Perl 5 -p , 66 byte

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

Hãy thử trực tuyến!

1 chỉ mục

J , ⁸⁷ 59 byte

-28 byte nhờ FrownFrog

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

Hãy thử trực tuyến!

nguyên

J , 87 byte

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

Hãy thử trực tuyến!

Rất tiếc.

Điều này quá dài đối với J, nhưng tôi không thấy những cách tuyệt vời để hạ nó xuống.

giải trình

Nó giúp giới thiệu một vài động từ trợ giúp để xem những gì đang xảy ra:

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

• d trả về một danh sách tất cả các ước của đối số của nó
• hcho bạn biết một danh sách như vậy là thù địch. Nó xâu chuỗi và lặp lại mỗi số ~.@":"0, trả về một ma trận vuông trong đó các số ngắn hơn được đệm bằng khoảng trắng. -.&' '@,/làm phẳng ma trận và loại bỏ khoảng trắng, và cuối cùng (-:~.)cho bạn biết nếu số đó có lặp lại hay không.

Với hai người trợ giúp này, động từ vô nghĩa của chúng ta trở thành:

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

Ở đây chúng tôi duy trì một danh sách có đầu là "ứng cử viên hiện tại" của chúng tôi (bắt đầu từ 1) và đuôi của họ là tất cả các số thù địch được tìm thấy cho đến nay.

Chúng tôi tăng đầu danh sách >:@[trên mỗi lần lặp và chỉ nối thêm "ứng cử viên hiện tại" nếu nó là thù địch h@d@[ # [. Chúng tôi tiếp tục làm điều này cho đến khi chiều dài danh sách của chúng tôi đạt 1 + n : ^:(#@] < 1 + [)^:_.

Cuối cùng, khi chúng tôi hoàn thành, chúng tôi trả về số cuối cùng của danh sách [: {:này là số thù địch thứ n.