Question

我是编写算法的新手，我正在创建一个程序来检查字符串是否是另外两个字符串的有序shuffle。（从左到右排序）例如

string 1 = dog
string 2 = cat
string shuffle = dcoagt

这是我的算法

**Algorithm: orderedSort(a,b,c)**
given strings a,b,c determine whether c is an ordered shuffle of a and b

l := length of (a + b)
if (l = 0) then
    return true
if (l not = length of c)
    return false
else
    d := substring of a position 1 to 1
    e := substring of b position 1 to 1
    f := substring of c position 1 to 1
if (d = f) then 
    return orderedSort(a-d, b, c-f) 
if (e = f) then
    return orderedSort(a, b-e, c-f)
if (d and e = f) then
    return orderedSort(a-d, b, c-f) or orderedSort(a, b-e, c-f)

我的问题是，这是否正确（如果没有，关于如何编写它的建议）因为我不确定如何为最后一个if语句编写伪代码，因为递归可以采用任何一种方式。

或者我不需要编写最后一个if语句，程序员在编写程序时会包含它，所以在

的情况下它不会失败

string 1 = aa
string 2 = aaf
string combination = aafaa

我的Java实现是

public class OrderedSort {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        String a = "xxyxxy";
        String b = "xxzxxz";
        String c = "xxzxxyxxyxxz";
        System.out.println(c + " is an ordered sort of " + a + " and " +  b + " ... " +  ordered(a,b,c));      
    }

    public static boolean ordered(String a, String b, String c){
        if(!((a.length()+b.length())==c.length()))
            return false;
        if(c.length()== 0)
            return true;
        if(a.length()>0 && b.length()>0 && a.substring(0,1).equals(b.substring(0,1)))
            return ordered(a.substring(1),b,c.substring(1)) || ordered(a,b.substring(1),c.substring(1));
        if(a.length()>0 && a.substring(0,1).equals(c.substring(0,1)))    
            return ordered(a.substring(1),b,c.substring(1));
        if(b.length()>0 &&b.substring(0,1).equals(c.substring(0,1)))
            return ordered(a,b.substring(1),c.substring(1));
        return false;
    }

}

Answer 1

你写的内容也是正确的，但如果你写的话

return max( orderedSort(a-d, b, c-f), orderedSort(a, b-e, c-f))

这可能会更清楚。

Answer 2

你的想法背后的逻辑是正确的，但没有必要将子串传递给递归函数。通过为每个字符串保留一个指针，我们可以完成任务。这是我的C ++实现：

#include<iostream>
using namespace std;

string a = "aa";
string b = "aaf";
string c = "aafaa";

bool check( int p1, int p2, int p3 ){
    bool c1 = p1 < a.size();
    bool c2 = p2 < b.size();
    bool c3 = p3 < c.size();
    if ( !c1 && !c2 && !c3 ){
        return true;
    }
    if ( c1 && c2 && c3 && a[p1]==b[p2] && b[p2]==c[p3] ){
        bool b1 = check(p1+1,p2,p3+1);
        bool b2 = check(p1,p2+1,p3+1);
        return (b1 || b2);
    } else if ( c3 && c1 && a[p1] == c[p3] ) {
        return check(p1+1,p2,p3+1 );
    } else if ( c2 && c3 && b[p2] == c[p3] ) {
        return check(p1,p2+1,p3+1 );
    } else {
        return false;
    }
}


int main()
{
    cout << check(0,0,0) << endl;
}

Answer 3

这里有一些Ruby代码（在它上面是imho伪代码）。

# with two strings
s1, s2 = 'abc', 'defg'
s1.split('').shuffle.join + s2.split('').shuffle.join
# "cbagefd"

# with variable number of strings
%w[abc defg hijkl].map{|string| string.split('').shuffle.join}.join
# "bacefdghlijk"

不需要递归，您可以自己对每个字符串进行随机连接并将它们连接在一起。

代码的一些解释：

.split(''): splits the string in an array of characters
.shuffle and .join speak for them self
%w[...] spilts the contained string in array of strings separated by a space
.map makes an array of the contained block of code

Answer 4

更简单的方法：计算您开始使用的字符串中所有字符的出现次数，并将它们放入由字符ascii编号索引的数组中。现在，当你得到一个新字符串时，检查你是否可以使每个字符之间的差异总和= 0.

递归算法

4 个答案: