精华内容
下载资源
问答
  • C++lambda递归的三种写法

    千次阅读 2020-06-25 00:01:34
    0x00问题引入 对于一个求自然数1-N和的问题,我们很容易写出以下递归公式: f(n) = n == 1 ? 1 : n + f(n - 1); ...原因是,由于lambda表达式的匿名特性,无法直接在lambda内部递归调用lambda,我

    0x00问题引入

    对于一个求自然数1-N和的问题,我们很容易写出以下递归公式:

    f(n) = n == 1 ? 1 : n + f(n - 1);
    

    若想使用C++lambda表达式实现上述过程,我们很容易将其改写为以下代码:

    const auto& f = [](const int& n) {
    	return n == 1 ? 1 : n + f(n - 1);
    };
    

    发现编译无法通过,为什么呢?原因是,由于lambda表达式的匿名特性,无法直接在lambda内部递归调用lambda,我们需要另寻其道来解决该问题。

    0x01使用std::function

    std::function可以把lambda包装起来,相当于赋予了其一个函数名,在通过引用捕获并实现递归调用,实现如下:

    const auto& sum1 = [](const int& n) {
    	std::function<int(const int&)>s;
    	s = [&](const int& n) {
    		return n == 1 ? 1 : n + s(n - 1);
    	};
    	return s(n);
    };
    

    0x02将lambda作为参数

    先附上代码:

    const auto& sum2 = [](const int& n) {
    	const auto& s = [&](auto&& self, const int& x) -> int{
    		return x == 1 ? 1 : x + self(self, x - 1);
    	};
    	return s(s,n);
    };
    
    

    注意到,调用s(s,n)时,我们把lambda表达式本身作为了参数传入来实现递归调用。

    0x03使用Y组合子

    构造一个Y组合子如下:

    const auto& y = [](const auto& f) {
    	return [&](const auto& x) {
    		return x(x);
    	}([&](const auto& x) -> std::function<int(int)> {
    		return f([&](const int& n) {
    			return x(x)(n);
    		});
    	});
    };
    

    再实现一个求和函数的高阶函数如下:

    const auto& sum3 = [](const auto& f) {
    	return [=](const int& n) {
    		return n == 1 ? 1 : n + f(n - 1);
    	};
    };
    

    然后连接即可。

    0x04测试

    在main中简单测试一下上述实现:

    int main() {
    	std::cout << sum1(100);//print 5050
    	std::cout << sum2(100);//print 5050
    	std::cout << y(sum3)(100);//print 5050
    }
    

    运行结果符合预期。

    展开全文
  • C# lambda递归

    2015-12-15 23:13:00
    Y(Y)(F)(10) == F(Y(Y)(F))(10) A:递归开始的地方  == F((f=>x=>f(Y(Y)(f))(x))(F))(10)  == F(x=>F(Y(Y)(F))(x))(10)  == (fac=>x=>x==0?1:x*fac(x-1))(x=>F(Y(Y)(F))(x))(10)  == (x=>x==0?1:x*(x=>F(Y...

    这个不是我发明的,只是拿来人脑运行一下,有点烧脑。

     1   public class Recursive
     2     {
     3         delegate T SelfApplicable<T>(SelfApplicable<T> self);
     4 
     5         public static void Run()
     6         {
     7             // The Y combinator
     8             SelfApplicable<Func<Func<Func<int, int>, Func<int, int>>, Func<int, int>>> Y =
     9                 y =>
    10                     f =>
    11                         x => f(y(y)(f))(x);
    12             
    13             // The fixed point generator
    14             Func<Func<Func<int, int>, Func<int, int>>, Func<int, int>> Fix = Y(Y);
    15 
    16             // The higher order function describing factorial
    17             Func<Func<int, int>, Func<int, int>> F =
    18                 fac =>
    19                     x =>
    20                         x == 0 ?
    21                             1 :
    22                             x * fac(x - 1);
    23 
    24             // The factorial function itself
    25             Func<int, int> factorial = Fix(F);
    26 
    27             Console.WriteLine(factorial(10));
    28 
    29         }
    30 
    31     }

    F == fac => x => x == 0 ? 1 : x * fac(x-1)
    Y == y=>f=>x=>f(y(y)(f))(x)
    Y(Y) == f=>x=>f(Y(Y)(f))(x)
    Y(Y)(F) == x=>F(Y(Y)(F))(x)
    Y(Y)(F)(10) == F(Y(Y)(F))(10)         A:递归开始的地方
          == F((f=>x=>f(Y(Y)(f))(x))(F))(10)
          == F(x=>F(Y(Y)(F))(x))(10)
          == (fac=>x=>x==0?1:x*fac(x-1))(x=>F(Y(Y)(F))(x))(10)
          == (x=>x==0?1:x*(x=>F(Y(Y)(F))(x))(x-1))(10)
          == 10==0?1:10*(x=>F(Y(Y)(F))(x))(10-1)
          == 10*(x=>F(Y(Y)(F))(x))(9)
          == 10*F(Y(Y)(F))(9)        B: 就像A,又一次开始
          == .......
          ..........
          == 10*9*8*7*6*5*4*3*2*1*F(Y(Y)(F))(0)
          == 10*9*8*7*6*5*4*3*2*1*F((f=>x=>f(Y(Y)(f))(x))(F))(0)
          == 10*9*8*7*6*5*4*3*2*1*F(x=>F(Y(Y)(F))(x))(0)
          == 10*9*8*7*6*5*4*3*2*1*(fac=>x=>x==0?1:x*fac(x-1))(x=>F(Y(Y)(F))(x))(0)
          == 10*9*8*7*6*5*4*3*2*1*(x=>x==0?1:x*(x=>F(Y(Y)(F))(x))(x-1))(0)
          == 10*9*8*7*6*5*4*3*2*1*(0==0?1:0*(x=>F(Y(Y)(F))(x))(0-1))
          == 10*9*8*7*6*5*4*3*2*1*1

     

    好美......

    So beautiful......

    终极感受:

      

    1 new Func<int, int>(i =>
    2                 new Func<Func<int, int>, Func<int, int>>(fac => x => x == 0 ? 1 : x * fac(x - 1))(
    3                     new SelfApplicable<Func<Func<Func<int, int>, Func<int, int>>, Func<int, int>>>(
    4                         y => f => x => f(y(y)(f))(x)
    5                     )(
    6                         y => f => x => f(y(y)(f))(x)
    7                     )(
    8                         fac => x => x == 0 ? 1 : x * fac(x - 1))
    9                     )(i))(10)

    No function Name,No trouble.

    转载于:https://www.cnblogs.com/javaleon/p/5049863.html

    展开全文
  • 主要介绍了Java8使用lambda实现Java的尾递归的相关资料,需要的朋友可以参考下
  • 偶然想到要在函数内部使用lambda递归调用,以下是可行的写法,可参考 1 std::function<void(Node * container,const BlendFunc &blendFunc)> blendFucCall; 2 3 blendFucCall = [&...

     

    偶然想到要在函数内部使用lambda递归调用,以下是可行的写法,可参考

     

     1     std::function<void(Node * container,const BlendFunc &blendFunc)> blendFucCall;
     2     
     3     blendFucCall = [&blendFucCall](Node * container,const BlendFunc &blendFunc)
     4     {
     5         for ( auto child : container->getChildren())
     6         {
     7             auto sp = dynamic_cast<Sprite*>(child);
     8             if (sp)
     9             {
    10                 sp->setBlendFunc(blendFunc);
    11             }
    12             else
    13             {
    14                 blendFucCall(child,blendFunc);
    15             }
    16         }
    17     };
    18     blendFucCall(this,blendFunc);

     

    转载于:https://www.cnblogs.com/howeho/p/4352918.html

    展开全文
  • python lambda lambda递归 lambda g=lambda x:2*x+1 def add(x,y): return x+y g= lambda x,y:x+y // lambda 省下定义函数过程 简化代码可读性 //过滤器 Filter() help(filter) list(filter(None,[1,0,False,True...

    python lambda

    lambda

    g=lambda x:2*x+1
    def add(x,y):
    	return x+y
    g= lambda x,y:x+y
    // lambda 省下定义函数过程 简化代码可读性
    
    
    //过滤器 Filter()
    help(filter)
    list(filter(None,[1,0,False,True]))
    
    list(filter(lambda x : x % 2, range(10)))
    
    list(map(lambda x: x*2,range(10)))
    [0,2,4,6,8,10,12,14,16,18]
    
    

    递归

    def factorial(n):
    	if n==1:
    		return 1
    	else:
    		return n*factorial(n-1)
    number=int(input('please input a number:'))
    result=factorial(number)
    print("%d 的阶乘是: %d" % (number,result) )
    
    展开全文
  • // 这里跟一个 别人写的 递归lambda 斐波那契递归,以上方法参考这个写法。但是实际上没有用这种方法还是用的函数 public static Func, int> Fibonacci = n => n > 1 ? Fibonacci(n - 1) + Fibonacci(n - 2) : n; ...
  • Lambda递归查询所有菜单树 /** * 查询所有菜单树 * JDK1.8 */ private List<MenuEntity> getMenuTreeList(List<MenuEntity> menuList,String pid) { // 查找所有菜单 List<MenuEntity> ...
  • 递归 递归就是自己调用自己 必须要有跳出出口 案例 # 3+2+1=6 def sum_func(num): if num == 1: return 1 return num + sum_func(num - 1) print(sum_func(3)) Lambda lambda表达式的参数可有可无,函数的参数...
  • Python递归lambda表达式 一、递归 1.1递归的特点 函数内部自己调用自己 必须有出口 1.2示例 def numFunc(num): if num == 1: return 1 return num + numFunc(num - 1) print(numFunc(3)) # 6 图示 [外链...
  • lambda递归

    2018-09-05 15:24:40
    package testLambda; import java.util.function.... * lambda递归 * @author P H * @date 2018/8/31 15:48 */ public class LambdaRecursion { //IntUnaryOperator 表示对单个int值的操作数的操作...
  • 递归实现从1加到N的和3.JAVA8的流对递归支持3.1 计算1的平方到n的平方的和,取前5个值3.2 阶乘函数3.3 斐波那契函数 递归算法,主要考虑两点,一是自己调用自己,二是调用自己终止的条件是什么 1. 用递归实现N的...
  • } /*** * Desc: 递归下一级子菜单 * @param root * @param all * @return {@link List< DeviceGroupVo>} * @author sheng jia hao * @date 2021/3/17 13:35 */ public List getDeviceGroupChilds(DeviceGroupVo ...
  • 这个例子的main函数用lambda写了一个斐波那契数列的递归计算函数。跟以往不同的是,在Y函数的帮助下,这个lambda表达是可以成功看到自己,然后递归调用。当然这仍然需要用普通的C++递归来实现,并不是λ-calculus...
  • C#基于Lambda递归的阶乘/累加实现

    千次阅读 2012-02-10 14:50:58
    http://www.cnblogs.com/tiscs/archive/2012/02/09/csharp-lambda-recursion.html  前天做一道面试题,要我用C#实现累加,想用Lambda写,结果面试官... 首先分享一个递归帮助类,写这个类的时候参考了老赵和装配
  • 在Java 1.8里,如何用Lambda实现递归

    千次阅读 2017-03-07 14:33:46
    那么如何才能用Lambda实现递归呢? 修改一下: public static void main(String[] args) {   IntFunc[] factor = new IntFunc[ 1 ];   factor[ 0 ] = n -> n ...
  • 其实这从来不是一个很简单的事情,虽然有些朋友认为这很简单。 伪递归 我的意思是,某些看上去像...例如,我们想要使用Lambda表达式编写一个计算递归的fac函数,一开始我们总会设法这样做: Func<int, int>...
  • Lambda表达式中进行递归调用

    千次阅读 2017-10-10 15:44:00
    Lambda表达式是一个匿名的方法,在开发期我们是不知道其方法名是什么的,所以我们要怎么递归调用呢? 如果你看过我这文章《让您知道您的方法是被何“人”调用》的话,你应该会“啊哈”的拍一下头脑,思路就出来了,...
  • Lambda递归

    2019-09-26 02:55:53
    1.Lambda表达式的标准格式 三部分组成: 一些参数 一个箭头 一段代码 格式: (参数列表) -> {一些重写方法的代码} 解释说明格式: ():接口中抽象方法的参数列表,没有参数,就空着;有参数就写出参数,多...
  • 注意: 使用Lambda表达式会增加额外开销,但却有时候又蛮方便的。 Windows下查找子孙窗口实例: HWND FindDescendantWindows(HWND hWndParent, LPCTSTR lpClassName, LPCTSTR lpWindowName) { HWND hFind =...
  • 递归优化 很多算法都依赖于递归,典型的比如分治法(Divide-and-Conquer)。但是普通的递归算法在处理规模较大的问题时,常常会出现StackOverflowError。处理这个问题,我们可以使用一种叫做尾调用(Tail-Call ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 31,333
精华内容 12,533
关键字:

lambda递归