عكس كل كلمة فردية من سلسلة "مرحبا العالم" مع جافا

Question

أريد أن أعالج كل فرد كلمة سلسلة في جافا (وليس السلسلة بأكملها، فقط كل كلمة فردية).

مثال: إذا كانت سلسلة الإدخال "Hello World"، فيجب أن يكون الإخراج "OLLEH DLROW".

Answer 1

هذا ينبغي أن تفعل خدعة. سيقوم هذا بتكرار من خلال كل كلمة في السلسلة المصدر، عكس ذلك باستخدام StringBuilderمدمج reverse() الطريقة، وإخراج الكلمة العكسية.

String source = "Hello World";

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

انتاج:

olleH dlroW 

ملاحظات: أشار المعلقون بشكل صحيح إلى بعض الأشياء التي اعتقدت أنني يجب أن أذكرها هنا. سيقوم هذا المثال بإلحاق مساحة إضافية إلى نهاية النتيجة. كما يفترض أن كلماتك مفصولة بمساحة واحدة لكل منها لا تحتوي جملةكم على علامات الترقيم.

Answer 2

تعرف مكتباتك ؛-)

import org.apache.commons.lang.StringUtils;

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

Answer 3

تحتاج إلى القيام بذلك في كل كلمة بعد split في an. 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);
}

Answer 4

إليك أبسط الحل الذي لا يستخدمه حتى أي حلقات.

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

حتى لو كانت هذه هي الواجبات المنزلية، فلا تتردد في نسخها وإرسالها بنفسك. ستحصل إما على رصيد إضافي (إذا كنت تستطيع أن تشرح كيف يعمل) أو اشتعلت إلى الانتحال (إذا كنت لا تستطيع).

Answer 5

لا أحد هنا يفكر أحرف يونيكود. تحتاج إلى استخدام 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.

Answer 6

حسنا، أنا رجل C / C ++، ممارسة جافا للمقابلات اسمحوا لي أن أعرف ما إذا كان يمكن تغيير شيء أو تحسينه. ما يلي يسمح بمساحات متعددة وخطوط جيولاين.

أول واحد يستخدم 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);
}

Answer 7

أفترض أنك يمكن أن تطبع فقط النتائج (قلت للتو "يجب أن يكون الإخراج ...) ؛-)

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

Answer 8

باستخدام فقط substring() وتوسيع:

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

Answer 9

مع الأخذ في الاعتبار أن الفاصل يمكن أن يكون أكثر من مساحة / علامة تبويب واحدة ونريد الحفاظ عليها:

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 10

هيريس طريقة تأخذ سلسلة ويعكسها.

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

Answer 11

توصلت إلى هذه الإجابة أثناء العمل على المشكلة. حاولت عدم استخدام محلول حلقة O (N ^ 2). أنا نوع من أجبر نفسي على استخدام المكدس للمتعة: د

    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 12

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)

Answer 13

باستخدام تقسيم ()، عليك فقط تغيير ما تريد تقسيمه.

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 14

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

Answer 15

    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 16

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 17

استخدام سبليت () وظيفة والكلمات الفردية العكسي

    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        

Answer 18

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 19

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

Answer 20

        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 21

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

Answer 22

أنا أعرف ذلك منصب قديم ولكن يعتقد أن يكتب الإجابة إذا كان يساعد شخص ما. يرجى استخدام الرمز أدناه للحل المناسب.

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

Answer 23

عكس نسخة من كتلة السلسلة الحكيمة ثم تسلسل Whitespaces. على سبيل المثال. "مرحبا جافا العالم".

1st Block = "Hello" نسخة عكسية: - "OLLEH" وإضافة Whitespace إذن
كتلة 2nd = "جافا" الخ

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

يعمل البرنامج أيضا على اماساكات متعددة بين الكلمات.

Answer 24

بعض الحلول المذكورة أعلاه هي من تعقيدات وقت الإدارة العالي. مع الخوارزمية أدناه، يمكن تحقيق ذلك في وقت O (ن).

خوارزمية:

1. تحليل السلسلة من النهاية إلى البداية.
2. في كل مرة تصادف فيها حرف مسافة أي ""، ضع قائمة الأحرف التي تحلل حتى ذلك الحين في قائمة صفيف يمكن أن تنمو ديناميكيا.
3. قم بطباعة قائمة الصفيف بالترتيب العكسي الذي يمنحك الإخراج المطلوب.

التعقيد: O (ن) حيث ن هو طول السلسلة.

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 25

هذا هو إصدار بلدي مع نفس المساحات. آمل أن تكونوا مثل ذلك يا رفاق!

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 26

هذا يعكس الكلمات في السلسلة المحددة. من المفترض أن تكون الكلمات مفصولة بمساحة واحدة. يتم الانعكاس في مكانه (في المخزن المؤقت للشخصية).

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 27

واحدة من أسهل الطرق:

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 28

طريقة سهلة:

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

Answer 29

إذا كان لعكس كل حرف من هذا الحلقة يعمل بشكل جيد:

for(int i = 0; i < input.length(); i++){
    output = output + input.substring((input.length()-i)-1, input.length()-i);
}

Answer 30

آمل أن يكون هذا مفيدا لشخص ما.

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