Aus einem STring Zeichen entnehmen

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