Inverser chaque mot individuel de la chaîne "Hello World" avec Java
Je veux inverser chaque individuel Word d'une chaîne en Java (pas la chaîne entière, juste chaque mot individuel).
Exemple: si la chaîne d'entrée est "Hello World", la sortie doit être "olleH dlroW".
Cela devrait faire l'affaire. Cela va parcourir chaque mot de la chaîne source, l'inverser à l'aide de la méthode StringBuilder intégrée de reverse() et générer le mot inversé.
String source = "Hello World";
for (String part : source.split(" ")) {
System.out.print(new StringBuilder(part).reverse().toString());
System.out.print(" ");
}
Sortie:
olleH dlroW
Notes: Les commentateurs ont correctement souligné quelques points que je pensais devoir mentionner ici. Cet exemple ajoutera un espace supplémentaire à la fin du résultat. Cela suppose également que vos mots sont séparés par un seul espace et que votre phrase ne contient aucune ponctuation.
Connaissez vos bibliothèques ;-)
import org.Apache.commons.lang.StringUtils;
String reverseWords(String sentence) {
return StringUtils.reverseDelimited(StringUtils.reverse(sentence), ' ');
}
Vous devez le faire sur chaque mot après split en array de mots.
public String reverse(String Word) {
char[] chs = Word.toCharArray();
int i=0, j=chs.length-1;
while (i < j) {
// swap chs[i] and chs[j]
char t = chs[i];
chs[i] = chs[j];
chs[j] = t;
i++; j--;
}
return String.valueOf(chs);
}
Voici la solution la plus simple qui n’utilise même pas de boucles.
public class olleHdlroW {
static String reverse(String in, String out) {
return (in.isEmpty()) ? out :
(in.charAt(0) == ' ')
? out + ' ' + reverse(in.substring(1), "")
: reverse(in.substring(1), in.charAt(0) + out);
}
public static void main(String args[]) {
System.out.println(reverse("Hello World", ""));
}
}
Même s'il s'agit d'un devoir, n'hésitez pas à le copier et à le soumettre comme vôtre. Vous aurez soit un crédit supplémentaire (si vous pouvez expliquer comment cela fonctionne), soit vous faites prendre pour plagiat (si vous ne le pouvez pas).
Personne ici ne considère les caractères unicode. Vous devez utiliser Java.text.BreakIterator pour rechercher les limites de Word, puis en utiliser une autre dans chaque limite de Word pour énumérer les limites des caractères:
String helloWorld = "He\u0308llo World"; // Hëllo World
StringBuilder reverseStringBuilder = new StringBuilder(helloWorld.length());
BreakIterator wordBreakIterator = BreakIterator.getWordInstance();
wordBreakIterator.setText(helloWorld);
int wordStart = wordIterator.first();
int wordEnd = wordIterator.next();
while (wordEnd != BreakIterator.DONE) {
String Word = helloWorld.substring(wordStart,wordEnd);
if (Character.isLetterOrDigit(Word.charAt(0))) {
// "Hello" or "World" in our example
BreakIterator characterBreakIterator = BreakIterator.getCharacterInstance();
characterBreakIterator.setText(Word);
int characterEnd = characterBreakIterator.last();
int characterStart = characterBreakIterator.previous();
while (characterStart != BreakIterator.DONE) {
reverseStringBuilder.append(Word.substring(characterStart, characterEnd));
characterEnd = characterStart;
characterStart = characterBreakIterator.previous();
}
} else {
// " " in our example
reverseStringBuilder.append(Word);
}
wordStart = wordEnd;
wordEnd = wordIterator.next();
}
String dlroWolleh = reverseStringBuilder.toString(); // "dlroW ollëH"
L'utilisation des méthodes naïves ci-dessus déplace le caractère diacritique \u0308 au-dessus de la première l lorsque vous inversez la String. Vous voulez qu'il reste au-dessus de la e.
Eh bien, je suis un gars de C/C++, en pratiquant Java pour des interviews, laissez-moi savoir si quelque chose peut être changé ou amélioré. Ce qui suit permet plusieurs espaces et nouvelles lignes.
Le premier utilise StringBuilder
public static String reverse(String str_words){
StringBuilder sb_result = new StringBuilder(str_words.length());
StringBuilder sb_tmp = new StringBuilder();
char c_tmp;
for(int i = 0; i < str_words.length(); i++){
c_tmp = str_words.charAt(i);
if(c_tmp == ' ' || c_tmp == '\n'){
if(sb_tmp.length() != 0){
sb_tmp.reverse();
sb_result.append(sb_tmp);
sb_tmp.setLength(0);
}
sb_result.append(c_tmp);
}else{
sb_tmp.append(c_tmp);
}
}
if(sb_tmp.length() != 0){
sb_tmp.reverse();
sb_result.append(sb_tmp);
}
return sb_result.toString();
}
Celui-ci utilise char []. Je pense que c'est plus efficace ...
public static String reverse(String str_words){
char[] c_array = str_words.toCharArray();
int pos_start = 0;
int pos_end;
char c, c_tmp;
int i, j, rev_length;
for(i = 0; i < c_array.length; i++){
c = c_array[i];
if( c == ' ' || c == '\n'){
if(pos_start != i){
pos_end = i-1;
rev_length = (i-pos_start)/2;
for(j = 0; j < rev_length; j++){
c_tmp = c_array[pos_start+j];
c_array[pos_start+j] = c_array[pos_end-j];
c_array[pos_end-j] = c_tmp;
}
}
pos_start = i+1;
}
}
//redundant, if only Java had '\0' @ end of string
if(pos_start != i){
pos_end = i-1;
rev_length = (i-pos_start)/2;
for(j = 0; j < rev_length; j++){
c_tmp = c_array[pos_start+j];
c_array[pos_start+j] = c_array[pos_end-j];
c_array[pos_end-j] = c_tmp;
}
}
return new String(c_array);
}
Je suppose que vous pouvez simplement imprimer les résultats (vous venez de dire «le résultat devrait être ...») ;-)
String str = "Hello World";
for (String Word : str.split(" "))
reverse(Word);
void reverse(String s) {
for (int idx = s.length() - 1; idx >= 0; idx--)
System.out.println(s.charAt(idx));
}
Ou renvoyer la chaîne inversée:
String str = "Hello World";
StringBuilder reversed = new StringBuilder();
for (String Word : str.split(" ")) {
reversed.append(reverse(Word));
reversed.append(' ');
}
System.out.println(reversed);
String reverse(String s) {
StringBuilder b = new StringBuilder();
for (int idx = s.length() - 1; idx >= 0; idx--)
b.append(s.charAt(idx));
return b.toString();
}
En utilisant uniquement substring() et récursivité:
public String rev(String rest) {
if (rest.equals(""))
return "";
return rev(rest.substring(1)) + rest.substring(0,1);
}
En prenant en compte que le séparateur peut être plus d’un espace/onglet et que nous voulons les conserver:
public static String reverse(String string)
{
StringBuilder sb = new StringBuilder(string.length());
StringBuilder wsb = new StringBuilder(string.length());
for (int i = 0; i < string.length(); i++)
{
char c = string.charAt(i);
if (c == '\t' || c == ' ')
{
if (wsb.length() > 0)
{
sb.append(wsb.reverse().toString());
wsb = new StringBuilder(string.length() - sb.length());
}
sb.append(c);
}
else
{
wsb.append(c);
}
}
if (wsb.length() > 0)
{
sb.append(wsb.reverse().toString());
}
return sb.toString();
}
Je suis venu avec cette réponse tout en travaillant sur le problème. J'ai essayé de ne pas utiliser la solution de boucle imbriquée O (N ^ 2). J'ai un peu forcé moi-même à utiliser pile pour le plaisir: D
public StringBuilder reverseWord(String input) {
char separator = ' ';
char[] chars = input.toCharArray();
Stack<Character> stack = new Stack<Character>();
StringBuilder sb = new StringBuilder(chars.length);
for(int i = 0; i < chars.length; i++) {
if(chars[i] != separator) { //letters
stack.Push(chars[i]);
//if not last letter don't go any further
if(i != chars.length - 1) { continue; }
}
while(!stack.isEmpty()) {
sb.append(stack.pop());
}
sb.append(separator);
}
//remove the last separator
sb.deleteCharAt(sb.length() - 1);
return sb;
}
Voici une méthode qui prend une chaîne et l'inverse.
public String reverse ( String s ) {
int length = s.length(), last = length - 1;
char[] chars = s.toCharArray();
for ( int i = 0; i < length/2; i++ ) {
char c = chars[i];
chars[i] = chars[last - i];
chars[last - i] = c;
}
return new String(chars);
}
D'abord, vous devez diviser la chaîne en mots comme celui-ci.
String sample = "hello world";
String[] words = sample.split(" ");
class ReverseWordsInString{
public static String reverse(String s1){
int l = s1.length();
if (l>1)
return(s1.substring(l-1) + reverse(s1.substring(0,l-1)));
else
return(s1.substring(0));
}
public static void main(String[] args){
String st = "Hello My World!";
String r = "";
for (String Word : st.split(" "))
r += " "+ reverse(Word);
System.out.println("Reversed words in the given string: "+r.trim());
}
}
public String reverse(String arg) {
char[] s = arg.toCharArray();
StringBuilder sb = new StringBuilder();
boolean reverse = false;
boolean isChar = false;
int insertPos = 0;
for (int i = 0; i < s.length; i++) {
isChar = Character.isAlphabetic(s[i]);
if (!reverse && isChar) {
sb.append(s[i]);
insertPos = i;
reverse = true;
} else if (reverse && isChar) {
sb.insert(insertPos, s[i]);
} else if (!reverse && !isChar) {
sb.append(s[i]);
} else if (reverse && !isChar) {
reverse = false;
sb.append(s[i]);
}
}
return sb.toString();
}
Utilisez la fonction split () et inversez les mots
public String reverseSentence(String input)
{
String[] words = input.split(" ");
StringBuilder builder = new StringBuilder();
for (String s : words)
{
String rev = " ";
for (int i = 0; i < s.length(); i++)
{
rev = s.charAt(i) + rev;
}
builder.append(rev);
}
return builder.toString().trim();
}
Supprimez l'espace supplémentaire ajouté à la fin de la nouvelle chaîne à l'aide de trim ()
Sortie:
This is my sentence
sihT si ym ecnetnes
public static void main(String[] args) {
System.out.println(eatWord(new StringBuilder("Hello World This Is Tony's Code"), new StringBuilder(), new StringBuilder()));
}
static StringBuilder eatWord(StringBuilder feed, StringBuilder swallowed, StringBuilder digested) {
for (int i = 0, size = feed.length(); i <= size; i++) {
if (feed.indexOf(" ") == 0 || feed.length() == 0) {
digested.append(swallowed + " ");
swallowed = new StringBuilder();
} else {
swallowed.insert(0, feed.charAt(0));
}
feed = (feed.length() > 0) ? feed.delete(0, 1) : feed ;
}
return digested;
}
courir:
olleH dlroW sihT sI s'ynoT edoC
BUILD SUCCESSFUL (total time: 0 seconds)
Je sais que c'est un vieil article, mais j'ai pensé écrire la réponse si cela peut aider quelqu'un. Veuillez utiliser le code ci-dessous pour une solution appropriée.
public static void main(String[] args) {
// TODO Auto-generated method stub
String string1 = "Hello how are you";
String[] string2 = string1.split(" ");
String result ="";
for(int i=0;i<string2.length;i++)
{
StringBuilder stringBuilder = new StringBuilder(string2[i]);
result = (i==0)?(result+ stringBuilder.reverse().toString()):(result +" "+stringBuilder.reverse().toString());
}
System.out.println("Result line:"+result);
}
Texte affiché dans la console: Ligne de résultats: olleH woh era uoy
Certaines des solutions ci-dessus sont plus complexes. Avec l'algorithme ci-dessous, cela peut être réalisé en O(n) temps.
Algorithme:
- Analyser la chaîne de la fin au début.
- Chaque fois qu'un caractère d'espacement est rencontré, c'est-à-dire "", placez la liste des caractères analysés jusque-là dans une liste de tableaux pouvant croître dynamiquement.
- Imprimez la liste de tableaux dans l'ordre inverse, ce qui vous donne la sortie souhaitée.
Complexité: O(n) où n est la longueur de la chaîne.
import Java.io.IOException;
import Java.util.ArrayList;
public class WordReverse {
public static void main(String[] args) throws IOException {
String inputStr = "Hello World";
String reversed = "";
ArrayList<String> alist = new ArrayList<String>();
for (int i = inputStr.length() - 1; i >= 0; i--) {
if (inputStr.charAt(i) != ' ') {
reversed = reversed + inputStr.charAt(i);
} else {
alist.add(reversed);
reversed = "";
}
}
alist.add(reversed);
String result = "";
for (int i = alist.size() - 1; i >= 0; i--) {
result = result + alist.get(i);
result = result + " ";
}
System.out.println(result);
}
}
En utilisant split (), il vous suffit de changer ce que vous souhaitez scinder.
public static String reverseString(String str)
{
String[] rstr;
String result = "";
int count = 0;
rstr = str.split(" ");
String words[] = new String[rstr.length];
for(int i = rstr.length-1; i >= 0; i--)
{
words[count] = rstr[i];
count++;
}
for(int j = 0; j <= words.length-1; j++)
{
result += words[j] + " ";
}
return result;
}
String input = "Hello World!";
String temp = "";
String result = "";
for (int i = 0; i <= input.length(); i++) {
if (i != input.length() && input.charAt(i) != ' ') {
temp = input.charAt(i) + temp;
} else {
result = temp + " " + result;
temp = "";
}
}
System.out.println("the result is: " + result);
Ceci est ma version avec le même nombre d'espaces. J'espère que vous aimez les gars!
public String reverseWords(String text){
StringBuilder out = new StringBuilder();
for(String Word : text.split(" ")){
out.append(new StringBuilder(Word).reverse().toString());
out.append(" ");
}
return out.toString().substring(0, out.length() - 1);
}
Copiez la chaîne en sens inverse, puis concaténez les espaces blancs ..__ par exemple. "Bonjour le monde Java".
1er bloc = "bonjour" inverser la copie: - "olleh" et ajouter des espaces puis
2nd block = "Java" etc.
public static void main(String args[]) {
String s, rev = "";
Scanner in = new Scanner(System.in);
System.out.println("Enter a string to reverse");
s = in.nextLine();
int length = s.length();
// char[] cs=s.toCharArray();
int l, r;
int i = 0;
while (i < length) {
l = i; // starting index
// find length of sub-block to reverse copy
while (i < length && s.charAt(i) != ' ') {
i++;
}
r = i - 1; // ending index
for (int j = r; j >= l; j--) { // copy reverse of sub-block
rev = rev + s.charAt(j);
}
rev = rev + " "; // add the whitespace
i++;
}
System.out.println("Reverse of entered string is: " + rev);
}
Le programme fonctionne également pour plusieurs espaces blancs entre les mots.
String someString = new String("Love thy neighbor");
System.out.println(someString);
char[] someChar = someString.toCharArray();
int j = someChar.length - 1;
char temp;
for (int i = 0; i <= someChar.length / 2; i++) {
temp = someChar[i];
someChar[i] = someChar[j];
someChar[j] = temp;
j--;
}
someString = new String(someChar);
System.out.println(someString);
Courir:
Love thy neighbor
robhgien yht evoL
with and without api.
public class Reversal {
public static void main(String s[]){
String str= "hello world";
reversal(str);
}
static void reversal(String str){
String s[]=str.split(" ");
StringBuilder noapi=new StringBuilder();
StringBuilder api=new StringBuilder();
for(String r:s){
noapi.append(reversenoapi(r));
api.append(reverseapi(r));
}
System.out.println(noapi.toString());
System.out.println(api.toString());
}
static String reverseapi(String str){
StringBuilder sb=new StringBuilder();
sb.append(new StringBuilder(str).reverse().toString());
sb.append(' ');
return sb.toString();
}
static String reversenoapi(String str){
StringBuilder sb=new StringBuilder();
for(int i=str.length()-1;i>=0;i--){
sb.append(str.charAt(i));
}
sb.append(" ");
return sb.toString();
}
}
package MujeebWorkspace.helps;
// [email protected]
public class Mujeeb {
static String str= "This code is simple to reverse the Word without changing positions";
static String[] reverse = str.split(" ");
public static void main(String [] args){
reverseMethod();
}
public static void reverseMethod(){
for (int k=0; k<=reverse.length-1; k++) {
String Word =reverse[reverse.length-(reverse.length-k)];
String subword = (Word+" ");
String [] splitsubword = subword.split("");
for (int i=subword.length(); i>0; i--){
System.out.print(splitsubword[i]);
}
}
}
}
String input = "Welcome To The Java Programming";
String output = "";
String[] cutAry = input.split("\\s+");
StringBuilder sb = new StringBuilder();
for(String s:cutAry){
sb.append(s);
output += sb.reverse().toString()+" ";
sb.replace(0, sb.length(), "");
}
System.out.println(output);