La sfida

Implementa la tetrazione (aka Power Tower o Hyperexponentiation) con il minor numero di personaggi.

Le condizioni

• Non utilizzare l'operatore 'potere' o suoi equivalenti (come ad esempio pow(x,y), x^y, x**y, etc.)
• Input dato come: x y(separato da uno spazio)
• xè esponenziale da solo yvolte.
• Il tuo metodo deve essere in grado di calcolare almeno 4 3(4 esponenziato da solo 3 volte)

Il punteggio

• Il punteggio più basso vince: (# di caratteri)
• Detrazione del bonus se non si utilizza l'operatore di moltiplicazione (-5 punti).
• Nessun requisito di velocità / memoria. Prendi tutto il tempo che vuoi.

Esempi

x, 0 -> 1

2, 2 -> 2^2 = 4

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

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

Aperto a suggerimenti / modifiche / domande

J, il punteggio è 7 (12 caratteri - 5 punti per evitare la moltiplicazione)

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

utilizzo:

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

Solo alcune pieghe nidificate:

• Usando la moltiplicazione sarebbe */@$~/@$~
• Usando il potere sarebbe ^/@$~dove $~crea array, /è una funzione di piega.

Haskell, 87 85 - 5 == 80 82

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

Non utilizza né di esponenziazione, moltiplicazione o aggiunta (!), Ma solo operazioni di elenco. Dimostrazione:

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 ... non hai detto nulla sulle prestazioni o sulla memoria, vero? Ma dati abbastanza miliardi di anni e alcuni petabyte di RAM, ciò produrrebbe comunque il risultato corretto (genericLength può usare un bigInt per contare la lunghezza dell'elenco).

GolfScript, 15 18 caratteri

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

Sì, una delle *s è un operatore di moltiplicazione (esercizio: quale?) Quindi non mi qualifico per il bonus di 5 caratteri. Tuttavia, è appena più breve della soluzione di Peter .

Questa versione precedente di 15 caratteri è la stessa, ma non produce alcun output quando il secondo argomento è 0. Grazie a res per aver individuato il bug.

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

J, 16 19 12 caratteri

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

o come verbo (17 caratteri):

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

utilizzo:

   h 2 4
65536

o prendendo input dalla tastiera ( 24 27 20 caratteri):

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

grazie a FUZxxl per aver sottolineato la mia stupidità. :-)

Spiegazione:

J viene letto da destra a sinistra, quindi usando 2 4:

/viene utilizzato per inserire il verbo $~tra ciascuna coppia di elementi nell'elenco. $~prende l'oggetto sinistro e lo modella $usando l'oggetto giusto ( ~inverte gli argomenti) - quindi questo sarebbe equivalente a quello 4 $ 2che ti dà un elenco di 2s che è lungo quattro elementi 2 2 2 2.

Ora aggiungiamo 1 all'elenco 1,~e poi facciamo di nuovo la stessa cosa; /inserire un verbo */@$~tra ogni coppia di elementi nell'elenco. Questo verbo inizia allo stesso modo, $~ma questa volta /inserisce una *tra ogni elemento dell'elenco appena generato. Il @solo si assicura che */@$~funzioni come un verbo anziché due. Questo dà 2moltiplicato per sé abbastanza volte per essere equivalente a 2^4.

Pagina del vocabolario di J - Trovo che risolvere i problemi con J sia solo per il modo diverso in cui a volte fa le cose.

L'aggiunta di un'ulteriore iterazione per rimuovere l' *operatore ha 2 problemi

• Viene fuori con 17 caratteri ( +/@$~/,@$~/1,~$~/) che, anche con il bonus di -5, è troppo lungo
• Si esaurisce la memoria se il numero diventa troppo grande, quindi non soddisfa il requisito di essere in grado di calcolare 4 3

GolfScript (24 caratteri - 5 = 19 punti)

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

è follemente lento.

(o 20 caratteri)

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

è molto più veloce.

Python, 70

Questo utilizza evalchiamate nidificate , producendo infine una stringa "a*a*a*a...*a"che viene valutata. Quasi la metà del punteggio è sprecata per ottenere gli argomenti ... anche se ho notato che alcune altre soluzioni non si preoccupano di questo.

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 (_, _, (_ + _))))

spiegazione:

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

inoltre, mul, high (: = pow), tetration funzionano tutti allo stesso modo. Il modello comune può essere estratto come metodo ricorsivo, che richiede due BigInts e una funzione di base:

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(_,_, (_+_))))

