Inverta cada palavra individual da string “Hello World” com Java

Eu quero inverter cada palavra individual de uma String em Java (não a string inteira, apenas cada palavra individual).

Exemplo: se a input String for “Hello World”, a saída deverá ser “olleH dlroW”.

    Isso deve fazer o truque. Isso irá percorrer cada palavra na string de origem, invertê-la usando o método reverse() embutido no StringBuilder e gerar a saída da palavra invertida.

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

    Saída:

     olleH dlroW 

    Observações: Os comentadores apontaram corretamente algumas coisas que eu pensei que deveria mencionar aqui. Este exemplo adicionará um espaço extra ao final do resultado. Ele também assume que suas palavras são separadas por um único espaço cada e sua sentença não contém pontuação.

    Conheça suas bibliotecas 😉

     import org.apache.commons.lang.StringUtils; String reverseWords(String sentence) { return StringUtils.reverseDelimited(StringUtils.reverse(sentence), ' '); } 

    Você precisa fazer isso em cada palavra depois de split em uma array de palavras.

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

    Aqui está a solução mais simples que nem usa loops.

     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", "")); } } 

    Mesmo que seja o dever de casa, sinta-se à vontade para copiá-lo e enviá-lo como seu. Você receberá um crédito extra (se puder explicar como funciona) ou será pego por plágio (se não puder).

    Ninguém aqui está considerando caracteres unicode. Você precisa usar java.text.BreakIterator para encontrar limites de palavras e, em seguida, usar outro dentro de cada limite de palavras para enumerar limites de caracteres:

     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" 

    Usar methods ingênuos acima mudará o caractere diacrítico acima do primeiro l quando você inverter a String . Você quer que ele fique acima do e .

    Bem, eu sou um cara C / C ++, praticando java para entrevistas, deixe-me saber se algo pode ser alterado ou melhorado. O seguinte permite vários espaços e novas linhas.

    Primeiro está usando 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(); } 

    Este está usando char []. Eu acho que é mais eficiente ...

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

    Eu estou supondo que você poderia apenas imprimir os resultados (você acabou de dizer ‘a saída deve ser …’) 😉

     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 retornando a string invertida:

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

    Usando apenas substring() e recursion:

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

    Levando em conta que o separador pode ter mais de um espaço / tabulação e que queremos preservá-los:

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

    Aqui está um método que pega uma corda e a inverte.

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

    Primeiro você precisa dividir a string em palavras como esta

     String sample = "hello world"; String[] words = sample.split(" "); 

    Eu encontrei esta resposta enquanto trabalhava no problema. Eu tentei não usar nested para solução de loop O (N ^ 2). Eu meio que me forcei a usar pilha para se divertir: D

      public StringBuilder reverseWord(String input) { char separator = ' '; char[] chars = input.toCharArray(); Stack stack = new Stack(); 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; } 
     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; } 

    corre:

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

    Usando split (), você só precisa alterar o que deseja dividir.

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

    Corre:

     Love thy neighbor robhgien yht evoL 
      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); 
     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()); } } 

    Use a function split () e inverta palavras individuais

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

    Remova o espaço extra que é adicionado ao final da nova String usando trim ()

    Saída:

      This is my sentence sihT si ym ecnetnes 
     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(); } 
      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]); } } } } 
      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); 
     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(); } } 

    Eu sei que é um post antigo, mas pensei em escrever a resposta se isso ajuda alguém. Por favor, use o código abaixo para a solução adequada.

     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 

    Texto exibido no console: Linha de resultado: olleH woh era uoy

    Inverta a cópia do bloco e depois concatene os espaços em branco. por exemplo. “olá mundo java”.

    1º bloco = “olá” inverta-o: – “olleh” e adicione os espaços em branco
    2º bloco = “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); } 

    O programa também funciona para vários espaços em branco entre as palavras.

    Algumas das soluções acima são das maiores complexidades de tempo de execução. Com o algoritmo abaixo, ele pode ser alcançado no tempo O (n).

    Algoritmo:

    1. Analise a String do final para o início.
    2. Toda vez que um caractere de espaço é encontrado, isto é, “”, coloque a lista de caracteres analisados ​​até então em uma ArrayList que pode crescer dinamicamente.
    3. Imprima a ArrayList na ordem inversa que lhe dá a saída desejada.

    Complexidade: O (n) onde n é o comprimento da String.

     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 alist = new ArrayList(); 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); } } 

    Esta é a minha versão com os mesmos espaços numéricos. Espero que gostem, pessoal!

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

    Isso inverte as palavras na string dada. As palavras são consideradas separadas por um único espaço. A reversão é feita no lugar (no buffer de caracteres).

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

    O de maneiras mais fáceis:

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

    Jeito fácil:

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

    Se o seu para reverter cada letra do que isso para o loop funciona muito bem:

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

    Espero que isso seja útil para alguém.

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