Arka fon

Bu bulmaca dört ayak bulmaca bir varyasyon (kendisi geçmiş bir sorunun konusu ). Bu bulmaca gibi, amaç sadece dört basamak ve belirli matematiksel operatörleri kullanarak farklı tam sayılar için matematiksel ifadeler bulmaktır. Ancak bu durumda izin verilen rakamlar sadece 2, 0, 1 ve 5'tir . Her biri çözeltide ve doğru sırada tam olarak bir kez görünmelidir. Şaşırtıcı bir şekilde birçok tam sayı bu şekilde temsil edilebilir. Çözücüler, garip bir şekilde eğlenceli olduğu için önce elle çözmeyi denemeye teşvik edilir.

kurallar

Sabitler tekli veya çoklu basamaklardan oluşturulabilir:

• Tamsayılar: örneğin 2, 0, 15 vb.
• Ondalık Sayılar: örneğin .2, .01, 1.5 vb.
• Tekrarlanan ondalık sayılar : örneğin .2 ~ (= 0.222 ...), .15 ~ (= 0.1555 ...), 20.15 ~~ (= 20.1515 ...)

Aşağıdaki tekli işlemlere izin verilir:

• Tekli olumsuzlama: -x
• Karekök: sqrt (x)
• Tamsayı faktöriyeli: x!

Aşağıdaki ikili işlemlere izin verilir:

• Standart aritmetik işleçler: x + y, xy, x * y ve x / y
• Rasgele üs: x ^ y
• Keyfi kökler: rt [x] (y) (= y'nin x'inci kökü)

Görev

Programınız, 0 ile 100 arasındaki tamsayıların olabildiğince çok sayıda ifadesini yazdırmalı ve ardından ürettiği ifadelerin sayısını çıkarmalıdır.

• Çözeltiler n = [ifade] formatında sırayla yazdırılmalıdır.
• İfadeler bu sırayla her biri bir kez olmak üzere 2, 0, 1, 5 basamaklarını kullanmalıdır.
• İfadeler, yukarıda açıklanan gösterim kullanılarak yazdırılmalıdır. Boşluk gibi gereksiz parantezlere izin verilir ancak zorunlu değildir. Operatör önceliği sırası, tek taraflı olumsuzlama, faktöriyel, üs alma, çarpma / bölme ve toplama / çıkarmadır.
• Programın tüm sayılar için çözüm getirmesi gerekmez. Bu nedenle, yalnızca 0 çıktısı alan bir program geçerlidir; ancak, aşağıdaki puanlama bölümüne bakın.
• Program modern bir bilgisayarda 15 dakikadan az bir sürede çalışmalıdır.

Bir program veya işlev yazabilirsiniz. İfadeler STDOUT'a (veya en yakın alternatife) yazdırılmalıdır. İfade sayısı STDOUT'a yazdırılabilir veya bir tamsayı olarak döndürülebilir. Standart kod golf kısıtlamaları geçerlidir.

Örnek çıktı

0=2*0*1*5
10=20*1*.5
42=((2+0!)!+1)!/5!
100=20*1*5
4

puanlama

Güncelleme : @orlp skorlama sisteminde bir hata olduğunu kaydetti. Bunun nasıl düzeltilip düzeltilmeyeceği veya gerekip gerekmediği hakkında bir tartışma için bkz. Http://meta.codegolf.stackexchange.com/questions/5106/way-of-salvaging-two-zero-one-five-puzzle-challenge .

Çözümler önce ürettikleri ifade sayısına ve ardından bayt cinsinden kod uzunluklarına göre puanlanır . Bu nedenle, 80 sonuç üreten 1000 baytlık bir program, yalnızca 79 üreten 100 baytlık bir programı geçecektir (ikincisi eksik sonuçları içerecek şekilde genişletilebilir).

Motive edici bir hedef isteyenler için, aşağıda temsil edilebilecek ifade sayısı üzerinde bir alt sınır vardır. Bir giriş göndermeyi planlamıyorum, bu yüzden daha azıyla kazanmak mümkün olabilir!

En az 85 (101 üzerinden), ancak daha yüksek olabilir.

sayı tahtası

Ek bir teşvik olarak, puan ilerlemesinin bir özeti burada. En yüksek puanı geçtiğinizde, kendinizi masanın tepesine eklemekten çekinmeyin (veya başka birinden isteyin).

• 0 ifade, 1 bayt (Pyth): 0 çıktısı alan uygulama

85, ~ 2400 bayt

