CDE

Task/Ackermann-function/C++/ackermann-function.cpp

@@ -0,0 +1,18 @@
+#include <iostream>
+using namespace std;
+long ackermann(long x, long y)
+{
+     if (x == 0)        return y+1;
+     else if (y == 0)        return ackermann(x-1, 1);
+     else return ackermann(x-1, ackermann(x, y-1));
+}
+
+int main()
+{
+        long x,y;
+        cout << "x ve y..:";
+        cin>>x;
+        cin>>y;
+        cout<<ackermann(x,y);
+        return 0;
+}

Task/Ackermann-function/C-sharp/ackermann-function.cs

@@ -0,0 +1,32 @@
+using System;
+class Program
+{
+    public static long Ackermann(long m, long n)
+    {
+        if(m > 0)
+        {
+            if (n > 0)
+                return Ackermann(m - 1, Ackermann(m, n - 1));
+            else if (n == 0)
+                return Ackermann(m - 1, 1);
+        }
+        else if(m == 0)
+        {
+            if(n >= 0)
+                return n + 1;
+        }
+
+        throw new System.ArgumentOutOfRangeException();
+    }
+
+    static void Main()
+    {
+        for (long m = 0; m <= 3; ++m)
+        {
+            for (long n = 0; n <= 4; ++n)
+            {
+                Console.WriteLine("Ackermann({0}, {1}) = {2}", m, n, Ackermann(m, n));
+            }
+        }
+    }
+}

Task/Ackermann-function/CLIPS/ackermann-function-1.clips

@@ -0,0 +1,10 @@
+(deffunction ackerman
+  (?m ?n)
+  (if (= 0 ?m)
+    then (+ ?n 1)
+    else (if (= 0 ?n)
+      then (ackerman (- ?m 1) 1)
+      else (ackerman (- ?m 1) (ackerman ?m (- ?n 1)))
+    )
+  )
+)

Task/Ackermann-function/CLIPS/ackermann-function-2.clips

@@ -0,0 +1,68 @@
+(deffacts solve-items
+  (solve 0 4)
+  (solve 1 4)
+  (solve 2 4)
+  (solve 3 4)
+)
+
+(defrule acker-m-0
+  ?compute <- (compute 0 ?n)
+  =>
+  (retract ?compute)
+  (assert (ackerman 0 ?n (+ ?n 1)))
+)
+
+(defrule acker-n-0-pre
+  (compute ?m&:(> ?m 0) 0)
+  (not (ackerman =(- ?m 1) 1 ?))
+  =>
+  (assert (compute (- ?m 1) 1))
+)
+
+(defrule acker-n-0
+  ?compute <- (compute ?m&:(> ?m 0) 0)
+  (ackerman =(- ?m 1) 1 ?val)
+  =>
+  (retract ?compute)
+  (assert (ackerman ?m 0 ?val))
+)
+
+(defrule acker-m-n-pre-1
+  (compute ?m&:(> ?m 0) ?n&:(> ?n 0))
+  (not (ackerman ?m =(- ?n 1) ?))
+  =>
+  (assert (compute ?m (- ?n 1)))
+)
+
+(defrule acker-m-n-pre-2
+  (compute ?m&:(> ?m 0) ?n&:(> ?n 0))
+  (ackerman ?m =(- ?n 1) ?newn)
+  (not (ackerman =(- ?m 1) ?newn ?))
+  =>
+  (assert (compute (- ?m 1) ?newn))
+)
+
+(defrule acker-m-n
+  ?compute <- (compute ?m&:(> ?m 0) ?n&:(> ?n 0))
+  (ackerman ?m =(- ?n 1) ?newn)
+  (ackerman =(- ?m 1) ?newn ?val)
+  =>
+  (retract ?compute)
+  (assert (ackerman ?m ?n ?val))
+)
+
+(defrule acker-solve
+  (solve ?m ?n)
+  (not (compute ?m ?n))
+  (not (ackerman ?m ?n ?))
+  =>
+  (assert (compute ?m ?n))
+)
+
+(defrule acker-solved
+  ?solve <- (solve ?m ?n)
+  (ackerman ?m ?n ?result)
+  =>
+  (retract ?solve)
+  (printout t "A(" ?m "," ?n ") = " ?result crlf)
+)

