CareerCup

Explanation:

We simply make `f` ignore its argument and constantly produce a fibonaci function:
`f(y) = fib`.
Then, `Y(f) = f(Y(f))=fib`.

Code:

public class AppLabmdaSubstitution {

	public static Function<Integer, Integer> Y(Function<Function<Integer, Integer>, Function<Integer, Integer>> f) {
		return x -> f.apply(Y(f)).apply(x);
	}

	public static void main(String[] args) {
		//Write your code here
		Function<Integer, Integer> fib = Y(
				func -> x -> {
			if (x < 2)
				return x;
			else
				return func.apply(x - 1) + func.apply(x - 2);
		});

		IntStream.range(1, 11).mapToObj(Integer::valueOf).map(fib).forEach(System.out::println);
	}
	
	/**
	* Function<Integer, Integer> fibonaci = new Function<Integer, Integer>() {
		@Override
		public Integer apply(Integer t) {
			if (t<2) {
				return t;
			} else {
				return apply(t - 1) + apply(t - 2);
			}
		}
		
	};
	*/
}

c# implementation.

using System;

namespace Fib {
    class Program {

        public static Func<int, int> Y( Func<Func<int, int>, Func<int, int>> f ) {
            return x => f( Y( f ) )( x );
        }

        static void Main(string[] args) {

            var resFunc = Y( func => {
                return new Func<int, int>( i => {
                    int fib0 = 0;
                    int fib1 = 1;
                    int resFib = 1;
                    for ( int j = 1; j < i; j++ ) {
                        resFib = fib0 + fib1;
                        fib0 = fib1;
                        fib1 = resFib;
                    }
                    return resFib;
                });
            });
            var res = resFunc.Invoke( 7 );
            Console.WriteLine( res );
        }
    }
}

class Program
    {
        public static Func<int, int> Y(Func<Func<int, int>, Func<int, int>> f)
        {
            return x => f(Y(f))(x);
        }
     
        static void Main(string[] args)
        {
          ///Fib 5	
            Console.WriteLine( Y(ff => x =>x<1?1:ff(x-1)+ff(x-2))(5));
          ////Fib 10  
	  Console.WriteLine( Y(ff => x =>x<1?1:ff(x-1)+ff(x-2))(10));
            
        }
    }

class Program
    {
        public static Func<int, int> Y(Func<Func<int, int>, Func<int, int>> f)
        {
            return x => f(Y(f))(x);
        }
 
        static void Main(string[] args)
        {
            //Fib 5
	    Console.WriteLine( Y(ff => x =>x<1?1:ff(x-1)+ff(x-2))(5));
             //Fib 10
	     Console.WriteLine( Y(ff => x =>x<1?1:ff(x-1)+ff(x-2))(10));
           
        }
    }
}

My solution is

class Program
    {
        public static Func<int, int> Y(Func<Func<int, int>, Func<int, int>> f)
        {
            return x => f(Y(f))(x);
        }
 
        static void Main(string[] args)
        {
            //Fib 5
	    Console.WriteLine( Y(ff => x => x<1 ? 1 : ff(x-1)+ff(x-2))(5));
             //Fib 10
	     Console.WriteLine( Y(ff => x => x<1 ? 1 : ff(x-1)+ff(x-2))(10));
           
        }
    }
}

What is there in this question. Its plain C# question if a candidate knows Anon and Lambda function.. its just copy that recursive fibo code in return dude..

In C++:

typedef function< int(int) > int_to_int;

int_to_int Y( function< int_to_int(int_to_int) > f )
{
  return [f](int n) -> int { return f(Y(f))(n); };
}

function< int_to_int(int_to_int) > f = [](int_to_int g) -> int_to_int { return [g](int n) { return n<= 1 ? 1 : g(n - 1) + g(n - 2); }; };

In C++:

typedef function< int(int) > int_to_int;

int_to_int Y( function< int_to_int(int_to_int) > f )
{
  return [f](int n) -> int { return f(Y(f))(n); };
}

function< int_to_int(int_to_int) > f = [](int_to_int g) -> int_to_int { return [g](int n) { return n <= 1 ? 1 : g(n - 1) + g(n - 2); }; };