Aus einem STring Zeichen entnehmen

Ahhh sry -.- AACCEEFF sollte es sein und der Quellstrng darf nicht verändert werden.. und dann eben in ACEFACEF

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?

Belli

Angenommen, Du hast die Position pos eines Buchstabens in einem String Quelle, dann kannst Du folgendes tun:

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.

unskilled

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

          }

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

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

Vicious Falcon

Wenn die Strings immer so aussehen, dass jeweils 2 (genau 2) Buchstaben gleich sind, dann kann man sich das Leben auch einfach machen

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++);

unskilled

sortieren war hier nicht erforderlich.
und da jz eh schon ne lösung da ist...

#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

Wo wir schon dabei sind:

#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;
}

unskilled

ist halt die frage, was bei AAAABB passieren soll...

bb

padreigh

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]);

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

:p

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

unskilled

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

ich hab nur drauf gewartet... : D

Dann halt

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)

krümelkacker

seldon schrieb:

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.

EOP

DumbAss schrieb:

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

cout << "ACEACE";

:p

padreigh

padreigh schrieb:

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