Giriş

Bu benim en sevdiğim matematik bulmaca biridir.

Bir basamak (3 diyelim) ve bu basamağı (5 diyelim) kullanma sayısı verildiğinde, yalnızca + kullanarak 1, 2, 3, 4, 5, 6, 7, 8, 9 ve 10 ile sonuçlanan 10 ifade oluşturun, -, ×, ÷, ^ ve √ (kök) (parantezlerin işlemleri gruplandırmasına izin verilir).

Örneğin:

(3^3 + 3)/(3 + 3) = (33 - 3)/(3 + 3) = 3 + 3/3 + 3/3 = 5

Yukarıdakilerin hepsinin beş 3 ve matematiksel işlemleri kullandığını ve 5 ile sonuçlandığını unutmayın. Bir küp kökünü belirtmek için before'dan önce 3 kullanabilirsiniz. Aynı şey, dördüncü bir kökü belirtmek için before'dan önce 4'ü kullanmak için de geçerlidir.

Ayrıca, 33'ü oluşturmak için iki 3'ün kullanılabileceğini veya 333'ü oluşturmak için üç 3'ün kullanılabileceğini unutmayın.

Meydan okuma

• Bir işlev bağımsız değişkeni, STDIN veya komut satırı bağımsız değişkeni olarak iki sayı (her ikisi de 1 ile 5 arasında) verilir .
• İlk sayı hangi basamağın kullanılacağını, ikinci sayı ise bu basamağın ifadede kaç kez kullanılacağını belirtir.
• Programınız, her bir öğenin (index + 1)sayı ile sonuçlanan bir matematiksel ifadenin (sadece izin verilen operatörleri kullanarak) mümkün olup olmadığını göstermesi için bir doğruluk / falsy değeri kullanıp kullanamayacağını belirten 10 (veya boşlukla ayrılmış 10 boyut) bir dizi çıkarmalıdır.

Örneğin, giriş

1 3

Sonra çıktı

[1, 1, 1, 0, 0, 0, 0, 0, 0, 1]

çünkü sadece 1, 2, 3 ve 10 üç 1 kullanılarak ifade edilebilir.

Puan

• Bu bir kod golfüdür, bu nedenle bayt cinsinden minimum kod uzunluğu kazanır.

Bonus

Hepsini yazdır [−50]

Çıktı dizisi öğeleri, (index + 1)doğruluk veya falsi değerleri yerine değeri elde etmek için toplam olası kombinasyon sayısına eşitse puanınızdan 50 çıkarın .

Örneğin, 5'e neden beş 3 's sadece 3 olası kombinasyonları, eğer var ise, çıkış dizisinin 4 ^inci giriş 3 olmalıdır.

Aşırı Matematik [−100]

Çıktı dizisi öğeleri (index + 1)değere neden olan gerçek ifadelerden en az birini içeriyorsa puanınızdan 100 çıkarın .

Örneğin, beş 3 'ler ile, çıkış dizisinin 4 ^inci girişi de olabilir (3^3 + 3)/(3 + 3), (33 - 3)/(3 + 3)ya da3 + 3/3 + 3/3

Aşırı doldu [−200]

Çıkış dizisi öğeleri olası tüm kombinasyonları içeriyorsa (ile ayrılmış |) 200'ü puanınızdan çıkarın . Bu bonus Ekstrem Matematik bonusunun üstüne eklenir , böylece toplamda −300 elde edersiniz.

Örneğin, beş 3 'ler ile, çıkış dizisinin 4 ^inci unsuru olmalıdır(3^3 + 3)/(3 + 3)|(33 - 3)/(3 + 3)|3 + 3/3 + 3/3

Not: Aynı sonucu elde etmek için her iki ifade, her ikisinde de farklı bir yaklaşımla mantıksal olarak farklı olmalıdır.

Örneğin, beş 3 ait kullanılarak 5 almak için, 3 + 3/3 + 3/3aynı 3/3 + 3 + 3/3veya 3/3 + 3/3 + 3aynı yaklaşım her biri için alınır çünkü. (3^3 + 3)/(3 + 3)ve (33 - 3)/(3 + 3)paydaki 30 farklı yaklaşımlarla elde edildiği için farklılık gösterir.

GÜNCELLEME : Tüm cevaplardan geçtikten sonra, tekli -ve edge uç vakalar nedeniyle tüm cevapların kusurları olduğu bulunmuştur . Bu nedenle, cevapların bütünlüğü söz konusu olduğunda, bu uç davaları kaçırmak iyi kabul edildi.

Bu zor bir soru, ama oldukça ilginç bir soru.

Mutlu golf!

Python 3 (kusurlu), 449-300 = 149

