आइए बात करते हैं दिव्यांगों के बारे में ...

संपूर्ण वर्गों (एक पल के लिए) को छोड़कर, सभी सकारात्मक पूर्णांकों को उनके 2 विभाजकों के उत्पाद के रूप में व्यक्त किया जा सकता है । के लिए त्वरित उदाहरण 126: यहाँ सभी के भाजक हैं126

जैसा कि आप देख सकते हैं कि सभी भाजक जोड़े जा सकते हैं। यहाँ हम दिव्यांग जोड़े को बुलाएंगे :
[1, 126], [2, 63], [3, 42], [6, 21], [7, 18], [9, 14]

इस चुनौती के लिए हमें इस सूची की अंतिम जोड़ी (जो तस्वीर का केंद्र जोड़ा है) की आवश्यकता
[9,14]होगी :। हम इस जोड़ी को मैक्समिन डिवाइयर जोड़ी कहेंगे । MaxMin भाजक जोड़ी के अंतर (DMDP) जोड़ी जो है की दो तत्वों का अंतर नहीं है के लिए एक और उदाहरण । भाजक हैं:
[9,14]=5
544

[1, 2, 4, 8, 16, 17, 32 , 34, 68, 136, 272, 544]

और DMDP (544) = 15 क्योंकि32-17=15

सही वर्गों के बारे में क्या ? सभी पूर्ण वर्गों में DMDP = 0
उदाहरण 64के लिए भाजक के साथ लेते हैं

{, 2, 4, 8 , 16, 32, 64}

जैसा कि आप इस मामले में देख सकते हैं कि मैक्समिन डिवाइजर पेयर है [8,8]जो DMDP=0
हमने लगभग पूरा कर लिया है।

चुनौती

एक पूर्णांक को देखते हुए n>0, आउटपुट कितने पूर्णांक से कम या उसके बराबर है 10000 , DMDP से कम है n

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

इनपुट -> आउटपुट

1->100 (those are all the perfect squares)
5->492  
13->1201
369->6175  
777->7264  
2000->8478  
5000->9440  
9000->9888  
10000->10000   
20000->10000

यह कोड-गोल्फ है । बाइट्स जीत में सबसे मजबूत जवाब ।

code-golf division

यह 10000एक दूसरे, चर, इनपुट के रूप में अधिक समझ में नहीं आएगा?

— जोनाथन एलन

1

हां, मैंने इसके बारे में सोचा था लेकिन यह चुनौती से कुछ भी नहीं जोड़ेगा। इस तरह मुझे लगता है कि चुनौती को समझना हर किसी के लिए आसान है।

1

जावास्क्रिप्ट (ईएस 7), 60 बाइट्स

f=(n,i=1e4,j=i**.5|0)=>i?i%j?f(n,i,j-1):(i/j-j<n)+f(n,i-1):0

संभवतः आपकी पुनरावृत्ति सीमा से अधिक है, इसलिए आप 70 बाइट्स के लिए पुनरावृत्ति संस्करण पसंद कर सकते हैं:

n=>[...Array(1e4)].map(g=(j=++i**.5|0)=>i%j?g(j-1):k+=i/j-j<n,i=k=0)|k

— नील
स्रोत

4

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

जोनाथन एलन को 1 बाइट धन्यवाद।

ȷ4RÆDạU$Ṃ€<⁸S

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

— लीक नन
स्रोत

ÆDạ"Ṛ$Ṃआपको एक बाइट पर बचाता है ÆDạ:@¥⁸Ṃ(मेरे पास ạ"ṚṂ... ȷ4RÆDÇ€<⁸S15 के लिए - बहुत समान - EDIT: हम्म या यह, कोई :शामिल नहीं था ... आपको क्या लगता है?)

— जोनाथन एलन

@JonathanAllan मुझे लगता है कि आपको यह 13-

— लीक नून

ओह वाह। nah आप इसके लिए जाते हैं, मैंने आपको एक बाइट से बचाया जो एक और 2 बचाता है!

— जोनाथन एलन

क्या आप एक स्पष्टीकरण जोड़ सकते हैं?

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

4

जावा 8, 151 111 110 101 बाइट्स

