Meydan okuma

Uygulamak tetrasyon karakterlerin az miktarda (aka Power Tower veya Hyperexponentiation).

Koşullar

• 'Güç' operatörü veya eşdeğerleri (örneğin kullanmayın pow(x,y), x^y, x**yvb)
• Verilen giriş: x y(boşlukla ayrılmış)
• xkendi yzamanları tarafından üstelleştirilir .
• Metodunuz en az hesaplayabilmelidir 4 3(4 kişi kendiliğinden 3 kez üst üste çıkarıldı)

Puanlama

• En düşük puan kazanır: (karakter sayısı )
• Çarpma operatörünü kullanmazsanız bonus indirimi (-5 puan).
• Hız / Bellek gerektirmez. İstediğin kadar al.

Örnekler

x, 0 -> 1

2, 2 -> 2^2 = 4

2, 4 -> 2^(2^(2^2)) = 65536

4, 3 -> 4^(4^4) = 4^256 = 13407807929942597099574024998205846127479365820592393377723561443721764030073546976801874298166903427690031858186486050853753882811946569946433649006084096

Önerilere / değişikliklere / sorulara açık

J, puan 7'dir (12 karakter - çarpmadan kaçınmak için 5 puan)

+/@$/@$~/@$~

kullanımı:

   4 +/@$/@$~/@$~ 3
1.34078e154
t=.+/@$/@$~/@$~  NB. define a function
   4 t 3
1.34078e154
   2 t 2
4

Sadece birkaç iç içe kıvrım:

• Çarpma kullanarak olacaktır */@$~/@$~
• Gücü kullanmak , diziyi yarattığı ^/@$~yerde , bir katlama işlevidir.$~/

Haskell, 87 85 - 5 == 80 82

import Data.List
t x=genericLength.(iterate(sequence.map(const$replicate x[]))[[]]!!)

Üstelik, çarpma veya toplama (!) 'Nın hiçbirini kullanmaz, sadece işlemleri listeler. gösteri:

Prelude> :m +Data.List
Prelude Data.List> let t x=genericLength.(iterate(sequence.map(const$replicate x[]))[[]]!!)
Prelude Data.List> t 2 2
4
Prelude Data.List> t 2 4
65536
Prelude Data.List> t 4 3

...
ahm ... performans ya da hafıza hakkında bir şey söylemedin, değil mi? Ancak, yeterli milyarlarca yıl ve bazı petabayt RAM'ler verilmişse, bu yine de doğru sonuç verecektir (genel uzunluğu listenin uzunluğunu saymak için büyük bir bilgi kullanabilir).

GolfScript, 15 karakter

~])*1\+{[]+*{*}*}*

Evet, *s lerden biri çarpma operatörüdür (alıştırma: hangisi?) Bu yüzden 5 karakter bonusu için hak kazanmıyorum. Yine de, Peter'ın çözümünden çok daha kısa .

Bu önceki 15 karakter sürümü aynıdır, ancak ikinci argüman 0 olduğunda çıktı vermez. Böceği saptadığınız için res.

~])*{[]+*{*}*}*

J, 16 19 12 karakter

*/@$~/1,~$~/

veya bir fiil olarak (17 karakter):

