backwards - Invierta cada palabra individual de la cadena "Hello World" con Java

stringbuilder java

Question

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".

Answer 1

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<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 2

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

Answer 3

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

Answer 4

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

Answer 5

Camino fácil:

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

Answer 6

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

Answer 7

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

Answer 8

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

Answer 9

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

Answer 10

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

Answer 11

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 programa también funciona para múltiples espacios en blanco entre palabras.

Answer 12

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 .

Answer 13

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

Texto que se muestra en la consola: Línea de resultado: olleH woh era uoy

Answer 14

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<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 15

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

Answer 16

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

Answer 17

Usando solo substring() y recursión:

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

Answer 18

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

Answer 19

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

Answer 20

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

Answer 21

Conozca sus bibliotecas ;-)

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

Answer 22

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.

Answer 23

 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 24

 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 25

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

Answer 26

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

Answer 27

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 28

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 29

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)

Answer 30

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