Le sottolineature sono segnaposto per qualcosa che viene chiamato in questa sequenza, ad esempio l'addizione plus (a, b) = (a + b); pertanto ( + ) è una funzione che accetta due argomenti e li aggiunge (a + b).

sfortunatamente, ho problemi con le dimensioni dello stack. Funziona con valori piccoli per 4 (ad esempio: 2) o se riduco la profondità per un passo:

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(_,_,(_+_)))) 

Il codice originale è di 112 caratteri e segnerebbe, se valido, 107. Forse scoprirò come aumentare lo stack.

L'algoritmo espanso può essere trasformato in chiamate ricorsive:

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

La chiamata tailrecursive è più lunga del metodo originale, ma non ha generato uno stackoverflow nella versione lunga, tuttavia non produce risultati in tempi ragionevoli. t (2,4) va bene, ma t (3,3) è già stato fermato da me dopo 5 minuti. Tuttavia, è molto elegante, vero?

// 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,(_+_))))

E ora lo stesso di cui sopra: usa la moltiplicazione puzzolente (guadagniamo anche rifiutando il bonus di 5, perché salviamo 7 caratteri: vincita = 4 caratteri :)

// 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,(_*_)))

invocazione:

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

durata: 1ms.

Br ** nfuck, 128-5 = 123 byte

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

L'input è in forma di caratteri con punti di codice dei numeri desiderati come input. L'output è lo stesso.

Una spiegazione sta arrivando quando avrò il tempo di seguito. Ricevo punti bonus per non usare esponenziazione, moltiplicazione o persino aggiunta?

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!

Questo funziona (testato) per x 0, 0 x, x 1, 1 x, x 2, 2 3, e 2 4. Ci ho provato 3 3, ma ha funzionato per diverse ore senza finire (nella mia implementazione Java - probabilmente non ottimale) (EDIT: in EsotericIDE di @ Timwi [È fantastico! Dovresti provare anche tu]. Nessuna fortuna.). In teoria, questo funziona fino alla dimensione della cella dell'implementazione specifica.

Python, 161-5 (no * operatore) = 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

invocare:

t(2, 4)

Perl, 61 caratteri

eccone uno bizzarro

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

utilizzo:

print t(2,4,1)

Mathematica , 40 33

Questo non è del tutto conforme alle regole, ma non è comunque in conflitto con il codice più breve, e spero che possa interessare qualcuno.

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

m[m@Sum]

Ciò crea una funzione di "tetrazione" quando viene eseguita, ma gli argomenti devono essere indicati in ordine inverso. Esempio:

m[m@Sum][3, 4]

1340780792994259709957402499820584612747936582059239337772356144372176 4030073546976801874298166903427690031858186486050853753882811946569946 433649006084096

Haskell:  58  51 caratteri, con o senza moltiplicazione.

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

Una definizione più breve deriva dall'integrare "bump" e dalla definizione di una versione personalizzata di "iterare". Sfortunatamente il risultato è incredibilmente inefficiente, ma a partire da (*) anziché (+) si ottiene una velocità decente. In 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 caratteri

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

Python, 112 caratteri

I numeri dovrebbero essere il 1 ° e il 2 ° argomento: python this.py 4 3
**operatore non utilizzato.
*Usato. È abbastanza banale da implementare, esattamente come **, ma costa più di 5 caratteri.

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 caratteri

EDIT: ha unito le due funzioni pe rin una sola, salvando alcuni caratteri.
Di 99 caratteri, 52 eseguono il calcolo effettivo (comprese le definizioni delle variabili). Gli altri 47 sono per la gestione di input e output.
ERRORE: gestisce male i poteri di 0 (ad es 0 2.). Dovrebbe trovare una soluzione di costo minimo. Questo non è un bug, ho dimenticato che 0 2non è definito.

Gestisce con successo 4 3e fornisce persino un risultato esatto. Tuttavia, può essere inaccurato per alcuni numeri più piccoli.
Stampa il numero con un trascinamento .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());
}

Fattore, 187 caratteri

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 .

Prima del golf:

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.

Non ho rimosso l'operatore di moltiplicazione *. Se lo facessi, allora avrei bisogno di aggiungere un po 'di logica per esprimere che la somma di una sequenza vuota è 0, non 1. Questa logica in più costerebbe più del bonus di -5.

Violatore di regole, 124 + 10 = 134 caratteri

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

