相关疑难解决方法(0)

最近对于编程类,我们被赋予了用任何语言编写程序的赋值,给定n,将产生大小为n的数组p的所有可能的紊乱,使得对于所有i:0的p [i]!= i <= i <n.我们必须使用迭代器,例如.yield

示例:n = 3,[0,1,2]不是紊乱,但[2,0,1]和[1,2,0]一样.

我提出了一个可以工作的伪代码解决方案,但问题是它需要电源循环(即n个嵌套循环,其中n仅在运行时已知).为此,我在一个字符串中生成了Ruby代码中的n个嵌套循环,然后eval是字符串.我的解决方案有效,但是我的教授认为使用少量gotos比动态代码生成更好的解决方案(至少更容易阅读).

我的印象goto总是一个糟糕的选择.为什么运行时评估动态生成的代码比选择更糟糕goto呢？生成的代码简洁明了,对于给定的问题似乎相当有效.代码生成所依赖的唯一用户输入是n,检查它以确保它是预先的整数值.这应该yield是唯一的紊乱.

我不是要求我的编程任务的解决方案,我只是想知道使用goto过度动态代码评估的原因,反之亦然.

编辑: 澄清一下,赋值包括使用迭代器编写程序和使用递归编写另一个程序,因此迭代版本不一定意味着高效.

可能重复:
每次递归都可以转换为迭代吗？

可以总是或在哪种情况下将递归函数转换为非递归函数或非递归函数集？

你能指出一些有用的例子吗？

谢谢

我在转换这个递归算法时遇到了一些困难,该算法用于将给定整数集的所有排列显示为迭代整数.

void getPermutationsR(int v[], int n, int i) 
{
    if (i == n)
    {
        //Display contents of v
    } 
    else
    {
        for (int j=i; j<n; j++) 
        {
            swap (v, i, j);
            getPermutationsR(v, n, i+1);
            swap (v, i, j);
        }
    }
}

这是我目前的尝试,这是完全错误的,但我没有看到任何方法来纠正它,而不使用本机迭代算法的问题.我的一半尝试让我'弹出'超过'推'(当我试图访问空堆栈中的元素时导致错误)而另一半我'推''超过'弹出'(无限循环).

