मिस्र के अंश

20

अवलोकन:

से विकिपीडिया : मिस्र की एक अंश अलग इकाई भिन्न का योग है। यही है, अभिव्यक्ति के प्रत्येक अंश में 1 के बराबर एक अंश होता है और एक भाजक जो एक पूर्णांक होता है, और सभी भाजक एक दूसरे से भिन्न होते हैं। इस प्रकार की अभिव्यक्ति का मान धनात्मक परिमेय संख्या a / b है। हर सकारात्मक तर्कसंगत संख्या को एक मिस्र के अंश द्वारा दर्शाया जा सकता है।

चुनौती:

सबसे छोटे फ़ंक्शन को लिखें, जो इकाई अंशों के सबसे छोटे सेट के लिए सभी विभाजनों के मूल्यों को लौटाएगा जो किसी दिए गए अंश तक जोड़ते हैं।

नियमों / प्रतिबंध:

  • इनपुट दो सकारात्मक पूर्णांक मान होंगे।
    • यह हो सकता है STDIN, पर , argvअल्पविराम से अलग, अंतरिक्ष सीमांकित, या कोई अन्य विधि जिसे आप पसंद करते हैं।
  • पहला इनपुट मान अंश होगा और दूसरा इनपुट मान भाजक होगा।
  • पहला इनपुट मान दूसरे से कम होगा।
  • आउटपुट में एक मान (s) शामिल हो सकता है जो आपके सिस्टम / भाषा (RAM, MAX_INT, या जो भी अन्य कोड / सिस्टम की कमी मौजूद है) की मेमोरी सीमाओं से अधिक हो। यदि ऐसा होता है, तो परिणाम को उच्चतम संभव मान पर काटें और ध्यान दें कि किसी भी तरह (यानी ...)।
  • आउटपुट कम से कम 2,147,483,647 (2 31 -1, हस्ताक्षर किए गए 32-बिट int) तक एक भाजक मान को संभालने में सक्षम होना चाहिए ।
    • एक उच्च मूल्य ( longआदि) पूरी तरह से स्वीकार्य है।
  • आउटपुट यूनिट फ्रैक्शन के सबसे छोटे सेट (या फ्रैक्शंस स्वयं, यानी 1/2) के हर के सभी मानों की एक सूची होगी ।
  • आउटपुट को हर के मूल्य के अनुसार आरोही करने का आदेश दिया जाएगा (अंश के मूल्य द्वारा अवरोही)।
  • अपनी इच्छानुसार आउटपुट को सीमांकित किया जा सकता है, लेकिन इसके बीच कुछ चरित्र होना चाहिए ताकि अगले से एक मान को अलग किया जा सके।
  • यह कोड गोल्फ है, इसलिए सबसे छोटा समाधान जीतता है।

exmaples:

  • इनपुट 1:

    43, 48

  • आउटपुट 1:

    2, 3, 16

  • इनपुट 2:

    8/11

  • आउटपुट 2:

    1/2 1/6 1/22 1/66

  • इनपुट 3:

    5 121

  • आउटपुट 3:

    33 121 363

code-golf  math  rational-numbers 
— Gaffi
स्रोत
इनपुट / आउटपुट 2 8, 11और 2, 6, 22, 66सही होना चाहिए ?
— मेलमोकब
2
संक्षिप्तता को हटाने के लिए एक संभावित सुझाव, सबसे छोटे अंतिम भाजक के साथ इकाई अंशों के सबसे छोटे सेट की आवश्यकता होगी। उदाहरण के लिए, इनपुट के लिए 1/2 1/6 1/22 1/66बेहतर होगा । 1/2 1/5 1/37 1/40708/11
— प्रिमो
2
मैं 5/121 = 1/33+1/121+1/363परीक्षण के मामलों में जोड़ने का सुझाव देता हूं । सभी लालची कार्यक्रम (मेरा सहित) इसके लिए 5 अंश देते हैं। उदाहरण विकिपीडिया से लिया गया है ।
— ugoren
1
@primo मुझे लगता है कि यदि कई न्यूनतम हैं, तो जो भी मिल सकता है वह स्वीकार्य होगा। यदि एक एल्गोरिथम को कम वर्णों के साथ लिखा जा सकता है, तो मैं उस समाधान में बाधा नहीं डालना चाहूंगा।
— गफ्फी
1
+1 के बाद से मैंने वास्तव में एक इतिहास के गणित पाठ्यक्रम में मिस्र के अंशों के बारे में सीखा है (और उनके साथ गणित करना था, साथ ही साथ इस समस्या की तरह भिन्नात्मक रकम का पता लगाना था।) एक अच्छी और रचनात्मक चुनौती।
— mbomb007

