जांचें कि क्या कोई संख्या लगातार पूर्णांक संख्याओं का एक उत्पाद है

Question

कुछ संख्याएँ जैसे: 6, 12, 20, 30, 42, 56, 60, 90, 120 और इसी तरह लगातार पूर्णांक संख्याओं के उत्पाद के रूप में व्यक्त किया जा सकता है जैसा कि नीचे दिखाया गया है।

6   = 2 * 3  
12  = 3 * 4  
30  = 5 * 6
60  = 3 * 4 * 5  
90  = 9 * 10  
120 = 4 * 5 * 6  

एक प्रोग्राम या फ़ंक्शन लिखें जो लगातार पूर्णांक की एक सूची को आउटपुट करता है जो उत्पाद निर्दिष्ट संख्या के बराबर होता है।

इस तर्क के लिए उपयुक्त संख्याओं के उदाहरण हैं:

99  = 9 * 11  (Product of non-consecutive numbers)
121 = 11 * 11 (Same numbers)
2   = 1 * 2   (Product of itself and 1)
13  = 13      (Product of only one number)

कृपया ध्यान दें कि के मामले के लिए 2 = 2 * 1, हम इसे एक वैध परिणाम नहीं मानते हैं, क्योंकि पूर्णांक 1 से गुणा करने पर समान परिणाम मिलता है। इस प्रश्न के लिए, हम उत्पाद में केवल पूर्णांक> = 2 पर विचार करेंगे।

इनपुट

एक मान्य 32-बिट सकारात्मक पूर्णांक। मानक इनपुट, एक फ़ंक्शन तर्क आदि से हो सकता है।

उत्पादन

लगातार पूर्णांक संख्याओं की सूची> = 2 (या तो आरोही या अवरोही क्रम में)। यदि लगातार पूर्णांक के कई संयोजन हैं, तो बस एक उदाहरण प्रदान करेगा। यदि आप अधिक प्रदान करते हैं, तो इसका जुर्माना।

प्रतिबंध

सभी मान्य इनपुट (सकारात्मक 32-बिट पूर्णांक) के लिए मानक कंप्यूटर पर चलने के लिए कोड को उचित समय (<5 मिनट) लेना चाहिए । यदि लगातार पूर्णांक उत्पाद है, तो कोड को एक या अधिक समय सीमा के भीतर आउटपुट करना चाहिए। इसके अलावा, कोड को समय सीमा के भीतर कोई आउटपुट नहीं देना चाहिए।

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

Comments

यह पहेली, जैसा कि कहा गया है, इस साइट के प्रारूप के लिए एक अच्छी फिट नहीं है। यह साइट उन कंटेस्टेंट्स के लिए है जहाँ विजेता का फैसला करने का एक अच्छा तरीका है (उदाहरण के लिए, सबसे छोटा कोड, सबसे तेज़ कोड, अधिकांश अपवोट्स इत्यादि)। आपने ऐसा कोई तरीका नहीं दिया है।

— क्रिस जस्टर-यंग

मैं आपको इसे एक कोड-गोल्फ (सबसे छोटा कोड) बनाने की सलाह देता हूं। हालांकि आपको इस पर कुछ सीमाएं लगाने की जरूरत है। उदाहरण संख्या 0 से 1000000 तक, अधिकतम निष्पादन समय 10 सेकंड, आदि

— लेवल रिवर सेंट

इस प्रश्न का निस्तारण करने के लिए इसे संपादित करने का प्रयास किया। लेकिन मैंने पहले कोई सवाल नहीं किया है, इसलिए यदि आप कुछ भी देखते हैं, तो कृपया संपादित करें।

— वेक्टर

कुछ टाइप्स के अलावा, @bitpwner मुझे ठीक लगता है। फिर से खोलने की वोटिंग की गई।

— 16

मुझे लगता है कि आपका मतलब है 30=5*6।

— काइल कानोस

Answer 1

जावा - १२४

String f(int t){int s=2,h=3,p=s,i;String o="";for(;p!=t&&s*s<t;p=p<t?p*h++:p/s++);if(p==t)for(i=s;i<h;o+++=i+" ");return o;}

