Змагання

Реалізувати тетраци (ака Power Tower або Hyperexponentiation) з найменшою кількістю символів.

Умови

• Не використовуйте «влада» оператор або його еквіваленти (такі як pow(x,y), x^y, x**yі т.д.)
• Введення подано у вигляді: x y(розділене пробілом)
• xпіддається експоненції самих yчасів.
• Ваш метод повинен бути в змозі обчислити принаймні 4 3(4 експоненції себе 3 рази)

Підрахунок балів

• Найнижча кількість виграшів: (кількість символів)
• Вирахування бонусів, якщо ви не використовуєте оператора множення (-5 балів).
• Немає вимог до швидкості / пам'яті. Візьміть скільки завгодно.

Приклади

x, 0 -> 1

2, 2 -> 2^2 = 4

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

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

Відкрити для пропозицій / змін / питань

J, оцінка 7 (12 знаків - 5 балів за уникнення множення)

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

використання:

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

Всього кілька вкладених складок:

• Використовуючи множення, це було б */@$~/@$~
• Використовуючи потужність, саме ^/@$~там, де $~створюється масив, /є функція складання.

Haskell, 87 85 - 5 == 80 82

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

Не використовує жодної експоненції, множення чи додавання (!), Просто перелічіть операції. Демонстрація:

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

...
ах ... ви нічого не сказали про продуктивність чи пам'ять, чи не так? Але, враховуючи достатню кількість мільярдів років та петабайтів оперативної пам’яті, це все одно дасть правильний результат (genericLength може використовувати bigInt для підрахунку довжини списку).

GolfScript, 15 18 символів

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

Так, один із *s є оператором множення (вправа: який?), Тому я не можу отримати бонус за 5 знаків. Але все-таки це ледь коротше рішення Петра .

Інакше ця попередня 15-char версія є такою ж, але не видає результатів, коли другий аргумент дорівнює 0. Завдяки res для виявлення помилки.

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

J, 16 19 12 символів

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

або як дієслово (17 символів):

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

використання:

   h 2 4
65536

або отримання даних із клавіатури ( 24 27 20 символів):

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

дякую FUZxxl за те, що вони вказали на мою дурість. :-)

Пояснення:

J читається справа наліво, використовуючи 2 4:

/використовується для вставки дієслова $~між кожною парою елементів у списку. $~бере лівий елемент і формує його, $використовуючи правий елемент ( ~зворотні аргументи) - так це було б еквівалентом, 4 $ 2який дає вам список 2s, який триває чотири елементи 2 2 2 2.

Тепер ми додаємо 1 до списку, 1,~а потім робимо те ж саме знову; /вставити дієслово */@$~між кожною парою елементів у списку. Це дієслово починається так само, $~але цього разу він /вставляє *між кожним елементом новоствореного списку. @Просто переконується , що */@$~працює як один дієслово замість двох. Це дає 2помножене на себе достатньо разів, щоб бути рівнозначним 2^4.

Сторінка словникового запасу J - я знаходжу вирішення проблем із J веселістю лише через те, що інколи це робить.

Додавання ще однієї ітерації для видалення *оператора має 2 проблеми

• Він виходить у 17 символів ( +/@$~/,@$~/1,~$~/), що навіть із бонусом -5 занадто довго
• Коли пам'ять стає занадто великою, вона не втрачає пам'яті, тому вона не відповідає вимозі можливості обчислення 4 3

GolfScript (24 символи - 5 = 19 балів)

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

шалено повільний.

(або 20 символів)

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

набагато швидше.

Пітона, 70

При цьому використовуються вкладені evalдзвінки, з часом виробляється рядок, "a*a*a*a...*a"який оцінюється. Майже половина балів витрачається на отримання аргументів ... хоча я помітив, що деякі інші рішення не турбують це.

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

Скала: 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(_,_,(_+_))))

неозорений:

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

пояснення:

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

плюс, mul, високий (: = pow), тетрація, все працює однаково. Загальну схему можна отримати як рекурсивний метод, який займає два BigInts та основну функцію:

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

Підкреслення є заповнювачем для чогось, що викликається в цій послідовності, наприклад додавання плюс (a, b) = (a + b); тому ( + ) - це функція, яка бере два аргументи і додає їх (a + b).