void getPermutationsI(int v[], int n, int i) 
    {
    stack<int> iStack;
    stack<int> jStack;

    iStack.push(i);
    jStack.push(i);

    while(iStack.size() > 0)
    {
        if (iStack.top() == n)
        {
            jStack.pop();
            iStack.pop();
            //Display contents of v
        }
        else
        {
            for (int j = iStack.top(); j …

有人可以用英语解释排序算法的非递归和递归实现是如何相互不同的？

我目前正在编写一些分治算法,其中函数递归在任何地方使用,但我有一个非常模糊的想法或不知道它是如何工作的,这就是为什么我在这里发布它并希望你不介意它太基本.

例如,如果我们有以下代码:

#include<iostream>
using namespace std;
void Recursion(int n)
{
  cout << n << endl;
  if(n > 0)
  {
    Recursion(n-1);
  }
  cout<<n<<endl;
}

int main()
{
  Recursion(3);
  return 0;
}

我测试了Recursion(3),终端中的打印输出是:

3
2
1
0
0
1
2
3

我可以理解函数的递归调用的概念,但我不理解它是如何工作的机制.例如,他们无法再次调用该函数后会做什么？例如,在这里,我可以理解它打印从3到0,但为什么它也会再次从0打印到3？我听说是因为函数递归存储在一个递归的堆栈中,当它到达"底部"时,它也必须删除.

但无论如何,我不知道.那么,任何人都可以帮助我,并清楚地告诉我这里发生了什么以及函数调用的确切流程？

谢谢你的帮助!

我遇到了这个可以压缩字典的功能:

def flatten(dictionnary, container=None):
    if container is None:
        container = []
    for k, v in dictionnary.items():
        container.append(k)
        if v:
            flatten(v, container)
    return container

为了测试它,我创建了一个嵌套n时间的字典,如下所示:

nesteddict = {}
for i in range(n, 0, -1):
    emptydict = {}
    emptydict[i] = nesteddict
    nesteddict = emptydict

该函数n小于999时工作,否则命中递归限制:

RecursionError: maximum recursion depth exceeded while calling a Python object

所以经过一点点搜索之后,似乎任何递归函数都可以重写为迭代,但是我无法看到如何为我必须产生相同结果的函数完成它.

我在玩这个游戏时遇到的另一个奇怪的问题是,如果我尝试下面的代码n >= 998:

nesteddict = {}
for i in range(n, 0, -1):
    emptydict = {}
    emptydict[i] = nesteddict …

我想,我有一个非常简单的问题.我有这个问题,可以通过递归函数很容易地解决,但我无法迭代地解决.

假设您有任何布尔矩阵,例如:

L:

111011111110
110111111100
001111111101
100111111101
110011111001
111111110011
111111100111
111110001111

我知道这不是一个普通的布尔矩阵,但它对我的例子很有用.你可以注意到那里有一些零路径......

我想创建一个接收这个矩阵的函数和一个存储零的点,并将同一区域中的每个零转换为2(假设矩阵可以存储任何整数,即使它最初是布尔值)

(就像在Paint或任何图像编辑器中绘制区域一样)

假设我用这个矩阵M调用函数并且右上角的坐标为零,结果将是:

111011111112
110111111122
001111111121
100111111121
110011111221
111111112211
111111122111
111112221111

好吧,我的问题是如何迭代地执行此操作...希望我没有把它弄得太乱

提前致谢!

曼努埃尔

ps:如果你能用C,S,python或伪代码显示函数,我会很感激,请:D

我有一个包含多个表单的页面,我通过串行方式通过Ajax POST提交.起初,我尝试使用同步XHR请求,但这会导致浏览器在请求期间锁定,并破坏我的DOM操作效果,这是不可接受的.所以我最终使用的模式基本上是这样的:

var fcount = 0;    // incremented for each form to be submitted
function submit_form( num ) { 
    var fdata = { ... }; // data from form # num
    $.ajax( { async:    true,
              url:      '/index.cgi',
              data:     fdata,
              type:     'POST',
              success:  function() { 
                  if ( num < fcount ) { 
                      submit_form( ++num );
                  }
              }
           } );
}

$( '#submit_form_btn' ).click( function() { submit_form( 1 ) } );

递归让我觉得这是一个基本上是迭代问题的丑陋解决方案.是否有更清洁或更优雅的方式可以处理？

是每一个递归函数转换为迭代？递归函数应该具有什么特性才能使用迭代实现它？

我一直在尝试使用迭代定义以下函数,但似乎是不行!它应该探索迷宫中的所有路径(节点).任何人都可以使用迭代重写这个吗？如果不可能,为什么不呢？

typedef int[0,99] id_t;
bool visited[id_t];
int path[id_t];
int pathCounter = 0;

struct { 
    id_t id;
    bool free;
    int neighborNode[4];
} nodeMap[id_t];

void findPath(int current){
    visited[current] = true;
    for (i : int[0, 3]){
        if(nodeMap[nodeMap[current].neighborNode[i]].free == true && visited[nodeMap[current].neighborNode[i]] == false && nodeMap[current].neighborNode[i] != -1){
        path[pathCounter] = nodeMap[nodeMap[current].neighborNode[i]].id;
        pathCounter++;
        findPath(nodeMap[current].neighborNode[i]);
        path[pathCounter] = nodeMap[current].id;
        pathCounter++;      
        }
    }
    path[0] = current;
}

扩展:是否可以将提到的递归函数转换为迭代而不实现我自己的堆栈？其中一个答案表明,每个尾递归函数都可以转换为迭代而不使用堆栈结构......如果是这样,每个递归函数是否可以转换为尾递归？怎么样？

如何将这种递归循环改为非递归？我知道这种方法很简单，但我对此解决方案的非递归方式感兴趣。

using System;
using System.IO;

namespace NonRecursion {
    class NonRecursion {
        static void Main() {
            string createPath = Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments);

            string getPath = createPath + @"\folder";
            GetDirsPath(getPath);

            Console.ReadKey();
        }

        static void GetDirsPath(string getPath) {
            string[] dirs = Directory.GetDirectories(getPath);

            for (int i = 0; i < dirs.Length; i++) {
                Console.WriteLine(dirs[i]);
                GetDirsPath(dirs[i]);
            }
        }
    }
}

我可以只更改这个功能吗？

static void GetDirsPath(string getPath) {
            string[] dirs = Directory.GetDirectories(getPath);

            for (int i = 0; i < dirs.Length; i++) {
                Console.WriteLine(dirs[i]);
                GetDirsPath(dirs[i]);
            }
        }

可能重复:
每次递归都可以转换为迭代吗？

是否存在必须使用递归的问题,并且无法迭代地执行此操作？例如,删除子文件夹中的文件.

public static boolean deleteFile(String sFilePath)
{
  File oFile = new File(sFilePath);
  if(oFile.isDirectory())
  {
    File[] aFiles = oFile.listFiles();
    for(File oFileCur: aFiles)
    {
       deleteFile(oFileCur.getAbsolutePath());
    }
  }
  return oFile.delete();
}

我无法想到上面那个的迭代版本,因为我们必须事先知道实际存在多少级别的文件夹,如果我们引入一个新的子文件夹,我们将不得不更改代码.是否可以制作上述代码的迭代版本,以便将来不需要更改代码？

我有这个功能,我想把它改成迭代的.有谁知道怎么做？

#include "list.h"

int count(LINK head)
{

if(head == NULL)
   return 0;
else
   return (1 + count(head -> next));
}