Bazı pozitif tam sayı bölenleri birbirlerinden gerçekten nefret ederler ve bir veya daha fazla sayıyı paylaşmayı sevmezler.

Bu tamsayılar, Hostile Divisor Numbers ( HDN ) olarak adlandırılır.

Örnekler

Numara 9566sahiptir 4bölenler: 1, 2, 4783 and 9566
(gördüğünüz gibi, bunların hiçbir iki aynı rakam paylaşan ).
Bu durumda, 9566 a, H ostile D ivisor K koyu kahverengi

Sayı 9567, HDN DEĞİLDİR , çünkü didizörleri ( 1, 3, 9, 1063, 3189, 9567) bazı ortak basamakları paylaşır.

İşte ilk birkaç 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...       

Görev

Yukarıdaki liste devam eder ve göreviniz N HDN'yi bulmaktır.

Giriş

Pozitif bir tam sayı ngelen 1için4000

Çıktı

nth HDN

Test Kılıfları

işte bazı 1 indeksli test durumları.
Lütfen karışıklığı önlemek için cevabınızda hangi indeksleme sistemini kullandığınızı belirtin.

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

Bu kod golf , yani bayt cinsinden en düşük puan kazanır.

DÜZENLE

İyi haberler! Dizimi OEIS'e gönderdim ve ...
Düşman Bölen Numaraları şimdi OEIS A307636

05AB1E , 12 10 bayt

µNNÑ€ÙSDÙQ

@Emigna sayesinde -2 bayt .

1 endeksli

Çevrimiçi deneyin ya da çoğu test vakasını doğrulayın (zaman aşımına uğradıklarından son iki test vakası çıkarıldı).

Açıklama:

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

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

Çevrimiçi deneyin!

0 endeksli.

JavaScript (ES6), 78 bayt

1 endeksli.

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

Çevrimiçi deneyin!

Daha hızlı sürüm, 79 bayt

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

Çevrimiçi deneyin!

Nasıl?

$k>0$ tamsayısına göre , $s$ dizgesini $k$ tüm bölenlerinin birleştirilmesi olarak oluştururuz .

Çünkü $k$ , her zaman kendisi bir bölen bir $s$ için başlatılır $k$ (bir dizeye zorla) ve biz olduğunu deneyin ilk bölen $d=k-1$ .

Her bölen için $d$ ait $k$ , biz herhangi haneli olmadığını test $d$ bulunabilir $s$ çevirerek $d$ normal ifadede bir karakter kümesi olarak.

Örnekler

• $s=\text{"}956647832\text{"}$ ,$d=1$ →"956647832".match(/[1]/)sahtedir
• $s=\text{"}9567\text{"}$ ,$d=3189$ →"9567".match(/[3189]/)gösterişsiz

Yorumlananlar

Bu eval()okunabilirlik için olmadan versiyonudur

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

Jöle , 10 bayt

ÆDQ€FQƑµ#Ṫ

Çevrimiçi deneyin!

ErikTheOutgolfer sayesinde -1 bayt

Jelly için sıradışı olan, ancak nfindkullanıldığı yerlerde normal olan STDIN'den girdi alır .

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

Perl 6 , 53 bayt

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

Çevrimiçi deneyin!

1 endeksli.

/(.).*$0/ herhangi bir sayı ile tekrarlanan rakamlarla eşleşir.

grep $_ %% *, 1 .. $_Listede $_üyelik için şu anda kontrol edilen numaranın tüm bölenlerinin bir listesini döndürür .

[~]tüm bu rakamları bir araya getirir ve ardından R!~~sağdaki dize, soldaki desene göre eşleştirir. ( ~~normal eşleşme operatörüdür, !~~bu operatörün Rihmalidir ve argümanlarını değiştiren bir üst yöneticidir !~~.)

Python 2 (PyPy) , 117 114 bayt

1-indeksleme kullanır

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

Çevrimiçi deneyin!

Wolfram Dili 103 bayt

1-indeksleme kullanır. Çok fazla kod gerektirdiğine şaşırdı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 bayt

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

Çevrimiçi deneyin!

1 indeksli girdiyi alır $args[0], içine $akaydeder, isabet edinceye kadar döngüler 0. Her yineleme, on elemanlı bir diziyi sıfırlıyoruz $z(sayı sayımızı tutmak için kullanılır). Sonra da bölen listemizi kurarız 1..++$n|?{!($n%$_)}. Her bölen için, bir dizeye döküm "$_", döküm toCharArra yve sortolanlar rakam -unique bayrağı (bölen kendisi yinelenen basamağa sahipse biz umurumda değil çünkü). Daha sonra uygun rakamı artırdık $z. Sonra, $asadece s ve s $ziçeriyorsa , azalırız (yani, bir HDN bulduk). Eğer döngümüzü tamamladıysak , bu, uygun sayıda HDN bulduğumuz anlamına gelir, bu yüzden boru hattında kalırız ve çıktı kapalıdır .01for$n

Python 3 , 115 bayt

1 endeksli

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

Çevrimiçi deneyin!

