Invierta cada palabra individual de la cadena “Hello World” con Java

Quiero invertir cada palabra individual de una cadena en Java (no la cadena completa, solo cada palabra individual).

Ejemplo: si la cadena de entrada es “Hello World”, la salida debería ser “olleH dlroW”.

Esto debería funcionar. Esto iterará a través de cada palabra en la cadena de origen, la revertirá utilizando el método reverse() incorporado de StringBuilder y generará la palabra invertida.

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

Salida:

 olleH dlroW 

Notas: los comentaristas señalaron correctamente algunas cosas que pensé que debería mencionar aquí. Este ejemplo agregará un espacio adicional al final del resultado. También asume que tus palabras están separadas por un solo espacio cada una y tu oración no contiene signos de puntuación.

Conozca sus bibliotecas 😉

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

Debe hacer esto en cada palabra después de split en una array de palabras.

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

Aquí está la solución más simple que ni siquiera usa ningún bucle.

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

Incluso si se trata de tareas, puede copiarlo y enviarlo como suyo. Obtendrás un crédito extra (si puedes explicar cómo funciona) o te atraparán por plagio (si no puedes).

Nadie aquí está considerando caracteres Unicode. Necesita usar java.text.BreakIterator para encontrar límites de palabras y luego use otro dentro de cada límite de palabras para enumerar los límites de los 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" 

El uso de métodos \u0308 anteriores cambiará el carácter diacrítico \u0308 encima del primer l cuando invierta la String . Usted quiere que se mantenga por encima de la e .

Bueno, soy un chico de C / C ++, practico java para entrevistas, avíseme si algo se puede cambiar o mejorar. Lo siguiente permite múltiples espacios y nuevas líneas.

El primero es usar 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 []. Creo que es más 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); } 

Supongo que podrías imprimir los resultados (solo dijiste ‘la salida debería 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)); } 

O devolviendo la secuencia 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 solo substring() y recursión:

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

Teniendo en cuenta que el separador puede ser más de un espacio / pestaña y que queremos preservarlos:

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

Aquí hay un método que toma una cuerda y la revierte.

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

Primero necesitas dividir la cadena en palabras como esta

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

Se me ocurrió esta respuesta mientras trabajaba en el problema. Intenté no utilizar la solución de lazo anidada O (N ^ 2). Me obligué a usar stack para divertirme: 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; } 

correr:

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

Usando split (), solo tienes que cambiar lo que deseas 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); 

Correr:

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

Utilice la función split () e invierta palabras individuales

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

Elimine el espacio adicional que se agrega al final de la nueva Cadena usando trim ()

Salida:

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

Sé que es una publicación anterior, pero pensé en escribir la respuesta si ayuda a alguien. Por favor, use el siguiente código para la solución adecuada.

 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 que se muestra en la consola: Línea de resultado: olleH woh era uoy

Invertir copia la secuencia en bloque y luego concatenar los espacios en blanco. por ej. “hola mundo de java”.

1er bloque = “hola” copiar al revés: – “olleh” y agregar espacios en blanco a continuación
2do bloque = “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); } 

El progtwig también funciona para múltiples espacios en blanco entre palabras.

Algunas de las soluciones anteriores son de las complejidades de tiempo de ejecución más altas. Con el algoritmo siguiente, se puede lograr en el tiempo O (n).

Algoritmo:

  1. Parse the String desde el final hasta el principio.
  2. Cada vez que se encuentra un carácter de espacio, es decir “”, ponga la lista de caracteres analizados hasta entonces en una ArrayList que puede crecer dinámicamente.
  3. Imprima ArrayList en el orden inverso que le proporciona la salida deseada.

Complejidad: O (n) donde n es la longitud de la Cadena.

 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 es mi versión con el mismo número de espacios. ¡Espero que les guste, chicos!

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

Esto invierte las palabras en la cadena dada. Se supone que las palabras están separadas por un solo espacio. La reversión se realiza en su lugar (en el búfer 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); } 

El de las maneras más fáciles:

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

Camino fácil:

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

si es para invertir cada letra, esto funciona bien:

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

Espero que esto sea útil para alguien.

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