Beberapa pembagi bilangan bulat positif benar-benar saling membenci dan mereka tidak suka berbagi satu angka atau lebih.

Bilangan bulat itu disebut Hostile Divisor Numbers ( HDN )

Contohnya

Angka 9566memiliki 4pembagi: 1, 2, 4783 and 9566
(seperti yang Anda lihat, tidak ada dua dari mereka yang berbagi angka yang sama ).
Jadi, 9566 adalah H ostile D ivisor N umber

Jumlah 9567ini tidak HDN karena pembagi nya ( 1, 3, 9, 1063, 3189, 9567) berbagi beberapa digit umum.

Berikut adalah beberapa HDN pertama

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

Tugas

Daftar di atas berjalan dan tugas Anda adalah menemukan HDN ke - n

Memasukkan

Bilangan bulat positif ndari 1hingga4000

Keluaran

The nth HDN

Uji Kasus

berikut adalah beberapa kasus uji 1-indeks
Harap sebutkan sistem pengindeksan yang Anda gunakan dalam jawaban Anda untuk menghindari kebingungan.

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

Ini adalah kode-golf , sehingga skor terendah dalam byte menang.

EDIT

Kabar baik! Saya mengirimkan urutan saya ke OEIS dan ...
Nomor Pembagi Hostile sekarang adalah OEIS A307636

05AB1E , 12 10 byte

µNNÑ€ÙSDÙQ

-2 byte terima kasih kepada @Emigna .

1-diindeks

Cobalah secara online atau verifikasi sebagian besar kasus uji (dua kasus uji terakhir dihilangkan, karena waktu habis).

Penjelasan:

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

Cobalah online!

Diindeks 0.

JavaScript (ES6), 78 byte

1-diindeks.

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

Cobalah online!

Versi lebih cepat, 79 byte

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

Cobalah online!

Bagaimana?

Diberikan bilangan bulat $k>0$ , kita membangun string $s$ sebagai gabungan dari semua pembagi $k$ .

Karena $k$ selalu merupakan pembagi dari dirinya sendiri, $s$ diinisialisasi ke $k$ (dipaksa ke string) dan pembagi pertama yang kita coba adalah $d=k-1$ .

Untuk setiap pembagi $d$ dari $k$ , kita menguji apakah setiap digit dari $d$ dapat ditemukan di $s$ dengan memutar $d$ ke dalam satu set karakter dalam ekspresi reguler.

Contohnya

• $s=\text{"}956647832\text{"}$ ,$d=1$ →"956647832".match(/[1]/)salah
• $s=\text{"}9567\text{"}$ ,$d=3189$ →"9567".match(/[3189]/)benar

Berkomentar

Ini adalah versi tanpa eval(), agar mudah dibaca

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

Jelly , 10 byte

ÆDQ€FQƑµ#Ṫ

Cobalah online!

-1 byte berkat ErikTheOutgolfer

Mengambil input dari STDIN, yang tidak biasa untuk Jelly tetapi biasa nfinddigunakan di mana .

Æ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 diindeks

Perl 6 , 53 byte

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

Cobalah online!

1-diindeks.

/(.).*$0/ cocok dengan nomor apa pun dengan digit yang diulang.

grep $_ %% *, 1 .. $_mengembalikan daftar semua pembagi nomor yang $_saat ini sedang diperiksa untuk keanggotaan dalam daftar.

[~]menggabungkan semua angka itu bersama-sama, dan kemudian R!~~mencocokkan string di sebelah kanan dengan pola di sebelah kiri. ( ~~Adalah operator pertandingan yang biasa, !~~adalah negasi dari operator itu, dan Rmerupakan metaoperator yang bertukar argumen !~~.)

Python 2 (PyPy) , 117 114 byte

Menggunakan pengindeksan 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

Cobalah online!

Bahasa Wolfram 103 byte

Menggunakan pengindeksan 1. Saya terkejut itu membutuhkan banyak kode.

