Aus einem STring Zeichen entnehmen

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