Task/Ackermann-function/Clay/ackermann-function.clay

@@ -0,0 +1,8 @@
+ackermann(m, n) {
+    if(m == 0)
+      return n + 1;
+    if(n == 0)
+      return ackermann(m - 1, 1);
+
+    return ackermann(m - 1, ackermann(m, n - 1));
+}

Task/Ackermann-function/Common-Lisp/ackermann-function-1.lisp

@@ -0,0 +1,4 @@
+(defun ackermann (m n)
+  (cond ((zerop m) (1+ n))
+        ((zerop n) (ackermann (1- m) 1))
+        (t         (ackermann (1- m) (ackermann m (1- n))))))

Task/Ackermann-function/Common-Lisp/ackermann-function-2.lisp

@@ -0,0 +1,10 @@
+(defun ackermann (m n)
+  (case m ((0) (1+ n))
+    ((1) (+ 2 n))
+    ((2) (+ n n 3))
+    ((3) (- (expt 2 (+ 3 n)) 3))
+    (otherwise (ackermann (1- m) (if (zerop n) 1 (ackermann m (1- n)))))))
+
+(loop for m from 0 to 4 do
+      (loop for n from (- 5 m) to (- 6 m) do
+	    (format t "A(~d, ~d) = ~d~%" m n (ackermann m n))))

Task/Ackermann-function/Coq/ackermann-function.coq

@@ -0,0 +1,10 @@
+Require Import Arith.
+Fixpoint A m := fix A_m n :=
+  match m with
+    | 0 => n + 1
+    | S pm =>
+      match n with
+        | 0 => A pm 1
+        | S pn => A pm (A_m pn)
+      end
+  end.

Task/Ackermann-function/D/ackermann-function-1.d

@@ -0,0 +1,11 @@
+ulong ackermann(in ulong m, in ulong n) pure nothrow {
+    if (m == 0)
+        return n + 1;
+    if (n == 0)
+        return ackermann(m - 1, 1);
+    return ackermann(m - 1, ackermann(m, n - 1));
+}
+
+void main() {
+    assert(ackermann(2, 4) == 11);
+}

Task/Ackermann-function/D/ackermann-function-2.d

@@ -0,0 +1,50 @@
+import std.stdio, std.bigint, std.conv;
+
+/*pure nothrow*/ BigInt ipow(/*in*/ BigInt base, /*in*/ BigInt exp){
+    auto result = BigInt(1);
+    //while (exp) {
+    while (exp != 0) {
+        //if (exp & 1)
+        if (exp % 2)
+            result *= base;
+        exp >>= 1;
+        base *= base;
+    }
+
+    return result;
+}
+
+/*pure nothrow*/ BigInt ackermann(in int m, in int n)
+in {
+    assert(m >= 0 && n >= 0);
+} out(result) {
+    //assert(result >= 0);
+    assert(cast()result >= 0);
+} body {
+    /*pure nothrow*/ static BigInt ack(in int m, /*in*/ BigInt n) {
+        switch (m) {
+            case 0: return n + 1;
+            case 1: return n + 2;
+            case 2: return 3 + 2 * n;
+            //case 3: return 5 + 8 * (2 ^^ n - 1);
+            case 3: return 5 + 8 * (ipow(BigInt(2), n) - 1);
+            default: if (n == 0)
+                        return ack(m - 1, BigInt(1));
+                     else
+                        return ack(m - 1, ack(m, n - 1));
+        }
+    }
+
+    return ack(m, BigInt(n));
+}
+
+void main() {
+    foreach (m; 1 .. 4)
+        foreach (n; 1 .. 9)
+            writefln("ackermann(%d, %d): %s", m, n, ackermann(m, n));
+    writefln("ackermann(4, 1): %s", ackermann(4, 1));
+
+    auto a = text(ackermann(4, 2));
+    writefln("ackermann(4, 2)) (%d digits):\n%s...\n%s",
+             a.length, a[0 .. 94], a[$-96 .. $]);
+}

Task/Ackermann-function/DWScript/ackermann-function.dwscript

