Inversez chaque mot de la chaîne "Hello World" avec Java
je veux Inverser chaque mot individuel mot D'une chaîne en Java (pas la chaîne entière, juste chaque mot individuel).
exemple: si la chaîne d'entrée est" Hello World "alors la sortie doit être"olleH dlroW".
30 réponses
ça devrait faire l'affaire. Cela va itérer à travers chaque mot dans la chaîne de caractères source, l'inverser en utilisant StringBuilder 's méthode intégrée reverse() , et sortie du mot inversé.
String source = "Hello World";
for (String part : source.split(" ")) {
System.out.print(new StringBuilder(part).reverse().toString());
System.out.print(" ");
}
sortie:
olleH dlroW
Notes: les commentateurs ont correctement souligné quelques choses que j'ai pensé que je devrais mentionner ici. Cet exemple ajoutera un espace supplémentaire à la fin du résultat. Il suppose également que vos mots sont séparés par un seul espace chacun et votre phrase ne contient aucune ponctuation.
connaissez vos bibliothèques ; -)
import org.apache.commons.lang.StringUtils;
String reverseWords(String sentence) {
return StringUtils.reverseDelimited(StringUtils.reverse(sentence), ' ');
}
vous devez faire ceci sur chaque mot après vous split dans un array de mots.
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);
}
Voici la solution la plus simple qui n'utilise même pas de boucles.
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", ""));
}
}
même s'il s'agit d'un devoir à la maison, n'hésitez pas à le copier et à le soumettre comme le vôtre. Vous obtiendrez un crédit supplémentaire (si vous pouvez expliquer comment cela fonctionne) ou vous serez pris pour plagiat (si vous ne pouvez pas).
personne ici ne considère les caractères unicode. Vous devez utiliser java.text.BreakIterator pour trouver des limites de mots et ensuite utiliser un autre dans chaque limite de mots pour énumérer les limites de caractères:
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"
en utilisant des méthodes naïves ci-dessus va déplacer le caractère diacritique \u0308 au-dessus du premier l quand vous inversez le String . Vous voulez qu'il reste au-dessus du e .
Eh bien je suis un gars de C/C++, pratiquant java pour les interviews faites-moi savoir si quelque chose peut être changé ou améliorée. Ce qui suit permet de multiples espaces et de nouvelles lignes.
le premier utilise 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();
}
celui-ci utilise char[]. Je pense que c'est plus efficace...
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 '"151910920"' @ 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);
}
je suppose que vous pourriez juste imprimer les résultats (vous avez juste dit 'la sortie devrait être...');- )
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));
}
ou retour de la chaîne inversée:
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();
}
utilisant seulement substring() et récursion:
public String rev(String rest) {
if (rest.equals(""))
return "";
return rev(rest.substring(1)) + rest.substring(0,1);
}
Tenant compte du fait que le séparateur peut être plus d'un espace/onglet et que nous voulons préserver:
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();
}
hérite d'une méthode qui prend une chaîne et l'inverse.
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);
}
vous devez d'abord diviser la chaîne en mots comme ceci
String sample = "hello world";
String[] words = sample.split(" ");
j'ai trouvé cette réponse tout en travaillant sur le problème. J'ai essayé de ne pas utiliser imbriqué pour la solution de boucle O(N^2). Je me suis en quelque sorte forcé à utiliser stack pour le plaisir: 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 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;
}
run:
olleH dlroW sihT sI s'ynoT edoC
BUILD SUCCESSFUL (total time: 0 seconds)
en utilisant split (), vous avez juste à changer ce que vous souhaitez partager.
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;
}
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);
Run:
Love thy neighbor
robhgien yht evoL
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);
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());
}
}
utiliser la fonction split () et inverser les mots individuels
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();
}
Supprimer l'espace supplémentaire ajouté à la fin de la nouvelle chaîne en utilisant trim ()
sortie:
This is my sentence
sihT si ym ecnetnes
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();
}
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]);
}
}
}
}
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);
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();
}
}
je sais que c'est un vieux post mais pensé à écrire la réponse si elle aide quelqu'un. Veuillez utiliser le code ci-dessous pour trouver la bonne solution.
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);
}
texte affiché en console: Ligne de résultat: olleH woh era uoy
inversez la chaîne par blocs et concaténez les espaces blancs. pour eg. "bonjour tout le monde java".
1er bloc = "bonjour" verso copie:- "olleh" et ajouter un espace puis
2e bloc = "java"etc.
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);
}
programme fonctionne également pour les espaces multiples entre les mots.
certaines des solutions ci-dessus sont plus complexes. Avec l'algorithme ci-dessous, il peut être atteint en O(n) temps.
algorithme:
- analysez la chaîne de la fin au début.
- chaque fois qu'un caractère d'espace est rencontré, c'est-à-dire"", mettez la liste des caractères analysés jusque-là dans un ArrayList qui peut se développer dynamiquement.
- Imprimer L'ArrayList au verso ordre qui vous donne la sortie désirée.
complexité: O (n) où n est la longueur de la chaîne.
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);
}
}
C'est ma version avec le même nombre d'espaces. J'espère que vous aimez ça les gars!
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);
}
ceci inverse les mots de la chaîne donnée. Les mots sont censés être séparés par un seul espace. L'inversion se fait en place (dans le tampon de caractères).
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);
}
le plus facile des chemins:
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;
}
voie Facile:
String reverseString(String string)
{
String newString = "";
for(int x = string.length() - 1; x > -1; x ++)
newString += string.charAt(x);
return newString;
}
si son pour inverser chaque lettre que ceci pour boucle fonctionne bien:
for(int i = 0; i < input.length(); i++){
output = output + input.substring((input.length()-i)-1, input.length()-i);
}
j'espère que ce sera utile pour quelqu'un.
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;
}
}