web-dev-qa-db-de.com

Einen bestimmten Satz in Java umkehren

Kann mir jemand sagen, wie man ein Java-Programm schreibt, um einen bestimmten Satz umzukehren?

Wenn die Eingabe beispielsweise lautet:

"Dies ist eine Interviewfrage"

Die Ausgabe muss sein:

"Frage Interview und ist das"

12
giri

Sie teilen die Zeichenfolge nach dem Leerzeichen und iterieren dann rückwärts, um den umgekehrten Satz zusammenzusetzen.

String[] words =  "This is interview question".split(" ");

String rev = "";
for(int i = words.length - 1; i >= 0 ; i--)
{
   rev += words[i] + " ";
}

// rev = "question interview is This "

// can also use StringBuilder:
StringBuilder revb = new StringBuilder();
for(int i = words.length - 1; i >= 0 ; i--)
{
   revb.append(words[i]);
   revb.append(" ");
}
// revb.toString() = "question interview is This "
24
Oded
String[] words = sentence.split(" ");
String[] reversedWords = ArrayUtils.reverse(words);
String reversedSentence = StringUtils.join(reversedWords, " ");

(mit ArrayUtils und StringUtils von commons-lang, aber das sind einfache Methoden zum Schreiben - nur ein paar Loops)

23
Bozho

Einfach anders sein: eine rekursive Lösung. Fügt keine zusätzlichen Leerzeichen hinzu.

public static String reverse(String s) {
   int k = s.indexOf(" ");
   return k == -1 ? s : reverse(s.substring(k + 1)) + " " + s.substring(0, k);
}


System.out.println("[" + reverse("This is interview question") + "]");
// prints "[question interview is This]"

Ich werde auch die split-Lösung verbessern, indem ich stattdessen \b verwende (das ist so offensichtlich!).

    String[] parts = "Word boundary is better than space".split("\\b");
    StringBuilder sb = new StringBuilder();
    for (int i = parts.length; i --> 0 ;) {
        sb.append(parts[i]);
    }
    System.out.println("[" + sb.toString() + "]");
    // prints "[space than better is boundary Word]"
19

Teilen Sie es einfach in ein Leerzeichen in ein String-Array auf, ziehen Sie es in umgekehrter Reihenfolge über das Array und konstruieren Sie den Ausgabe-String.

String input = "This is interview question";
String output = "";
String[] array = input.split(" ");
for(int i = array.length-1; i >= 0; i--)
{
    output += array[i];
    if (i != 0) { output += " "; }
}
6
Rich Adams

Bozho hat bereits eine großartige Java-spezifische Antwort gegeben, aber für den Fall, dass Sie dieses Problem ohne Java-API-Methoden lösen müssen:

Zum Umkehren können Sie einfach einzelne Wörter auf eine stack setzen und sie alle wieder entfernen, wenn keine Wörter mehr vorhanden sind.

(Um es noch übersichtlicher zu machen, stellt Java eine Stack-Klasse bereit, daher ist es auch möglich, diese Methode in Java zu verwenden.).

6
Pops

Ich versuche es auch: Hier ist eine Version, die einen Stapel und einen Scanner verwendet:

String input = "this is interview question";
Scanner sc = new Scanner(input);
Stack<String> stack = new Stack<String>();

while(sc.hasNext()) {
    stack.Push(sc.next());
}

StringBuilder output = new StringBuilder();

for(;;) { // forever
    output.append(stack.pop());

    if(stack.isEmpty()) {
        break; // end loop
    } else {
        output.append(" ");
    }
}
3
Searles

ein langweiliges bisschen Java:

List<String> l = new ArrayList<String>(Arrays.asList("this is an interview question".split("\\s")));
Collections.reverse(l);
StringBuffer b = new StringBuffer();
for( String s : l ){
    b.append(s).append(' ');
}
b.toString().trim();

in groovy ist es etwas lesbarer:

"this is an interview question"
    .split("\\s")
    .reverse()
    .join(' ')
3
Gareth Davis
public class ReverseString {