Bu çok fazla özyineleme kullanır ; artan özyineleme limiti olsa bile, yapamaz f(30). Daha fazla golf oynayabileceğini düşünüyorum ve bunun yerine bir şeyler bulmaya çalıştım (1-x%d), ancak hiçbir şey bulamadım ( -~-x%dyanlış önceliğe sahip). Tıraş olabilir herhangi bir bayt büyük beğeni topluyor.

Nasıl çalışır

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

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

Çevrimiçi deneyin!

İşlev sunumu; soldan giriş, sağa çıkış. (TIO bağlantısı bir işlevi tam programmış gibi çalıştırmak için bir komut satırı argümanı içerir.)

açıklama

"Bu düşmanca bir bölen numarası mı?" karar-problem kodu:

ℕ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

Bu, temel olarak @ UnrelatedString'inkiyle aynı çıktı, ancak bağımsız olarak yazdım.

"Bir karar sorununa nnth çözüm " sarmalayıcı:

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

Bu, nth çıktı üretmek için gereken sargının sırayla her çıktıyı test etmek için gereken koddan önemli ölçüde daha uzun olduğu durumlardan biridir :-)

Bu sarmalayıcıyı @ UnrelatedString'den bağımsız olarak gördüm. Aynı uzunluk ve aynı prensibe göre çalışıyor, ancak bir şekilde oldukça farklı bir şekilde yazılması sona eriyor. ABazı kısıtlama değişkenleriyle değiştirerek hangi değerleri ücretsiz aradığımızı gösteren kısıtlamalar ekleyebildiğimiz için, geliştirme için daha fazla potansiyel kapsama alanı vardır , ancak olası kısıtlama değişkenlerinin hiçbiri byte kaydetmez. ("Negatif olmayan bir tamsayı" kısıtlama değişkeni Aolsaydı, onunla değiştirebilir ve ardından ℕgereksiz hale getirerek bir bayt kaydedebilirsiniz .)

Java 10, 149 139 138 126 125 120 119 bayt

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, basamak başına kullanmak .matchesyerine, @Arnauld'un JavaScript yanıtından.contains ilham aldı . -5 sayesinde bayt @ValueInk -1 bayt sayesinde @ceilingcat

1 endeksli

Çevrimiçi deneyin.

Açıklama:

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 bayt

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

Çevrimiçi deneyin!

Çok yavaş ve bu bir karar sorunu olsaydı iki kat daha uzun olurdu . 1 endeksli.

                    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 Dili (Mathematica) , 74 bayt

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

Çevrimiçi deneyin!

Japt v2.0a0, 17 bayt

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

Dene

Port Bu Brachylog cevap .

Credit: 4 baytlık tasarruf toplamı Shaggy sayesinde daha fazla bayt için daha iyi bir çözüm önerdi.

Orijinal cevap 28 byte yaklaşımı:

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

Dene

Bu JavaScript cevabının limanı .

Simge , 123 bayt

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

Çevrimiçi deneyin!

1 endeksli. Büyük girişler için gerçekten yavaş.

Perl 6 , 74 bayt

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

0 endeksli. TIO'da sadece ilk üç vaka listeleniyor, çünkü geri kalanını test etmek için çok yavaş.

Çevrimiçi deneyin!

Ruby , 110 97 92 84 bayt

-13 bayt kaldırarak Arnauld's JavaScript regex check @ @ kaldırarak .

-5 takas için bayt timesBir düşürücü ve a için döngüwhile .

-8 byte combinationdiğer cevaplar gibi daha fazla bir şey için kazarak .

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

Çevrimiçi deneyin!

Perl 5 -p , 66 bayt

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

Çevrimiçi deneyin!

1 endeksli

J , ⁸⁷ 59 bayt

FrownFrog sayesinde -28 bayt

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

Çevrimiçi deneyin!

orijinal

J , 87 bayt

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

Çevrimiçi deneyin!

Amanın.

Bu, J için acımasızca uzun, ama onu yıkmanın harika yollarını göremiyorum.

açıklama

Neler olduğunu görmek için birkaç yardımcı fiil getirmeye yardımcı olur:

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

• d argümanının tüm bölenlerinin bir listesini verir
• hBöyle bir listenin düşmanca olduğunu söyler. Her sayıyı siler ve tekilleştirir ~.@":"0, bu sayede kısa sayılar boşluklarla doldurulur. -.&' '@,/matrisi düzleştirir ve boşlukları kaldırır ve sonunda bu sayının tekrar (-:~.)edip etmediğini size bildirir .

Bu iki yardımcımızla birlikte, bizim genelimiz unungolfed fiili olur:

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

Burada, başını "şu anki adayımız" olan (1'den başlayan) ve kuyruğunun şu ana kadar bulunan tüm düşman sayıları olan bir listesini tutuyoruz.

>:@[Her yinelemede listenin başını arttırır ve yalnızca "mevcut aday" ı düşmanca kullanıyoruz h@d@[ # [. Bunu liste uzunluğumuz 1 + n olana kadar sürdürüyoruz ^:(#@] < 1 + [)^:_.

Sonunda, bittiğimizde, bu [: {:düşmanca sayı olan listenin son sayısını döndürüyoruz.