(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

Cobalah online!

Membawa input 1-diindeks $args[0], menyimpan ke dalam $a, loop sampai hits 0. Setiap iterasi, kami nolkan array sepuluh elemen $z(digunakan untuk menampung jumlah digit kami). Kemudian kami membuat daftar pembagi dengan 1..++$n|?{!($n%$_)}. Untuk setiap pembagi, kami melemparkannya ke string "$_", melemparkannya toCharArra y, dan sortangka-angka dengan -ubendera nique (karena kami tidak peduli jika pembagi itu sendiri memiliki angka duplikat). Kami kemudian menambah jumlah digit yang sesuai di $z. Kemudian, kami mengurangi $ahanya jika $zmengandung 0s dan 1s (yaitu, kami telah menemukan HDN). Jika kami telah menyelesaikan forloop kami , itu berarti kami menemukan jumlah HDN yang sesuai, jadi kami pergi $npada jalur pipa dan hasilnya tersirat.

Python 3 , 115 byte

1-diindeks

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

Cobalah online!

Ini menggunakan banyak rekursi; bahkan dengan peningkatan batas rekursi, itu tidak bisa dilakukan f(30). Saya pikir itu mungkin golf lebih jauh, dan saya mencoba menemukan sesuatu untuk menggantikan (1-x%d)dengan, tetapi tidak dapat menemukan apa pun ( -~-x%dmemiliki prioritas yang salah). Setiap byte yang dapat dicukur sangat dihargai.

Bagaimana itu bekerja

# 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

Cobalah online!

Pengiriman fungsi; input dari kiri, output ke kanan. (TIO link berisi argumen baris perintah untuk menjalankan fungsi seolah-olah itu adalah program lengkap.)

Penjelasan

"Apakah ini nomor pembagi musuh?" kode keputusan-masalah :

ℕ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

Ini ternyata pada dasarnya sama dengan @ UnrelatedString, walaupun saya menulisnya secara independen.

"n solusi untuk bungkus masalah-keputusan ":

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

Ini adalah salah satu kasus di mana pembungkus yang diperlukan untuk menghasilkan keluaran ke-n secara signifikan lebih lama dari kode yang diperlukan untuk menguji setiap keluaran pada gilirannya :-)

Saya datang dengan bungkus ini secara independen dari @ UnrelatedString. Panjangnya sama dan bekerja dengan prinsip yang sama, tetapi entah bagaimana akhirnya ditulis agak berbeda. Itu memang memiliki ruang lingkup yang lebih potensial untuk perbaikan, karena kita bisa menambahkan batasan pada nilai apa yang kita lihat secara gratis dengan mengganti Adengan beberapa variabel kendala, tetapi tidak ada variabel kendala yang mungkin yang menyelamatkan byte. (Jika ada variabel kendala "nonnegative integer", Anda bisa menggantinya A, dan kemudian menyimpan byte melalui pembuatan yang ℕtidak perlu.)

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 dengan menggunakan .matchesbukan .containsper digit, terinspirasi oleh jawaban JavaScript @Arnauld .
-5 byte terima kasih kepada @ValueInk
-1 byte terima kasih kepada @ceilingcat

1-diindeks

Cobalah online.

Penjelasan:

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

Cobalah online!

Sangat lambat, dan dua kali lebih lama jika ini merupakan masalah keputusan . 1-diindeks.

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

Bahasa Wolfram (Mathematica) , 74 byte

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

Cobalah online!

Japt v2.0a0, 17 byte

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

Cobalah

Port jawaban Brachylog ini .

Kredit: total penghematan 4 byte berkat Shaggy yang juga menyarankan ada solusi yang lebih baik yang mengarah ke lebih banyak byte :)

Jawaban asli pendekatan 28 byte:

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

Cobalah

Port jawaban JavaScript ini .

Ikon , 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

Cobalah online!

1-diindeks. Sangat lambat untuk input besar.

Perl 6 , 74 byte

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

Diindeks 0. Hanya tiga kasus pertama yang terdaftar di TIO karena terlalu lambat untuk menguji sisanya.

Cobalah online!

Ruby , 110 97 92 84 byte

-13 bytes dengan memanfaatkan cek regex JavaScript dari Arnauld .

-5 byte untuk menukar timesloop untuk decrementer dan awhile .

-8 byte dengan membuang combinationsesuatu yang lebih seperti jawaban lainnya.

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

Cobalah online!

Perl 5 -p , 66 byte

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

Cobalah online!

1 diindeks

J , ⁸⁷ 59 byte

-28 byte berkat FrownFrog

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

Cobalah online!

asli

J , 87 byte

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

Cobalah online!

Astaga.

Ini sangat lama bagi J, tetapi saya tidak melihat cara yang bagus untuk menjatuhkannya.

penjelasan

Membantu mengenalkan kata kerja pembantu pasangan untuk melihat apa yang terjadi:

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

• d mengembalikan daftar semua pembagi argumennya
• hmemberitahu Anda daftar seperti itu bermusuhan. Ini merangkum dan menduplikasi setiap angka ~.@":"0, yang mengembalikan matriks persegi di mana angka yang lebih pendek diisi dengan spasi. -.&' '@,/merata matriks dan menghapus spasi, dan akhirnya (-:~.)memberitahu Anda jika bahwa angka memiliki mengulangi atau tidak.

Dengan dua pembantu itu, kata kerja kami yang tidak disatukan secara keseluruhan menjadi:

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

Di sini kita menyimpan daftar yang kepalanya adalah "kandidat kita saat ini" (yang dimulai dari 1), dan yang ekornya adalah semua angka yang bermusuhan sejauh ini.

Kami menambah kepala daftar >:@[pada setiap iterasi, dan hanya menambahkan "kandidat saat ini" jika itu bermusuhan h@d@[ # [. Kami terus melakukan ini sampai panjang daftar kami mencapai 1 + n:^:(#@] < 1 + [)^:_ .

Akhirnya, ketika kita selesai, kita mengembalikan nomor terakhir dari daftar ini [: {:yang merupakan nomor bermusuhan ke-n.