भिन्नों को कम करने के लिए कैसे नहीं

Question

भिन्नों को कम करना गलत तरीका है

इस कोड-गोल्फ चुनौती में आपको ऐसे अंश ढूंढने होंगे जो गलत तरीके से कम हो सकते हैं लेकिन फिर भी एक ही संख्या में समाप्त हो सकते हैं।

नोट: भिन्नों को कम करने से गलत तरीके से यहां एक सटीक परिभाषा होती है, विवरण देखें।

उदाहरण:

64/16 = 6 4/1 6 = 4/1 = 4

बेशक आप दोनों 6es पर हमला नहीं कर सकते हैं, लेकिन यहां आप अभी भी सही मूल्य के साथ समाप्त होते हैं। इस चुनौती में आपको इस तरह के उदाहरण खोजने होंगे।

विवरण

आपको एक फ़ंक्शन / प्रोग्राम लिखना होगा जो nइनपुट और आउटपुट के रूप में एक सकारात्मक पूर्णांक को स्वीकार करता है / प्रारूप में भिन्नता की एक सूची / सरणी देता है।
numerator1,denominator1,numerator2,denominator2,...

कार्यक्रम के a/bसाथ प्रत्येक अंश के लिए पता लगाना है a+b=nऔर a,b>0क्या इसे गलत तरीके से कम किया जा सकता है । (इससे कोई फर्क नहीं पड़ता कि क्या इसे पारंपरिक तरीके से कम किया जा सकता है या क्या इसमें कटौती की बहुत संभावनाएं हैं या नहीं, बस इसे गलत तरीके से कम करना संभव है कम से कम एक तरीके से ।)

गलत तरीके की परिभाषा : एक अंश को गलत तरीके से कम किया जा सकता है यदि और केवल यदि क्रमिक अंकों का एक ही क्रम बी और बी में दिखाई देता है यदि अंश हटाए जाने पर अंश का मान समान रहता है।

उदाहरण: 1536/353 को 16/3 पर 'कम' किया जा सकता है, लेकिन वे दो मूल्य समान नहीं हैं, इसलिए आप इस अंश को गलत तरीके से कम नहीं कर सकते हैं ।

ध्यान दें कि गलत तरीके से कम करने की इस परिभाषा में वे अंश भी शामिल हो सकते हैं जो सही तरीके से कम हो जाते हैं: गलत तरीके110/10 = 11/1 से कम करने की परिभाषा के भीतर भले ही यह एक वैध कदम हो।

स्कोरिंग

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

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

कृपया निम्नलिखित टेस्टकेस शामिल करें (मुझे बताएं कि मुझे किन लोगों को जोड़ना चाहिए, मुझे नहीं पता कि उनमें से कितने अंश हैं / उम्मीद करने के लिए कितने उदाहरण हैं)

n=80 (64/16 should be in this list)
n=147 (98/49 should be in this list)
n=500 (294/196 should be in this list) WRONG since 294+196 != 500 Thanks Falko

Comments

"गलत तरीके" के लिए एक शब्द को परिभाषित करने पर विचार करें, जैसे "नासमझ" या "अजीब"। मुझे लगता है कि पोस्ट को समझना आसान होगा, क्योंकि पाठकों ने तुरंत कहा कि इस पद के लिए एक परिभाषा होनी चाहिए।

— माइकल ईस्टर

क्या होगा अगर एक अंश को कम करने के कई तरीके हैं और केवल उनमें से कुछ गलत हैं? 1010/10 = 101/1 && 1010/10 /= 110/1

— जॉन ड्वोरक

Projecteuler.net/problem=33 का वेरिएंट ?

— user80551

आपका दूसरा परीक्षण मामला ( n=147) गलत है 49/89 != 4/8:।

— बीटा डिके

यदि एक अंश को कम करने का एक से अधिक तरीका है, तो क्या हम इसे परिणाम सेट में कई बार शामिल कर सकते हैं?

— जॉन ड्वोरक

Answer 1

अजगर 2 - 183 180

r=range
s=lambda a:[(a[i:j],int(a[:i]+a[j:]))for i in r(len(a))for j in r(i+1,len(a)+(i>0))]
l=sum([[a,n-a]for a in r(n)for p,x in s(`a`)for q,y in s(`n-a`)if(n-a)*x==a*y<p==q],[])

इनपुट को स्टोर किया जाना चाहिए n, आउटपुट को स्टोर किया जाएगा l।

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

n = 80:

