शत्रुतापूर्ण विभाजक संख्या

Question

सकारात्मक पूर्णांक के कुछ भाजक वास्तव में एक दूसरे से घृणा करते हैं और वे एक या अधिक सामान्य अंक साझा करना पसंद नहीं करते हैं।

उन पूर्णांकों को शत्रुतापूर्ण विभाजक संख्या ( HDN ) कहा जाता है

उदाहरण

संख्या 9566में 4भाजक होते हैं: 1, 2, 4783 and 9566
(जैसा कि आप देख सकते हैं, उनमें से कोई भी एक ही अंक साझा नहीं करता है )।
इस प्रकार, 9566 एक है एच ostile डी ivisor एन भूरा रंग

संख्या 9567है नहीं HDN क्योंकि इसके divisors ( 1, 3, 9, 1063, 3189, 9567) कुछ सामान्य अंक को साझा करें।

यहां पहले कुछ एचडीएन हैं

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

कार्य

उपरोक्त सूची जारी है और आपका कार्य nth HDN को खोजना है

इनपुट

एक सकारात्मक पूर्णांक nसे 1करने के लिए4000

उत्पादन

nth HDN

परीक्षण के मामलों

यहाँ कुछ 1-अनुक्रमित परीक्षण मामले हैं।
कृपया बताएं कि भ्रम से बचने के लिए आप अपने जवाब में किस इंडेक्सिंग सिस्टम का उपयोग करते हैं।

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

यह कोड-गोल्फ है , इसलिए बाइट्स में सबसे कम स्कोर जीतता है।

संपादित करें

खुशखबरी! मैंने अपना अनुक्रम OEIS को प्रस्तुत कर दिया है ...
शत्रुतापूर्ण विभाजक संख्याएँ अब OEIS A307636 हैं

Comments

मुझे लगता है कि वर्ग संख्या कम से कम शत्रुतापूर्ण होगी ।

— फ्राम्बोट

@JoeFrambach जो मुझे समझ नहीं आ रहा है। परफेक्ट-स्क्वायर HDN हैं। एक बड़े उदाहरण के लिए, 94699599289के वर्ग में 307733, भाजक हैं [1, 307733, 94699599289]जो दर्शाता है कि यह एक एचडीएन है। मुझसे शत्रुता रखता है।

— जेपी स्टिग नीलसन

@JeppeStigNielsen बहुत छोटे उदाहरण के लिए, सिर्फ क्यों नहीं 49? कारक [1, 7, 49]शत्रुता के रूप में अर्हता प्राप्त करते हैं ... या, ठीक है 4: [1, 2, 4]...

— डारेल हॉफमैन

@DarrelHoffman का उल्लेख नहीं है, 1विभाजक सूची के साथ वर्ग संख्या [1]। (शायद बड़े एचडीएन अधिक दिलचस्प हैं?)

— जेपी स्टिग नीलसन

मैंने विभाजक49 होने के रूप में व्याख्या की , जो न केवल अंकों को साझा करते हैं बल्कि समान अंक होते हैं। है कारकों [7, 7]49 [1, 7, 49]

— Frambot

Answer 1

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)

Comments

आपने मुझे इस बार हराया। मैंने µNNÑ€ÙSDÙQ10. के लिए

— एमिग्ना

@ इम्मिगा आह, मैं बस एक विकल्प पर काम कर रहा था µ, इसलिए आप मुझे परेशानी से बचाएं। ;)

— केविन क्रूज़सेन

यह काबिलेतारीफ है

— उज्ज्वल उज्ज्वल

Answer 2

पायथन 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 अनुक्रमित।

Answer 3

जावास्क्रिप्ट (ईएस 6), 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$ के सभी divisors के संयोजन के रूप में $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
}                        //

Answer 4

जेली , 10 बाइट्स

ÆDQ€FQƑµ#Ṫ

इसे ऑनलाइन आज़माएं!

