Die Suche nach Strings Nachbarn bis zu 2 unterschiedlichen Positionen
https://stackoverflow.com/questions/680011
-
22-08-2019 - |
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianFrage
Bei einer Samen Zeichenfolge, ich will mit seinen Nachbarn finden, höchstens in zwei Positionen unterscheiden. Alle Ziffern beinhalten in Zeichenfolge zu erzeugen sind nur vier (d.h. 0,1,2,3). Dies ist das Beispiel für das, was ich meine:
# In this example, 'first' column
# are neighbors with only 1 position differ.
# The rest of the columns are 2 positions differ
Seed = 000
100 110 120 130 101 102 103
200 210 220 230 201 202 203
300 310 320 330 301 302 303
010 011 012 013
020 021 022 023
030 031 032 033
001
002
003
Seed = 001
101 111 121 131 100 102 103
201 211 221 231 200 202 203
301 311 321 331 300 302 303
011 010 012 013
021 020 022 023
031 030 032 033
000
003
002
Hence given a tag of length L
we will have 3*L + 9L(L-1)/2 neighbors
Aber warum dieser Code von mir scheitert es richtig zu generieren? Vor allem, wenn die Samen Zeichenfolge außer "000".
Andere Ansätze sind auch escpecially Geschwindigkeit Verbesserung begrüßt. Schon seit wir werden Millionen von Samen-Tags der Länge 34 bis 36 werden verarbeitet.
#include <iostream>
#include <vector>
#include <fstream>
#include <sstream>
using namespace std;
string ConvertInt2String(int IntVal) {
std::string S;
std::stringstream out;
out << IntVal;
S = out.str();
return S;
}
string Vec2Str (vector <int> NTg) {
string StTg = "";
for (unsigned i = 0; i < NTg.size(); i++) {
StTg += ConvertInt2String(NTg[i]);
}
return StTg;
}
template <typename T> void prn_vec(const std::vector < T >&arg, string sep="")
{
for (unsigned n = 0; n < arg.size(); n++) {
cout << arg[n] << sep;
}
return;
}
vector <int> neighbors(vector<int>& arg, int posNo, int baseNo) {
// pass base position and return neighbors
vector <int> transfVec;
transfVec = arg;
//modified according to strager's first post
transfVec[posNo % arg.size()] = baseNo;
return transfVec;
}
int main () {
vector <int> numTag;
numTag.push_back(0);
numTag.push_back(0);
numTag.push_back(1); // If "000" this code works, but not 001 or others
// Note that in actual practice numTag can be greater than 3
int TagLen = static_cast<int>(numTag.size());
for ( int p=0; p< TagLen ; p++ ) {
// First loop is to generate tags 1 position differ
for ( int b=1; b<=3 ; b++ ) {
int bval = b;
if (numTag[p] == b) {
bval = 0;
}
vector <int> nbnumTag = neighbors(numTag, p, bval);
string SnbnumTag = Vec2Str(nbnumTag);
cout << SnbnumTag;
cout << "\n";
// Second loop for tags in 2 position differ
for (int l=p+1; l < TagLen; l++) {
for (int c=1; c<=3; c++) {
int cval = c;
if (nbnumTag[l] == c) {
cval = c;
}
vector <int> nbnumTag2 = neighbors(nbnumTag, l, cval);
string SnbnumTag2 = Vec2Str(nbnumTag2);
cout << "\t" << SnbnumTag2;
cout << "\n";
}
}
}
}
return 0;
}
Lösung
Würde dies tun? Es aufzählt den Baum von möglichen Strings, Beschneiden alle mit> 2 Abweichungen vom Original.
void walk(char* s, int i, int ndiff){
char c = s[i];
if (ndiff > 2) return;
if (c == '\0'){
if (ndiff > 0) print(s);
}
else {
s[i] = '0'; walk(s, i+1, (s[i]==c ? ndiff : ndiff+1);
s[i] = '1'; walk(s, i+1, (s[i]==c ? ndiff : ndiff+1);
s[i] = '2'; walk(s, i+1, (s[i]==c ? ndiff : ndiff+1);
s[i] = '3'; walk(s, i+1, (s[i]==c ? ndiff : ndiff+1);
s[i] = c;
}
}
char seed[] = "000";
main(){
walk(seed, 0, 0);
}
Andere Tipps
Hier ist eine Möglichkeit, es zu tun, die für eine beliebige Anzahl von Zeichen und die Länge der Zeichenfolge funktionieren sollte:
string base = "000";
char values[] = {'0', '1', '2', '3' };
for (int i = 0; i < base.length(); ++i)
{
for (int j = 0; j < countof(values); ++j)
{
if (base[i] != values[j])
{
string copy = base;
copy[i] = values[j];
cout << copy << endl;
for (int k = i+1; k < base.length(); ++k)
{
for (int l = 0; l < countof(values); ++l)
{
if (copy[k] != values[l])
{
string copy2 = copy;
copy[k] = values[l];
cout << copy2 << endl;
}
}
}
}
}
}
Dies sollte äquivalent alle Fäden innerhalb eines Hamming-Abstand von 2, die über einen 4-Symbol-Alphabet zu erzeugen. Ich habe es gesehen Algorithmen, aber ich bin ratlos sie jetzt zu finden. Vielleicht kann dies in der richtigen Richtung als Zeiger dienen.
Ihr Problem [ EDIT: das Original (vorherige Revisionen Frage) ] ist, dass in der inneren Schleife, du bist nur das 'next' Element zugeordnet wird. Eine schnelle Lösung ist es, die Schreib in neighbors einzuwickeln:
vector <int> neighbors(const vector<int>& arg, int posNo, int baseNo) {
// pass base position and return neighbors
vector <int> transfVec = arg
transfVec[posNo % arg.size()] = baseNo;
return transfVec;
}
Dieses Update funktioniert nur, wenn Sie zwei oder drei Elemente im Array. Wenn Sie mehr wollen, müssen Sie Ihren Algorithmus neu zu schreiben, da es Fälle nicht behandeln, in denen die Länge von mehr als drei überhaupt. (Es sollte nicht brauchen, auch. Der Algorithmus Sie verwenden einfach zu restriktiv ist.)
Diese beiden, wenn ist:
if (numTag[p] == b) {
bval = 0;
}
if (nbnumTag[l] == c) {
cval = c;
}
Sollte stattdessen Leichen von continue hat.
Diese beiden Schleifen sollten bei 0 beginnen:
for ( int b=1; b<=3 ; b++ ) {
for (int c=1; c<=3; c++) {
// i.e.
for ( int b=0; b<=3 ; b++ ) {
for (int c=0; c<=3; c++) {
Es sieht aus wie strager das Hauptproblem identifiziert hat: die Schleifenbedingungen. Ihr Alphabet ist 0,1,2,3, so sollten Sie eine Schleife über diesen gesamten Bereich. 0 ist kein Sonderfall, wie Ihr Code versucht, sie zu behandeln. Der Sonderfall ist die Iteration zu überspringen, wenn das Alphabet Wert den Wert in Ihrem Schlüssel entspricht, das ist es, was die von strager vorgeschlagen weiterhin erreicht.
Im Folgenden finden Sie meine Version Ihres Algorithmus. Es hat einige alternativen Ideen für Loop-Strukturen und vermeidet den Schlüssel zu kopieren, indem es an Ort und Stelle zu ändern. Beachten Sie, dass Sie auch die Größe des Alphabets ändern, indem sie die MIN_VALUE und MAX_VALUE Konstanten ändern.
Hier ist der Ausgang für den "001" Fall:
101 111 121 131 102 103 100
201 211 221 231 202 203 200
301 311 321 331 302 303 300
011 012 013 010
021 022 023 020
031 032 033 030
002
003
000
Und hier ist der Code:
#include <iostream>
#include <vector>
#include <string>
#include <sstream>
using namespace std;
const int MIN_VALUE = 0;
const int MAX_VALUE = 3;
int increment(int& ch)
{
if (ch == MAX_VALUE)
ch = MIN_VALUE;
else
++ch;
return ch;
}
string stringKey(const vector<int>& key)
{
ostringstream sout;
for (int i = 0; i < key.size(); ++i)
sout << key[i];
return sout.str();
}
int main()
{
vector<int> key;
key.push_back(0);
key.push_back(0);
key.push_back(1);
for (int outerKeyPos = 0; outerKeyPos < key.size(); ++outerKeyPos)
{
int outerOriginal = key[outerKeyPos];
while (increment(key[outerKeyPos]) != outerOriginal)
{
cout << stringKey(key);
for (int innerKeyPos = outerKeyPos + 1; innerKeyPos < key.size(); ++innerKeyPos)
{
int innerOriginal = key[innerKeyPos];
while (increment(key[innerKeyPos]) != innerOriginal)
{
cout << " " << stringKey(key);
}
}
cout << endl;
}
}
}
Ich habe versucht, Ihren Algorithmus zu korrigieren, so nah wie möglich am Original zu bleiben:
int TagLen = static_cast<int>(numTag.size());
for ( int p=0; p< TagLen ; p++ ) {
// First loop is to generate tags 1 position differ
for ( int b=0; b<=3 ; b++ ) { // Loop over all 4 elements
int bval = b;
if (numTag[p] == b) {
continue; // This is the seed vector, ignore it
}
vector <int> nbnumTag = neighbors(numTag, p, bval);
string SnbnumTag = Vec2Str(nbnumTag);
cout << SnbnumTag;
cout << "\n";
// Second loop for tags in 2 position differ
for (int l=p+1; l < TagLen; l++) {
for (int c=0; c<=3; c++) {
int cval = c;
if (nbnumTag[l] == c) { // Loop over all 4 elements
continue; // This is nbnumTag, ignore it
}
vector <int> nbnumTag2 = neighbors(nbnumTag, l, cval);
string SnbnumTag2 = Vec2Str(nbnumTag2);
cout << "\t" << SnbnumTag2;
cout << "\n";
}
}
}
}
Das Problem ist, dass Sie iterieren nicht alle vier möglichen Werte (0,1,2,3), aber Sie 0 aus irgendeinem Grund überspringen. So wie ich es tue, ist, sie alle zu durchlaufen und ignorieren (unter Verwendung eines weiter), um den Vektor, der das gleiches mit dem Samen oder den 1-Punkt anderen Tag in Phase 1 berechnet.
Having said that, ich glaube, dass eine bessere Algorithmen als Ihre vorgeschlagen werden und es wäre besser, eine von ihnen zu betrachten.
Hier ist meine hässliche, hacky Lösung:
#include <iostream>
#include <vector>
using std::cout;
using std::endl;
using std::vector;
struct tri
{
tri(int a, int b, int c)
{
switch (a)
{
case 0:
m[0] = 0;
m[1] = b;
m[2] = c;
break;
case 1:
m[0] = b;
m[1] = 0;
m[2] = c;
break;
case 2:
m[0] = b;
m[1] = c;
m[2] = 0;
break;
}
}
int m[3];
};
int main()
{
vector<tri> v;
for (int i = 0; i < 3; i++)
for (int j = 0; j < 4; j++)
for (int k = 0; k < 4; k++)
{
v.push_back(tri(i,j,k));
}
vector<tri>::iterator it;
for (it = v.begin(); it != v.end(); ++it)
{
cout << (*it).m[0];
cout << (*it).m[1];
cout << (*it).m[2];
cout << endl;
}
}
