いろんな言葉で竹内関数

Kink

#!/usr/bin/env kink

&tak = { ( &X  &Y  &Z )
    ( X <= Y ).then {
        Y
    } {
        tak( tak( X - 1  Y  Z )  tak( Y - 1  Z  X )  tak( Z - 1  X  Y ) )
    }
}

[ &X  &Y  &Z ] = ARGS.map { __.int }
&TAK = tak( X  Y  Z )
print_line: format: 'tak( #X  #Y  #Z ) = #TAK'

Scheme

#!/usr/bin/scm -f

(require 'srfi-1)

(define (tak x y z)
  (if (<= x y)
    y
    (tak (tak (- x 1) y z) (tak (- y 1) z x) (tak (- z 1) x y))))

(write (apply tak (map string->number (drop *argv* *optind*))))
(newline)

Ruby

#!/usr/bin/env ruby

def tak( x , y , z )
  if x <= y
    y
  else
    tak( tak( x - 1 , y , z ) , tak( y - 1 , z , x ) , tak( z - 1 , x , y ) )
  end
end

x , y , z = ARGV.map { |arg| arg.to_i }
tak = tak( x , y , z )
puts "tak(#{x}, #{y}, #{z}) = #{tak}"

Python

#!/usr/bin/env python

import sys

def tak(x, y, z):
    if x <= y:
        return y
    else:
        return tak(tak(x - 1, y, z), tak(y - 1, z, x), tak(z - 1, x, y))

x = int(sys.argv[1])
y = int(sys.argv[2])
z = int(sys.argv[3])
result = tak(x, y, z)
print "tak(%s, %s, %s) = %s" % (x, y, z, result)

Groovy

#!/usr/bin/env groovy

def tak(x, y, z) {
    if (x <= y) {
        return y
    } else {
        return tak(tak(x - 1, y, z), tak(y - 1, z, x), tak(z - 1, x, y))
    }
}

x = Integer.decode(args[0])
y = Integer.decode(args[1])
z = Integer.decode(args[2])
result = tak(x, y, z)
println "tak($x, $y, $z) = $result"

Bourne Shell

#!/bin/sh

x=$1
y=$2
z=$3

if [ $x -le $y ]; then
  echo $y
else
  x1=`expr $x - 1`
  y1=`expr $y - 1`
  z1=`expr $z - 1`
  xx=`$0 $x1 $y $z`
  yy=`$0 $y1 $z $x`
  zz=`$0 $z1 $x $y`
  $0 $xx $yy $zz
fi

Lua

function tak(x, y, z)
  if x <= y then
    return y
  else
    return tak(tak(x - 1, y, z), tak(y - 1, z, x), tak(z - 1, x, y))
  end
end

x = tonumber(arg[1])
y = tonumber(arg[2])
z = tonumber(arg[3])
result = tak(x, y, z)
print(result)