@@ -0,0 +1,8 @@
+function Ackermann(m, n : Integer) : Integer;
+begin
+    if m = 0 then
+        Result := n+1
+    else if n = 0 then
+        Result := Ackermann(m-1, 1)
+    else Result := Ackermann(m-1, Ackermann(m, n-1));
+end;

Task/Ackermann-function/Dart/ackermann-function.dart

@@ -0,0 +1,13 @@
+int A(int m, int n) => m==0 ? n+1 : n==0 ? A(m-1,1) : A(m-1,A(m,n-1));
+
+main() {
+  print(A(0,0));
+  print(A(1,0));
+  print(A(0,1));
+  print(A(2,2));
+  print(A(2,3));
+  print(A(3,3));
+  print(A(3,4));
+  print(A(3,5));
+  print(A(4,0));
+}

Task/Ackermann-function/Delphi/ackermann-function.delphi

@@ -0,0 +1,9 @@
+function Ackermann(m,n:Int64):Int64;
+begin
+    if m = 0 then
+        Result := n + 1
+    else if n = 0 then
+        Result := Ackermann(m-1, 1)
+    else
+        Result := Ackermann(m-1, Ackermann(m, n - 1));
+end;

Task/Ackermann-function/E/ackermann-function.e

@@ -0,0 +1,5 @@
+def A(m, n) {
+    return if (m <=> 0)          { n+1              } \
+      else if (m > 0 && n <=> 0) { A(m-1, 1)        } \
+      else                       { A(m-1, A(m,n-1)) }
+}

Task/Ackermann-function/Ela/ackermann-function.ela

@@ -0,0 +1,3 @@
+ack 0 n = n+1
+ack m 0 = ack (m - 1) 1
+ack m n = ack (m - 1) <| ack m <| n - 1

Task/Ackermann-function/Elena/ackermann-function.elena

@@ -0,0 +1,33 @@
+#define std'dictionary'*.
+#define std'patterns'*.
+
+#subject m, n.
+
+// --- Ackermann function ---
+
+#symbol Ackermann &m:anM &n:anN =
+[
+    #if anM
+        ifequal:0 [ ^ anN + 1. ]
+        | greater:0 ?
+        [
+            #if anN
+                ifequal:0 [ ^ Ackermann &&m:(anM - 1) &n:1. ]
+                | greater:0 ? [ ^ Ackermann &&m:(anM - 1) &n:(Ackermann &&m:anM &n:(anN - 1)). ].
+        ].
+
+    control fail.
+].
+
+#symbol Program =
+[
+    loop &&from:0 &to:3 run: anM =
+    [
+        loop &&from:0 &to:5 run: anN =
+        [
+            'program'output << "A(" << anM << "," << anN << ")=" << (Ackermann &&m:anM &n:anN) << "%n".
+        ].
+    ].
+
+    'program'Input get.
+].

Task/Ackermann-function/Euler-Math-Toolbox/ackermann-function.euler

@@ -0,0 +1,16 @@
+>M=zeros(1000,1000);
+>function map A(m,n) ...
+$  global M;
+$  if m==0 then return n+1; endif;
+$  if n==0 then return A(m-1,1); endif;
+$  if m<=cols(M) and n<=cols(M) then
+$    M[m,n]=A(m-1,A(m,n-1));
+$    return M[m,n];
+$  else return A(m-1,A(m,n-1));
+$  endif;
+$endfunction
+>shortestformat; A((0:3)',0:5)
+         1         2         3         4         5         6
+         2         3         4         5         6         7
+         3         5         7         9        11        13
+         5        13        29        61       125       253

Task/Ackermann-function/Euphoria/ackermann-function.euphoria

@@ -0,0 +1,16 @@
+function ack(atom m, atom n)
+    if m = 0 then
+        return n + 1
+    elsif m > 0 and n = 0 then
+        return ack(m - 1, 1)
+    else
+        return ack(m - 1, ack(m, n - 1))
+    end if
+end function
+
+for i = 0 to 3 do
+    for j = 0 to 6 do
+        printf( 1, "%5d", ack( i, j ) )
+    end for
+    puts( 1, "\n" )
+end for