на жаль, у мене виникають проблеми з розміром стека. Він працює для малих значень для 4 (наприклад: 2) або якщо я зменшу глибину на один крок:

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

Оригінальний код - 112 символів і набрав би, якщо дійсний, 107. Можливо, я дізнаюся, як збільшити стек.

Розширений алгоритм може бути перетворений на рекурсивні виклики:

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

Хвостовий рекурсивний виклик довший, ніж оригінальний метод, але не викликав поточного потоку у довгому варіанті - однак це не дає результату у розумні строки. t (2,4) добре, але t (3,3) мене вже зупинили через 5 хв. Однак це дуже елегантно, чи не так?

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

І тепер те саме, що вище: використовуйте смердюче множення (ми навіть отримуємо прибуток, відкидаючи бонус 5, тому що ми економимо 7 символів: win = 4 символи :)

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

виклик:

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

тривалість виконання: 1 мс.

Br ** nfuck, 128-5 = 123 байт

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

Введення здійснюється у вигляді символів з кодовими точками цифр, бажаних як введення. Вихід той самий

Пояснення приходить, коли в мене є час нижче. Чи отримую я бонусні бали за те, що не використовую експоненцію, множення чи АБО навіть додавання?

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!

Це працює (протестовані) для x 0, 0 x, x 1, 1 x, x 2, 2 3, і 2 4. Я намагався 3 3, але він побіг в протягом декількох годин без обробки (в моїй реалізації, ймовірно , Java не оптимальною) (EDIT: в @ Timwi в EsotericIDE .. [! Це здорово Y'all повинен спробувати це], а без удачі). Теоретично це відповідає розміру комірок конкретної реалізації.

Python, 161 - 5 (не * оператор) = 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

викликати:

t(2, 4)

Перл, 61 ч

ось химерний

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

використання:

print t(2,4,1)

Математика , 40 33

Це не зовсім відповідає правилам, але все-таки це не суперечить найкоротшому коду, і я сподіваюся, що він когось зацікавить.

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

m[m@Sum]

Це будує функцію "тетрації" під час її запуску, але аргументи повинні бути наведені у зворотному порядку. Приклад:

m[m@Sum][3, 4]

1340780792994259709957402499820584612747936582059239337772356144372176 4030073546976801874298166903427690031858186486050853753882811946569946 433649006084096

Haskell:  58  51 знак, з множенням або без нього.

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

Безголівки:

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

Коротше визначення походить від вбудованого "bump" та визначення користувацької версії "iterate". На жаль, результат неможливо неефективний, але починаючи з (*) замість (+) дає гідну швидкість. В 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)

Рубін 66 59 символів

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

Пітон, 112 символів

Цифри повинні бути першим та другим аргументом: python this.py 4 3
**оператор не використовується.
*б / в. Це досить тривіально реалізувати, точно так само **, але коштує більше 5 символів.

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 символів

EDIT: Об'єднувати дві функції pі rв одну, заощадивши кілька символів.
З 99 знаків 52 здійснюють фактичний розрахунок (включаючи визначення змінних). Інші 47 - для обробки вводу та виводу.
BUG: погано обробляє сили 0 (наприклад 0 2). Слід знайти виправлення мінімальної вартості. Це не помилка, я забув, що 0 2це не визначено.

Успішно справляється 4 3і навіть дає точний результат. Однак для деяких менших чисел може бути неточним.
Друкує номер із заднім числом .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());
}

Фактор, 187 символів

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 .

Перед гольфом:

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.

Я не видалив оператора множення *. Якби я це зробив, то мені потрібно було б додати деяку логіку, яка виражає, що сума порожньої послідовності дорівнює 0, а не 1. Ця додаткова логіка коштуватиме дорожче ніж бонус -5.

Вимикач правил, 124 + 10 = 134 символи

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

Ця програма має нижчий бал, але оператор експоненції ^порушує правила. У правилах написано "(# символів) + (10 * (# операторів" харчування ")", тому я застосував +10 штраф. Однак у правилах також написано "Не використовуйте" оператора "живлення", тому будь-яка програма, яка застосовує цей штраф, порушує правила. Тому ця програма з 134 символів не є правильною відповіддю, і я повинен подати свою більш довгу програму з 187 символів як свою відповідь.

