Algorithm 替换未知数量字符的所有选项

我试图找到一种算法，对于字符串中未知数量的字符，生成用星号替换某些字符的所有选项

例如，对于字符串“abc”，输出应为：

*bc   
a*c  
ab*  
**c  
*b*  
a**
***  

---

对于已知数量的星星来说，这很简单，只需使用for循环运行所有选项，但我在使用所有选项时遇到困难。

这基本上是一个二进制增量问题。 您可以创建一个整数变量向量来表示二进制数组isStar，并且对于每个迭代，您可以向向量“添加一个”

bool AddOne (int* isStar, int size) {
    isStar[size - 1] += 1
    for (i = size - 1; i >= 0; i++) {
        if (isStar[i] > 1) {
            if (i = 0) { return true; }
            isStar[i] = 0;
            isStar[i - 1] += 1;
        }
    }
    return false;
}

---

这样，在替换字符时仍保留原始字符串，这基本上是一个二进制增量问题。 您可以创建一个整数变量向量来表示二进制数组isStar，并且对于每个迭代，您可以向向量“添加一个”

bool AddOne (int* isStar, int size) {
    isStar[size - 1] += 1
    for (i = size - 1; i >= 0; i++) {
        if (isStar[i] > 1) {
            if (i = 0) { return true; }
            isStar[i] = 0;
            isStar[i - 1] += 1;
        }
    }
    return false;
}

---

这样，在替换字符时仍保留原始字符串，这基本上是一个二进制增量问题。 您可以创建一个整数变量向量来表示二进制数组isStar，并且对于每个迭代，您可以向向量“添加一个”

bool AddOne (int* isStar, int size) {
    isStar[size - 1] += 1
    for (i = size - 1; i >= 0; i++) {
        if (isStar[i] > 1) {
            if (i = 0) { return true; }
            isStar[i] = 0;
            isStar[i - 1] += 1;
        }
    }
    return false;
}

---

这样，在替换字符时仍保留原始字符串，这基本上是一个二进制增量问题。 您可以创建一个整数变量向量来表示二进制数组isStar，并且对于每个迭代，您可以向向量“添加一个”

bool AddOne (int* isStar, int size) {
    isStar[size - 1] += 1
    for (i = size - 1; i >= 0; i++) {
        if (isStar[i] > 1) {
            if (i = 0) { return true; }
            isStar[i] = 0;
            isStar[i - 1] += 1;
        }
    }
    return false;
}

---

这样，在替换字符时仍保留原始字符串

每个星号组合对应于二进制数，因此可以使用简单循环

for i = 1 to 2^n-1  

其中n是字符串长度
并将星星设置为i的二进制表示的1位位置

---

例如：i=5=101b=>*b*

每个星的组合都对应于二进制数，所以可以使用简单循环

for i = 1 to 2^n-1  

其中n是字符串长度
并将星星设置为i的二进制表示的1位位置

---

例如：i=5=101b=>*b*

每个星的组合都对应于二进制数，所以可以使用简单循环

for i = 1 to 2^n-1  

其中n是字符串长度
并将星星设置为i的二进制表示的1位位置

---

例如：i=5=101b=>*b*

每个星的组合都对应于二进制数，所以可以使用简单循环

for i = 1 to 2^n-1  

其中n是字符串长度
并将星星设置为i的二进制表示的1位位置

---

例如：i=5=101b=>*b*

这是一个简单的二进制计数问题，其中

*

对应于

1

，原始字母对应于

0

。所以你可以用一个计数器，在字符串上加上一个掩码，但是在适当的地方进行“计数”同样容易

下面是一个简单的C++实现：

（编辑：原来的问题似乎暗示至少有一个字符必须替换为星号，因此计数应从1开始，而不是从0开始。或者，在以下情况下，后测试

do

应替换为

的预测试
）

#包括
#包括
//更聪明的实现将实现C++的迭代器协议。
//但这会给算法的简单逻辑蒙上阴影。
类星形置换器{
公众：
StarReplacer（const std:：string&s）：原始的，当前的{
常量std:：string¤t（）常量{返回当前值}
//返回true，除非我们在最后一个可能性（全明星），
//在这种情况下，它返回false，但仍将当前值重置为
//原始配置。
bool advance（）{
对于（int i=当前大小（）-1；i>=0；--i）{
如果（当前_u[i]='*'）当前_[i]=原始_[i]；
否则{
当前_ui]='*'；
返回true；
}
}
返回false；
}
私人：
std：：字符串原始值；
std：：串电流；
};
int main（int argc，常量字符**argv）{
对于（int a=1；astd:：cout这是一个简单的二进制计数问题，
*
对应一个
1
，而原始字母对应一个
0
。因此，您可以使用计数器，对字符串应用位掩码，但在适当的位置进行“计数”同样容易

下面是一个简单的C++实现：

（编辑：原来的问题似乎暗示至少有一个字符必须替换为星号，因此计数应从1开始，而不是从0开始。或者，在以下情况下，后测试
do
应替换为
的预测试
）

#包括
#包括
//更聪明的实现将实现C++的迭代器协议。
//但这会给算法的简单逻辑蒙上阴影。
类星形置换器{
公众：
StarReplacer（const std:：string&s）：原始的，当前的{
常量std:：string¤t（）常量{返回当前值}
//返回true，除非我们在最后一个可能性（全明星），
//在这种情况下，它返回false，但仍将当前值重置为
//原始配置。
bool advance（）{
对于（int i=当前大小（）-1；i>=0；--i）{
如果（当前_u[i]='*'）当前_[i]=原始_[i]；
否则{
当前_ui]='*'；
返回true；
}
}
返回false；
}
私人：
std：：字符串原始值；
std：：串电流；
};
int main（int argc，常量字符**argv）{
对于（int a=1；astd:：cout这是一个简单的二进制计数问题，
*
对应一个
1
，而原始字母对应一个
0
。因此，您可以使用计数器，对字符串应用位掩码，但在适当的位置进行“计数”同样容易

下面是一个简单的C++实现：

（编辑：原始问题似乎暗示至少有一个字符必须替换为星形，因此计数应从1开始，而不是从0开始。或者，在下面的测试中，是后测