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"
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 "
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)
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]"
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 += " "; }
}
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.).
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(" ");
}
}
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(' ')
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);
}
}
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(" ")));
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;
}
}
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]+" ");
}
}
}
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;
}
}
`
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] +" ");
}
}
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());