h=:[:*/@$~/1,~$~/

kullanımı:

   h 2 4
65536

veya klavyeden giriş almak ( 24 27 20 karakter):

*/@$~/1,~$~/".1!:1]1

Aptallığımı işaret ettiği için FUZxxl'e teşekkür ederim . :-)

Açıklama:

J sağdan sola okunur, bu nedenle şunu kullanarak 2 4:

/fiili $~listedeki her bir öğe çifti arasına yerleştirmek için kullanılır . $~soldaki öğeyi alır ve $doğru öğeyi kullanarak ~biçimlendirir (argümanları tersine çevirir) - yani bu 4 $ 2, size 2dört öğeden oluşan bir liste veren eşdeğer olacaktır 2 2 2 2.

Şimdi listeye 1 ekleriz 1,~ve sonra aynı şeyi tekrar yaparız; Listedeki her bir öğe çifti arasına /bir fiil ekleyin */@$~. Bu fiil aynı şekilde başlar, $~ancak bu kez yeni oluşturulan listenin her maddesi arasına /bir *boşluk ekler . @Sadece emin olur */@$~birinin fiil yerine ikisi olarak çalışır. Bu, 2kendisiyle eşdeğer olması için yeterli zamanla çarpılır 2^4.

J'nin kelime sayfası - J eğlenceli ile ilgili problem çözmeyi sadece bazen farklı şeyler yaptığı için buluyorum.

*Operatörü kaldırmak için bir tane daha yineleme eklemek için 2 sorun var

• +/@$~/,@$~/1,~$~/-5 bonus ile bile çok uzun olan 17 karakterden ( ) çıkıyor
• Sayı çok fazla artarsa ​​hesaplanamaz hale gelmiyorsa, hafızası tükenir. 4 3

GolfScript (24 karakter - 5 = 19 puan)

~\1{1{0{+}?}?}{@\+@*}:?~

delicesine yavaş.

(veya 20 karakter)

~\1{1{*}?}{@\+@*}:?~

çok daha hızlı.

Python, 70

Bu, iç içe geçmiş evalaramaları kullanır ve sonunda "a*a*a*a...*a"değerlendirilen bir dize üretir . Skorun neredeyse yarısı tartışmayı almakla boşa harcanıyor ... ancak birkaç çözümün bununla uğraşmadığını fark ettim.

a,b=map(int,raw_input().split())
exec"eval('*'.join('a'*"*b+'1'+'))'*b

Scala: 110

type B=BigInt
def r(a:B,b:B,f:(B,B)=>B):B=if(b>1)f(a,r(a,b-1,f))else a
def h(a:B,b:B)=r(a,b,r(_,_,r(_,_,(_+_))))

ungolfed:

type B=BigInt
def recursive (a:B, b:B, f:(B,B)=>B): B = 
  if (b>1) f (a, recursive (a, b-1, f)) 
  else a
recursive (2, 3, recursive (_, _, recursive (_, _, (_ + _))))

açıklama:

type B=BigInt
def p (a:B, b:B):B = a+b
def m (a:B, b:B):B = if (b>1) p (a, m (a, b-1)) else a
def h (a:B, b:B):B = if (b>1) m (a, h (a, b-1)) else a
def t (a:B, b:B):B = if (b>1) h (a, t (a, b-1)) else a

artı, mul, yüksek (: = pow), tetrasyonun tümü aynı şekilde çalışır. Ortak kalıp, iki BigInts ve temel bir işlev alan özyinelemeli yöntem olarak çıkarılabilir:

def r (a:B, b:B, f:(B,B)=>B):B = 
  if (b>1) f(a, r(a, b-1, f)) else a
r (4, 3, r (_,_, r(_,_, (_+_))))

Altı çizili çizgiler, bu sırayla çağrılan bir şeyin yer tutucusudur; örneğin toplama artı (a, b) = (a + b); bu nedenle ( + ) iki argüman alan ve bunları ekleyen bir fonksiyondur (a + b).

ne yazık ki, yığın boyutu ile ilgili sorunlar alıyorum. 4 değerinde küçük değerler için çalışır (örneğin: 2) veya bir adım için derinliği azaltırsam:

def h(a:B,b:B)=r(a,b,r(_,_,(_*_))) // size -7, penalty + 5
def h(a:B,b:B)=r(a,b,r(_,_,r(_,_,(_+_)))) 

Orijinal kod 112 karakterdir ve geçerliyse, 107 olur. Belki yığını nasıl artıracağımı öğrendim.

Genişletilmiş algoritma, özyinelemeli çağrılara dönüştürülebilir:

type B=BigInt
def p(a:B,b:B):B=a+b
import annotation._
@tailrec
def m(a:B,b:B,c:B=0):B=if(b>0)m(a,b-1,p(a,c))else c
@tailrec
def h(a:B,b:B,c:B=1):B=if(b>0)h(a,b-1,m(a,c))else c
@tailrec
def t(a:B,b:B,c:B=1):B=if(b>0)t(a,b-1,h(a,c))else c

Özyinelemeli çağrı orijinal yöntemden daha uzun, ancak uzun sürümde bir yığın akışını yükseltmedi - ancak makul sürede sonuç vermedi. t (2,4) iyi, ancak t (3,3) 5 dakika sonra zaten benim tarafımdan durduruldu. Ancak, çok zarif, değil mi?

// 124 = 119-5 bonus
type B=BigInt
def r(a:B,b:B,c:B,f:(B,B)=>B):B=if(b>0)r(a,b-1,f(a,c),f)else c
def t(a:B,b:B)=r(a,b,1,r(_,_,1,r(_,_,0,(_+_))))

Ve şimdi yukarıdakiyle aynı: kokmuş çarpma kullanın (5 bonusu reddederken bile kâr ediyoruz, çünkü 7 karakter kazanıyoruz: win = 4 karakter :)

// 115 without bonus
type B=BigInt
def r(a:B,b:B,c:B,f:(B,B)=>B):B=if(b>0)r(a,b-1,f(a,c),f)else c
def t(a:B,b:B)=r(a,b,1,r(_,_,1,(_*_)))

çağırma:

timed ("t(4,3)")(t(4,3)) 
t(4,3): 1
scala> t(4,3)
res89: B = 13407807929942597099574024998205846127479365820592393377723561443721764030073546976801874298166903427690031858186486050853753882811946569946433649006084096

çalışma zamanı: 1ms.

Br ** nfuck, 128-5 = 123 bayt

+<<+<<,<,[>[>+>>+<<<-]>[<+>-]>[>[>>+>+<<<-]>>>[<<<+>>>-]<<[>[>+>+<<-]>>[<<+>>-]<<<-]>[-]>[<<+>>-]<<<<-]>>[<<+>>-]+<[-]<<<<-]>>>.

Giriş, giriş olarak istenen sayıların kod noktalarına sahip karakter biçimindedir. Çıktı aynı.

Aşağıdaki zamana sahip olduğumda bir açıklama geliyor . Üstel, çarpma, VEYA ekleme kullanmadığım için bonus puanları alabilir miyim?

Cell 3 (0-indexed) is the running total x.
This calculates the nth tetration of a.

+<<+<<,<,                                       Initialize tape with [n, a, 0, 1, 0, 1]
[                                               While n:
  >[>+>>+<<<-]>[<+>-]                             Copy a 3 cells to right: [n, a, 0, x, a, 1]
  >[                                              While x:
    >[>>+>+<<<-]>>>[<<<+>>>-]                       Copy a 2 cells to right: [n, a, 0, x, a, 1, a, 0]
    <<[>[>+>+<<-]>>[<<+>>-]<<<-]                    Cell 7 = prod(cell 5, cell 6)
    >[-]>[<<+>>-]<<<<-]                             Move this value to cell 5. End while.
  >>[<<+>>-]+<[-]<<<<-]                           Update x to result of exponentiation. End while.
>>>.                                            Print the result!

İçin (test) Bu çalışmalar x 0, 0 x, x 1, 1 x, x 2, 2 3, ve 2 4. Denedim 3 3ama bitmeden birkaç saat sürdü (Java uygulamamda — muhtemelen optimal değil) (EDIT: @ Timwi'nin Ezoterik'in [Bu harika! Hepiniz denemelisiniz] de. Şans yok.). Teorik olarak, bu spesifik uygulamanın hücre boyutuna kadar çalışır.

Python, 161 - 5 (operatör yok) = 156

r=xrange
def m(x,y):
 i=0
 for n in r(y):i+=x
 return i
def e(x,y):
 i=1
 for n in r(1,y+1):i=m(i,x)
 return i
def t(x,y):
 i=1
 for n in r(y):i=e(x,i)
 return i

çağırmak:

t(2, 4)

Perl, 61 karakter

işte tuhaf olanı

sub t
{
  ($x,$y,$z)=@_;
  $y>1&&t($x,$y-1,eval$x."*$x"x($z-1||1))||$z
}

kullanımı:

print t(2,4,1)

Mathematica , 40 33

Bu kurallara tam olarak uymuyor ancak yine de en kısa kod için geçerli değil ve birisinin ilgisini çekeceğini umuyorum.

m@f_:=Fold[f,1,#2~Table~{#}]&;

m[m@Sum]

Bu, çalıştırıldığında bir "tetration" işlevi oluşturur, ancak argümanlar ters sırada verilmelidir. Örnek:

m[m@Sum][3, 4]

1340780792994259709957402499820584612747936582059239337772356144372176 4030073546976801874298166903427690031858186486050853753882811946569946 433649006084096’lı.

Haskell:  58  Çarpma ile veya çarpma olmadan 51 karakter.

i f x 1=x;i f x n=f$i f x$n-1
t=i(\o n->i(o n)n)(+)4

Ungolfed:

bump op n a = iterate (op n) n !! (fromIntegral $ a-1)
tetrate = iterate bump (+) !! 3

Daha kısa tanım, "çarpma" satırının iç içe geçmesinden ve "yinelemenin" özel bir versiyonunun tanımlanmasından gelir. Ne yazık ki sonuç imkansız derecede verimsiz, ancak (+) yerine (*) ile başlamak iyi bir hız veriyor. İçinde ghci:

Prelude> let i f x 1=x;i f x n=f$i f x$n-1
(0.00 secs, 1564024 bytes)
Prelude> let t=i(\o n->i(o n)n)(*)3
(0.00 secs, 1076200 bytes)
Prelude> t 4 3
13407807929942597099574024998205846127479365820592393377723561443721764030073546
976801874298166903427690031858186486050853753882811946569946433649006084096
(0.01 secs, 1081720 bytes)

Ruby 66 59 karakter

def e(x,y)
r=1
(1..y).each{t=x
(2..r).each{t*=x}
r=t}
r
end

Python, 112 karakter

Rakamlar 1. ve 2. argüman olmalıdır: python this.py 4 3
**operatör kullanılmamış.
*Kullanılmış. Aynen gibi uygulanması oldukça önemsiz **ama 5 karakterden daha fazla.

import sys
p=lambda y:y and x*p(y-1)or 1
t=lambda y:y>1 and p(t(y-1))or x
x,y=map(long,sys.argv[1:])
print t(y)

C, 117 105 99 karakter

DÜZENLEME: iki işlev Birleştirilmiş pve rbazı karakter tasarruf birine.
99 karakterden 52'si gerçek hesaplamayı yapar (değişken tanımları dahil). Diğer 47, giriş ve çıkış işlemlerini yapmak içindir.
HATA: Kötü 0 (örneğin 0 2) güçleri ele alır . Minimum maliyet düzeltmesi bulmalı. Bu bir hata değil 0 2, undefined olduğunu unuttum .

Başarıyla işler 4 3ve kesin sonuç verir. Ancak, bazı küçük sayılar için yanlış olabilir.
Sayıyı bir iz ile yazdırır .000000.

x,y,z;
double R(){return--y?!z?y=R(),R(z=1):x*R():x;}
main(){
    scanf("%d%d",&x,&y);
    printf("%f\n",R());
}

Faktör, 187 karakter

USING: eval io kernel locals math prettyprint sequences ;
IN: g
:: c ( y x o! -- v )
o 0 = [ x y * ] [ o 1 - o!
y x <repetition> 1 [ o c ] reduce ] if ;
contents eval( -- x y ) swap 2 c .

Golften önce:

USING: eval io kernel locals math prettyprint sequences ;
IN: script

! Calculate by opcode:
!   0 => x * y, multiplication
!   1 => x ^ y, exponentiation
!   2 => x ^^ y, tetration
:: calculate ( y x opcode! -- value )
    opcode 0 = [
        x y *
    ] [
        ! Decrement the opcode. Tetration is repeated exponentiation,
        ! and exponentiation is repeated multiplication.
        opcode 1 - opcode!

        ! Do right-associative reduction. The pattern is
        !   seq reverse 1 [ swap ^ ] reduce
        ! but a repetition equals its own reverse, and 'calculate'
        ! already swaps its inputs.
        y x <repetition> 1 [ opcode calculate ] reduce
    ] if ;

contents eval( -- x y )         ! Read input.
swap 2 calculate .              ! Calculate tetration. Print result.

Çarpma operatörünü kaldırmadım *. Bunu yaparsam, boş bir dizinin toplamının 1 değil, 0 olduğunu ifade eden bir mantık eklemem gerekirdi.

Kural kırıcı, 124 + 10 = 134 karakter

USING: eval kernel math.functions prettyprint sequences ;
contents eval( -- x y ) swap <repetition> 1 [ swap ^ ] reduce .

Bu program daha düşük bir puana sahip, ancak üs işletmecisi ^kuralları ihlal ediyor. Kurallar "(karakter sayısı) + (10 * ('güç' operatörlerinin sayısı))" derken, +10 ceza uygulamıştım. Bununla birlikte, kurallar aynı zamanda “'güç' operatörünü kullanma” diyor, bu nedenle bu ceza alan herhangi bir program kuralları ihlal ediyor. Bu nedenle, 134 karakterden oluşan bu program doğru bir cevap değildir ve 187 karakterden oluşan uzun programımı cevabım olarak sunmalıyım.

Haskell 110 - 5 = 105

Tetration Peano Stili. Bu mümkün olan en delice yavaş bir çözümdür, sadece bir uyarıdır, fakat aynı zamanda eklemeyi bile önler.

data N=Z|S N
a&+Z=a
a&+S b=S$a&+b
_&*Z=Z
a&*S b=a&+(a&*b)
_&^Z=S Z
a&^S b=a&*(a&^b)
_&>Z=S Z
a&>S b=a&^(a&>b)

Bu, Peano numaralarını yazma sabrına sahip olmanıza bağlıdır (ve cevabı göstermez, Gerçekten çalıştırmak istiyorsanız, aşağıdaki birkaç satırı ekleyin (90 karakter):

f 0=Z
f a=S$f$a-1
t Z=0
t(S a)=1+t a
main=interact$show.f.(\[x,y]->x&>y).map(f.read).words

Ruby, 47 46 45

t=->x,n{r=x;2.upto(n){r=([x]*r).inject :*};r}

Lua: 133 karakter, çarpma-az

a,b=io.read():match"(%d+) (%d+)"a,b,ba=a+0,b+0,a for i=1,b-1 do o=1 for i=1,a do o=o+o for i=1,ba-b do o=o+o end end a=o end print(o)

Başlangıçta sahte çarpma yapmak için dize tekrarlama kesmeleri kullanacaktım, ancak büyük değerlerde başarısız olmayı seviyor. Bunu daha küçük hale getirmek için dinamik derleme ve yükleme strüktürünü kullanabilirim, ama burada geç oluyor ... uykuya ihtiyacım var.

Stdin çıkışlarına "4 3" girilmesi:

1.3407807929943e+154

VBA, 90 Karakter

* Belki de çarpma bonusu yok, yeterince iyi değil. Ben çarpma yok cevap çok daha ilginç olduğunu düşünüyorum, ama bu kod golf, bu yüzden en iyisi değil. İşte bir cevap olmadan* ve daha iyi (daha kısa ve daha iyi bir puanlama) cevabı:

90 karakter, elektrik operatörü yok, çarpım kullanır = 90

Sub c(x,y)
f=IIf(y,x,1):For l=2 To y:b=x:For j=2 To f:b=b*x:Next:f=b:Next:MsgBox f
End Sub

116 karakter, operatör yok, çarpma bonusu yok (-5) = 111

Sub c(x,y)
f=IIf(y,x,1):For l=2 To y:b=x:For j=2 To f:For i=1 To x:a=a+b:Next:b=a:a=0:Next:f=b:Next:MsgBox f
End Sub

NOT: VBA, sonuç çok büyük olduğunda (yani 4, 3) sayıyı yazdırırken sorun yaşar , ancak doğru hesaplar, bu nedenle, örneğin, bu sayıyı KULLANMAK istiyorsanız, gitmeniz iyi olur. Ayrıca, BIGGER numaraları bile taşar (yani 3, 4).

Perl 6 , 32 bayt

->\a,\b{(1,{[*] a xx$_}...*)[b]}

Çevrimiçi deneyin!

(1, { [*] a xx $_ } ... *)güç kulesini oluşturan tembel bir sekans olup, her bir eleman bir önceki elemana ( ) eşit sayıda defa açoğaltılmış ( xx) ilk giriş parametresinden oluşan bir listedir $_, bu liste daha sonra çarpma ( [*]) ile azaltılır . Bu diziden basitçe b-th elementini çıkarırız.

Lambda hesabı, 10-5

( Kilise kodlaması ve De Bruijn içindekiler kullanılarak )
λλ(1λ13)λ1

açıklama

De Bruijn dışkı olmadan λa,b.(b λc.ca)λc.c:

λa,b.                                                 define the anonymous function f(a,b)=
     (b                                                apply the following function b times
        λc.                                                    the anonymous function g(c)=
           ca)                 apply c to a because of church encoding this is equal to a^c
              λc.c                              the identity function, 1 in church encoding

Eğer exp_a(x)=a^xbu programı tanımlarsanız , fonksiyon itirazının a↑↑b=exp_a^b(1)nerelerde olduğunu tanımlar ^b.

Buna izin verilip verilmediğinden emin değilim, çünkü cateknik olarak a^cne kadar gerçek bir yerleşik olmadığına ve tamsayıların lambda hesabında kodlanmasının bir yan etkisi olmasına eşdeğerdir .

Javascript: 116 karakter

function t(i){y=i.split(' ');a=y[0];b=y[1];return+b&&p(a,t(a+' '+(b-1)))||1}function p(a,b){return+b&&a*p(a,b-1)||1}

t ('4 3') Çıktılar:

1.3407807929942597e+154

piton (111) (113) no *

r=lambda x,y:(x for _ in range(y));t=lambda x,y:reduce(lambda y,x:reduce(lambda x,y:sum(r(x,y)),r(x,y)),r(x,y),1)

6 *** 3 - 36 bin basamak))

Upd: İlk değer eklemek zorunda, t (X, 0) = 1

Haskell: Çarpma olmadan 88-5 karakter, çarpma ile 59 karakter

Çarpma olmadan:

h x y=foldr(\x y->foldl(\x y->foldl(+)0(replicate x y))1(replicate y x))1(replicate y x)

Muhtemelen biraz golf oynamanın yolları var.

Çarpma ile:

h x y=foldr(\x y->foldl(*)1(replicate y x))1(replicate y x)

Ve nihayet, ungolfed programı:

mult x y = foldl (+) 0 (replicate x y)
expo x y = foldl (mult) 1 (replicate y x)
h x y = foldr (expo) 1 (replicate y x)

Bu muhtemelen, tekrarlanan toplama olarak çarpma, tekrarlanan çarpma olarak tekrar kullanma ve tekrarlanan açıklama olarak tekrarlama olarak tanımlayan, bu problemi yapmanın en basit yoludur.

Raket 58 (hayır *)

(define(t x y)(if(= y 0)1(for/product([i(t x(- y 1))])x)))

Common Lisp, 85 karakter

(lambda(b c)(let((r b)u)(dotimes(c c r)(setf u 1 r(dotimes(c b u)(setf u(* u r)))))))

Tekrarlı ekleme yoluyla çarpımları yapmaya çalıştım, ama 5 karakterden çok daha fazlaydı. Makrolarla aynı şey, beyannameler kazanılmaya değmezdi.

Booth'un python çözümünden ilham alan başka bir çözüm. Yukarıdaki çözümden 1 karakter daha az.

(lambda(a b)(eval`(*,@(loop for x below b nconc(loop for x below a nconc`(,a,a))))))

Python 3 - 68

(güç operatörü için 10 puan ceza dahil)

a,b=input().split()
r=1
exec("r=%s**r;"%a*int(b))
print(r)

Yabasic , 71 bayt

Girdiyi ave bboşlukla sınırlandırılmış bir dize alan bir işlev .

Input""a,b
d=a^(b>0)
For i=2To b
c=a
For j=2To d
c=c*a
Next
d=c
Next
?d

Çevrimiçi deneyin!

R , 71 - 5 = 66 bayt

function(x,y,b=x){for(i in 2:y)b=cumprod(z<-rep(x,b))[sum(z|1)];cat(b)}

Çevrimiçi deneyin!

-5 * önlemek için, ki beklediğimden daha zordu. Çok hızlı patlar ve çalışmaz (daha fazla hafızası olmadığı sürece) ancak gerekli tüm kriterleri karşılar.