-1 बाइट धन्यवाद ErikTheOutgolfer के लिए

एसटीडीआईएन से इनपुट लेता है, जो जेली के लिए असामान्य है, लेकिन सामान्य रूप 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-अनुक्रमित

Comments

क्या यह 2-अनुक्रमित है? यह मेरे साथ ठीक है, लेकिन कृपया इसे दूसरों के लिए

— बताएं

यह जो भी आपके परीक्षण के मामले थे, इसलिए 1

— HyperNeutrino

नहीं, यह नहीं है। 101 रिटर्न 839. और 102 -> 853. यह ठीक काम करता है लेकिन यह 2-अनुक्रमित है

— J42161217

@ J42161217 इंतजार करें क्या? मुझे लगता है कि जब मैंने nfindइसे स्थानांतरित किया तो अनुक्रमणिका को बदल दिया

— हाइपरयुट्रीनो

⁼Q$के रूप में ही है QƑ।

— आउटगोल्फ को एरिक

Answer 5

पर्ल 6 , 53 बाइट्स

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

इसे ऑनलाइन आज़माएं!

1 अनुक्रमित।

/(.).*$0/ किसी भी संख्या को दोहराया अंक के साथ मेल खाता है।

grep $_ %% *, 1 .. $_$_वर्तमान में सूची में सदस्यता के लिए जाँच की जा रही संख्या के सभी विभाजकों की सूची देता है।

[~]उन सभी अंकों को एक साथ समेटता है, और फिर R!~~बाईं ओर पैटर्न के खिलाफ दाईं ओर स्ट्रिंग से मेल खाता है। ( ~~सामान्य मिलान ऑपरेटर है, !~~उस ऑपरेटर का निषेध है, और Rएक मेटाऑपरेटर है जो तर्क को स्वैप करता है !~~)

Comments

50 बाइट्स

— जो किंग

Answer 6

पायथन 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

इसे ऑनलाइन आज़माएं!

Answer 7

वोल्फ्राम भाषा 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)&

Comments

क्या आप कृपया एक TIO लिंक जोड़ सकते हैं ताकि हर कोई आपके उत्तर की जांच कर सके?

— J42161217

