Inverser chaque mot de la chaîne « Bonjour tout le monde » avec Java

Question

Je veux inverser chaque individuelle mot d'une chaîne en Java (pas la chaîne entière, juste chaque mot).

Exemple: si la chaîne d'entrée est « Bonjour tout le monde », la sortie devrait être « olleH EDNOM ».

Answer 1

Cela devrait faire l'affaire. Cela itérer chaque mot dans la chaîne source, inverse à l'aide de StringBuilder méthode de reverse() l 'intégré , et délivrer en sortie le mot inverse.

String source = "Hello World";

for (String part : source.split(" ")) {
    System.out.print(new StringBuilder(part).reverse().toString());
    System.out.print(" ");
}

Sortie:

olleH dlroW 

Notes: ont Commenters souligné à juste quelques petites choses que je pensais que je devrais mentionner ici. Cet exemple ajoutera un espace supplémentaire à la fin du résultat. Il suppose également vos mots sont séparés par un espace unique et chaque phrase contient votre pas de ponctuation.

Answer 2

Connaissez vos bibliothèques; -)

import org.apache.commons.lang.StringUtils;

String reverseWords(String sentence) {
    return StringUtils.reverseDelimited(StringUtils.reverse(sentence), ' ');
}

Answer 3

Vous devez le faire sur chaque mot après avoir split dans un 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);
}

Answer 4

Voici la solution la plus simple qui ne même pas utiliser des 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 si cela devoirs, ne hésitez pas à le copier et de le soumettre comme votre propre. Vous aurez soit obtenir un crédit supplémentaire (si vous pouvez expliquer comment cela fonctionne) ou se faire prendre pour plagiat (si vous ne pouvez pas).

Answer 5

Personne ici envisage des caractères unicode. Vous devez utiliser java.text.BreakIterator pour trouver les limites de mots et ensuite utiliser un autre dans chaque limite de mot d'énumérer les limites de 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"

En utilisant des méthodes naïves vont au-dessus de déplacer le \u0308 de caractère diacritique au-dessus du premier l lorsque vous inversez la String. Vous voulez rester au-dessus du e.

Answer 6

Eh bien, je suis un gars de C / C ++, java pratique pour des entrevues faites-moi savoir si quelque chose peut être modifié ou amélioré. Ce qui suit permet de multiples espaces et des sauts de ligne.

La première est à l'aide 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 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);
}

Answer 7

Je suppose que vous pouvez simplement imprimer les résultats (vous venez de dire la sortie doit ê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 retourner 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();
}

Answer 8

En utilisant seulement substring() et récursion:

public String rev(String rest) {
    if (rest.equals(""))
        return "";
    return rev(rest.substring(1)) + rest.substring(0,1);
}

Answer 9

La prise en compte du fait 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();

}

Answer 10

Heres une méthode qui prend une chaîne de caractères et inverse il.

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(" ");  

Answer 11

Je suis venu avec cette réponse tout en travaillant sur le problème. J'essayé de ne pas utiliser imbriquée pour la solution de boucle O (N ^ 2). Je genre de moi-même forcé d'utiliser la 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;
    }

Answer 12

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;
}

run:

olleH dlroW sihT sI s'ynoT edoC 
BUILD SUCCESSFUL (total time: 0 seconds)

Answer 13

Utilisation de split (), il vous suffit de changer ce que vous souhaitez partager sur.

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;


}

Answer 14

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);

Exécuter:

Love thy neighbor
robhgien yht evoL

Answer 15

    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);

Answer 16

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());
    }
}

Answer 17

Utiliser la fonction split () et inverser les mots individuels

    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();
      }

Supprimer l'espace supplémentaire qui est ajouté à la fin de la nouvelle chaîne en utilisant trim ()

Sortie:

    This is my sentence        
    sihT si ym ecnetnes        

Answer 18

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();
}

Answer 19

 package MujeebWorkspace.helps;
 // javamujeeb@gmail.com

 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]);  
             }
         }
     }
 }

Answer 20

        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);

Answer 21

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();
    }
}

Answer 22

Je sais que un ancien poste mais je pensais à écrire la réponse si elle aide quelqu'un. S'il vous plaît 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: Résultat ligne: olleH ère Woh uoy

Answer 23

copie inversée du bloc-sage chaîne, puis concaténer les espaces blancs. pour exemple. "Monde java bonjour".

1er bloc = « bonjour » copie inverse il: - « olleh » et ajouter des espaces alors
2ème bloc = "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.

Answer 24

Certaines des solutions ci-dessus sont des complexités de temps d'exécution plus élevés. Avec l'algorithme ci-dessous, il peut être réalisé en O (n).

Algorithme:

1. Parse la chaîne de la fin au début.
2. Chaque fois un espace est rencontré à savoir « », mettre la liste des caractères analysés jusque-là dans une ArrayList qui peut se développer de façon dynamique.
3. Imprimer la liste de tableaux dans l'ordre inverse qui vous donne la sortie désiré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);
    }
}

Answer 25

Ceci est ma version avec les mêmes espaces numériques. Nous espérons 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);
}

Answer 26

Ceci inverse les mots dans la chaîne donnée. Les mots sont supposés être séparés par un espace unique. L'inversion se fait en place (dans la mémoire tampon de caractères).

public static String reversePhrases(String s)
{
    char[] buf = s.toCharArray();
    int len = buf.length;
    int start = 0;
    for (int i = 0; i < len; i++) {
        if (buf[i] == ' ' || i == (len-1)) {
            if (i == (len-1)) {
                i = len;
            }
            int end = (start + i)/2;
            for (int j = start; j < end; j++) {
                char c = buf[j];
                int pos = (start + i) - j - 1;
                buf[j] = buf[pos];
                buf[pos] = c;
            }
            start = i + 1;    
        }
    }
    return new String(buf);
}

Answer 27

L'une des façons les plus simples:

public String reverse(String post)
{       
    String backward = "";
    for(int i = post.length()-1; i >= 0; i--) {
        backward = backward + post.substring(i, i+1);
    }        
    return backward;
} 

Answer 28

Manière simple:

String reverseString(String string)
{
    String newString = "";
    for(int x = string.length() - 1; x > -1; x ++)
        newString += string.charAt(x);
    return newString;
}

Answer 29

si son à chaque lettre inverse que cette boucle fonctionne bien:

for(int i = 0; i < input.length(); i++){
    output = output + input.substring((input.length()-i)-1, input.length()-i);
}

Answer 30

J'espère que cela sera utile pour quelqu'un.

public class ReverseString {

public static void main(String[] args) {
    String a="abrakadabra";
    String b=reverse(a);
    System.out.print(b);
}
    public static String reverse(String b){
        String j="";
        int a=b.length();           
        for (int x=a;x>0;x--){          
        j=j+b.substring(x-1,x);}

        return j;
    }
}