webentwicklung-frage-antwort-db.com.de

Umkehren Sie jedes einzelne Wort von "Hello World" mit Java

Ich möchte jedes individual Word eines Strings in Java umkehren (nicht den gesamten String, nur jedes einzelne Word).

Beispiel: Wenn input String "Hello World" ist, sollte die Ausgabe "olleH dlroW" sein. 

37
Vicheanak

Das sollte den Trick tun. Dadurch wird jedes Wort in der Quellzeichenfolge durchlaufen, mit der integrierten reverse()-Methode von StringBuilder umgekehrt und das umgekehrte Word ausgegeben.

String source = "Hello World";

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

Ausgabe:

olleH dlroW 

Notes: Die Kommentatoren haben einige Dinge richtig hervorgehoben, von denen ich dachte, dass ich sie hier erwähnen sollte. In diesem Beispiel wird ein zusätzliches Leerzeichen an das Ende des Ergebnisses angehängt. Es wird auch davon ausgegangen, dass Ihre Wörter durch jeweils ein Leerzeichen getrennt sind und Ihr Satz keine Interpunktion enthält.

105
William Brendel

Kennen Sie Ihre Bibliotheken ;-)

import org.Apache.commons.lang.StringUtils;

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

Sie müssen dies für jedes Wort tun, nachdem Sie split in eine array von Wörtern eingefügt haben. 

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

Hier ist die einfachste Lösung, die keine Schleifen verwendet.

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

Selbst wenn dies Hausaufgaben sind, können Sie es gerne kopieren und als Ihre eigenen einreichen. Sie erhalten entweder eine zusätzliche Gutschrift (wenn Sie erklären können, wie es funktioniert) oder Sie werden wegen Plagiaten erwischt (wenn Sie nicht können).

16

Niemand erwägt hier Unicode-Zeichen. Sie müssen Java.text.BreakIterator verwenden, um Word-Grenzen zu finden, und dann innerhalb jeder Word-Grenze eine andere verwenden, um Zeichengrenzen aufzuzählen:

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"

Bei Verwendung der oben beschriebenen naiven Methoden wird das diakritische Zeichen \u0308 über das erste l verschoben, wenn Sie das String-Objekt umkehren. Sie möchten, dass es über dem e bleibt.

8
Heath Borders

Nun, ich bin ein C/C++ - Typ, der Java für Interviews übt und mich wissen lässt, ob etwas geändert oder verbessert werden kann. Im Folgenden sind mehrere Leerzeichen und Zeilenumbrüche zulässig.

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

Dieser verwendet char []. Ich finde es effizienter ...

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

Ich gehe davon aus, dass Sie die Ergebnisse einfach ausdrucken können (Sie sagten nur 'die Ausgabe sollte ...') ;-)

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

Oder den umgekehrten String zurückgeben:

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

Verwenden Sie nur substring() und Rekursion:

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

Wenn man berücksichtigt, dass das Trennzeichen mehr als ein Leerzeichen/einen Tab haben kann und wir diese beibehalten möchten:

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

}
3
Mikel

Ich habe diese Antwort gefunden, als ich an dem Problem arbeitete. Ich habe versucht, keine verschachtelte Lösung für die Schleife O (N ^ 2) zu verwenden. Ich habe mich irgendwie gezwungen, Stack zum Spaß zu verwenden: 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;
    }
1
masato-san

Hier ist eine Methode, die eine Zeichenfolge verwendet und diese umkehrt. 

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

Zuerst müssen Sie die Zeichenfolge in solche Wörter aufteilen

String sample = "hello world";  
String[] words = sample.split(" ");  
1
Zaki
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());
    }
}
0
dganesh2002
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();
}
0
user3105683

Verwenden Sie die Funktion split () und kehren Sie einzelne Wörter um

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

Entfernen Sie den zusätzlichen Platz, der am Ende des neuen Strings hinzugefügt wird, indem Sie trim () verwenden.

Ausgabe:

    This is my sentence        
    sihT si ym ecnetnes        
0
Rashmi
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;
}

lauf:

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

Ich weiß, es ist ein alter Beitrag, aber ich dachte daran, die Antwort zu schreiben, wenn es jemandem hilft. Bitte verwenden Sie den nachstehenden Code, um die richtige Lösung zu finden.

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

In der Konsole angezeigter Text: Ergebniszeile: olleH woh Ära

0
udai

Einige der oben genannten Lösungen weisen eine höhere Laufzeitkomplexität auf. Mit dem untenstehenden Algorithmus kann dies in der Zeit O(n) erreicht werden.

Algorithmus:

  1. Durchsuchen Sie den String vom Ende bis zum Anfang. 
  2. Jedes Mal, wenn ein Leerzeichen auftritt, d. H. "", Fügen Sie die Liste der bis dahin analysierten Zeichen in eine ArrayList ein, die dynamisch wachsen kann.
  3. Drucken Sie die ArrayList in umgekehrter Reihenfolge, um die gewünschte Ausgabe zu erhalten.

Komplexität: O(n) wobei n die Länge des Strings ist. 

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

Mit split () müssen Sie nur das ändern, worauf Sie aufteilen möchten.

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;


}
0
ewein
    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);
0
JC9162

Dies ist meine Version mit den gleichen Nummernräumen. Hoffe es gefällt euch Jungs!

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);
}
0
Ismael Terreno

Umgekehrt kopieren Sie den String blockweise und verketten dann die Whitespaces . "Hallo Java-Welt".

1. Block = "Hallo", kopiere es umgekehrt: - "olleh" und füge dann Leerzeichen hinzu
2. Block = "Java" usw.

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

Das Programm funktioniert auch für mehrere Leerzeichen zwischen Wörtern.

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

Lauf:

Love thy neighbor
robhgien yht evoL
0
Mike Moon
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();
    }
}
0
math
 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]);  
             }
         }
     }
 }
0
user3053722
        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);