n->{int r=0,x=10000,i;for(;x-->0;r-=i-n>>-1)for(i=x;i-->1;)if(x>=i*i&x%i<1){i=x/i-i;break;}return r;}

-10 बाइट्स थैंक्स टू @ नवे ।

स्पष्टीकरण:

इसे यहाँ आज़माएँ।

n->{               // Method with integer as parameter and return-type
  int r=0,         //  Result-integer
      x=10000,     //  Index-integer starting at 10,000
      i;           //  Another index-integer for the inner loop
  for(;x-->0;      //  Loop (1) from 10,000 down to 0
      r-=i-n>>-1)  //   If the MaxMin-Divisor Pair's difference is lower than the input,
                   //    add 1 to the result (after every iteration)
    for(i=x,       //   Set `i` to `x`
        i-->1;)    //   Inner loop (2) from `i` downwards to 1
      if(x>=i*i    //    If the current square-root of `x` is smaller than or equal to `i`,
         &x%i<1){  //    and if the current `x` is divisible by `i`:
        i=x/i-i;   //     Calculate the MaxMin-Division difference
        break;}    //     And leave the inner loop (2)
                   //   End of inner loop (2) (implicit / single-line body)
                   //  End of loop (1) (implicit / single-line body)
  return r;        //  Return the result
}                  // End of method

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

1