[10, 70, 16, 64, 20, 60, 30, 50, 40, 40, 40, 40, 50, 30, 60, 20, 64, 16, 70, 10]

n = 147:

[49, 98, 98, 49]

n = 490:

[10, 480, 20, 470, 30, 460, 40, 450, 50, 440, 60, 430, 70, 420, 80, 410, 90, 400, 90, 400, 98, 392, 100, 390, 100, 390, 110, 380, 120, 370, 130, 360, 140, 350, 150, 340, 160, 330, 170, 320, 180, 310, 190, 300, 190, 300, 196, 294, 200, 290, 200, 290, 210, 280, 220, 270, 230, 260, 240, 250, 245, 245, 245, 245, 245, 245, 245, 245, 245, 245, 250, 240, 260, 230, 270, 220, 280, 210, 290, 200, 290, 200, 294, 196, 300, 190, 300, 190, 310, 180, 320, 170, 330, 160, 340, 150, 350, 140, 360, 130, 370, 120, 380, 110, 390, 100, 390, 100, 392, 98, 400, 90, 400, 90, 410, 80, 420, 70, 430, 60, 440, 50, 450, 40, 460, 30, 470, 20, 480, 10]

---

आउटपुट में डुप्लिकेट को निषिद्ध किया जाना चाहिए, इसे 10 वर्ण लंबा हो जाता है:

r=range
s=lambda a:[(a[i:j],int(a[:i]+a[j:]))for i in r(len(a))for j in r(i+1,len(a)+(i>0))]
l=sum(map(list,{(a,n-a)for a in r(n)for p,x in s(`a`)for q,y in s(`n-a`)if(n-a)*x==a*y<p==q}),[])

Answer 2

हास्केल, 207 206 (209?) वर्ण

import Data.List
x![]=[x];(w:x)!(y:z)|w==y=x!z;_!_=[]
a@(w:x)%b=a!b++[w:e|e<-x%b];a%b=a!b
h=show
f n=[(c,n-c)|c<-[1..n-1],i<-inits$h c,s<-init$tails i,s/=h c,a<-h c%s,b<-h(n-c)%s,read a*(n-c)==read('0':b)*c]

