c++ variable Anzahl von for Schleifen

Gast #5958259
Lesenswert?

Hallo

ich möchte in visual studio ein kleines c++ tool, das einen 
kleingeschriebenen Text liest (originalText) und dann alle Möglichkeiten 
ausgibt, mit jeweils einen großgeschriebenen Buchstaben. Das klappt so 
ganz gut:
1
for (int n = 0; n < Text_lenght; n++) {
2
    modifiedText1 = originalText;    
3
    modifiedText1[n] ^= 0x20;
4
    cout << modifiedText1 << endl;
5
}


Analog dazu gibt der folgende Code maximal 2 großgeschriebene Buchstaben 
aus:
1
for (int n = 0; n < Text_lenght; n++) {
2
    modifiedText1 = originalText;    
3
    modifiedText1[n] ^= 0x20;
4
    cout << modifiedText1 << endl;
5
    for (int m = n+1; m < Text_lenght; m++) {
6
      modifiedText2 = modifiedText1;
7
      modifiedText2[m] ^= 0x20;
8
      cout << modifiedText2 << endl;
9
      }
10
}


Natürlich kann man entsprechende Verschachtelungen auch für max.3, max.4 
usw anwenden.
Wie geh ich aber vor, wenn ich nun maximal n großgeschriebene Buchstaben 
möchte? Zum Beispiel dass n jeweils die Länge des Textes ist?
Gast #5959333
Lesenswert?

Beispiel:
1
#include <stdio.h>
2
#include <stdlib.h>
3

4
void
5
foo(char *str, int i, int n)
6
{
7
    if (str[i] && n > 0)   
8
    {    
9
        str[i] ^= 0x20;
10
        printf("%s\n", str);
11
        foo(str, i+1, n-1);
12
        str[i] ^= 0x20;
13
        foo(str, i+1, n);
14
    }
15
}
16
    
17
int 
18
main(int argc, char **argv)
19
{   
20
    if (argc == 3) 
21
        foo(argv[1], 0, atoi(argv[2])); 
22
    
23
    return 0;
24
}
Gast #5959379
Lesenswert?

Hmm... mit meinem Beispiel bin ich evtl etwas über's Ziel 
hinausgeschossen und mag einen Anfänger überfordern, deshalb hier ein 
etwas zugänglichere Version der Funktion foo.  Die Endrekursion, die 
hier nicht Thema ist, wurde durch eine Schleife ersetzt und es werden 
sprechende Namen benutzt:
1
void
2
grossklein(char *str, int ab_pos, int wieviele)
3
{        
4
    if (wieviele > 0)
5
        for (int i = ab_pos; str[i]; i++)
6
        {
7
            str[i] ^= 0x20;
8
            printf("%s\n", str);
9
            grossklein(str, i+1, wieviele-1);
10
            str[i] ^= 0x20;
11
        }
12
}

Die Rekursion ist klar zu erkennen und mit etwas Überlegung wird 
deutlich, dass durch sie bis zu wieviele Schleifen gleichzeitig 
aktiv sind.

Übung: Die Funktion so abändern, dass nur Strings, die exakt wieviele 
Zeichen geändert haben, ausgegeben werden.
Beitrag #5960150 wurde von einem Moderator gelöscht.
#5960156
Lesenswert?

Erstmal sollte man das ganze in C++ schreiben wie eingangs gefordert, 
dann wirds auch gleich viel simpler...

Als einfaches Beispiel großschreiben des ganzen Strings:
1
#include <array>
2
#include <iostream>
3
#include <algorithm>
4
#include <cctype>
5

6
int main()
7
{
8
    const std::array<std::string, 2> textSnippets = {"testString123!?", "testString456()"};
9
    
10
    for(const std::string &snippet: textSnippets) {
11
        std::string modifiedText;
12
        modifiedText.resize(snippet.size());
13
        std::transform(snippet.begin(), snippet.end(), modifiedText.begin(), ::toupper);
14
        
15
        std::cout << snippet << "-->" << modifiedText << "\n";
16
    }
17
}

Runs as expected:
1
testString123!?-->TESTSTRING123!?
2
testString456()-->TESTSTRING456()
http://www.cpp.sh/6kj2d

Darauf aufbauend sollte es kein Problem sein, mit foobars Ansatz deine 
ursprüngliche Aufgabe zu lösen, nur halt in C++ statt C.

Antwort schreiben

Bitte melde dich an, um einen Beitrag zu schreiben.

oder

Mit Google-Account einloggen

Die Registrierung ist kostenlos und dauert nur eine Minute.

Jetzt registrieren