KSab'ın çözümü ile aynı eksikliklerden muzdariptir : tamamen parantez içinde olan tekli operatörler (1+1)+1ve gibi eşdeğer ifadeler içermez 1+(1+1). Sonuçları kopyalayarak tam kopyaları ortadan kaldırdım set(). Çıktı birkaç bayt kaydetmek için biraz daha çirkin olabilir, ama bu şekilde beğendim. Ayrıca nth kökleri yapmadım çünkü bu problemde sizi çok satın alıyor gibi görünmüyor.

R=range
E=lambda z:eval(z.replace("^","**"))
def m(d,n):_=R(1,11);s={i:[]for i in _};r=R(1,n);n<2 and s[d].append(str(d));d=str(d);t=[[(d*i,i)for i in r]]+[[]]*n;h=[];[(h.append("("+A+o+B+")"),t[l].append((h[0],a+b))if a+b<n else E(*h)in _ and s[E(*h)].append(h[0]),h.pop())for l in r for j in R(l)for A,a in t[j]for k in R(l)for B,b in t[k]if a+b<=n for o in"+-*/^"if(o=="^"and-~-(0<E(B)<9)or 0==E(B)and"/"==o)-1];[print(i,set(s[i])or'')for i in _]

Bu ikinci argüman 5. Testi arayarak ise çalıştırmak için birkaç dakika sürecektir m(digit, number):

>>> m(1,3)
1 {'((1*1)^1)', '(1^(1+1))', '((1-1)+1)', '((1/1)/1)', '((1*1)*1)', '((1^1)/1)', '(1*(1*1))', '(1^(1*1))', '(1+(1-1))', '(1^(1^1))', '((1^1)*1)', '(1^(1/1))', '((1/1)*1)', '(1-(1-1))', '(1/(1^1))', '(1/(1*1))', '(1/(1/1))', '(1*(1^1))', '((1+1)-1)', '((1*1)/1)', '((1^1)^1)', '(1*(1/1))', '((1/1)^1)'}
2 {'(1*(1+1))', '((1^1)+1)', '((1+1)/1)', '((1*1)+1)', '((1+1)^1)', '(1+(1*1))', '((1/1)+1)', '(1+(1^1))', '(1+(1/1))', '((1+1)*1)'}
3 {'((1+1)+1)', '(1+(1+1))'}
4 
5 
6 
7 
8 
9 
10 {'(11-1)'}
>>> m(3,3)
1 {'((3/3)^3)'}
2 {'(3-(3/3))', '((3+3)/3)'}
3 {'(3-(3-3))', '((3-3)+3)', '((3/3)*3)', '(3*(3/3))', '(3/(3/3))', '((3+3)-3)', '(3^(3/3))', '(3+(3-3))', '((3*3)/3)'}
4 {'((3/3)+3)', '(3+(3/3))'}
5 
6 {'((3*3)-3)'}
7 
8 
9 {'(3+(3+3))', '((3+3)+3)', '((3^3)/3)'}
10 

Python (kusurlu) 493474-300 = 174