Questo programma ha un punteggio più basso, ma l'operatore esponenziale ^infrange le regole. Le regole dicono "(# di caratteri) + (10 * (# di operatori" potenti "))", quindi ho applicato la penalità di +10. Tuttavia, le regole dicono anche "Non usare l'operatore 'potere'", quindi qualsiasi programma che prende questa penalità infrange le regole. Pertanto, questo programma di 134 caratteri non è una risposta corretta e devo presentare il mio programma più lungo di 187 caratteri come mia risposta.

Haskell 110-5 = 105

Tetration Peano Style. Questa è la soluzione più follemente lenta possibile, solo un avvertimento, ma evita anche l'aggiunta.

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)

Questo dipende dal fatto che tu abbia la pazienza di digitare i numeri di Peano (e non mostrerà la risposta, se vuoi davvero eseguirlo, aggiungi queste poche righe (90 caratteri):

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 caratteri, senza moltiplicazione

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)

Inizialmente avrei usato gli hack di ripetizione delle stringhe per fare una falsa moltiplicazione, ma a lui piace fallire su valori di grandi dimensioni. Potrei usare la compilazione dinamica e il loadstring per renderlo più piccolo, ma qui si sta facendo tardi ... Ho bisogno di dormire.

Immettere "4 3" nelle uscite stdin:

1.3407807929943e+154

VBA, 90 caratteri

* Forse il bonus di non moltiplicazione non è abbastanza buono. Penso che la risposta senza moltiplicazione sia molto più interessante, ma questo è il golf del codice, quindi non è il migliore. Ecco una risposta senza *e una risposta migliore (più breve e migliore) con essa:

90 caratteri, nessun operatore di potenza, utilizza la moltiplicazione = 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 caratteri, nessun operatore di potenza, nessun bonus di moltiplicazione (-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

NOTA: VBA ha problemi a stampare il numero quando il risultato è molto grande (ad es. 4, 3), Ma viene calcolato correttamente, quindi se, ad esempio, si desidera UTILIZZARE quel numero, sarebbe opportuno procedere. Inoltre, anche i numeri più grandi traboccano (cioè 3, 4).

Perl 6 , 32 byte

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

Provalo online!

(1, { [*] a xx $_ } ... *)è una sequenza pigra che genera la power tower, ogni elemento è un elenco che consiste nel primo parametro di input areplicato ( xx) un numero di volte uguale all'elemento precedente ( $_), tale elenco viene quindi ridotto con la moltiplicazione ( [*]). Da quella sequenza estraiamo semplicemente l' bennesimo elemento.

Calcolo lambda, 10-5

(usando la codifica della Chiesa e le voci di De Bruijn )
λλ(1λ13)λ1

Spiegazione

Senza indumenti De Bruijn λ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

Se si definisce exp_a(x)=a^xquesto programma si definisce a↑↑b=exp_a^b(1)dove ^bindica l'iterazione della funzione.

Non sono sicuro che ciò sia consentito perché caè tecnicamente equivalente a a^ccome mai non è un vero built-in e solo un effetto collaterale del modo in cui gli interi sono codificati nel calcolo lambda.

Javascript: 116 caratteri

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') Uscite:

1.3407807929942597e+154

Python (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 - 36k cifre))

Aggiornamento: deve aggiungere il valore iniziale, per adattarsi a t (X, 0) = 1

Haskell: 88-5 caratteri senza moltiplicazione, 59 caratteri con moltiplicazione

Senza moltiplicazione:

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

Probabilmente ci sono dei modi in cui potrei golf un po 'giù.

Con moltiplicazione:

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

E infine, il programma ungolfed:

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)

Questo è probabilmente il modo più semplice di fare questo problema, che sta definendo la moltiplicazione come addizione ripetuta, esponentiazione come ripetizione ripetuta e tetrazione come esponenziazione ripetuta.

Racchetta 58 (no *)

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

Lisp comune, 85 caratteri

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

Ho provato a fare le moltiplicazioni attraverso l'aggiunta ripetuta, ma era molto più di 5 caratteri. Stessa cosa con i macrolet, le dichiarazioni non valgono i guadagni.

Un'altra soluzione, ispirata alla soluzione di pitone di boothby. È 1 carattere in meno rispetto alla soluzione sopra.

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

Python 3 - 68

(compresa la penalità di 10 punti per l'operatore di potenza)

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

Yabasic , 71 byte

Una funzione che accetta input ae bcome stringa delimitata da spazi.

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

Provalo online!

R , 71-5 = 66 byte

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

Provalo online!

-5 per evitare *, che è stato più difficile di quanto mi aspettassi. Esplode molto velocemente e non funzionerà (a meno che non abbia più memoria) ma soddisfa tutti i criteri necessari.