95 बाइट्स: (n=t=1;While[t<=#,If[!Or@@IntersectingQ@@@Subsets[IntegerDigits@Divisors@n,{2}],t++];n++];n-1)&मैं एक उत्तर पोस्ट करने की योजना नहीं बना रहा हूं, इसलिए मैं इसे यहां छोड़

— दूंगा

@ J42161217, मैं सफलता के बिना TIO में काम करने के लिए कोड प्राप्त करने की कोशिश कर रहा हूं। कुछ ट्रिक होनी चाहिए मुझे याद आ रही है।

— डेविड

@ J42161217, आपका कोड काम करने लगता है लेकिन रनटाइम का 3 गुना होता है। आप इसे अपने रूप में जमा कर सकते हैं। (शायद मैं आपके उदाहरण से

— टीआईओ

बहुत तेजी से वास्तव में! यहाँ आपका लिंक है इसे ऑनलाइन आज़माएं!

— J42161217

Answer 8

पॉवरशेल , 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। प्रत्येक पुनरावृत्ति, हम एक दस-तत्व सरणी को शून्य करते हैं $z(हमारे अंक गिनते हैं)। फिर हम अपने साथ दिव्यांगों की सूची बनाते हैं 1..++$n|?{!($n%$_)}। प्रत्येक भाजक के लिए, हम इसे एक स्ट्रिंग में डालते हैं , "$_"इसे toCharArra में डालते हैं y, और sortउन अंकों को नीच -uध्वज के साथ (क्योंकि हम परवाह नहीं करते हैं कि एक भाजक के पास खुद ही नकली अंक हैं)। हम तब उचित अंक गणना में वृद्धि करते हैं $z। फिर, हम घटती $aही अगर $zहोता है 0और 1एस (यानी, हम एक HDN पाया है)। यदि हमने अपना forलूप पूरा कर लिया है , तो इसका मतलब है कि हमें उपयुक्त संख्या में एचडीएन मिल गया है, इसलिए हम $nपाइपलाइन पर छोड़ देते हैं और आउटपुट निहित है।

Comments

: क्या आप कुछ बाइट्स बचा सकता है $a-=!($z-ge2)बजाय$a-=!($z|?{$_-ge2})

— Mazzy

थोड़ा गोल्फ

— mazzy

Answer 9

पायथन 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

Answer 10

ब्रेकीलॉग (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 की तरह ही था, हालांकि मैंने इसे स्वतंत्र रूप से लिखा था।

" निर्णय-समस्या का nth समाधान " आवरण:

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

यह उन मामलों में से एक है जहां nth आउटपुट का उत्पादन करने के लिए आवश्यक रैपर कोड के प्रत्येक आउटपुट का परीक्षण करने के लिए आवश्यक कोड से काफी अधिक है :-)

मैं इस आवरण के साथ स्वतंत्र रूप से @ असंबंधित स्ट्रिंग के साथ आया था। यह एक ही लंबाई है और एक ही सिद्धांत पर काम करता है, लेकिन किसी भी तरह अलग-अलग लिखा जा रहा है। इसमें सुधार की अधिक संभावनाएं हैं, क्योंकि हम Aकुछ बाधाओं को दूर करने के माध्यम से उन मूल्यों पर अवरोध जोड़ सकते हैं जिन्हें हम मुफ्त में देख रहे थे , लेकिन संभावित बाधाओं में से कोई भी बाइट्स को नहीं बचा सकता है। (यदि एक "नॉननेगेटिव पूर्णांक" बाधा चर था, तो आप Aइसे बदल सकते हैं , और फिर एक बाइट को ℕअनावश्यक बनाकर बचा सकते हैं ।)

Comments

यह 2-अनुक्रमित है?

— FrownyFrog

Answer 11

जावा 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 के जावास्क्रिप्ट उत्तर से प्रेरित है ।
-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`

Comments

आप स्विच करते हैं iऔर sअपने रेगुलर एक्सप्रेशन से खोज में, आप अतिरिक्त स्ट्रिंग रूपांतरण की जरूरत नहीं है, और परिणाम एक ही है।

— मूल्य इंक

@ValueInk धन्यवाद! :)

— केविन क्रूज़सेन

Answer 12

ब्रेकीलॉग , 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).

Comments

यदि आप अभी उस वाक्य को वाक्य के रूप में पढ़ते हैं, तो ...

— FireCubez

मैं अपनी व्याख्याओं को सादे अंग्रेजी की तरह लिखने की कोशिश करता हूं, जो आम तौर पर समाप्त होती है जिससे उन्हें पढ़ने में मुश्किल होती है

— असंबंधित स्ट्रिंग

Answer 13

वोल्फ्राम भाषा (गणितज्ञ) , 74 बाइट्स

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

इसे ऑनलाइन आज़माएं!

Answer 14

जाप v2.0a0, 17 बाइट्स

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

कोशिश करो

इस Brachylog उत्तर का पोर्ट ।

क्रेडिट: 4 बाइट्स बचत कुल मिलाकर शगी को धन्यवाद, जिसने यह भी सुझाव दिया कि एक बेहतर समाधान कई और बाइट्स की ओर ले जाता है :)

---

मूल उत्तर 28 बाइट दृष्टिकोण:

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

कोशिश करो

इस जावास्क्रिप्ट उत्तर का पोर्ट ।

Comments

28 बाइट्स

— झबरा

अच्छा - मैंने «पहले शॉर्टकट का इस्तेमाल नहीं किया था :) मुझे पता है कि अगर शागी केवल मुट्ठी भर बाइट्स से मेरे स्कोर में सुधार कर रहा है, तो मुझे इस पर (कुछ) सभ्य होना चाहिए?

— दाना

यह 20 (शायद कम) बी 7 में थोड़ा अलग तरीका नियोजित किया जा सकता है।

— झबरा

हाह - मुझे लगता है कि मैंने बहुत जल्द ही बात की :) हाँ, अन्य गोल्फिंग लैंग के कुछ छोटे समाधान हैं।

— दाना

17 बाइट्स

— शैगी

Answer 15

आइकन , 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 अनुक्रमित। वास्तव में बड़े इनपुट के लिए धीमा।

Answer 16

पर्ल 6 , 74 बाइट्स

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

0 अनुक्रमित। टीआईओ पर केवल पहले तीन मामले सूचीबद्ध हैं क्योंकि यह बाकी का परीक्षण करने के लिए बहुत धीमा है।

इसे ऑनलाइन आज़माएं!

Comments

57 बाइट्स

— जो किंग

Answer 17

रूबी , 110 97 92 84 बाइट्स

-13 बाइट्स @ अर्नुल्ड्स जावास्क्रिप्ट रेगेक्स चेक का लाभ उठाकर ।

timesएक decrementer और एक के लिए पाश बाहर गमागमन के लिए -5 बाइट्स while।

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

इसे ऑनलाइन आज़माएं!

Answer 18

पर्ल 5 -p , 66 बाइट्स

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

इसे ऑनलाइन आज़माएं!

1 अनुक्रमित

Answer 19

जे , ⁸⁷ 59 बाइट्स

-28 बाइट्स FrownFrog की बदौलत

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

इसे ऑनलाइन आज़माएं!

मूल

जे , 87 बाइट्स

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

इसे ऑनलाइन आज़माएं!

ओह।

यह जे के लिए अत्यावश्यक रूप से लंबा है, लेकिन मैं इसे नीचे लाने के महान तरीके नहीं देख रहा हूं।

व्याख्या

यह देखने में मदद करता है कि क्या हो रहा है:

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

• d अपने तर्क के सभी विभाजकों की सूची देता है
• hआपको बताता है कि ऐसी सूची शत्रुतापूर्ण है। यह प्रत्येक संख्या को स्ट्रिंग करता है और घटाता है ~.@":"0, जो एक वर्ग मैट्रिक्स देता है जहां छोटी संख्या रिक्त स्थान के साथ गद्देदार होती है। -.&' '@,/मैट्रिक्स को समतल करता है और रिक्त स्थान को हटाता है, और अंत में (-:~.)आपको बताता है कि क्या संख्या दोहराई गई है या नहीं।

उन दो सहायकों के साथ हमारा समग्र, असंयमित क्रिया बन जाता है:

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

यहां हम एक सूची बनाए रखते हैं जिसका प्रमुख हमारा "वर्तमान उम्मीदवार" है (जो 1 से शुरू होता है), और जिसकी पूंछ अब तक पाई गई सभी शत्रुतापूर्ण संख्या है।

हम >:@[प्रत्येक पुनरावृत्ति पर सूची के प्रमुख को बढ़ाते हैं , और केवल "वर्तमान उम्मीदवार" को जोड़ते हैं यदि यह शत्रुतापूर्ण है h@d@[ # [। हम ऐसा तब तक करते रहते हैं जब तक हमारी सूची की लंबाई 1 + n: तक ​​नहीं पहुंच जाती ^:(#@] < 1 + [)^:_।

अंत में, जब हम कर लेते हैं, तो हम इस सूची के अंतिम नंबर को वापस कर देते हैं, [: {:जो कि nth शत्रुतापूर्ण संख्या है।

Comments

66

— फ्रॉफफ्रॉग

62

— फ्रॉफफ्रॉग

यह बहुत अच्छा है, बहुत धन्यवाद। इसके ऊपर जाएगा और आज रात को अद्यतन करेगा

— योना

५

— FrownyFrog