आप for(i=1,i+=Math.sqrt(x);--i>0;)if(...1 बाइट बचाने के लिए उपयोग कर सकते हैं ।

— नेवले

इसे स्वयं आजमाने का समय नहीं है, लेकिन क्या यह आंतरिक लूप x से शुरू होने के लिए कम होगा और वर्तमान न्यूनतम के लिए एक अतिरिक्त चर होगा?

— जॉली जोकर

1

101 बाइट्स:n->{int r=0,x=10000,i;for(;x-->0;r-=i-n>>-1)for(i=x;i-->1;)if(x>=i*i&x%i<1){i=x/i-i;break;}return r;}

— नेवई

@ नोवे धन्यवाद फिर से, वास्तव में x>=i*iउपयोग करने के लिए विकल्प के रूप में याद रखने की आवश्यकता है Math.sqrt, क्योंकि यह दूसरी बार है जब आपने मेरे कोड में गोल्फ डाला है।

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

2

आर , 73 77 बाइट्स

4 बाइट्स के लिए @Guiseppe को धन्यवाद

sum(sapply(1:1e4,function(x)min(abs((w=which(x%%1:x<1))-rev(w))))<scan())

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

DMDP की गणना करने के लिए वेक्टराइज़ फ़ंक्शन खो दिया है और अब फ़ंक्शन पर एक नीलमणि का उपयोग कर रहा है। आइटम के लिए सत्य जो इनपुट से कम हैं परिणाम के लिए अभिव्यक्त किए गए हैं।

— MickyT
स्रोत

आह, मुझे पता नहीं था कि DMDP उस कारक सूची का न्यूनतम अंतर है! बहुत अच्छा। मुझे लगता sum(sapply(1:1e4,function(x)min(abs((w=which(x%%1:x<1))-rev(w))))<scan())है कि थोड़ा छोटा है

— Giuseppe

2

मैथेमेटिका, 64 बाइट्स

Count[Divisors~Array~1*^4,a_/;#+a[[i=⌈Tr[1^a]/2⌉]]>a[[-i]]]&

इसे वुल्फ्राम सैंडबॉक्स पर आज़माएं

प्रयोग

f = Count[Divisors~Array~1*^4,a_/;#+a[[i=⌈Tr[1^a]/2⌉]]>a[[-i]]]&

f[1]

f /@ {1, 5, 13, 369, 777, 2000, 5000, 9000, 10000, 20000}

{100, 492, 1201, 6175, 7264, 8478, 9440, 9888, 10000, 10000}

व्याख्या

Divisors~Array~1*^4

से, के लिए विभाजकों की सूची तैयार 1करें 10000। (भाजक की सूची स्वचालित रूप से हल की जाती है)

Count[ ..., a_/; ... ]

तत्वों की घटनाओं को गिनें a, जैसे कि ...

#+a[[i=⌈Tr[1^a]/2⌉]]>a[[-i]]]

(input) + (left one of the middle element(s)) > (right one of the middle element(s)) यदि केवल एक मध्य तत्व है, तो बाएं = दाएं।

— जंगवान मिन
स्रोत

2

05AB1E , 19 18 17 16 15 12 बाइट्स

4°ƒNÑÂα{нI‹O

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

व्याख्या

4°ƒ            # for N in [0 ... 10**4] do:
   NÑ          # push divisors of N 
     Â         # bifurcate
      α        # element-wise absolute difference
       {       # sort
        н      # pop the head (smallest difference)
         I‹    # is it smaller than the input?
           O   # sum the stack

— Emigna
स्रोत

1

MATL , 20 बाइट्स

1e4:"@Z\2Y"dJ2/)G<vs

TIO में कोड बार। यहां एक उदाहरण ऑफ़लाइन कंपाइलर के साथ चलाया गया है:

>> matl 1e4:"@Z\2Y"dJ2/)G<vs
> 13
1201

— लुइस मेंडो
स्रोत

1

आर , 91 बाइट्स

function(n)sum(sapply(1:1e4,function(x,d=(1:x)[x%%1:x<1])diff(d[median(seq(d))+.5*0:1]))<n)

सरणी अनुक्रमण का उपयोग करके और इसकी गणना करने के लिए मिकी के समाधान से DMDP की गणना करने के लिए एक अलग (बदतर) दृष्टिकोण लेता है diff। अफसोस।

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

— ग्यूसेप
स्रोत

1

मैथेमेटिका, 119 115 बाइट्स

(n=#;Tr[1^Select[Last@#-First@#&/@(Take[Divisors@#,Round[{-.1,.1}+(1+Length@Divisors@#)/2]]&/@Range@10000),#<n&]])&

मुझे आखिरकार यह काम मिला और मैं पिछले आधे घंटे से कोशिश कर रहा हूं। ._।

उदाहरण चलाते हैं

— totallyhuman
स्रोत

Casesहै 4कम बाइट्स: Tr[1^Cases[Last@#-First@#&/@(Take[Divisors@#,Round[{-.1,.1}+(1+Length@Divisors@#)/2]]&/@Range@10000),n_/;n<#]]&। इस टिप को देखें ।

— ngenisis

1

@ngenisis वास्तव में Countसे भी छोटा है Cases। Count[Last@#-First@#&/@(Take[Divisors@#,Round[{-.1,.1}+‌(1+Length@Divisors@#‌)/2]]&/@Range@10000)‌,n_/;n<#]&

— जुंगह्वान मिन

इसके अलावा, 10^4या 1*^4की तुलना में कम है 10000, और /@Range@करने के लिए समान है ~Array~।

— जुंगह्वान मिन

1

गणितज्ञ, 78 बाइट्स

(s=#;Tr[1^Select[Table[#2-#&@@Quantile[Divisors@i,{.5,.51}],{i,10^4}],#<s&]])&

— J42161217
स्रोत

Casesहै 4कम बाइट्स: Tr[1^Cases[Table[#2-#&@@Quantile[Divisors@i,{.5,.51}],{i,10^4}],s_/;s<#]]&। इस टिप को देखें ।

— ngenisis

1

@ngenisis Countऔर भी छोटा है:Count[Table[#2-#&@@Quantile[Divisors@i,{.5,.51}],{i,10^‌4}],s_/;s<#]&

— JungHwan Min

1

हस्क , 19 बाइट्स

#ȯV<⁰Sz≠↔§f`¦ḣḣ□100

कोई TIO लिंक नहीं है, क्योंकि यह कई बार है। यह संस्करण 10000 के स्थान पर 100 का उपयोग करता है और कुछ सेकंड में खत्म कर देता है।

व्याख्या

हस्क के पास अभी तक वैज्ञानिक संकेतन के लिए अंतर्निहित या समर्थन नहीं है।

#ȯV<⁰Sz≠↔§f`¦ḣḣ□100  Input is n (accessed with ⁰).
               □100  Square of 100: 10000
              ḣ      Inclusive range from 1.
#                    Count number of elements for which
 ȯ                   this composition of 3 functions gives truthy result:
                       Argument k, say k = 12.
         §f`¦ḣ         Divisors of k:
             ḣ           Range: [1,2,3,..,12]
         §f              Filter by
           `¦            divides k: [1,2,3,4,6,12]
     Sz≠↔              Absolute differences of divisor pairs:
        ↔                Reverse: [12,6,4,3,2,1]
     Sz                  Zip with divisor list
       ≠                 using absolute difference: [11,4,1,1,4,11]
  V<⁰                  Is any of these less than n?

— Zgarb
स्रोत

1

जाप , 25 19 17 बाइट्स

L²õÈâ ®aX/ZÃd<UÃè

झसे आज़माओ

व्याख्या

पूर्णांक का निहित इनपुट U।

L²õ

õ1 से 100 तक पूर्णांक ( L) वर्ग का एक सरणी उत्पन्न करें ।

Èâ          Ã

प्रत्येक को एक फ़ंक्शन (जहां Xवर्तमान तत्व है) के माध्यम से पास करें जो विभाजक का एक सरणी उत्पन्न करता है ( â) X।

®    Ã

विभाजकों के उस सरणी पर मैप करें, जहां Zवर्तमान तत्व है।

aX/Z

का पूर्ण अंतर प्राप्त करें ( a) Zऔर से Xविभाजित करें Z।

d<U

किसी भी तत्व ( d) परिणामी सरणी में से कम हैं U?

è

सत्य तत्वों की गणना करें और परिणाम को स्पष्ट रूप से बताएं।

— झबरा
स्रोत

1

रूबी, 62 बाइट्स

->n{(1..1e4).count{|x|(1..x).any?{|i|1>x%i&&x/i<=i&&i-x/i<n}}}

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

— क्रिस्टियन लुपस्कू
स्रोत

1

टीआई-बेसिक, 46 बाइट्स

ध्यान दें कि TI-BASIC एक टोकन भाषा है। इसके अलावा, लाइन 2 में E एक छोटी पूंजी E है, जिसे 2ND + दबाकर पाया जाता है।

Input A
DelVar DFor(B,1,E4
For(C,1,√(B
If not(fPart(B/C
B/C-C<A
End
D+Ans→D
End

परिणाम कार्यक्रम निष्पादन के तुरंत बाद डी, और Ans में होगा। यदि इसे प्रदर्शित करना है, तो दो और बाइट्स (न्यूलाइन और Ans) जोड़ना होगा।

— जोशिया विंसलो
स्रोत

0

पायथन 2 , 134 बाइट्स

lambda i:len(filter(lambda n:n<i,[reduce(lambda x,y:y-x,[[x,n/x]for x in range(1,int(n**.5+1))if n%x<1][-1])for n in range(1,10001)]))

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

Eugh ... बहुत बेहतर करने की जरूरत है ।

— totallyhuman
स्रोत

125 बाइट्स (-9 बाइट्स) अपने वर्तमान दृष्टिकोण का उपयोग करते हुए, लेकिन len(filter(lambda n:n<i,...))साथ की जगहsum(n<i for n in ....)

— श्री एक्सकोडर

Mr.Xcoder की टिप्पणी के आधार पर 114 बाइट्स ।

— अंडा

113 बाइट्स ओव्स की टिप्पणी के आधार पर।

— श्री Xcoder

0

पायथन 2 , 83 बाइट्स

धीमी गति से थोड़ा सा, प्रति परीक्षण मामले में 5 सेकंड का उपयोग करता है

lambda x:sum(x>min(abs(y/t-t)for t in range(1,y+1)if y%t<1)for y in range(1,10001))

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

— हलवार्ड वुल्म
स्रोत

0

PHP, 94 + 1 बाइट्स

for(;$n++<1e4;$c+=$d<$argn)if(($i=$n**.5)>~~$i){while($n%++$i);for($d=1;$n%--$i;)$d++;}echo$c;

ऑनलाइन के साथ पाइप के रूप में चलाएं -nRया इसे आज़माएं ।

— टाइटस
स्रोत

0

VB.NET (.NET 4.5) 116 115 बाइट्स

Function A(n)
For i=1To 10^4
Dim s As Byte=Math.Sqrt(i)
While i Mod s>0
s-=1
End While
A-=i/s-s<n
Next
End Function

स्पष्टीकरण:

एक फ़ंक्शन जो लेता है n पैरामीटर के रूप में , और परिणाम देता है।

वर्गमूल में शुरू होता है, और निकटतम पूर्णांक की तलाश करता है जो समान रूप से विभाजित होता है (छोटा होगा MaxMin Divisor Pair)। फिर जोड़ी में से बड़ा हो जाता है (i/s ), अंतर पाता है, और इनपुट के खिलाफ तुलना करता है।

गोल्फ रणनीति का इस्तेमाल किया:

Dim महंगा है, इसलिए कम चर मैं बेहतर घोषित करता हूं।
मैं वर्गमूल को खोजना शुरू करता हूं, लेकिन केवल पूर्णांकों को देखना चाहता हूं। घोषित करकेsएक अभिन्न प्रकार के रूप में , यह मेरे लिए मंजिल तक ले जाता है।
VB ^घातांक के रूप में उपयोग करता है । तो जबकि 100005 अक्षर है, 10^4केवल 4 है।
VB समान नाम के साथ एक स्वचालित चर बनाता है और फ़ंक्शन परिभाषा (मेरे मामले में A) के रूप में टाइप करता है। फ़ंक्शन के अंत में, यदि कोई नहीं है return, तो फ़ंक्शन चर का मान बदले में वापस किया जाएगा। इसलिए मैं एक अलग चर घोषित करके और रिटर्न स्टेटमेंट का उपयोग न करके पात्रों को बचाता हूं।
VB में बहुत क्षमाशील टाइपिंग / कास्टिंग है। iमाना जाता है Integerक्योंकि मैंने एक पूर्णांक शाब्दिक सौंपा है। Aमाना जाता है Objectलेकिन जैसे ही मैं एक पूर्णांक जोड़ता हूं, यह एक की तरह व्यवहार करता है Integer।
यह ifजाँचने के बजाय कि अंतर संतोषजनक है, बूलियन को एक पूर्णांक तक कास्टिंग करके परिणाम में सीधे जोड़ें। हालाँकि, VB के लिए उपयोग करता -1हैTrue , इसलिए सही संकेत प्राप्त करने के लिए घटाना।
तकनीकी रूप से, हम Modनहीं बनना चाहते हैं 0। VB.NET में एक ऋणात्मक संख्या के मापांक लेने से एक नकारात्मक परिणाम मिलेगा। लेकिन, सब कुछ तो मैं बदल कर एक बाइट बचा सकता है सकारात्मक है <>में >।
जाँच करने के लिए सबसे बड़ी संख्या 10000 है। उस का वर्गमूल 100 है। इसलिए मुझे केवल एक Byteस्टोर करने की आवश्यकता है, जो छोटे नाम वाले प्रकार का उपयोग करके घोषणा में बाइट्स की बचत कर रहा है।

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

— ब्रायन जे
स्रोत

0

सी # (.NET कोर) , 104 बाइट्स

x=>{int o=0,i=1;for(;i<=10000;i++)for(int j=1;j<=i;j++)if(i%j<1&Math.Abs(j-i/j)<x){o++;break;}return o;}

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

— Dennis.Verweij
स्रोत

मैक्सिन डिवाइज़र पेयर (DMDP) के अंतर

आइए बात करते हैं दिव्यांगों के बारे में ...

चुनौती

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

जावास्क्रिप्ट (ईएस 7), 60 बाइट्स

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

जावा 8, 151 111 110 101 बाइट्स

आर , 73 77 बाइट्स

मैथेमेटिका, 64 बाइट्स

प्रयोग

व्याख्या

05AB1E , 19 18 17 16 15 12 बाइट्स

MATL , 20 बाइट्स

आर , 91 बाइट्स

मैथेमेटिका, 119 115 बाइट्स

उदाहरण चलाते हैं

गणितज्ञ, 78 बाइट्स

हस्क , 19 बाइट्स

व्याख्या

जाप , 25 19 17 बाइट्स

व्याख्या

रूबी, 62 बाइट्स

टीआई-बेसिक, 46 बाइट्स

पायथन 2 , 134 बाइट्स

पायथन 2 , 83 बाइट्स

PHP, 94 + 1 बाइट्स

VB.NET (.NET 4.5) 116 115 बाइट्स

सी # (.NET कोर) , 104 बाइट्स