Kesirleri yanlış şekilde azaltmak

Bu kod golf mücadelesinde yanlış şekilde azaltılabilen ancak yine de aynı sayıya ulaşabilen kesirler bulmak zorundasınız.

Not: Kesirleri yanlış şekilde azaltmak burada tam bir tanımlamaya sahiptir, ayrıntılara bakın.

Misal:

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

Tabii ki her iki 6'yı da vuramazsınız ama burada hala doğru değerle sonuçlanırsınız. Bu meydan okumada bunun gibi örnekler bulmalısınız.

ayrıntılar

nGirdi olarak bir pozitif tamsayıyı kabul eden ve çıktılar halinde / kesirlerin bir listesini / dizisini format olarak döndüren bir işlev / program yazmanız gerekir
numerator1,denominator1,numerator2,denominator2,...

Program, her kesir a/biçin a+b=nve yanlış şekildea,b>0 azaltılıp azaltılamayacağını bulmalıdır . (Konvansiyonel şekilde azaltılabilir mi, yoksa çok sayıda azaltma olasılığı olup olmadığı önemli değil, sadece en az bir şekilde yanlış şekilde azaltmak mümkün olmalıdır .)

Tanımı hatalı bir şekilde: bir kısmı azaltılabilir yanlış bir şekilde , ancak ve ancak, a ve b ardışık basamak göründüğünü aynı sıra ve sen substring kaldırmak fraksiyon kalır değeri aynı ise.

Örnek: 1536/353, 16 / 3'e 'indirgenebilir' ancak bu iki değer eşit değildir, bu nedenle bu kesri yanlış şekilde azaltamazsınız .

Yanlış yolu azaltma tanımının , doğru şekilde azaltılmış kesirler de içerebileceğini unutmayın: geçerli bir adım olsa bile yanlış yolu110/10 = 11/1 azaltma tanımı dahilindedir .

puanlama

En az bayt sayısı kazanır. Bir tamsayıyı kabul eden ve stdin / stdout kullanan bir dizi veya program döndüren bir işlev veya program yazabilir veya bir değişkene n kaydedilmiş olduğunu ve programın sonunda listenin başka bir değişkene kaydedilmesi gerektiğini düşünebilirsiniz.

Test senaryoları

Lütfen aşağıdaki test vakalarını ekleyin (Hangisini eklemem gerektiğini söyle, bu kesirlerden kaç tanesinin olduğunu / kaç örnek beklediğini bilmiyorum)

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

Python 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],[])

girişin depolanması gerekir n, çıkış depolanır l.

Test senaryoları:

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]

Çıktıda kopyalar yasaklanırsa, 10 karakter daha uzun olur:

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}),[])

Haskell, 207 206 (209?) Karakter

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]

Aynı oranın birden fazla döndürülmesine izin verilmiyorsa (400/400 = 40/40 = 4/4), f n=nub[...filtrelemek için kullanın .

Çiftlerin bir listesini döndürür. İki elemanlı çiftlerin listesi aynıdır. Gerçek kesirlerin bir listesi içe aktarmayı Data.Ratioveya tam olarak nitelendirmeyi gerektirir Data.Ratio.%(bu da %burada tanımlanan işlevle çakışır )

test senaryoları (ile 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)]

ungolfed ve yorumladı :

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]

Python 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

Python 3-302

Not: Ayrıştırma zorlukları nedeniyle, 0 rakamlı kesir yoktur (bu nedenle doğru yöntem kullanılarak kesir hesaplanmaz).

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 ile:

[[64, 16]]

N = 147 ile

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

N = 500 ile

[[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]]