Bu çözümle ilgili çok sayıda sorun vardır, ilk olarak çok büyük olan herhangi bir üsse (üssün 100'den büyük olduğu herhangi bir üs) yoksayar. Aslında bunun 5 veya daha küçük girdiler için herhangi bir olasılığı ortadan kaldırdığını düşünmüyorum, ancak% 100 emin değilim.

Başka bir şey, karmaşık olacağı için herhangi bir tek kare kökü dikkate almamasıdır (0 veya 1'e eşit herhangi bir terimi olan herhangi bir çözüm, sonsuz sayıda çözüm üretecektir). Aynı nedenden dolayı herhangi bir tekli olumsuzlama ('-' sembolü) ve sorunun sorulup sorulmadığından gerçekten emin olmadığım gerçeğini dikkate almaz.

Ayrıca, iki ifadenin eşdeğer olup olmadığına hangi kriterlerin karar vermesi gerektiğini düşündüm, ancak bunu sezgisel bulduğum bir şekilde titizlikle tanımlamanın bir yolunu bulamadım, bu yüzden (en azından şimdilik) böyle bir şey uygulamadım. Bu, oldukça az sonuç çıkardığı anlamına gelir ve parantezleri de oldukça naif bir şekilde kullanır.

Bir yan not, bu özellikle tamamen golfe önce yazdım, en uzun tek satır satır içerebilir düşünüyorum.

R=range
F=lambda s:lambda a,b:eval(s)
L=lambda D,N:[(int(str(D)*N),str(D)*N)]+[(o(u,v),"(%s%s%s)"%(s,c,t))for p in R(1,N)for u,s in L(D,p)for v,t in L(D,N-p)for c,o in[('+',F('a+b')),('-',F('a-b')),('*',F('a*b')),('/',F("1.*a/b if b else''")),('^',F("''if(a<0 and int(b)!=b)|(a and b<0)|(b>99)else a**b")),('v',F("b**(1./a)if a and(a>=0 or b)and(b>=0 or int(1./a)==1./a)&(1./a<99)else''"))]if o(u,v)!='']
A=L(*input())
for i in R(11):
 for v,s in A:
    if v==i:print i,s[1:-1]

Örnek: ('v' '√' yi temsil eder)

2,3

0 2*(2-2)
0 2v(2-2)
0 (2-2)*2
0 (2-2)/2
0 (2-2)^2
1 2^(2-2)
1 2-(2/2)
1 2v(2/2)
1 (2/2)^2
2 2v(2+2)
2 2+(2-2)
2 2-(2-2)
2 2v(2*2)
2 2*(2/2)
2 2/(2/2)
2 2^(2/2)
2 2v(2^2)
2 (2+2)-2
2 (2+2)/2
2 (2-2)+2
2 (2*2)-2
2 (2*2)/2
2 (2/2)*2
2 (2/2)v2
2 (2^2)-2
2 (2^2)/2
3 2+(2/2)
3 (2/2)+2
6 2+(2+2)
6 2+(2*2)
6 2+(2^2)
6 (2+2)+2
6 (2*2)+2
6 (2^2)+2
8 2*(2+2)
8 2*(2*2)
8 2*(2^2)
8 (2+2)*2
8 (2*2)*2
8 (2^2)*2

Python 3 - 349 346

r=range
l=lambda s:eval("lambda a"+s)
def T(u,f,X,Y):
    try:return u(f(X,Y))
    except:0
c=l(',x:{x}.union(*[{u(int("1"*a)*x)}|{T(u,f,X,Y)for j in r(1,a)for X in c(j,x)for Y in c(a-j,x)for f in[l(",b:a%sb"%o)for o in{"**"}|set("+-*/")]+[l(",b:a**b**-1")]}for u in[l(":-a")]+[l(":a**.5**%i"%k)for k in r(9)]])')
R=l(",i:[{n+1}<c(i,a)for n in r(10)]")

İşte oldukça ungolfed versiyonu:

def R(x,i):
    # Unary Operations
    U = [lambda a:-a] + [eval("lambda a:a**(1/2.**%i)" % j) for j in range(9)]
    # Binary Operations
    F = [eval("lambda a,b:a%sb"%o) for o in ["+","-","*","/","**"]] + [lambda a,b:a**(1./b)]

    def combos(i):
        L = {x}
        for u in U:
            # 3, 33, 333, etc.
            L |= {u(int(str(x)*i))}

            for j in range(1,i):
                for X in combos(j):
                    for Y in combos(i-j):
                        for f in F:
                            # To avoid trouble with division by zero, overflows and similar:
                            try:
                                L |= {u(f(X,Y))}
                            except:
                                pass
        return L

    return [n in combos(i) for n in range(1,11)]

Test (9)için daha küçük bir şeye geçmenizi tavsiye ederim , çünkü bu dikkate alınan çoklu kare köklerin sayısıdır, bu da performans üzerinde büyük bir etkiye sahiptir.

Son olarak, bu, tek bir durumda tekli eksi gerçekten gerekip gerekmediğini merak etti ...

Mathematica - 246 karakter (bonus talep edilmedi)

f[x_,y_]:=x-y
g[x_,y_]:=x/y
h[x_,y_]:=x^(1/y)
j[x_,y_]:=FromDigits@Join[IntegerDigits@x,{y}]
z[{r_,n_,L_}]:=z[{L[[1]][r,n],n,Rest@L}]
z[{r_,n_,{}}]:=r
a[n_,t_]:=Union@Select[z[{n,n,#}]&/@Tuples[{Plus,f,Times,g,Power,h,j},t-1],IntegerQ@#&&0<#<11&]

açıklama

Fonksiyon jiki sayıyı rakamsal olarak birleştirir.

İşlev , her biri iki bağımsız değişken üzerinde çalışan zbir sonuç r, sayı nve işlev listesi alır L. Daha sonra, liste boşalana [r,n]kadar sonuç listesini döndüren özyineleme kullanarak argümanlara sırayla işlev listesini uygular .

İşlev abir sayı nve birkaç kopya alır t. Tüm uzunluk gruplarını (t-1) işlevler listesinden oluşturur {Plus, f, Times, g, Power, h, j}ve her bir diziyi z işleviyle gönderir, sonra oluşturulan 1 ile 10 arasındaki tüm sayıların listesini döndürür.

Örnek yürütme a[2,3]dönen {1, 2, 3, 6, 8}.

Sınırlamalar

İşlevler listesi sırayla uygulandığından, her seferinde sayının bir kopyasını tüketerek, bazı kombinasyonları kaçırabilir. Örneğin, dört ikişer ikişer çalıştığında, işlevlerin listesini bozuk olarak değerlendirememesi nedeniyle 22/22 = 1'i özleyecektir. Tabii ki, 2/2 * 2/2 = 1 bu durumu kapsar.