2 से शुरू, यह लूप तब तक होता है जब तक कि प्रारंभ संख्या> लक्ष्य का वर्गमूल (या लक्ष्य बिल्कुल नहीं पहुंच जाता)। यदि उत्पाद कम है, तो यह उच्च संख्या से गुणा करता है और इसे बढ़ाता है। यदि उच्च है, तो यह प्रारंभिक संख्या से विभाजित होता है और इसे बढ़ाता है।

उदाहरण के लिए, 30 के लिए, यह जाँच करेगा:

2*3     = 6 (too low, multiply)
2*3*4   = 24 (too low, multiply)
2*3*4*5 = 120 (too high, divide)
3*4*5   = 60 (too high, divide)
4*5     = 20 (too low, multiply)
4*5*6   = 120 (too high, divide)
5*6     = 30 (bingo!)

आरोही क्रम में कारकों के एक अंतरिक्ष-पृथक स्ट्रिंग को आउटपुट करता है।

लाइन ब्रेक के साथ:

String p(int t){
    int s=2,h=3,p=s,i;
    String o="";
    for(;p!=t&&s*s<t;p=p<t?p*h++:p/s++);
    if(p==t)
        for(i=s;i<h;o+=i+" ");
    return o;
}

Answer 2

पायथन - 104 97 95 92 इसे आज़माएं

n=input()
s=i=2
c=1
while s<n:
 s*=i+c;c+=1
 if s==n:print range(i,i+c)
 if s/n:i+=1;s,c=i,1

यदि n, उदाहरण के लिए, पहले से 120 सेट है, तो प्रोग्राम दो समाधानों को आउटपुट करता है:

[2, 3, 4, 5]
[4, 5, 6]

Comments

क्षमा करें, मैं कुछ इनपुट को परिभाषित करना भूल गया।

— फाल्को

c = c + 1, i = i + 1 को c + = 1, i + = 1 से

— बदलें

अरे हाँ, के बारे में नहीं सोचा था +=। लेकिन मुझे ++पायथन में याद आती है ...

— फाल्को

if s>=nऔर if s/nसमतुल्य हैं, इसलिए आप एक ही संख्या में सभी समाधान प्रदान कर सकते हैं।

— isaacg

आप को बदलने के द्वारा तीन पात्रों को बचा सकता है s=s*(i+c)के लिए s*=i+c।

— एल'एंडिया स्ट्रैटन

Answer 3

क्लोजर - 127 109 बाइट्स

