8 Réponses :
Vous pouvez utiliser std :: string code> std :: vecteur code> et std :: inverse code> pour faciliter les choses: #include <string> // for storing strings in a C++ way
#include <sstream> // to easily separate sentences into words
#include <vector> // to dynamically store arbitrary amounts of words
#include <algorithm> // for std::reverse
/ * Ne pas imprimer espace après le 1er mot * /
Si (index> 0)
Si la phrase commence par une seule lettre, un espace ne sera pas imprimé dans la chèque ci-dessus.
Il devrait être Si (index> = 0)
@inquisitive_mind Excuse-moi? Je n'ai rien comme ça dans ma réponse / code. Pouvez-vous m'éclairer sur ce que votre commentaire est censé me dire?
#include <sstream>
#include <iostream>
#include <list>
int main() {
char sentence[256];
std::cin.getline(sentence, 256);
std::istringstream f(sentence );
std::string s;
std::list<std::string> strings;
while (f >> s)
{
strings.push_front(s);
}
}
at this moment strings contains the words in reverse order
Correction à la version antérieure, fermement langue-in-joue :) Notez que le programme lit tout STDIN, traiter chaque ligne individuelle en tant que «phrase».
Cela renverse le caractère de la phrase entière par caractère, pas le mot par mot.
Ah, vous avez tout à fait raison :) Oh bien, en utilisant une plage de boost, je fixais que et le rendent plus élégant, mais je suppose que ce genre de dépasse la portée des réponses utiles ...
Eh bien, je ne suis personnellement pas un fan de boost, mais d'autres pourraient être en désaccord. Voyons votre approche de boost ;-)
@stefan là-bas, le dîner est venu de la manière suivante: / Toutefois, le résultat est une quasi-terre. C'est évidemment la solution la plus simple :)
Dafuq est-ce que je viens de lire? Je ne peux tout simplement pas dire si cela est correct. Eh bien, je vais juste faire confiance à ce que son code de travail est en réalité (je n'ai pas de boost installé, alors je ne peux même pas vérifier), mais je ne recommande jamais de le faire de cette façon: à mon avis, l'intention du code devrait être directement visible.
@stefan lol. J'espère bien que vous n'avez pas manqué le point sur les positions relatives de la lingua et buccae :)
Lorsque vous dites
void reverse(char* sentence, const int START)
{
if(sentence[START] == '\0') return;
char last = '\0';
int hold = 0;
int index = START + 1;
while(sentence[index] != '\0' && sentence[index] != ' ') {//There are better ways to do this logic, but I wanted to remain true to your implementation as much as possible
index++;
}
reverse(sentence, index);
for(int j = START; j < index; j++) {
cout << sentence[j];
}
cout << endl;
return;
}
Comme les autres réponses suggèrent que vous devriez utiliser std :: string code> qui peut économiser beaucoup de tracas.
Mais juste pour la note, void reverse(char* sentence)
{
int index = strlen(sentence) - 1,hold,last = '\0';
/*For the 1st iteration last is `\0` for all others it is ` `*/
while (index >= 0)
{
/*
In your original code,
This while loop(below) will continue to keep decrementing index
even below `0`,You wont exit this while loop until you encounter a ` `.
For the 1st word of the sentence you will never come out of the loop.
Hence the check, index>=0
*/
while (index>=0 && sentence[index] != ' ')
index--;
/* You can print the whitespace later*/
hold = index - 1; // This keeps track of the last character
// of preceding word
index++; //character after space
while (sentence[index] != last)
{
cout << sentence[index];
index++;
}
last = ' ';
index = hold;
/* Dont print space after 1st word*/
if(index > 0)
cout<<" ";
}
}
int main()
{
char* sentence = new char[256];
cin.getline(sentence, 256);
reverse(sentence);
delete[] sentence; // Delete the allocated memory
}
Juste ce que je voulais, tellement.
J'aimerais utiliser la pile. 1.entre la chaîne à l'aide de Délimiteur ("") 2. Poussez le mot dans la pile 3. Comme vous apparaissez, stockez ce mot dans la nouvelle variable de chaîne.
Ici, j'ai utilisé une phrase (tokenizing) avec des mots, puis utilisez cela pour l'impression inversée. J'espère que cette aide-
Vous pouvez le faire par la classe ISTRingStream de C ++
#include <bits/stdc++.h>
using namespace std;
int main()
{
string s,st,w;
int i;
getline(cin,s);
istringstream is(s);
st="";
is>>st;
while(is>>w)
{
st=w+' '+st;
}
cout<<st<<endl;
return 0;
}
Si vous utilisez C ++, pourquoi utilisez-vous CHAR *? Ce serait beaucoup plus facile avec les chaînes. Je me suis remarqué que vous avez marqué avec des "tableaux dynamiques", y a-t-il une raison particulière que vous utilisez Char * qui ferait une réponse à l'utilisation de chaînes inacceptables?
Que voyez-vous lorsque vous exécutez votre exemple à travers un débogueur?
Ce serait maintenant un bon moment pour commencer à apprendre à utiliser un débogueur. En entrant dans le code et en inspectant les variables, vous devriez pouvoir trouver le (s) bogue (s) pour vous-même assez rapidement.
Oui, je suis conscient que ce serait plus facile avec les chaînes et les autres moyens, mais je pratique simplement comme débutant.
Ajoutez chaque mot à empiler et commencez à faire apparaître ces ventouses
Faire cela en C Ça va être brut et, à mon avis, pas un exercice utile, à moins que vous n'essayez de vous apprendre à vous-même pourquoi les anciens cyclings cassent. Cela étant dit, j'utiliserais une approche récursive, chaque appel à la recherche d'un nouveau caractère WhitSpace ou du caractère / 0, alors que vous retournez la pile fonctionne (ajoutez-la à une liste) avec le mot que vous avez trouvé. Si vous faites ce travail après votre appel récursif, vos mots seront inversés!