相关疑难解决方法(0)

我想过滤掉列表'a from list'b中的所有元素并返回过滤后的'b.这是我的功能:

(defun filter (a b)
  "Filters out all items in a from b"
    (if (= 0 (length a)) b
      (filter (remove (first a) a) (remove (first a) b))))

我是lisp的新手,不知道'删除它是怎么回事,这个过滤器运行的时间是什么？

假设我们有这个代码：

a = 1

def func1():
    if a == 1:
        func2()

def func2():
    if a == 1:
        func3()

def func3():
    func1()

有没有办法让 func3 call func1跳出它已经产生的“父函数”？意思是，回到“递归深度 0”，就好像它重新开始一样？

谢谢！

我想知道递归是否是一个问题的唯一解决方案，那么堆栈迭代是否是唯一的其他解决方案？我认为它们是等效的：如果递归有效，那么迭代肯定会起作用，反之亦然。

另外，我不确定为什么递归被认为效率低下，并且经常导致堆栈溢出，而使用堆栈的迭代却没有。递归仅以用户不可见的自动方式使用堆栈。

在"像程序员一样思考"一书中,下面的递归函数被称为"非常低效",我无法弄清楚为什么(这本书没有解释).似乎没有任何不必要的计算.是因为调用这么多函数(多次使用相同的函数)的开销,从而为每次调用函数设置环境？

int factorial(int n) {
  if (n == 1) return 1;
  else return n * factorial(n-1);
}

我需要构建一个字符串只包含字符的所有可能的二进制表示0,1和V(通配符).字符串可以是任意长度(超过1000个字符),但通配符的数量小于20.

例如,对于输入V1V,输出将是[010, 011, 110, 111]

我当前的实现工作正常,但是使用适量的通配符溢出堆栈.代码在这里运行,如下所示.

def permutts
permutts =
{
  if (!it.contains('V'))
    return [it]

  def target = it
  def res = []

  ['0', '1'].each
  {
    def s = target.replaceFirst(~/V/, it)
    if (s.contains('V'))
    {
      res += permutts(s)
    }
    else
    {
      res << s
    }
  }
  res
}
println permutts('V1V')

我试图遵循一些使用的例子,trampoline()但我甚至不确定这是否是正确的方法. API说,"...函数应该执行计算的一个步骤..."但每个步骤执行两个动作:替换in 0和1for V.

这是我的一次尝试,可以在这里运行.

def permutts

permutts =
{ it, …

我已经编写了一个函数来递归地求和值,但它不符合ES6尾部调用优化的标准(原因我无法清晰表达).

function sum(...values) {
  if(!values.length) { 
    return 0; 
  }
  return values.shift() + sum(...values);
}

如何更改它才有资格进行优化？

最近,我们的老师给了我们关于JavaScript的测验.我在编程方面比较先进,所以当我遇到一个问题时:

在同一个函数中使用函数的名称会导致无限循环？

因为递归,我回答错误.根据我的理解,你必须使用函数的名称来调用它,所以递归会使这并不总是正确的.

我的理解是正确的,还是措辞不同？

我是c ++的初学者,我遇到了使这段代码按照我想要的方式工作的问题.任务是编写一个程序,将所有自然数乘以加载数n.

为了使打印出正确的结果,我分x的n(见下面的代码).如何进行打印x而不必将其除以n得到正确的答案？

#include<iostream>
using namespace std;
int main(){
    int n,x=1;
    int i=0;
    cout<<"Enter a number bigger than 0:"<<endl;
    cin>>n;
    while(i<n){
        i++;
        x=i*x;  
    };
    cout<<"The result is: "<<x/n<<endl;
    return 0;
}

我正在尝试学习C的更高级方面，并在尝试使用__inline__关键字时编写了此代码：

#include <stdio.h>


void f(int);
void g(int);


__inline__ void f(int egg)
{
    printf("f %d\n", egg);
    g(egg);
}


__inline__ void g(int egg)
{
    printf("g %d\n", egg);
    f(egg);
}


int main()
{
    f(123);

    return 0;
}

我浏览了GNU手册，发现-Winline当标记的功能__inline__无法替代时，编译器选项会发出警告。

我确实希望gcc -ansi -pedantic -Wall -Wextra -Winline -o test test.c收到警告，但是我使用编译了该程序，但没有警告。

当我运行该程序时，它可能会由于超出了递归限制而在出现分段错误之前将数字打印了很多次。

我的问题是，gcc在这种情况下会如何表现？如果它确实内联了函​​数，怎么知道它在两个函数之间进行了递归调用？

先感谢您

如何在cat中实现以下循环？

首先（正常while（true）循环）：

while(true) { doSomething() }

第二个（while（true）循环递增）：

var i = 1
while(true) { i +=1; doSomething() }

第三（while（true）里面有几个自变量）：

var x = 1
var y = 2
while(true) {
  x = someCalculation()
  y = otherCalculation()
  doSomething()
}