(defn f[x](first(for[r[range]y(r 2 x)v[(take-while #(<=(apply * %(r y %))x)(r y x))]:when(=(apply * v)x)]v)))

उदाहरण:

(map f [6 12 30 60 90 120 1404816 99 121 2 13])
=> ((2 3) (3 4) (5 6) (3 4 5) (9 10) (2 3 4 5) (111 112 113) nil nil nil nil)

स्पष्टीकरण:

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

Http://tryclj.com/ में परीक्षण करने के लिए सबसे आसान ।

---

मैंने अब यह भी देखा कि मैं सभी संभावनाओं को वापस कर सकता हूं: 120 बाइट्स 102 बाइट्स , लेकिन एक नेस्टेड सूची में परिणाम देता है।

(defn f[x](for[r[range]y(r 2 x)v[(take-while #(<=(apply * %(r y %))x)(r y x))]:when(=(apply * v)x)]v))

उदाहरण:

(map f [6 12 30 60 90 120 1404816 99 121 2 13])
=> (((2 3)) ((3 4)) ((5 6)) ((3 4 5)) ((9 10)) ((2 3 4 5) (4 5 6)) ((111 112 113)) () () () ())

Answer 4

सीजेएम, 31 बाइट्स

q~:Qmq,A,m*{2f+~,f+_:*Q={p}*}%;

यह एक जानवर-बल दृष्टिकोण है, लेकिन निष्पादन का समय आधिकारिक जावा दुभाषिया का उपयोग करते हुए केवल कुछ सेकंड का है ।

यदि आप ऑनलाइन इंटरप्रेटर का उपयोग करके कोड का परीक्षण करना चाहते हैं , तो आपको इनपुट को यथोचित रूप से कम रखना चाहिए। 2 ²⁶ से कम कुछ भी अभी भी मेरी मशीन पर काम करता है।

उदाहरण

$ TIME="%e s"
$ time cjam product.cjam <<< 2
0.12 s
$ time cjam product.cjam <<< 6
[2 3]
0.10 s
$ time cjam product.cjam <<< 120
[2 3 4 5]
[4 5 6]
0.12 s
$ time cjam product.cjam <<< 479001600
[2 3 4 5 6 7 8 9 10 11 12]
0.68 s
$ time cjam product.cjam <<< 4294901760
[65535 65536]
1.48 s
$ time cjam product.cjam <<< 4294967295
1.40 s

यह काम किस प्रकार करता है

q~:Q      " Read from STDIN, interpret the input and save the result in variable “Q”.     ";
mq,       " Push the array [ 0 1 2 … (Q ** 0.5 - 1) ].                                    ";
A,m*      " Push the array [ 0 1 2 … 9 ] and take the Cartesian product.                  ";
{         " For each pair in the Cartesian product:                                       ";
  2f+     " Add 2 to each component.                                                      ";
  ~       " Dump the array's elements on the stack.                                       ";
  ,       " Push the array [ 0 1 2 … n ], where “n” is the topmost integer on the stack.  ";
  f+      " Add “m” to each element, where “m” is the integer below the array.            ";
  _:*     " Duplicate the resulting array and push the product of its elements.           ";
  Q={p}*  " If the product is equal to “Q”, print.                                        ";
}%        " Collect the remaining results into an array.                                  ";
;         " Discard the array from the stack.                                             ";

Answer 5

जावा, 162

पूर्णांकों की एक सरणी देता है, या nullयदि कोई लगातार संख्या मौजूद नहीं है।

int[] e(int n){for(int i=1;i<n;i++){int h=i+1,c=1,s=i;while(s<n){c++;s*=h++;}if(s==n){int[] o=new int[c];for(int j=0;j<c;j++){o[j]=h-j-1;}return o;}}return null;}

ungolfed:

int[] execute(int input){
    for(int i=1; i<input; i++){
        int highest = i+1, count = 1, sum = i;
        while(sum < input){
            count++;
            sum *= highest++;
        }
        if(sum == input){
            int[] numbers = new int[count];
            for(int j=0; j<count; j++){
                numbers[j] = highest-j-1;
            }
            return numbers;
        }
    }
    return null;
}

Answer 6

C 105 110 इसे आज़माएँ

n,k,l;main(i){for(scanf("%d",&n);++i<n;)for(k=1,l=i;k<n;)if(k*=l++,k==n)for(l=n;l/=i;)printf("%d ",i++);}

144 बोनस के साथ: यह हर संख्या के माध्यम से पुनरावृत्ति करता है और मिलान उत्पादों को पाता है

main(i,j,k,l,m){for(scanf("%d",&m);++i<13;)for(j=0;++j<46341-i;){for(l=k=1;k<=i;)l*=j+k++;if(l==m)for(puts(""),k=0;k<i;)printf("%d ",j+k+++1);}}

Comments

अच्छा, बहुत सरल और सुरुचिपूर्ण! निश्चित रूप से कुछ छोटी संख्याओं के लिए काम किया, जिन्हें मैंने इसे फेंक दिया। फिर मैंने इसे 50815512 (7128 x 7129) दिया और यह एक अनंत लूप में चला गया। जब यह 7128 x 7129 x 7130 = 362314600560 गणना करने की कोशिश करता है तो क्या यह बह निकला है?

— टॉड लेहमैन

धन्यवाद! जाहिरा तौर पर हालत k < nबहुत अधिक हो जाती है k *= l++। मैं लंबे शुरुआत लेकिन ... कि जीवन को बर्बाद करने के लिए होगा अहस्ताक्षरित संलग्न कर सकता है

— bebe

Answer 7

PHP 258 चार्ट, 201 फैक्टरियल फंक्शन की गिनती नहीं।

गणितीय रूप से "लगातार कारकों कि एक संख्या के बराबर" को व्यक्त करने का सबसे सरल तरीका है, X!/Y!जहां Xसबसे अधिक संख्या है और Yसबसे कम एक शून्य है। दुर्भाग्य से मैंने गणना करने से पहले गणना करना बंद कर दिया Z = X!/Y!था, इसलिए मुझे इसे थोड़ा कम करना पड़ा।

गन्दा, असभ्य संस्करण:

<?php
// PHP does not define a factorial function, so I've kludged one in.
function fact($n) {
    $r = 1;
    for($i=$n; $i>1; $i--) {
        $r *= $i;
    }
    return $r;
}

$input = intval($argv[1]);

if( $input < 2 ) { die('invalid input'); }

printf("input: %s\n", $input);

$max=min(ceil(sqrt($input)),170); // integer breakdown for > 170!
$grid = array();
for( $x=1;$x<$max;$x++ ) {
    for( $y=$max;$y>=1;$y-- ) {
        if( $y >= $x ) { continue; } // Skip results that would be < 1
        $cur = fact($x)/fact($y);
        if( $cur > $input ) { // too large!
            echo "\n"; continue 2;
        }
        if( $cur == $input ) { //just right
            printf("%7d\n\nFound %s == %s\n", $cur, implode(' * ', range($y+1, $x)), $cur);
            break 2;
        }
        printf("%7d ", $cur);
    }
    echo "\n";
}
if($cur!=$input){printf("No consecutive factors produce %d\n", $input);}

उदाहरण आउटपुट:

input: 518918400

  2
  3       6
  4      12      24
  5      20      60     120
  6      30     120     360     720
  7      42     210     840    2520    5040
  8      56     336    1680    6720   20160   40320
  9      72     504    3024   15120   60480  181440  362880
 10      90     720    5040   30240  151200  604800 1814400 3628800
 11     110     990    7920   55440  332640 1663200 6652800 19958400 39916800
 12     132    1320   11880   95040  665280 3991680 19958400 79833600 239500800 479001600
 13     156    1716   17160  154440 1235520 8648640 51891840 259459200
 14     182    2184   24024  240240 2162160 17297280 121080960
 15     210    2730   32760  360360 3603600 32432400 259459200
 16     240    3360   43680  524160 5765760 57657600 518918400

Found 9 * 10 * 11 * 12 * 13 * 14 * 15 * 16 == 518918400

golfed:

<? function f($n){$r=1;for($i=$n;$i>1;$i--)$r*=$i;return $r;}$i=$argv[1];$m=min(ceil(sqrt($i)),170);for($x=1;$x<$m;$x++){for($y=$m;$y>0;$y--){if($y>=$x)continue;$c=f($x)/f($y);if($c>$i)continue 2;if($c==$i){$y++;echo "$y $x";break 2;}}}if($c!=$i){echo 'No';}

आउटपुट:

[sammitch@vm ~/golf] time php consecutive_golf.php 518918400
9 16
real 0m0.019s
user 0m0.011s
sys  0m0.009s
[sammitch@vm ~/golf] time php consecutive_golf.php 518918401
No
real 0m0.027s
user 0m0.017s
sys  0m0.011s

मैं रन के समय की उम्मीद नहीं कर रहा था यह बहुत जल्दी हो सकता है!

Comments

यह विचार मेरे दिमाग में भी आया था और यह बहुत ही प्रभावोत्पादक लगता है लेकिन मुझे संदेह है कि इसे "योग्य होने के लिए" पर्याप्त रूप से छोटा किया जा सकता है।

— बेबे

@bebe यह 258 वर्ण है, PHP के लिए बहुत बुरा नहीं है। अगर मैं इतना आलसी और दुराचारी नहीं होता तो मैं इसे एक वास्तविक भाषा में करता। : पी

— सेमिच

एक्स! / वाई! पूर्णांक N का उत्पाद ऐसा है जो Y <N <= X है। क्या उससे किसी भी तरह से सहायता मिलती है?

— ट्राइकोप्लाक्स

Answer 8

अजगर , ३५

JvwKr2 4W-ZJ~@KgJZ1=YurGHK=Zu*NTY)Y

नोट: मेरा कोड वास्तव में लगातार पूर्णांक> = 2 के प्रतिनिधित्व के रूप में इनपुट का सबसे छोटा प्रतिनिधित्व पाता है, इसलिए अमान्य इनपुट पर यह 1 तत्व सूची को मुद्रित करेगा, संभवतः बहुत लंबे समय के बाद। चूंकि समस्या कथन में कहा गया है कि इनपुट मान्य होगा, इसलिए मुझे लगता है कि यह ठीक है।

संक्षिप्त विवरण:

अनिवार्य रूप से, प्रोग्राम एक श्रेणी की ऊपरी और निचली सीमाओं को संग्रहीत करता है, एक कम का उपयोग करके सीमा में संख्याओं के उत्पाद की गणना करता है, आवश्यक के रूप में समापन बिंदुओं को समायोजित करता है और तब तक दोहराता है जब तक कि उत्पाद इनपुट के बराबर न हो जाए।

लंबी व्याख्या:

कोड के प्रत्येक स्निपेट के लिए, मैं बराबर अजगर दूंगा, साथ ही अधिक विस्तृत विवरण और तर्क भी दूंगा।

Jvw => J=eval(input())

पायथ में इनपुट लेने का मानक तरीका।

Kr2 4 => K=range(2,4) =>K=[2,3]

यहां पहला अजीब हिस्सा है: अंतिम बिंदुओं को अलग-अलग चर के रूप में संग्रहीत करने के बजाय, मैं उन्हें सूची के तत्वों के रूप में संग्रहीत कर रहा हूं। जल्द ही कारण स्पष्ट हो जाएगा। इसके अलावा, एक साधारण असाइनमेंट करने के बजाय, जो पायथ में होगा K[2 3), मैं एक चरित्र को बचाने के लिए एक सीमा का उपयोग कर रहा हूं।

W-ZJ => while Z-J =>while Z!=J

इस बिंदु पर, आप पूछ सकते हैं, "जेड क्या है? आपने इसे परिभाषित नहीं किया है।" पायथ में, सभी चर पूर्वनिर्धारित आते हैं। Z 0. के रूप में शुरू होता है। हालांकि, Z को बाद में उत्पाद के मूल्य पर सेट किया जाएगा, इसलिए यह चेक सही समय पर सूची में आते ही लूप को समाप्त करने का काम करेगा।

~@K>JZ1 => K[J>Z] += 1

यहां मैं एक सूची में मानों को संग्रहीत कर रहा हूं, अलग-अलग चर में नहीं: मैं दो समापन बिंदुओं में से एक को बढ़ाना चाहता हूं, यह इस बात पर निर्भर करता है कि उत्पाद वर्तमान में बहुत अधिक है या बहुत कम है। यदि समापन बिंदु अलग-अलग चर होते, तो यह एक लंबी स्थिति होगी, लेकिन सूची अनुक्रमण के जादू के साथ, यह छोटा हो जाता है। इसके अलावा, तथ्य यह है कि यह जांच उत्पाद से पहले आती है, और यह तथ्य कि जेड 0 के लिए आरंभीकृत है, यह सुनिश्चित करें कि K तब तक होगा [2,4]जब हम पहली बार उत्पाद लेते हैं, जो उचित समापन बिंदु हैं।

=YurGHK=>Y=reduce(lambda G,H: range(G,H),K) =>Y=range(K[0],K[1])

अब, मुझे वास्तविक सूची की आवश्यकता है जिसे उत्पाद पर ले जाया जाएगा, और यदि हम सफल होते हैं तो इसका प्रिंट आउट लिया जाएगा। स्पष्ट रूप से, हम एक रेंज फंक्शन का उपयोग करेंगे। सीमा समारोह के लिए इनपुट प्राप्त करने में चालाकी निहित है। ऐसा करने का स्पष्ट तरीका, सूची को अनुक्रमित करके होगा =Yr'K@K1। हालांकि, इस दो तत्व सूची में एक कम फ़ंक्शन का उपयोग करके, हम एक चरित्र द्वारा छोटा कर सकते हैं।

=Zu*NTY => Z=reduce(lambda N,T: N*T,Y)

और अब, इस चक्कर के पूरे बिंदु के लिए, सूची के उत्पाद को खोजने के लिए ऑपरेशन कम करें।

) => जबकि अंत

Y => print(Y)

सफलता पर, सूची को प्रिंट करें।

उदाहरण रन:

$ cat seq_prod 
JvwKr2 4W-ZJ~@K>JZ1=YurGHK=Zu*NTY)Y

$ cat seq_prod | python3 pyth.py
<debug stuff>
==================================================
[9, 10, 11, 12, 13, 14, 15, 16]

Answer 9

जावा - 115

void f(int i){for(int j=2;j<i;j++)for(int k=1,x=j;(x*=j+k)<i;k++);if(x==i)for(i=j;i<j+k;i++)System.out.println(i);}

थोड़ा कम गोल्फ:

void f(int i) {
 for(int j=2; j<i; j++)
  for(int k=1, x=j; (x*=j+k) < i; k++);
   if(x == i)
    for(i=j; i<j+k; i++)
     System.out.println(i);
}

Comments

एह, आपने एक फ़ंक्शन बनाया और रिटर्न मान प्रिंट किया। पहले ऐसा नहीं देखा गया।

— १०

मैं इसे कुछ भी छापने के लिए नहीं प्राप्त कर सकता ... लेकिन अगर यह मुझे कुछ आउटपुट देगा, तो आप System.out.printlnनीचे गोल्फ कर सकते हैं System.out.printऔर अंत में अर्धविराम for(int k=1,x=j;(x*=j+k)<i;k++)न केवल अनावश्यक है, बल्कि त्रुटियों का कारण भी है।

— क्यूविक्स

यह मेरे लिए काम नहीं करता है। x, j, kआखिरी में क्षेत्र से बाहर कर रहे हैं if/for, क्योंकि एक के ब्लॉक ;। अगर मैं ;इसे हटाता हूं , तो यह कुछ भी प्रिंट नहीं करता है।

— Geobits

@Qwix बदलने का printमतलब है कि उसे एक व्हाट्सएप चरित्र जोड़ने की जरूरत है ताकि एक साथ चलने वाले नंबरों से बचा जा सके।

— जियोबिट्स

@Geobits अच्छी बात! मैंने शायद देखा होगा कि अगर इसने मुझे कुछ आउटपुट दिया है।

— क्यूविक्स Q

Answer 10

मतलाब (88)

कोड की उम्मीद है कि संख्या में xऔर उत्पादन में संग्रहीत किया जाएगा l।

for n=2:12
r=ceil(x^(1/n))
for s=-3*n:n
l=r-s+(1:n)
if prod(l)==x
return 
end;end;l=x;end

चूंकि 13! > 2^32यह कोड केवल 12 तक की लंबाई के उत्पादों के लिए खोज करता है। इस कोड में लगभग 0.001 का निरंतर रनटाइम है।

Answer 11

स्काला - 86

def p(n:Int)=(2 to n).flatMap(i=>(i to n).map(i to _-1).find(_.product==n)).headOption

यह कोड बहुत ही अकुशल है लेकिन इसे अनुकूलित करने से इसमें कुछ और चरित्र जुड़ेंगे। यह सभी संभावित लगातार अनुक्रमों के उत्पादों की जांच के लिए एक कार्यात्मक दृष्टिकोण का उपयोग करता है। (पूर्णांक का एक निरंतर अनुक्रम स्काला में एक रेंज ऑब्जेक्ट के रूप में दर्शाया गया है)

ungolfed:

def product(n: Int): Option[Range] = {
  def productStartingAt(start: Int): Option[Range] =
    (start to n-1).map(start to _).find(_.product == n)

  (2 to n).flatMap(i => productStartingAt(i)).headOption
}

Answer 12

CJam वर्तमान में लंबी गणना समय के कारण बड़ी संख्या में काम नहीं करता है

यह मेरा सबसे छोटा CJam कोड है। Http://cjam.aditsu.net/ पर परीक्षण करें । यह काम करता है: ए के रूप में इनपुट को परिभाषित करना; 0 से ए -1 तक सभी संख्याओं की एक सरणी बनाना; लात मारना; सरणी में सभी संख्याओं को गुणा करने तक छोटी संख्याओं को मारना ए से अधिक नहीं है; यदि यह A से अधिक है तो जाँच करना; यदि नहीं, तो 0 से A-2 तक एक सरणी बना रहा है; और जवाब मिलने तक दोहराते रहें। यदि कोई नहीं पाया जाता है, तो एक अपवाद फेंक दिया जाता है। मुझे नहीं लगा कि संख्याओं के बीच रिक्त स्थान की आवश्यकता थी, इसलिए वे दूसरे कोड में inlcuded हैं जो कि 32 वर्ण लंबा है।

ri:A,{)\;,1{;(;_{*}*_A>}gA<}g

ri:A,{)\;,1{;(;_{*}*_A>}gA<}g" "*

Comments

मुझे लगता है कि मान्य होने के लिए आपका उत्तर बहुत धीमा है। याद रखें, यह किसी भी वैध 32 बिट पूर्णांक पर 5 मिनट से अधिक समय में पूरा होना चाहिए। 3600060000 == 60000 * 60001 पर कितना समय लगता है?

— isaacg

उचित बिंदु, मैं इसे फिर से काम करूंगा और पोस्ट करूंगा अगर यह छोटा हो

— kaine

यदि आप इसे फिर से तैयार करने जा रहे हैं, तो कृपया इस उत्तर को तब तक हटा दें, या किसी और तरह से इंगित करें जो वर्तमान में मान्य नहीं है।

— isaacg

Answer 13

डार्ट - 102 वर्ण

यह एक धीमी गति से कार्यान्वयन है। इसे और तेज़ बनाया जा सकता है लेकिन इसके लिए अधिक वर्णों की आवश्यकता होती है (जैसे कि लूप को केवल तब तक करना i*i<n)

f(n,[i=2]){
  t(j,p,a)=>p<n?t(++j,p*j,a..add(j)):p>n?f(n,i+1):a;
  for(;i<n;i++)if(n%i<1)return t(i,i,[i]);
}

(102 चार्ट बिना लाइन ब्रेक और प्रमुख स्थानों के हैं)।

इसका उपयोग करने के लिए, ऐसा कुछ करें:

main() {
  print(f(123456789*123456790));
}

Answer 14

जावास्क्रिप्ट, 88

गोल्फ कोड:

function f(a){for(i=2;i<a;i++){b=[1];for(j=i;j>1;j--)if((b[0]*=b[i-j+1]=j)==a)alert(b)}}

पढ़ने के लिए आसान (अच्छी तरह से जगह) कोड:

function f(a){
    for(i=2;i<a;i++){
        b=[1];
        for(j=i;j>1;j--)
            if((b[0]*=b[i-j+1]=j)==a)
                alert(b);
    }
}

2 से इनपुट संख्या के लिए प्रत्येक संख्या के लिए, यह वर्तमान संख्या से लगातार 2 पूर्णांक के उत्पाद को नीचे से 2 तक ढूंढता है। यदि यह उत्पाद इनपुट संख्या के बराबर है, तो मूल इनपुट संख्या के साथ लगातार संख्याओं की श्रृंखला आउटपुट है। ।

यह लगातार संख्याओं के बाद इनपुट संख्या को आउटपुट करता है जिसका उत्पाद इनपुट नंबर है।

उदाहरण के लिए f (120) "120,5,4,3,2" टेक्स्ट के साथ एक अलर्ट उत्पन्न करता है और फिर "120,6,4,4" टेक्स्ट के साथ दूसरा अलर्ट।