ตัวหารบางตัวของจำนวนเต็มบวกเกลียดกันและพวกเขาไม่ต้องการแบ่งปันตัวเลขหนึ่งหลักหรือมากกว่า

จำนวนเต็มเหล่านั้นเรียกว่าHostile Divisor Numbers ( HDN )

ตัวอย่าง

Number 9566มี4ตัวหาร: 1, 2, 4783 and 9566
(อย่างที่คุณเห็นไม่มีสองคนที่มีตัวเลขเดียวกัน )
ดังนั้น9566จึงเป็นH ostile D ivisor N umber

จำนวน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...       

งาน

รายการข้างต้นดำเนินต่อไปและหน้าที่ของคุณคือค้นหาHDNลำดับที่ n

อินพุต

จำนวนเต็มบวก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$

เพราะ$k$อยู่เสมอหารของตัวเอง$s$จะเริ่มต้นที่จะ$k$ (บังคับให้สตริง) และหารแรกที่เราพยายามคือ$d=k-1$ 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 ซึ่งเป็นเรื่องปกติสำหรับเยลลี่ แต่เป็นเรื่องปกติเมื่อ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 , 53 ไบต์

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

ลองออนไลน์!

1 การจัดทำดัชนี

/(.).*$0/ ตรงกับตัวเลขใด ๆ ที่มีตัวเลขซ้ำ

grep $_ %% *, 1 .. $_ส่งคืนรายการตัวหารทั้งหมดของหมายเลขที่$_กำลังตรวจสอบความเป็นสมาชิกในรายการ

[~]ต่อตัวเลขทั้งหมดเหล่านั้นเข้าด้วยกันแล้วR!~~จับคู่สตริงทางด้านขวากับรูปแบบทางด้านซ้าย ( ~~เป็นโอเปอเรเตอร์การจับคู่ปกติ!~~คือการปฏิเสธของโอเปอเรเตอร์นั้นและ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)&

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ซ้ำจนกระทั่งฮิต การวนซ้ำแต่ละครั้งเรา zero-out อาเรย์สิบองค์ประกอบ$z(ใช้เพื่อนับจำนวนหลักของเรา) 1..++$n|?{!($n%$_)}จากนั้นเราก็สร้างรายชื่อของตัวหารกับเรา สำหรับตัวหารแต่ละตัวเราจะโยนมันไปที่สตริง"$_", โยนมันtoCharArra yและsortตัวเลขเหล่านั้นด้วย-uแฟล็ก nique (เพราะเราไม่สนใจว่าตัวหารนั้นมีตัวเลขที่ซ้ำกัน) $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's แม้ว่าฉันจะเขียนมันอย่างอิสระ

"คำตอบที่ n เพื่อแก้ปัญหาการตัดสินใจ " wrapper:

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

นี่เป็นหนึ่งในกรณีที่ wrapper ที่จำเป็นในการสร้างเอาต์พุต nth นั้นยาวกว่าโค้ดที่ต้องใช้ในการทดสอบแต่ละเอาต์พุตในทางกลับกัน :-)

ฉันใช้กระดาษห่อนี้เป็นอิสระจาก @ UnrelatedString's มันมีความยาวเท่ากันและทำงานบนหลักการเดียวกัน แต่ท้ายที่สุดการเขียนค่อนข้างต่างออกไป มันมีขอบเขตที่เป็นไปได้มากขึ้นสำหรับการปรับปรุงเนื่องจากเราสามารถเพิ่มข้อ จำกัด เกี่ยวกับค่าที่เรากำลังมองหาได้ฟรีผ่านการแทนที่Aด้วยตัวแปรข้อ จำกัด บางอย่าง แต่ไม่มีตัวแปรข้อ จำกัด ที่เป็นไปได้ที่จะบันทึกไบต์ (หากมีตัวแปรข้อ จำกัด "ไม่ใช่จำนวนเต็ม" คุณสามารถแทนที่Aด้วยแล้วบันทึกไบต์ผ่านการทำให้ℕไม่จำเป็น)

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

-10 ไบต์โดยใช้.matchesแทนการ.containsต่อหลักแรงบันดาลใจจาก@Arnauldคำตอบ JavaScript 's
-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นี้

เครดิต: ประหยัดทั้งหมด 4 ไบต์ขอบคุณ Shaggy ผู้แนะนำด้วยว่ามีวิธีแก้ปัญหาที่ดีกว่าซึ่งนำไปสู่การเพิ่มจำนวนไบต์ :)

คำตอบเดิมวิธีการ 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 เนื่องจากช้าเกินไปที่จะทดสอบส่วนที่เหลือ

ลองออนไลน์!

ทับทิม , 110 97 92 84 ไบต์

-13 ไบต์โดยใช้ประโยชน์จากการตรวจสอบ regex ของ JavaScript @ Arnauldตรวจสอบ

-5 ไบต์สำหรับการสลับtimesลูปเป็นตัวลดและ awhileและ

-8 ไบต์โดยการทิ้งcombinationบางอย่างเช่นคำตอบอื่น ๆ

->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 5 -p , 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

ลองออนไลน์!

Yikes

นี่เป็นเวลานานสำหรับ J แต่ฉันไม่ได้เห็นวิธีที่ดีในการทำให้มันแย่ลง

คำอธิบาย

ช่วยแนะนำคำกริยาผู้ช่วยสองคนเพื่อดูว่าเกิดอะไรขึ้น:

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

• d ส่งคืนรายการตัวหารทั้งหมดของอาร์กิวเมนต์
• hบอกคุณรายการดังกล่าวเป็นศัตรู มันจะทำให้สตริงและซ้ำกันแต่ละจำนวน~.@":"0ซึ่งส่งกลับเมทริกซ์จตุรัสโดยที่ตัวเลขที่สั้นกว่าจะถูกเติมด้วยช่องว่าง -.&' '@,/แบนเมทริกซ์และลบช่องว่างและในที่สุดก็(-:~.)บอกคุณว่าหมายเลขนั้นซ้ำหรือไม่

ด้วยผู้ช่วยทั้งสองของเราโดยรวมคำกริยาที่ไม่อวดดีจะกลายเป็น:

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

ที่นี่เราเก็บรักษารายการที่มีหัวเป็น "ผู้สมัครปัจจุบัน" ของเรา (ซึ่งเริ่มต้นที่ 1) และที่มีหางเป็นหมายเลขที่ไม่เป็นมิตรพบจนถึง

เราเพิ่มหัวของรายการ>:@[ในแต่ละซ้ำและมีเพียงผนวก "ผู้สมัครปัจจุบัน" h@d@[ # [ถ้ามันเป็นศัตรู เราให้ทำเช่นนี้จนกว่ารายการถึงความยาวของเรา 1 + ^:(#@] < 1 + [)^:_n:

ในที่สุดเมื่อเราทำเสร็จแล้วเราจะส่งกลับจำนวนสุดท้ายของรายการนี้[: {:ซึ่งเป็นหมายเลขที่ไม่เป็นมิตร