Chan.c numbers

The chan.c numbers were three numbers entered by Tak-Shing Chan in the Bignum Bakeoff contest.

Programs

chan.c

chan.c's program is the following:

int A(int y, int z) { return !y?z+1:!z?A(y-1,1):A(y-1,A(y,z-1)); }
#define _(A, B) int B(int y, int z) { return !y?A(z+1,z+1):!z?\
B(y-1,1):B(y-1,B(y,z-1)); }
_(A,B)_(B,C)_(C,D)_(D,E)_(E,F)_(F,G)_(G,H)_(H,I)_(I,J)_(J,K)_(K,L)
_(L,M)_(M,N)_(N,O)_(O,P)_(P,Q)_(Q,R)_(R,S)_(S,T)_(T,U)_(U,V)_(V,W)
_(W,X)_(X,Y)_(Y,Z)_(Z,a)_(a,b)_(b,c)_(c,d)_(d,e)_(e,f)_(f,g)_(g,h)
_(h,i)_(i,j)_(j,k)_(k,l)_(l,m)_(m,n)_(n,o)_(o,p)_(p,q)_(q,r)_(r,s)
_(s,t)_(t,u)_(u,v)_(v,w)_(w,x)
int main(void) { return x(99999, 99999); }

The lower bound is F[50,0](99998) and the upper bound is F[50,0](100001) under a different form of the fast-growing hierarchy.

chan-2.c

chan-2.c's program is the following:

int A(int x, int y, int z)
{ return !x?y+z:!z?y:A(x-1,y,A(x,y,z-1)); }
#define B(x, y) A(y, y, y)
#define _(F, G) int G(int x, int y) \
{ return !x?G(F(0,y),F(0,y)):x==1?F(0,y):G(x-1,F(0,y)); }
_(B,C)_(C,D)_(D,E)_(E,F)_(F,G)_(G,H)_(H,I)_(I,J)_(J,K)_(K,L)
_(L,M)_(M,N)_(N,O)_(O,P)_(P,Q)_(Q,R)_(R,S)_(S,T)_(T,U)_(U,V)
_(V,W)_(W,X)_(X,Y)_(Y,Z)_(Z,a)_(a,b)_(b,c)_(c,d)_(d,e)_(e,f)
_(f,g)_(g,h)_(h,i)_(i,j)_(j,k)_(k,l)_(l,m)_(m,n)_(n,o)_(o,p)
_(p,q)_(q,r)_(r,s)_(s,t)_(t,u)_(u,v)_(v,w)
int main(void)
{ return w(0, 999999999999999999999999999999999999999); }

The lower bound is F[1,47](5*10**38-1) and the upper bound is F[1,48](10**39+95) under a different form of the fast-growing hierarchy. Note x**y means x to the power of y.

chan-3.c

chan-3.c's program is the following:

int A(int x, int y, int z)
{ return !x?y+z:!z?y:A(x-1,y,A(x,y,z-1)); }
int B(int z)
{ return A(z,z,z); }
int C(int t, int u, int v, int w, int x, int y, int z)
{ return !t?B(z):
!u?B(C(t,C(t-1,0,0,0,0,0,B(z)),v,w,x,y,B(z))):u==1?B(z):
!v?B(C(t,u,C(t,u-1,0,0,0,0,B(z)),w,x,y,B(z))):v==1?B(z):
!w?B(C(t,u,v,C(t,u,v-1,0,0,0,B(z)),x,y,B(z))):w==1?B(z):
!x?B(C(t,u,v,w,C(t,u,v,w-1,0,0,B(z)),y,B(z))):x==1?B(z):
!y?B(C(t,u,v,w,x,C(t,u,v,w,x-1,0,B(z)),B(z))):y==1?B(z):
  B(C(t,u,v,w,x,y-1,B(C(t,u,v,w,x-1,0,B(z))))); }
int main(void)
{ return C(9999, 0, 0, 0, 0, 0, 9999); }

The lower bound is F[2,0](4999) and the upper bound is F[2,4](199999) under a different form of the fast growing hierarchy.

See also

Large numbers in computers

Main article: Numbers in computer arithmetic

127 · 128 · 256 · 32767 · 32768 · 65536 · 2147483647 · 4294967296 · 9007199254740991 · 9223372036854775807 · FRACTRAN catalogue numbers
Bignum Bakeoff contestants: pete-3.c · pete-9.c · pete-8.c · harper.c · ioannis.c · chan-2.c · chan-3.c · pete-4.c · chan.c · pete-5.c · pete-6.c · pete-7.c · marxen.c · loader.c
Channel systems: lossy channel system · priority channel system
Concepts: Recursion