Инвертировать каждое отдельное слово строки "Hello World" с помощью Java
Я хочу поменять местами каждое отдельное слово строки в Java (не всю строку, а каждое отдельное слово).
Пример: если входной строкой является "Hello World", то выходной должен быть "olleH dlroW".
33 ответа
Решение
Это должно сделать свое дело. Это будет перебирать каждое слово в исходной строке, повернуть его, используя StringBuilder встроенный reverse() метод и выведите перевернутое слово.
String source = "Hello World";
for (String part : source.split(" ")) {
System.out.print(new StringBuilder(part).reverse().toString());
System.out.print(" ");
}
Выход:
olleH dlroW
Примечания: Комментаторы правильно указали на несколько вещей, о которых я подумал упомянуть здесь. Этот пример добавит дополнительный пробел к концу результата. Он также предполагает, что ваши слова разделены одним пробелом, а предложение не содержит знаков препинания.
Знай свои библиотеки;-)
import org.apache.commons.lang.StringUtils;
String reverseWords(String sentence) {
return StringUtils.reverseDelimited(StringUtils.reverse(sentence), ' ');
}
Вы должны сделать это на каждом слове после вас split в array слов.
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);
}
Вот самое простое решение, которое даже не использует циклы.
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", ""));
}
}
Даже если это домашнее задание, не стесняйтесь копировать его и отправлять как свое собственное. Вы либо получите дополнительный кредит (если сможете объяснить, как это работает), либо попадете на плагиат (если не можете).
Здесь никто не рассматривает символы Юникода. Вам нужно использовать java.text.BreakIterator чтобы найти границы слов, а затем использовать другую в пределах каждой границы слов, чтобы перечислить границы символов:
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"
Использование вышеуказанных наивных методов сместит диакритический знак \u0308 выше первого l когда вы меняете String, Вы хотите, чтобы он оставался выше e,
Ну, я парень C/C++, практикую Java для интервью, дайте мне знать, если что-то можно изменить или улучшить. Следующее позволяет использовать несколько пробелов и новых строк.
Первый использует 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();
}
Этот использует char[]. Я думаю, что это более эффективно...
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);
}
Используя только substring() и рекурсия:
public String rev(String rest) {
if (rest.equals(""))
return "";
return rev(rest.substring(1)) + rest.substring(0,1);
}
Я предполагаю, что вы можете просто напечатать результаты (вы только что сказали "результат должен быть...");-)
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));
}
Или возвращая обратную строку:
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();
}
Принимая во внимание, что разделителем может быть несколько пробелов / табуляций и что мы хотим сохранить их:
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();
}
Я придумал этот ответ, работая над проблемой. Я старался не использовать вложенный для решения цикла O(N^2). Я как бы заставил себя использовать стек для удовольствия: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;
}
Вот метод, который берет строку и переворачивает ее.
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);
}
Сначала нужно разбить строку на слова вроде этого
String sample = "hello world";
String[] words = sample.split(" ");
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]);
}
}
}
}
Некоторые из вышеуказанных решений имеют более высокую сложность во время выполнения. С помощью приведенного ниже алгоритма это может быть достигнуто за время O(n).
Алгоритм:
- Разбор строки с конца до начала.
- Каждый раз, когда встречается символ пробела, т. Е. " ", Помещайте список символов, проанализированных до тех пор, в ArrayList, который может динамически увеличиваться.
- Распечатайте ArrayList в обратном порядке, что даст вам желаемый результат.
Сложность: O(n) где n - длина строки.
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);
}
}
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();
}
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);
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());
}
}
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);
Я знаю, это старый пост, но подумал написать ответ, если это кому-нибудь поможет. Пожалуйста, используйте приведенный ниже код для правильного решения.
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);
}
Текст, отображаемый в консоли: Строка результата:olleH woh era uoy
Это моя версия с теми же номерами. Надеюсь, вам понравится, ребята!
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);
}
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;
}
бежать:
olleH dlroW sihT sI s'ynoT edoC
BUILD SUCCESSFUL (total time: 0 seconds)
Вы можете перевернуть строку, используя расширенный цикл for, и поменять местами слагаемые внутри:
public static String reverse(String str) {
String revStr = "";
for (char ch : str.toCharArray()) {
// concat of chars in reverse order
revStr = ch + revStr;
}
return revStr;
}
public static String[] reverse(String[] arr) {
String[] revArr = new String[arr.length];
for (int i = 0; i < arr.length; i++) {
// same word order
revArr[i] = reverse(arr[i]);
}
return revArr;
}
public static void main(String[] args) {
String[] arr = reverse("Hello World".split(" "));
System.out.println(String.join(" ", arr));
}
Выход:
olleH dlroW
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();
}
}
Используйте функцию split() и переворачивайте отдельные слова
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();
}
Удалите лишнее пространство, добавленное в конце новой строки, используя trim().
Выход:
This is my sentence
sihT si ym ecnetnes
Используя split(), вам просто нужно изменить то, что вы хотите разделить.
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;
}
Обратно скопируйте строку по блокам, а затем объедините пробелы. например, "Привет, мир Java".
1st block = "hello" обратный скопировать его:- "olleh" и затем добавить пробел
2-й блок = "Ява" и т. Д.
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);
}
Программа также работает для нескольких пробелов между словами.
Решение с TC - O(n) и SC - O(1)
public String reverseString(String str){
String str = "Hello Wrold";
int start = 0;
for (int i = 0; i < str.length(); i++) {
if (str.charAt(i) == ' ' || i == str.length() - 1) {
int end = 0;
if (i == str.length() - 1) {
end = i;
} else {
end = i - 1;
}
str = swap(str, start, end);
start = i + 1;
}
}
System.out.println(str);
}
private static String swap(String str, int start, int end) {
StringBuilder sb = new StringBuilder(str);
while (start < end) {
sb.setCharAt(start, str.charAt(end));
sb.setCharAt(end, str.charAt(start));
start++;
end--;
}
return sb.toString();
}
Пример с потоковым API
public static String reverseAllWords(String str) {
String[] arr = str.split(" ");
String res = "";
for (int x = 0; x < arr.length; x++) {
res = res + Stream.of(arr[x].split("")).reduce("", (a, b) -> b + a) + " ";
}
return res;
}
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);
Бежать:
Love thy neighbor
robhgien yht evoL
Это переворачивает слова в данной строке. Предполагается, что слова разделены одним пробелом. Обращение производится на месте (в символьном буфере).
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);
}
Если его поменять каждую букву, то цикл отлично работает:
for(int i = 0; i < input.length(); i++){
output = output + input.substring((input.length()-i)-1, input.length()-i);
}