Ben bu yazacağım şimdi önceki tüm çabalarım oldukça yararsız olduğunu hissediyorum, bu bir kod golf meydan biraz üzgünüm:

  0 = ((2*0)^15)
  1 = ((2^0)^15)
  2 = (2-(0^15))
  3 = (20*.15)
  4 = (20*(1/5))
  5 = (20-15)
  6 = ((.20+1)*5)
  7 = ((20*.1)+5)
  8 = (2*((0-1)+5))
  9 = ((.20/.1~)*5)
 10 = (20/(1/.5))
 11 = ((((2-0)+1))!+5)
 12 = (20*(.1+.5))
 13 = ((-(2)-0)+15)
 14 = (20-(1+5))
 15 = ((2*0)+15)
 16 = ((2^0)+15)
 17 = ((2-0)+15)
 18 = (20-(1/.5))
 19 = (20-(1^5))
 20 = (20^(1^5))
 21 = (20+(1^5))
 22 = (20+(1/.5))
 23 = (((2-0)/.1~)+5)
 24 = ((20-1)+5)
 25 = ((20^1)+5)
 26 = ((20+1)+5)
 27 = (rt[.2](((0)!+1))-5)
 28 = (2*(-((0)!)+15))
 29 = ((((2+(0)!)+1))!+5)
 30 = ((2-0)*15)
 31 = (20+sqrt((1+(5)!)))
 32 = ((20*.1)^5)
 33 = ((.2^-((0)!))/.15~~)
 34 = (2+(((0)!+1)^5))
 35 = (20+15)
 36 = (20*(1/.5~))
 37 = (rt[.2](((0)!+1))+5)
 38 = ((20-1)/.5)
 39 = (-((2^0))+(sqrt(.1~)*(5)!))
 40 = (20*(1/.5))
 41 = (((.2~^-((0)!))/.1~)+.5)
 42 = ((20+1)/.5)
 43 = (-(2)+(((0)!/.1~)*5))
 44 = (20+((-(1)+5))!)
 45 = (20/(1-.5~))
 46 = ((.2+((0)!/.1~))*5)
 47 = (2+(((0)!/.1~)*5))
 48 = (2*(((0-1)+5))!)
 49 = ((((2+(0)!))!/.1~)-5)
 50 = (((2^0)/.1)*5)
 51 = ((.2+((0)!/.1))*5)
 52 = (2+(((0)!/.1)*5))
 54 = (((2+(0)!)/.1)/.5~)
 55 = ((2+((0)!/.1~))*5)
 56 = (((.2-(0)!)+sqrt(.1~))*-((5)!))
 58 = (-(2)+sqrt((((((0)!/sqrt(.1~)))!)!*5)))
 59 = ((((2+(0)!))!/.1~)+5)
 60 = (20/(.1~^.5))
 62 = (2*(-((0)!)+sqrt(rt[-(.1)](.5))))
 64 = ((2-0)^(1+5))
 65 = ((20/sqrt(.1~))+5)
 66 = ((-(((2+(0)!))!)/.1~)+(5)!)
 67 = (((((2+(0)!))!)!*.1)-5)
 69 = ((2^(((0)!/sqrt(.1~)))!)+5)
 70 = (((.2^-((0)!))/-(.1))+(5)!)
 72 = ((2+(0)!)*((-(1)+5))!)
 75 = ((.2^-((0)!))*15)
 76 = (rt[(-(2)^-((0)!))](.1~)-5)
 77 = (((((2+(0)!))!)!*.1)+5)
 78 = (2*(-((0)!)+(sqrt(.1~)*(5)!)))
 80 = (-(20)*(1-5))
 81 = (201-(5)!)
 82 = (2*((0)!+(sqrt(.1~)*(5)!)))
 84 = (((.2-(0)!)+.1)*-((5)!))
 85 = (((((2+(0)!))!)!*.1~)+5)
 86 = (rt[(-(2)^-((0)!))](.1~)+5)
 88 = (rt[.2]((-((0)!)-1))+(5)!)
 90 = ((20/.1~)*.5)
 93 = (((2+(0)!)/-(.1~))+(5)!)
 95 = ((20-1)*5)
 96 = ((.20-1)*-((5)!))
 98 = (-(20)*(.1-5))
 99 = ((-(20)-1)+(5)!)
100 = (20/(1/5))
85

Buradan itibaren bu sadece bir sıkıştırma zorluğu. Belki daha sonra yarışacağım, belki yapmayacağım. Benim için eğlencenin çoğu, en fazla formülü bulmak için uğraşıyordu.

Çözücü yazmak için mücadele edenler için bir ipucu sorun olmamalı. Kontrol etmek için çok fazla formülünüz varsa, umutsuz çözümleri ve kopyaları atmak için daha iyi buluşsal yöntemlere ihtiyacınız vardır. Yukarıdaki oluşturmak için yazdığım kod Python üzerinde ~ 5 saniye içinde çalışır.