यदि एक ही अनुपात (400/400 = 40/40 = 4/4) से अधिक वापस करने की अनुमति नहीं है, तो f n=nub[...उन्हें फ़िल्टर करने के लिए उपयोग करें।

जोड़े की सूची लौटाता है। दो-तत्व जोड़े की एक सूची समान है। वास्तविक अंशों की एक सूची को आयात करने Data.Ratioया पूरी तरह से योग्य बनाने की आवश्यकता होगी Data.Ratio.%(जो %यहां परिभाषित फ़ंक्शन से भी टकराता है)

परीक्षण मामलों (साथ nub):

Prelude Data.List> f 80
[(10,70),(16,64),(20,60),(30,50),(40,40),(50,30),(60,20),(64,16),(70,10)]
Prelude Data.List> f 147
[(49,98),(98,49)]
Prelude Data.List> f 500
[(10,490),(20,480),(30,470),(40,460),(50,450),(60,440),(70,430),(80,420),(90,410
),(100,400),(110,390),(120,380),(130,370),(140,360),(150,350),(160,340),(170,330
),(180,320),(190,310),(200,300),(210,290),(220,280),(230,270),(240,260),(250,250
),(260,240),(270,230),(280,220),(290,210),(300,200),(310,190),(320,180),(330,170
),(340,160),(350,150),(360,140),(370,130),(380,120),(390,110),(400,100),(410,90)
,(420,80),(430,70),(440,60),(450,50),(460,40),(470,30),(480,20),(490,10)]

अपुष्ट और टिप्पणी :

import Data.List

-- haystack ! needle - the haystack with the needle removed, wrapped in a single-element list
--                       or an empty array if the haystack does not start with the needle

x ! [] = [x]                        -- case: empty needle = match with the full haystack left
(h:hs) ! (n:ns) | h == n = hs ! ns  -- case: needle and haystack match
_ ! _ = []                          -- case: no match

-- haystack % needle - the haystack with the needle removed 
--                       for all positions of the needle in the haystack

a@(h:hs) % b = a ! b ++ map (h:) (hs%b) -- either remove the needle here, or elsewhere
a % b = a                               -- empty haystack cannot be popped

-- f - the function we are interested in

f total = [ (num, total - num) 
          | num   <- [1 .. total-1],            -- for each numerator in range
            i     <- inits $ show num,          -- for each postfix of the numerator
            sub   <- init $ tails i,            -- for each prefix of the postfix except the last (empty) one
            sub /= show num,                    -- that isn't equal to the numerator
            reNum <- show num % sub,            -- remove the substring from the numerator
            reDiv <- show (total - num) % sub,  -- as well as from the denominator.

                                                -- the resulting ratios must be equal by value:
            (read reNum) ^ (total - num) == (read '0':reDiv) * num]

Comments

क्या तुम बदल सकते हो ';' newlines (गोल्फ कोड में)? यह बाइट की गिनती को नहीं बदलता है और यह कोड को अधिक पठनीय बनाता है

— गर्व हैकर सेपर

@proudhaskeller यह जानबूझकर किया गया है; मुझे गॉल्फर्ड कोड में कम लाइनें पसंद हैं। इसके अलावा, लाइन की लंबाई इस तरह से अधिक संतुलित है। क्या आपको लगता है कि मुझे बदलना चाहिए?

— जॉन डावरक

जो आप चाहते हैं, करें, लेकिन मैं चाहूंगा कि लाइनें फैल जाएं, इसलिए मैं कोड को बेहतर तरीके से पढ़ सकूंगा (बल्कि तब असंबद्ध कोड का सहारा ले रहा हूं)

— गर्वित हेकलर

क्या आप वर्तमान संस्करण के साथ ठीक हैं? मैं अंतिम पंक्ति को नहीं बाँट सकता, दुर्भाग्य से (रिक्त स्थान को छोड़कर, जो पठनीयता को मार देगा)

— जॉन ड्वोरक

जैसा कि मैंने कहा, जो कुछ भी आपको अच्छा लगता है

— गर्वित हेकेलर

Answer 3

अजगर 2 - 236

n=input()
r=range
f=float
l=len
for a in r(n):
 A=`a`;B=`n-a`
 for i in r(l(A)):
  for j in r(i+1,l(A)+1):
   for u in r(l(B)):
    C=A[:i]+A[j:];D=B[:u]+B[u+j-i:]
    if A[i:j]==B[u:u+j-i]and l(C)*l(D)and f(C)==f(A)/f(B)*f(D):print A,B

Answer 4

अजगर 3 - 302

नोट: पार्सिंग कठिनाइयों के कारण, 0 में नंबर के साथ कोई भिन्न नहीं होते हैं (इसलिए सही विधि का उपयोग करके कोई अंशों की गणना नहीं की जाती है)।

n=int(input());s=str;r=range
print([[a,b]for a in r(1,n)for b in r(1,a)for i in r(1,n)if i!=a and i!=b and s(i)in s(a)and s(i)in s(b)and s(a).count(s(i))<len(s(a))and s(b).count(s(i))<len(s(b))and not'0'in s(a)and not'0'in s(b)and eval(s(a).replace(s(i),'')+'/'+s(b).replace(s(i),''))==a/b and a+b<=n])

N = 80 के साथ:

[[64, 16]]

N = 147 के साथ

[[64, 16], [65, 26], [95, 19], [98, 49]]

एन = 500 के साथ

[[64, 16], [65, 26], [95, 19], [98, 49], [136, 34], [192, 96], [194, 97], [195, 39], [196, 49], [196, 98], [231, 132], [238, 34], [238, 136], [242, 143], [253, 154], [264, 165], [268, 67], [275, 176], [286, 187], [291, 97], [291, 194], [294, 49], [294, 98], [294, 196], [295, 59], [297, 198], [298, 149], [325, 13], [341, 143], [345, 138], [392, 49], [392, 98], [395, 79]]

Comments

के लिए n=80इस प्रिंट [[64, 16], [65, 26]], लेकिन स्पष्ट रूप से 65 + 26 = 91 > 80।

— इंगो बुर्क

सभी शर्तों को जोड़ने के साथ सभी ifएस को एक बड़े में बदल दें ? मुझे लगता है कि काफी कुछ बचा है। ifand

— सोहम चौधरी

@Soham हाँ, यह करता है, धन्यवाद!

— बीटा डिके

क्या आप मेरे द्वारा जोड़े गए टेस्टकेस को भी शामिल कर सकते हैं? (और क्या आप शायद देख सकते हैं कि अगर आपको कुछ दिलचस्प परीक्षण मामले मिलते हैं जो मुझे भी जोड़ना चाहिए?)

— 16:14

कहाँ हैं 10/70, 20/60और 30/50?

— जॉन डेवोरक