जवाबों:

6

कॉमन लिस्प, 137 वर्ण

(defun z(n)(labels((i(n s r)(cond((= n 0)r)((< n(/ 1 s))(i n(ceiling(/ 1 n))r))(t(i(- n(/ 1 s))(1+ s)(cons s r))))))(reverse(i n 2'()))))

(z ४३/४)) -> (२ ३ १६)

(z 8/11) -> (२ ५ ३ 8 ४० --०)

(z 5/121) -> (25 757 763309 873960180913 1527612795642093418846225)

भारी संख्या के बारे में चिंता करने की जरूरत नहीं है, या आंशिक संकेतन को संभालना है!

— पॉल रिक्टर
स्रोत
(defun z (n) (लेबल ((((nsr) (cond (= n 0) r) ((<n (/ 1 s)) ((छत (/ 1 n)) r) (t) i (- n (/ 1 s)) (1+ s) (cons sr)))))) (रिवर्स (2 '()))) (z 43/48) tio में परिणाम न दिखाएं ... परिणाम प्रिंट करने के लिए मुझे क्या उपयोग करना होगा?
— रोजलूपी
1
(प्रिंट (z 103/333)) 5 नंबरों की एक सूची लौटाता है, लेकिन 4 नंबरों की एक सूची मौजूद होगी जैसे: 1 / 4,1 / 18,1 / 333,1 / 1332। इसलिए उपरोक्त फ़ंक्शन न्यूनतम वापस नहीं करेगा।
— रोजलूपी
8

अजगर 2, 169 167 चर

x,y=input()
def R(n,a,b):
 if n<2:return[b/a][b%a:]
 for m in range((b+a-1)/a,b*n/a):
  L=R(n-1,a*m-b,m*b)
  if L:return[m]+L
n=L=0
while not L:n+=1;L=R(n,x,y)
print L

स्टैडम पर अल्पविराम से अलग आर्गन्स लेता है और स्टडआउट पर एक अजगर सूची को प्रिंट करता है।

$ echo 8,11 | ./egypt.py 
[2, 5, 37, 4070]
— कीथ रान्डेल
स्रोत
2
1. मुझे लगता है कि आप दूसरे इंडेंटेशन स्तर पर टैब का उपयोग करके दो चार्ट बचा सकते हैं। 2. सिस्टम मेमोरी सीमाओं से अधिक होने के कारण स्क्रिप्ट ट्रंकेशन को इंगित नहीं करती है।
— ब्रेडबॉक्स
Tio में आपका कोड मेमोरी से केवल 103/45533
— RosLuP
Ideone के बजाय आपका कोड समान इनपुट 103,45533 के लिए रन टाइम एरर में चला जाता है: रनटाइम एरर #stdin #stdout #stderr 0.89s 99264KB
— RosLuP
4

PHP 82 बाइट्स

<?for(fscanf(STDIN,"%d%d",$a,$b);$a;)++$i<$b/$a||printf("$i ",$a=$a*$i-$b,$b*=$i);

इसे कम किया जा सकता है, लेकिन फ्लोटिंग पॉइंट राउंडिंग एरर (वर्तमान अंश को रखने के बजाय) से बचने के लिए वर्तमान संख्या और हर को पूरे संख्या के रूप में रखना आवश्यक है।

नमूना उपयोग:

$ echo 43 48 | php egyptian-fraction.php
2 3 16
$ echo 8 11 | php egyptian-fraction.php
2 5 37 4070
— Primo
स्रोत
कोम्मा संचालक ने छापने के लिए बेकार तर्क के रूप में अनुकरण किया? मुझे इस चाल को कहीं बचाना चाहिए।
— कोनराड बोरोस्की
1
मुझे पूरा यकीन है कि यह एक लालची एल्गोरिथ्म है , इसलिए यह हमेशा अंशों का सबसे छोटा सेट नहीं देगा। यदि आप इसे इनपुट के साथ चलाते हैं जैसे 5 121या 31 311, यह गलत उत्तर देगा (बहुत लंबे समय के बाद)।
— GRC
@grc ३१/३११ -> {a [१] -> ११, एक [२] - ११५, एक [३] -> १३५ ]०, एक [४] -> ४६४२२ ९ }
— ०
4

सी, 163 177 वर्ण

6/6 : अंत में, प्रोग्राम अब सभी मामलों में सही ढंग से ट्रंकेशन को संभालता है। जितना मैं उम्मीद कर रहा था, उससे कहीं ज्यादा चार्म लिया, लेकिन यह इसके लायक था। कार्यक्रम को अब 100% समस्या आवश्यकताओं का पालन करना चाहिए।

d[99],c,z;
r(p,q,n,i){for(c=n+q%p<2,i=q/p;c?d[c++]=i,0:++i<n*q/p;)q>~0U/2/i?c=2:r(i*p-q,i*q,n-1);}
main(a,b){for(scanf("%d%d",&a,&b);!c;r(a,b,++z));while(--c)printf("%d\n",d[c]);}

कार्यक्रम मानक इनपुट पर अंश और हर लेता है। हर एक मानक लाइन के लिए प्रिंट किए गए हैं। ट्रेंकेटेड आउटपुट को सूची के अंत में एक शून्य हर को प्रिंट करके इंगित किया गया है:

$ ./a.out
2020 2064
2
3
7
402
242004

$ ./a.out
6745 7604
2
3
19
937
1007747
0

दूसरे उदाहरण में भाजक 95485142815/107645519046 है, जो लगभग 1e-14 द्वारा 6745/7604 से भिन्न है।

— रोटी का डिब्बा
स्रोत
फिर से, मुझे लगता है कि यह एक लालची एल्गोरिथ्म है।
— GRC
बाहरी लूप N + 1 हर के उत्तर का परीक्षण शुरू करने से पहले N हर के सभी संभावित उत्तरों की खोज करता है। आप इसे लालची कह सकते हैं, मुझे लगता है, लेकिन मेरा मानना ​​है कि यह बताई गई समस्या को पूरा करता है।
— ब्रेडबॉक्स
क्षमा करें, मैं इसे वापस लेता हूं। यह लालची समाधान का पालन नहीं करता है, लेकिन मैंने पाया है कि यह कुछ इनपुट ( 31 311उदाहरण के लिए) के लिए पूरी तरह से सही नहीं है ।
— GRC
31 311ओवरफ्लो होता है, लेकिन प्रोग्राम इसे फ्लैग करने में विफल रहता है।
— ब्रेडबॉक्स
3

पायथन, 61 वर्ण

STDIN से इनपुट, अल्पविराम अलग।
STDOUT में आउटपुट, नईलाइन अलग हो गई।
हमेशा सबसे छोटा प्रतिनिधित्व नहीं लौटाता (उदाहरण के लिए 5/121)।

a,b=input()
while a:
    i=(b+a-1)/a
    print"1/%d"%i
    a,b=a*i-b,i*b

वर्णों को बिना किसी नई सीमा के गिना जाता है (अर्थात whileप्रयोग के भीतर सभी पंक्तियों को मिलाना ;)।
अंश है a/b।
iहै b/a, को गिरफ्तार तो मुझे पता है 1/i <= a/b।
छपाई के बाद 1/i, मैं उसके a/bसाथ प्रतिस्थापित करता हूं a/b - 1/i, जो है (a*i-b)/(i*b)।

— ugoren
स्रोत
मैं, इस वोट बढ़ाने के लिए चाहते हैं, क्योंकि यह है इतना छोटा है, लेकिन यह सिर्फ इतना है कि एक टुकड़ा याद आ रही है!
— गफ्फी
2
मैं इस एक टुकड़े को ठीक करना चाहता हूं, लेकिन तब यह इतना छोटा नहीं होगा ... मुझे लग रहा है कि मैं कीथ रान्डेल के समाधान को फिर से लागू करूंगा।
— ugoren
2

सी, 94 बाइट्स

n,d,i;main(){scanf("%i%i",&n,&d);for(i=1;n>0&++i>0;){if(n*i>=d)printf("%i ",i),n=n*i-d,d*=i;}}

यह ऑनलाइन की कोशिश करो

संपादित करें: कोड का एक छोटा संस्करण टिप्पणियों में पोस्ट किया गया था इसलिए मैंने इसे बदल दिया। धन्यवाद!

— わ わ う わ わ
स्रोत
2
नमस्कार, और साइट पर आपका स्वागत है! यह एक कोड-गोल्फ प्रतियोगिता है, इसलिए इसका उद्देश्य आपके कोड को यथासंभव कम करना है । ऐसा लगता है कि बहुत सारी चीजें हैं जो आप अपने कोड को कम करने के लिए कर सकते हैं। उदाहरण के लिए, आप अपने उत्तर से सभी अनावश्यक व्हाट्सएप को हटा सकते हैं।
— DJMcMayhem
@DJMcMayhem धन्यवाद सर, समझा और किया गया।
— わ 密
नमस्ते, PPCG में आपका स्वागत है! आप शायद चुनौती में परीक्षण मामलों के लिए परीक्षण कोड के साथ एक TryItOnline- लिंक जोड़ सकते हैं ? इसके अलावा, कुछ चीजें जो आप गोल्फ for(i=2;n>0&&i>0;i++)कर सकते हैं : हो सकती हैं for(i=1;n>0&++i>0;); फॉर-लूप के ब्रैकेट्स को हटाया जा सकता है (क्योंकि इसमें केवल ifअंदर है); d=d*i;हो सकता है d*=i;; और मुझे पूरी तरह यकीन नहीं है, लेकिन मुझे लगता है कि #include <stdio.h>बिना रिक्त स्थान के हो सकता है #include<stdio.h>:। ओह, और इसे पढ़ने के लिए दिलचस्प हो सकता है सी में गोल्फ के लिए सुझाव और में गोल्फ के लिए सुझाव <सभी भाषाओं>
— केविन Cruijssen
@KevinCruijssen सुझावों के लिए धन्यवाद।
— わ 密 う
— जोनाथन फ्रेच
0

AXIOM, 753 बाइट्स

L==>List FRAC INT
macro  M(q)==if c<m or(c=m and m<999 and reduce(max,map(denom,q))<xv)then(m:=c;a:=q;xv:=reduce(max,map(denom,a)))
f(x,n)==(y:=x;a:L:=[];c:=0;q:=denom x;q:=q^4;for i in n.. repeat((c:=c+1)>50=>(a:=[];break);1/i>y=>1;member?(1/i,a)=>1;a:=concat(a,1/i);(y:=y-1/i)=0=>break;numer(y)=1 and ~member?(y,a)=>(a:=concat(a,y);break);(i:=floor(1/y))>q=>(a:=[];break));a)
h(x:FRAC INT):L==(a:L:=[];x>1=>a;numer(x)=1=>[x];n:=max(2,floor(1/x));xv:=m:=999;d:=denom x;zd:=divisors d;z:=copy zd;for i in 2..30 repeat z:=concat(z,i*zd);d:=min(10*d,n+9*m);for i in n..d repeat((c:=maxIndex(b:=f(x,i)))=0=>1;c>m+1=>1;M(b);v:=reduce(+,delete(b,1));for j in z repeat((c:=1+maxIndex(q:=f(v,j)))=1=>1;member?(b.1,q)=>1;q:=concat(b.1,q);M(q)));reverse(sort a))

यह विचार अलग-अलग प्रारंभिक बिंदुओं के साथ "लालची एल्गोरिथ्म" लागू होगा, और न्यूनतम लंबाई वाली सूची को बचाएंगे। लेकिन हमेशा यह नहीं होता है कि यह कम से कम अंतर के साथ न्यूनतम समाधान प्राप्त करे: "सरणी A सरणी B से कम होगा यदि केवल और यदि A में B के कुछ तत्व हैं, या यदि A के तत्वों की संख्या B के तत्वों की संख्या के समान है। , A की तुलना में यह B से कम है यदि A का अधिक छोटा तत्व B के अधिक छोटे तत्व की तुलना में बड़ा है। अघोषित और परीक्षण

-- this would be the "Greedy Algorithm"
fracR(x,n)==
   y:=x;a:L:=[];c:=0;q:=denom x;q:=q^4
   for i in n.. repeat
      (c:=c+1)>50   =>(a:=[];break)
      1/i>y         =>1
      member?(1/i,a)=>1
      a:=concat(a,1/i)
      (y:=y-1/i)=0  =>break
      numer(y)=1 and ~member?(y,a)=>(a:=concat(a,y);break)
      (i:=floor(1/y))>q           =>(a:=[];break)
   a

-- Return one List a=[1/x1,...,1/xn] with xn PI and x=r/s=reduce(+,a) or return [] for fail
Frazione2SommaReciproci(x:FRAC INT):L==
    a:L:=[]
    x>1       =>a
    numer(x)=1=>[x]
    n:=max(2,floor(1/x));xv:=m:=999;d:=denom x;zd:=divisors d;z:=copy zd
    for i in 2..30 repeat z:=concat(z,i*zd)
    d:=min(10*d,n+9*m) 
    for i in n..d repeat
        (c:=maxIndex(b:=fracR(x,i)))=0=>1 
        c>m+1                         =>1
        M(b)
        v:=reduce(+,delete(b,1))
        for j in z repeat
              (c:=1+maxIndex(q:=fracR(v,j)))=1=>1
              member?(b.1,q)                  =>1
              q:=concat(b.1,q)
              M(q) 
    reverse(sort a)

(7) -> [[i,h(i)] for i in [1/23,2/23,43/48,8/11,5/121,2020/2064,6745/7604,77/79,732/733]]
   (7)
      1   1      2   1  1      43  1 1  1      8  1 1  1  1
   [[--,[--]], [--,[--,---]], [--,[-,-,--]], [--,[-,-,--,--]],
     23  23     23  12 276     48  2 3 16     11  2 6 22 66
      5    1  1   1      505  1 1 1  1    1
    [---,[--,---,---]], [---,[-,-,-,---,----]],
     121  33 121 363     516  2 3 7 602 1204
     6745  1 1  1  1    1      1       77  1 1 1  1  1   1
    [----,[-,-,--,---,-----,------]], [--,[-,-,-,--,---,---]],
     7604  2 3 19 950 72238 570300     79  2 3 8 79 474 632
     732  1 1 1  1   1    1     1
    [---,[-,-,-,--,----,-----,-----]]]
     733  2 3 7 45 7330 20524 26388
                                                      Type: List List Any
       Time: 0.07 (IN) + 200.50 (EV) + 0.03 (OT) + 9.28 (GC) = 209.88 sec
(8) -> h(124547787/123456789456123456)
   (8)
        1             1                         1
   [---------, ---------------, ---------------------------------,
    991247326  140441667310032  613970685539400439432280360548704
                                     1
    -------------------------------------------------------------------]
    3855153765004125533560441957890277453240310786542602992016409976384
                                              Type: List Fraction Integer
                     Time: 17.73 (EV) + 0.02 (OT) + 1.08 (GC) = 18.83 sec
(9) -> h(27538/27539)
         1 1 1  1  1    1      1        1
   (9)  [-,-,-,--,---,-----,------,----------]
         2 3 7 52 225 10332 826170 1100871525
                                              Type: List Fraction Integer
                     Time: 0.02 (IN) + 28.08 (EV) + 1.28 (GC) = 29.38 sec

संदर्भ और संख्या: http://www.maths.surrey.ac.uk/hosted-sites/R.Knott/Fractions/egyptian.html

कुछ जोड़ने के लिए, यह नीचे न्यूनतम लंबाई वाले अंश को खोजने के लिए अनुकूलित होगा जिसमें अधिकतम भाजक कम है (और जेनरेटर के लिए अनुकूलित नहीं है)

L==>List FRAC INT

-- this would be the "Greedy Algorithm"
fracR(x,n)==
   y:=x;a:L:=[];c:=0;q:=denom x;q:=q^20
   for i in n.. repeat
      (c:=c+1)>1000  =>(a:=[];break)
      1/i>y          =>1
      member?(1/i,a) =>1
      a:=concat(a,1/i)
      (y:=y-1/i)=0  =>break
      numer(y)=1 and ~member?(y,a)=>(a:=concat(a,y);break)
      (i:=floor(1/y))>q           =>(a:=[];break)
   a

-- Return one List a=[1/x1,...,1/xn] with xn PI and x=r/s=reduce(+,a) or return [] for fail
Frazione2SommaReciproci(x:FRAC INT):L==
    a:L:=[]
    x>1       =>a
    numer(x)=1=>[x]
    n:=max(2,floor(1/x));xv:=m:=999;d:=denom x;zd:=divisors d;z:=copy zd; 
    w1:= if d>1.e10 then 1000 else 300; w2:= if d>1.e10 then 1000 else if d>1.e7 then 600 else if d>1.e5 then 500 else if d>1.e3 then 400 else 100;
    for i in 2..w1 repeat(mt:=(i*zd)::List PI;mv:=[yy for yy in mt|yy>=n];z:=sort(removeDuplicates(concat(z,mv)));#z>w2=>break)
    for i in z repeat
        (c:=maxIndex(b:=fracR(x,i)))=0=>1 
        c>m+1                         =>1
        if c<m or(c=m and m<999 and reduce(max,map(denom,b))<xv)then(m:=c;a:=b;xv:=reduce(max,map(denom,a)))
        v:=reduce(+,delete(b,1))
        for j in z repeat
              (c:=1+maxIndex(q:=fracR(v,j)))=1=>1
              member?(b.1,q)                  =>1
              q:=concat(b.1,q)
              if c<m or(c=m and m<999 and reduce(max,map(denom,q))<xv)then(m:=c;a:=q;xv:=reduce(max,map(denom,a)))
    reverse(sort a)

परिणाम:

(5) -> [[i,Frazione2SommaReciproci(i)] for i in [1/23,2/23,43/48,8/11,5/121,2020/2064,6745/7604,77/79,732/733]]
   (5)
      1   1      2   1  1      43  1 1  1      8  1 1  1  1
   [[--,[--]], [--,[--,---]], [--,[-,-,--]], [--,[-,-,--,--]],
     23  23     23  12 276     48  2 3 16     11  2 6 22 66
      5    1  1   1      505  1 1 1  1    1
    [---,[--,---,---]], [---,[-,-,-,---,----]],
     121  33 121 363     516  2 3 7 602 1204
     6745  1 1  1  1    1      1       77  1 1 1  1  1   1
    [----,[-,-,--,---,-----,------]], [--,[-,-,-,--,---,---]],
     7604  2 3 19 950 72238 570300     79  2 3 8 79 474 632
     732  1 1 1  1   1    1     1
    [---,[-,-,-,--,----,-----,-----]]]
     733  2 3 7 45 7330 20524 26388
                                                      Type: List List Any
                     Time: 0.08 (IN) + 53.45 (EV) + 3.03 (GC) = 56.57 sec
(6) -> Frazione2SommaReciproci(124547787/123456789456123456)
   (6)
        1            1               1                  1
   [---------, ------------, ----------------, -------------------,
    994074172  347757767307  2764751529594496  1142210063701888512
                      1
    -------------------------------------]
    2531144929865351036156388364636113408
                                              Type: List Fraction Integer
         Time: 0.15 (IN) + 78.30 (EV) + 0.02 (OT) + 5.28 (GC) = 83.75 sec
(7) -> Frazione2SommaReciproci(27538/27539)
         1 1 1  1   1     1       1       1
   (7)  [-,-,-,--,----,-------,-------,-------]
         2 3 7 43 1935 3717765 5204871 7105062
                                              Type: List Fraction Integer
                     Time: 0.05 (IN) + 45.43 (EV) + 2.42 (GC) = 47.90 sec

ऐसा लगता है कि कई अच्छे भाजक इनपुट अंश भाजक के कारक विभाजक हैं।

— RosLuP
स्रोत
0

सी, 85 78 बाइट्स

@Ceilingcat द्वारा सुधार , 78 बाइट्स:

n,d;main(i){for(scanf("%i%i",&n,&d);n;n*++i/d&&printf("%i ",i,d*=i,n=n*i-d));}

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

मेरा मूल उत्तर, 85 बाइट्स:

n,d,i=1;main(){for(scanf("%i%i",&n,&d);n&&++i;n*i/d?printf("%i ",i),n=n*i-d,d*=i:0);}

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

श्रेय का हिस्सा जोनाथन फ्रेच को जाना चाहिए , जिन्होंने इस 94 बाइट समाधान को लिखा था, जिस पर मैंने सुधार किया।

— OverclockedSanic
स्रोत
0

एपीएल (एनएआरएस), 2502 बाइट्स

fdn←{1∧÷⍵}⋄fnm←{1∧⍵}⋄ffl←{m←⎕ct⋄⎕ct←0⋄r←⌊⍵⋄⎕ct←m⋄r}⋄divisori←{a[⍋a←{∪×/¨{0=≢⍵:⊂⍬⋄s,(⊂1⌷⍵),¨s←∇1↓⍵}π⍵}⍵]}

r←frRF w;x;y;c;q;i;j
(x i)←w⋄i-←1⋄y←x⋄r←⍬⋄c←0⋄q←fdn x⋄q←q*20
i+←1
→4×⍳∼1000<c+←1⋄→6
j←÷i⋄→2×⍳j>y⋄→2×⍳(⊂j)∊r⋄r←r,(⊂j)⋄y←y-j⋄→0×⍳y=0⋄→5×⍳1≠fnm y⋄→5×⍳(⊂y)∊r⋄r←r,⊂y⋄→0
→2×⍳∼q<i←ffl ÷y
r←⍬

r←fr2SumF x;n;xv;m;d;zd;z;i;b;c;t;v;j;k;q;w1;w2;t;b1
z←r←⍬⋄→0×⍳1≤ffl x
:if 1=fnm x⋄r←,⊂x⋄→0⋄:endif
n←2⌈ffl÷x⋄xv←m←999⋄d←fdn x⋄zd←divisori d
w1←1000⋄w2←50⋄:if d>1.e10⋄w2←700⋄:elseif d>1.e7⋄w2←600⋄:elseif d>1.e5⋄w2←500⋄:elseif d>1.e3⋄w2←400⋄:elseif d>1.e2⋄w2←100⋄:endif
:for i :in ⍳w1⋄z←∪z∪k/⍨{⍵≥n}¨k←i×zd⋄:if w2<≢z⋄:leave⋄:endif⋄:endfor
z←∪z∪zd⋄z←z[⍋z]
:for i :in z
    :if 0=c←≢b←frRF x i ⋄:continue⋄:endif
    :if      c>m+1      ⋄:continue⋄:endif
    :if      c<m        ⋄m←c⋄r←b⋄xv←⌈/fdn¨b
    :elseif (c=m)∧(m<999)
         :if xv>t←⌈/fdn¨b⋄m←c⋄r←b⋄xv←t⋄:endif
    :endif
    :if c≤2⋄:continue⋄:endif
    v←↑+/1↓b⋄b1←(⊂↑b)
    :for j :in z
       :if 1=c←1+≢q←frRF v j⋄:continue⋄:endif
       :if        b1∊q      ⋄:continue⋄:endif
       q←b1,q
       :if  c<m⋄m←c⋄r←q     ⋄xv←⌈/fdn¨q
       :elseif (c=m)∧(m<999)
           :if xv>t←⌈/fdn¨q⋄m←c⋄r←q⋄xv←t⋄:endif
       :endif
    :endfor
:endfor
→0×⍳1≥≢r⋄r←r[⍋fdn¨r]

इस समस्या के लिए AXIOM कोड से एपीएल, पहली बार (मेरे लिए) अंश प्रकार (जो कि bignum है ...) का उपयोग करके ट्रैसलेशन।

103r233 का मतलब है अंश 103/233। परीक्षा:

  ⎕fmt fr2SumF 1r23
┌1────┐
│ 1r23│
└~────┘
  ⎕fmt fr2SumF 2r23
┌2──────────┐
│ 1r12 1r276│
└~──────────┘
  ⎕fmt fr2SumF 43r48
┌3────────────┐
│ 1r2 1r3 1r16│
└~────────────┘
  fr2SumF 8r11
1r2 1r6 1r22 1r66 
  fr2SumF 5r121
1r33 1r121 1r363 
  fr2SumF 2020r2064
1r2 1r3 1r7 1r602 1r1204 
  fr2SumF 6745r7604
1r2 1r3 1r19 1r950 1r72238 1r570300 
  fr2SumF 77r79
1r2 1r3 1r8 1r79 1r474 1r632 
  fr2SumF 732r733
1r2 1r3 1r7 1r45 1r7330 1r20524 1r26388 
  fr2SumF 27538r27539
1r2 1r3 1r7 1r43 1r1935 1r3717765 1r5204871 1r7105062 
  fr2SumF 124547787r123456789456123456
1r994074172 1r347757767307 1r2764751529594496 1r1142210063701888512 
  1r2531144929865351036156388364636113408
— RosLuP
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.