Haskell 110 - 5 = 105

Тетраційний стиль піано. Це найбільш шалено можливе рішення, лише попередження, але також дозволяє уникнути навіть додавання.

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)

Це покладається на те, що ви матимете терпіння вводити номери Peano (і відповідь не відображатиметься. Якщо ви дійсно хочете її запустити, додайте ці кілька рядків (90 символів):

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

Рубі, 47 46 45

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

Луа: 133 символів, без множення

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)

Я спочатку збирався використовувати штрихи для повторення рядків, щоб зробити фальшиве множення, але це подобається, щоб провалити великі значення. Я міг би використовувати динамічну компіляцію та навантажувальну нитку, щоб зробити її меншою, але тут вже запізно ... Мені потрібен сон.

Введення "4 3" у виходи stdin:

1.3407807929943e+154

VBA, 90 чол

* Можливо, бонус за множення не є досить хорошим. Я думаю, що відповідь на множення не набагато цікавіша, але це кодовий гольф, тому це не найкраще. Ось відповідь без *, і краща (коротша та краща оцінка) відповідь:

90 символів, без операторів живлення, використовується множення = 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 знаків, немає операторів електроенергії, немає бонусу на множення (-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

ПРИМІТКА. У VBA є проблеми з друком номера, коли результат дуже великий (тобто 4, 3), але він обчислює правильно, тому, якщо, наприклад, ви хотіли ВИКОРИСТОВУВАТИ це число, ви б добре піти. Крім того, навіть BIGGER числа переповнюються (тобто 3, 4).

Perl 6 , 32 байти

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

Спробуйте в Інтернеті!

(1, { [*] a xx $_ } ... *)являє собою ледачу послідовність, яка генерує вежу з потужністю, кожен елемент - це список, що складається з першого вхідного параметра, aреплікуваного ( xx) у кілька разів, рівний попередньому елементу ( $_), і цей список зменшується при множенні ( [*]). З цієї послідовності ми просто вириваємо b-й елемент.

Обчислення лямбда, 10-5

(з використанням кодування Церкви та де Бреййн )
λλ(1λ13)λ1

Пояснення

Без де Бреййн роздумів λ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

Якщо ви визначаєте exp_a(x)=a^xцю програму, визначається, a↑↑b=exp_a^b(1)де ^bпозначається ітерація функції.

Я не впевнений, чи це дозволено, оскільки caтехнічно це еквівалентно тому, a^cяк ніколи це не справжня вбудована, а лише побічний ефект від того, як цілі числа кодуються в обчисленні лямбда.

Javascript: 116 знаків

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') Виходи:

1.3407807929942597e+154

Пітон (111) (113) ні *

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 цифр))

Upd: Додайте початкове значення, щоб відповідати t (X, 0) = 1

Haskell: 88-5 символів без множення, 59 символів з множенням

Без множення:

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

Ймовірно, є способи, щоб я міг трохи пограти в гольф.

З множенням:

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

І нарешті, програма, що не має волі:

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)

Це, мабуть, найпростіший спосіб вирішити цю проблему, який визначає множення як повторне додавання, експоненцію як повторне множення, а тетрацію як повторне експонування.

Ракетка 58 (ні *)

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

Лист звичайний, 85 ч

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

Я намагався робити множення шляхом повторного додавання, але це було більше ніж 5 символів. Те ж саме і з макролетами, декларації не вартували надбавки.

Ще одне рішення, натхнене рішенням пітону кабінки. Це на 1 символ менше, ніж зазначене вище рішення.

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

Пітон 3 - 68

(включаючи 10-бальний штраф для енергооператора)

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

Ябасич , 71 байт

Функція, яка приймає введення aі bє рядком, обмеженим пробілом.

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

Спробуйте в Інтернеті!

R , 71 - 5 = 66 байт

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

Спробуйте в Інтернеті!

-5 для уникнення *, що було важче, ніж я очікував. Він вибухає дуже швидко і не спрацює (якщо у нього не буде більше пам'яті), але він відповідає всім необхідним критеріям.