Ich hab nen Quellstring in dem AAEECC steht

Ich soll ein Algorithmus schreiben der den folgenden Zielstring ausgibt: ACEACE.

So weit so gut...

Ich wollte nur fragen was ich nutzen muss um an spezielle zeichen zu kommen?
(zB das zweite A)

Mit find() kann ich ja nur die Position rausbekommen.

Bitte ne idioten-sichere Antwort ^^

das machst du so lang, bis der string leer ist...
wo liegt das problem?
wo ist dein ansatz?

Mein Ansatz sieht so aus:

#include <iostream>
#include <string>

using namespace std;
int main()

{
        string Quelle = "AAEECCFF";
        string Ziel;
        int i=0;

          for( i=0; i<=(Quelle.length()+4)/2; i++)
          {
               i++;
               cout<<Quelle.size();

          }

          for( i=1; i<=(Quelle.length()+6)/2; i++) 
          {
               ++i;
          }

system ("pause");        
}

Mit den Forschleifen hab ich ja schon die richtigen Postionen der einzelnen Buchstaben. Bloß wie les ich diese jetzt aus und speicher sie in einem String?

string ziel; //echter Code

mach
{
  ermittel pos   //Pseudocode
  ziel.push_back(Quelle[pos]); //echter Code
} bis fertig; //Pseudocode

Das push_back hängt ein Zeichen hinten an ziel an. Der Quellstring bleibt hierbei unverändert.

die schleifen an sich sehen beide so aus, als ob du sie nicht so verwenden solltest...
geh noch mal auf einem blatt papier durch, welche buchstaben genommen werden müssen - und wenn du die indizes dann auf das blatt geschrieben hast, versuchst du nach nem algorithmus zu suchen, der diese zahlen nacheinander ausspuckt...
den brauchst du dann nur noch in C++ "zu übersetzen".
ich sehe hier allerdings noch nicht mal ansatzweise nen algorithmus. nur 2 forschleifen, die zumindest extrem komisch sind.

bb

std::string str = "AAZZIIEECCFFGGHHJJ";
std::string str2(str);
std::sort(str2.begin(),str2.end(),std::less<char>());
std::string::iterator it = std::unique(str2.begin(),str2.end());
int i=0;
for(;it!=str2.end();++it)
	*it = *(str2.begin()+i++);

#include <string>

std::string get_magic_string(const std::string& value)
{
  std::string ret_val;
  ret_val.reserve(value.size());

  for(std::string::size_type i(0), e(value.size()); i < e; i += 2)
  {
    ret_val.push_back(value[i]);
  }

  return ret_val += ret_val;
}

#include <iostream>

int main()
{
  std::cout << get_magic_string("AACCEEFF") << std::endl;

  char dont_close_console;
  std::cin >> dont_close_console;
}

bb

#include <algorithm>
#include <iterator>
#include <string>

std::string get_magic_string(const std::string& value)
{
  std::string result;

  result.reserve(value.size());

  std::unique_copy(value.begin(), value.end(), std::back_inserter(result));
  result += result;

  return result;
}

bb

:p

Fazit: Ein einziges Ein-/Ausgabe Beipiel ohne weitere Details über das, was da eigentlich passieren soll, ist nicht zielführend.

string funktion(string const& s)
{
  return "ACEFACEF";
}

ich hab nur drauf gewartet... : D

std::string get_magic_string(std::string value)
{
  unsigned pos = 0;
  std::stable_partition(value.begin(),
                        value.end  (),
                        [&pos](char) { return ++pos % 2 == 1; });
  return value;
}

(Der C++-0x-Lambda-Ausdruck ist ggf. durch std::tr1::bind oder einen handgeschriebenen Funktor ersetzbar)

std::string get_magic_string(std::string value)
{
  unsigned pos = 0;
  std::stable_partition(value.begin(),
                        value.end  (),
                        [&pos](char) { return ++pos % 2 == 1; });
  return value;
}

Autsch! Die Reihenfolge, in der stable_partition das Prädikat auf die Elemente loslässt ist ja gar nicht vom Standard festgelegt.

Ich soll ein Algorithmus schreiben der den folgenden Zielstring ausgibt: ACEACE.

cout << "ACEACE";

:p

std::string start = "AABBCCDDEE";
std::string erg;
for (int i=0;i<start.size();i++)
  if (i%2==0) erg.insert(erg.size()/2,start[i]); else erg.append(start[i]);

Aufgerollt da iss_doch_einfach meinte man sollte was verboser sein :

std::string start = "AABBCCDDEE";
std::string   erg = "";
// Schleife aufgerollt:
// for (int i=0;i<start.size();i++)  
// i == 0, 0 % 2 == 0, erg.size() == 0
    erg.insert(erg.size()/2,start[0]);         // erg.insert(0,'A'); --> erg = "A";
// i == 1, 1 % 2 == 1 
    erg.append(start[1]);                      // erg.append('A'); --> erg = "AA";
// i == 2, 2 % 2 == 0, erg.size() == 2
    erg.insert(erg.size()/2,start[2]);         // erg.insert(1,'B'); --> erg = "ABA";
// i == 3, 3 % 2 == 1
    erg.append(start[3]);                      // erg.append('B'); --> erg = "ABAB";
// i == 4, 4 % 2 == 0, erg.size() == 4
    erg.insert(erg.size()/2,start[4]);         // erg.insert(2,'C'); --> erg = "ABCAB";
// i == 5, 5 % 2 == 1
    erg.append(start[5]);                      // erg.append('C'); --> erg = "ABCABC";
// i == 6, 6 % 2 == 0, erg.size() == 6
    erg.insert(erg.size()/2,start[6]);         // erg.insert(3,'D'); --> erg = "ABCDAB";
// i == 7, 7 % 2 == 1
    erg.append(start[7]);                      // erg.append('D'); --> erg = "ABCDABCD";
// i == 8, 8 % 2 == 0, erg.size() == 8
    erg.insert(erg.size()/2,start[8]);         // erg.insert(4,'E'); --> erg = "ABCDEABCD";
// i == 9, 9 % 2 == 1
    erg.append(start[9]);                      // erg.append('e'); --> erg = "ABCDEABCDE";
// i == 10, i nicht < start.size() ... feddich