    public void reverse(String[] source) {

        String dest = "";
        for (int n = source.length - 1; n >= 0; n--) {
            dest += source[n] + " ";
        }
        System.out.println(dest);

    }

    public static void main(String args[]) {
        ReverseString rs = new ReverseString();
        String[] str = "What is going on".split(" ");
        rs.reverse(str);

    }

}
2
gmhk

Bisher hat noch niemand eine auf Vanilla Java 8 basierende Lösung erwähnt, die mit Bozho's identisch ist, jedoch ohne Bibliotheken von Drittanbietern. Hier ist es also:

String input = "This is interview question";

List<String> list = Arrays.asList(input.split(" "));
Collections.reverse(list);
System.out.println(list.stream().collect(Collectors.joining(" ")));
1
Lukas Eder

netterer Ansatz wahrscheinlich .. hatte die Logik irgendwo gesehen. Hier ist mein Code, der die Arbeit machen könnte.

    public class revWords {

    public static void main(String[] args) {

        revWords obj = new revWords();
        String print = obj.reverseWords("I am God");
        System.out.println(print);

    }

    public String reverseWords(String words)
    {
      if(words == null || words.isEmpty() || !words.contains(" "))
        return words;

      String reversed = "";
      for( String Word : words.split(" "))
        reversed = Word + " " + reversed;

      return reversed;
    }

}
1
Shashi

bitte versuchen Sie die Lösung unten, das funktioniert für mich. 

public class reverseline {

public static void main(String[] args) {
    // TODO Auto-generated method stub

        String str="This is interview question";
    String words[]=str.split(" ");
    for(int i=words.length-1;i>=0;i--){
        System.out.print(words[i]+" ");
    }
}

}
1

Ich denke nicht, dass Sie eine Bibliothek verwenden sollten. 1) Ganze Zeichenkette umkehren 2) Jedes Wort umkehren.

public static void revWord(char[] a) {

    // reverse whole
    revWord(a, 0, a.length);

    int st = -1;
    int end = -1;

    for (int i = 0; i < a.length; i++) {

        if (st == -1 && a[i] != ' ') {
            st = i;
        }
        if (end == -1 && a[i] == ' ' ) {
            end = i;
        }
        if(i == a.length-1){
            end=i+1;
        }

        if (st != -1 && end != -1) {
            revWord(a, st, end );

            st = -1;
            end = -1;
        }

    }

}

public static void revWord(char[] a, int s, int l) {
    int mid = (l - s) / 2;
    l--;

    for (int i = 0; i < mid; i++, l--) {
        char t = a[s+i];
        a[s+i] = a[l];
        a[l] = t;
    }
}

`

1
Rajender Saini

Kürzeste Antwort

public class ReverseSentance {

public static void main(String[] args) {
    Scanner sc = new Scanner(System.in);
    System.out.println("Enter a sentance");
    String inputString = sc.nextLine();

    String[] words = inputString.split(" ");

    List<String> reverseWord = Arrays.asList(words);
    Collections.reverse(reverseWord);

    Iterator itr = reverseWord.iterator();

    while (itr.hasNext()) {
        System.out.print(itr.next() + " ");
    }
}

}

ODER

public class ReverseSentance {

public static void main(String[] args) {
    Scanner sc = new Scanner(System.in);
    System.out.println("Enter a sentance");
    String inputString = sc.nextLine();

    String[] words = inputString.split(" ");

    for (int i = words.length-1 ; i >= 0; i--) {
        System.out.print(words[i] +" ");
    }
}
0
Rishabh Agarwal

Bevor StringTokenizer als veraltet erklärt wurde, benutzten viele StringTokenizer hierfür. Ich dachte, ich würde es einfach hier lassen.

String sentence = "This is interview question";
String reversed = "";
StringTokenizer tokens = new StringTokenizer(sentence); 

while (tokens.hasMoreTokens()) { // Loop through each token
    reversed =  tokens.nextToken() + ' ' + reversed; //add to start
}

System.out.println(reversed.trim());
0
Sajal Dutta