Imprimer en sens inverse d’une chaîne sans utiliser de fonction prédéfinie?
Comment imprimer l'inverse de la chaîne Java is object orientated language sans utiliser de fonction prédéfinie telle que reverse()?
Vous pouvez le faire de manière récursive ou itérative (en boucle).
Itérativement:
static String reverseMe(String s) {
StringBuilder sb = new StringBuilder();
for(int i = s.length() - 1; i >= 0; --i)
sb.append(s.charAt(i));
return sb.toString();
}
Récursivement:
static String reverseMe(String s) {
if(s.length() == 0)
return "";
return s.charAt(s.length() - 1) + reverseMe(s.substring(0,s.length()-1));
}
C'est la solution la plus simple:
System.out.print("egaugnal detatneiro tcejbo si avaj");
Eh bien, imprimer lui-même suggérerait une fonction prédéfinie ...
Cependant, vous pouvez probablement obtenir les caractères et les concaténer manuellement en sens inverse (c’est-à-dire en boucle). Bien sûr, vous pourriez dire que concatenation est une fonction prédéfinie ... alors peut-être que le tableau de caractères lui-même. Mais encore une fois ... pourquoi?
La source est-elle autorisée à contenir "egaugnal detatneiro tcejbo si avaj" ;-p
Notez également que l’inversion de chaîne est en fait assez complexe si vous envisagez de combiner des caractères unicode, des paires de substitution, etc. Notez que la plupart des mécanismes d’inversion de chaîne ne traitent que les cas les plus courants, mais peuvent rencontrer des difficultés avec i18n.
String reverse(String s) {
int legnth = s.length();
char[] arrayCh = s.toCharArray();
for(int i=0; i< length/2; i++) {
char ch = s.charAt(i);
arrayCh[i] = arrayCh[legnth-1-i];
arrayCh[legnth-1-i] = ch;
}
return new String(arrayCh);
}
Que diriez-vous d'une simple traversée de la fin de la chaîne au début:
void printRev(String str) {
for(int i=str.length()-1;i>=0;i--)
System.out.print(str.charAt(i));
}
public class StringReverse {
public static void main(String[] args) {
String s= (args[0]);
for (int i =s.length()-1; i >= 0; i--) {
System.out.print(s.charAt(i));
}
}
}
Imprime la chaîne inversée de l'entrée.
Tout d'abord: pourquoi réinventer la roue?
Cela étant dit: boucle de la longueur de la chaîne à 0 et concaténer dans une autre chaîne.
String a="Siva";
for(int i=0;i<=a.length()-1;i++){
System.out.print(a.charAt(i));
}
for(int i = a.length() - 1; i >= 0; --i){
System.out.println(a.charAt(i));
}
final String s = "123456789";
final char[] Word = s.toCharArray();
final int l = s.length() - 2;
final int ll = s.length() - 1;
for (int i = 0; i < l; i++) {
char x = Word[i];
Word[i] = Word[ll - i];
Word[ll - i] = x;
}
System.out.println(s);
System.out.println(new String(Word));
Vous pouvez le faire de manière récursive ou itérative (en boucle).
Itérativement:
static String reverseMe(String s) {
StringBuilder sb = new StringBuilder();
for (int i = s.length() - 1; i >= 0; --i)
sb.append(s.charAt(i));
return sb.toString();
}
Récursivement:
static String reverseMe(String s) {
if (s.length() == 0)
return "";
return s.charAt(s.length() - 1) + reverseMe(s.substring(1));
}
Integer i = new Integer(15);
test(i);
System.out.println(i);
test(i);
System.out.println(i);
public static void test (Integer i) {
i = (Integer)i + 10;
}
Ce qui est étonnant, c'est que la plupart des réponses sont fausses! Quand Unicode est utilisé. On dirait que personne ne comprend que Java utilise UTF-16 pour le codage de texte.
Voici ma réponse simple.
static String reverseMe(String s) {
StringBuilder sb = new StringBuilder();
int count = s.codePointCount(0,s.length());
for(int i = count - 1; i >= 0; --i)
sb.append(Character.toChars(s.codePointAt(i)));
return sb.toString();
}
Voici une solution récursive qui n'imprime que la chaîne dans l'ordre inverse. Cela devrait être éducatif si vous essayez d'apprendre la récursivité. Je l'ai aussi rendu "faux" en ayant en fait 2 déclarations print; l'un d'eux devrait être commenté. Essayez de savoir lequel ou de faire des expériences mentalement. De toute façon, apprenez-en.
static void printReverse(String s) {
if (!s.isEmpty()) {
System.out.print(s.substring(0, 1));
printReverse(s.substring(1));
System.out.print(s.substring(0, 1));
}
}
Points bonus si vous répondez à ces questions:
- Quelle est son exigence de pile? Est-il sujet à stack overflow ?
- Est-ce une queue récursive ?
c'est la meilleure solution pour cela
public class String_rev {
public static void main(String[] args) {
String str="Karan Rajput";
int ln=str.length();
for (int i = ln; i > 0; i--) {
System.out.print(str.charAt(i-1));
}
}
}
private void rev() {
String st="hello";
String b="";
for(int i=st.length()-1;i>=0;i--){
b=b+st.charAt(i);
}
System.out.println("reverse:::"+b);
}
Essaye ça:
public class Test {
public static void main(String[] args) {
String s = "welcome";
for( int i=0, j = (s.length())-1; i <= j; j-- ) {
char c=s.charAt(j);
System.out.print(c);
}
}
}
public class StringReverse {
public static void main(String ar[]){
System.out.println(reverseMe("SRINIVAS"));
}
static String reverseMe(String s){
StringBuffer sb=new StringBuffer();
for(int i=s.length()-1;i>=0;--i){
sb.append(s.charAt(i));
}
return sb.toString();
}
}
Ici vous allez:
public static void main (String[] args) { System.out.println(reverserString("Akshay")); } private static String reverserString(String src) { char[] sArr = src.toCharArray(); char[] dArr = new char[sArr.length]; for(int i=sArr.length; i>0; i--) { dArr[sArr.length-i] = sArr[i-1]; } return new String(dArr); }</ pre></ code> </ pre>
public class ReverseString {
public static void main(String [] args) {
String s = "reverse string" ;
String b = "";
for (int i = 0; i < s.length(); i++ ){
b= b + s.substring(s.length()-1-i, s.length()-i);
}
System.out.println(b);
}
Il est très simple d'utiliser une boucle while
public class Test {
public static void main(String[] args) {
String name = "subha chandra";
int len = name.length();
while(len > 0){
len--;
char c = name.charAt(len);
System.out.print(c); // use String.valueOf(c) to convert char to String
}
}
}
public String reverse(String arg)
{
String tmp = null;
if (arg.length() == 1)
{
return arg;
}
else
{
String lastChar = arg.substring(arg.length()-1,arg.length());
String remainingString = arg.substring(0, arg.length() -1);
tmp = lastChar + reverse(remainingString);
return tmp;
}
}
package com.ofs;
public class ReverseWordsInString{
public static void main(String[] args) {
String str = "welcome to the new world and how are you feeling ?";
// Get the Java runtime
Runtime runtime = Runtime.getRuntime();
// Run the garbage collector
runtime.gc();
// Calculate the used memory
long firstUsageMemory = runtime.totalMemory() - runtime.freeMemory();
System.out.println("Used memory in bytes: " + firstUsageMemory);
System.out.println(str);
str = new StringBuffer(str).reverse().toString();
int count = 0;
int preValue = 0;
int lastspaceIndexVal = str.lastIndexOf(" ");
int strLen = str.length();
for (int i = 0; i < strLen - 1; i++) {
if (Character.isWhitespace(str.charAt(i))) {
if (i - preValue == 1 && count == 0) {
str = str.substring(0, preValue) + str.charAt(i - 1)
+ str.substring(i, strLen);
preValue = i;
count++;
} else if (i - preValue == 2 && count == 0) {
str = str.substring(0, preValue) + str.charAt(i - 1)
+ str.charAt(i - 2) + str.substring(i, strLen);
preValue = i;
count++;
} else if (i - preValue == 3 && count == 0) {
str = str.substring(0, preValue) + str.charAt(i - 1)
+ str.charAt(i - 2) + str.charAt(i - 3)
+ str.substring(i, strLen);
preValue = i;
count++;
} else if (i - preValue == 4 && count == 0) {
str = str.substring(0, preValue) + str.charAt(i - 1)
+ str.charAt(i - 2) + str.charAt(i - 3)
+ str.charAt(i - 4) + str.substring(i, strLen);
preValue = i;
count++;
} else if (i - preValue == 5 && count == 0) {
str = str.substring(0, preValue) + str.charAt(i - 1)
+ str.substring(i - 2, i - 1) + str.charAt(i - 3)
+ str.charAt(i - 3) + str.charAt(i - 5)
+ str.substring(i, strLen);
preValue = i;
count++;
} else if (i - preValue == 6 && count == 0) {
str = str.substring(0, preValue) + str.charAt(i - 1)
+ str.charAt(i - 2) + str.charAt(i - 3)
+ str.charAt(i - 4) + str.charAt(i - 5)
+ str.charAt(i - 6) + str.substring(i, strLen);
preValue = i;
count++;
} else if (i - preValue == 7 && count == 0) {
str = str.substring(0, preValue) + str.charAt(i - 1)
+ str.charAt(i - 2) + str.charAt(i - 3)
+ str.charAt(i - 4) + str.charAt(i - 5)
+ str.charAt(i - 6) + str.charAt(i - 7)
+ str.substring(i, strLen);
preValue = i;
count++;
} else if (i - preValue == 8 && count == 0) {
str = str.substring(0, preValue) + str.charAt(i - 1)
+ str.charAt(i - 2) + str.charAt(i - 3)
+ str.charAt(i - 4) + str.charAt(i - 5)
+ str.charAt(i - 6) + str.charAt(i - 7)
+ str.charAt(i - 8) + str.substring(i, strLen);
preValue = i;
count++;
} else if (i - preValue == 2 && count != 0) {
str = str.substring(0, preValue) + str.charAt(i - 1)
+ str.substring(i, strLen);
preValue = i;
} else if (i - preValue == 3 && count != 0) {
str = str.substring(0, preValue + 1) + str.charAt(i - 1)
+ str.charAt(i - 2) + str.substring(i, strLen);
preValue = i;
} else if (i - preValue == 4 && count != 0) {
str = str.substring(0, preValue + 1) + str.charAt(i - 1)
+ str.charAt(i - 2) + str.charAt(i - 3)
+ str.substring(i, strLen);
preValue = i;
} else if (i - preValue == 5 && count != 0) {
str = str.substring(0, preValue + 1) + str.charAt(i - 1)
+ str.charAt(i - 2) + str.charAt(i - 3)
+ str.charAt(i - 4) + str.substring(i, strLen);
preValue = i;
count++;
} else if (i - preValue == 6 && count != 0) {
str = str.substring(0, preValue + 1) + str.charAt(i - 1)
+ str.charAt(i - 2) + str.charAt(i - 3)
+ str.charAt(i - 4) + str.charAt(i - 5)
+ str.substring(i, strLen);
preValue = i;
count++;
} else if (i - preValue == 7 && count != 0) {
str = str.substring(0, preValue + 1) + str.charAt(i - 1)
+ str.charAt(i - 2) + str.charAt(i - 3)
+ str.charAt(i - 4) + str.charAt(i - 5)
+ str.charAt(i - 6) + str.substring(i, strLen);
preValue = i;
count++;
} else if (i - preValue == 8 && count != 0) {
str = str.substring(0, preValue + 1) + str.charAt(i - 1)
+ str.charAt(i - 2) + str.charAt(i - 3)
+ str.charAt(i - 4) + str.charAt(i - 5)
+ str.charAt(i - 6) + str.charAt(i - 7)
+ str.substring(i, strLen);
preValue = i;
count++;
}
if (lastspaceIndexVal == preValue) {
if (strLen - lastspaceIndexVal == 2 && count != 0) {
str = str.substring(0, preValue + 1)
+ str.charAt(strLen - 1);
preValue = i;
} else if (strLen - lastspaceIndexVal == 3 && count != 0) {
str = str.substring(0, preValue + 1)
+ str.charAt(strLen - 1)
+ str.charAt(strLen - 2);
preValue = i;
} else if (strLen - lastspaceIndexVal == 4 && count != 0) {
str = str.substring(0, preValue + 1)
+ str.charAt(strLen - 1)
+ str.charAt(strLen - 2)
+ str.charAt(strLen - 3);
preValue = i;
count++;
} else if (strLen - lastspaceIndexVal == 5 && count != 0) {
str = str.substring(0, preValue + 1)
+ str.charAt(strLen - 1)
+ str.charAt(strLen - 2)
+ str.charAt(strLen - 3)
+ str.charAt(strLen - 4);
preValue = i;
} else if (strLen - lastspaceIndexVal == 6 && count != 0) {
str = str.substring(0, preValue + 1)
+ str.charAt(strLen - 1)
+ str.charAt(strLen - 2)
+ str.charAt(strLen - 3)
+ str.charAt(strLen - 4)
+ str.charAt(strLen - 5);
preValue = i;
count++;
} else if (strLen - lastspaceIndexVal == 7 && count != 0) {
str = str.substring(0, preValue + 1)
+ str.charAt(strLen - 1)
+ str.charAt(strLen - 2)
+ str.charAt(strLen - 3)
+ str.charAt(strLen - 4)
+ str.charAt(strLen - 5)
+ str.charAt(strLen - 6);
preValue = i;
} else if (strLen - lastspaceIndexVal == 8 && count != 0) {
str = str.substring(0, preValue + 1)
+ str.charAt(strLen - 1)
+ str.charAt(strLen - 2)
+ str.charAt(strLen - 3)
+ str.charAt(strLen - 4)
+ str.charAt(strLen - 5)
+ str.charAt(strLen - 6)
+ str.charAt(strLen - 7);
preValue = i;
}
}
}
}
runtime.gc();
// Calculate the used memory
long SecondaryUsageMemory = runtime.totalMemory()
- runtime.freeMemory();
System.out.println("Used memory in bytes: " + SecondaryUsageMemory);
System.out.println(str);
}
}
import Java.util.*;
public class Restring {
public static void main(String[] args) {
String input,output;
Scanner kbd=new Scanner(System.in);
System.out.println("Please Enter a String");
input=kbd.nextLine();
int n=input.length();
char tmp[]=new char[n];
char nxt[]=new char[n];
tmp=input.toCharArray();
int m=0;
for(int i=n-1;i>=0;i--)
{
nxt[m]=tmp[i];
m++;
}
System.out.print("Reversed String is ");
for(int i=0;i<n;i++)
{
System.out.print(nxt[i]);
}
}
Le code sera comme ci-dessous:
public class A{
public static void main(String args[]){
String str="hello";
for(int i=str.length()-1;i>=0;i--){
String str1=str.charAt(i);
system.out.print(str1);
}
}
}
import Java.util.Scanner;
public class StringReverse {
public static void main(String[] args) {
//Read user Data From Console
Scanner sc = new Scanner(System.in);
System.out.println("Enter Your String:");
//Take an String so that it can Store the string data
String s1 = sc.nextLine();
//split the string and keep in an array
String[] s2 = s1.split(" ");
String s3 = " ";
//reverse the string and placed in an String s3
for (int i = 0; i < s2.length; i++) {
for (int j= s2[i].length()-1;j>=0;j--) {
s3 += s2[i].charAt(j);
}//for
s3 += " ";
}//for
System.out.println("After Reverse: "+s3);
}//main
}//StringReverse
ReverseString.Java
public class ReverseString {
public static void main(String[] args) {
String str = "Ranga Reddy";
String revStr = reverseStr(str);
System.out.println(revStr);
}
// Way1 - Recursive
public static String reverseStr(String str) {
char arrStr[] = reverseString(0, str.toCharArray());
return new String(arrStr);
}
private static char[] reverseString(int charIndex, char[] arr) {
if (charIndex > arr.length - (charIndex+1)) {
return arr;
}
int startIndex = charIndex;
int endIndex = arr.length - (charIndex+1);
char temp = arr[startIndex];
arr[startIndex] = arr[endIndex];
arr[endIndex] = temp;
charIndex++;
return reverseString(charIndex++, arr);
}
// Way2
private static String strReverse(String str) {
char ch[] = new char[str.length()];
for (int i = str.length() - 1, j = 0; i >= 0; i--) {
ch[j++] = str.charAt(i);
}
return new String(ch);
}
}
Vous pouvez simplement essayer comme ceci de prendre une chaîne itérative dessus en utilisant for boucle jusqu'au dernier dernier caractère de chaîne, puis en inversant simplement votre boucle comme suit:
public class StringReverse {
public static void main(String ar[]){
System.out.println(reverseMe("iniana"));
}
static String reverseMe(String s){
String reverse = "";
for(int i = s.length()-1; i>=0; i--){
resverse = reverse + s.charAt(i);
}
return reverse;
}
}
String x = "stack overflow";
String reversed = "";
for(int i = x.length()-1 ; i>=0; i--){
reversed = reversed+ x.charAt(i);
}
System.out.println("reversed string is : "+ reversed);
public class ReverseString {
public static void main(String[] args) {
reverseString("HELLO");
}
public static String reverseString(String s){
char []arr=s.toCharArray();
for(int i= (arr.length)-1;i>=0;i--){
System.out.print(arr[i]);
}
String str=String.copyValueOf(arr);
return str;
}
public class MyStack {
private int maxSize;
private char[] stackArray;
private int top;
public MyStack(int s) {
maxSize = s;
stackArray = new char[maxSize];
top = -1;
}
public void Push(char j) {
stackArray[++top] = j;
}
public char pop() {
return stackArray[top--];
}
public char peek() {
return stackArray[top];
}
public boolean isEmpty() {
return (top == -1);
}
public boolean isFull() {
return (top == maxSize - 1);
}
public static void main(String[] args) {
MyStack theStack = new MyStack(10);
String s="abcd";
for(int i=0;i<s.length();i++)
theStack.Push(s.charAt(i));
for(int i=0;i<s.length();i++)
System.out.println(theStack.pop());
}
public class ReverseWithoutStringAPI {
public static void main(String[] args) {
String st="hello";
StringBuffer b=new StringBuffer();
for(int i=st.length()-1;i>=0;i--){
b.append(st.charAt(i)); }
System.out.println("reverse:::"+b);
}
}
J'avais eu cela il y a quelque temps et, après avoir répondu à l'évidence avec StringBuffer.reverse (), ils m'ont alors demandé: "Pouvez-vous inverser un tableau de caractères sans utiliser ces méthodes API et obtenir le résultat sans spouler dans un nouveau tableau de caractères?"
À l'époque, j'ai compris que je n'avais besoin que d'itérer plus de la moitié de la longueur du tableau de caractères, mais je me suis efforcé d'expliquer le code à utiliser (il s'agissait d'une question verbale). Quoi qu'il en soit, j'ai essayé quand je suis rentré à la maison et j'ai trouvé ceci:
public class StringReverse {
public static void main(String[] args){
String a = "String";
char[] aChar = a.toCharArray();
for (int i = (aChar.length-1)/2 ; i >= 0 ; i--){
int posA = i;
int posB = (aChar.length-1-i);
char tmpA = aChar[posA];
char tmpB = aChar[posB];
System.out.println("Setting " + posA + " to " + tmpB);
System.out.println("Setting " + posB + " to " + tmpA);
aChar[posA] = tmpB;
aChar[posB] = tmpA;
}
System.out.println(aChar);
}
}
Vous pouvez évidemment y parvenir avec moins de code, mais je pense que les assignations temporaires de la méthode rendent plus clair le travail du code.
Sort quelque chose comme:
Setting 2 to i
Setting 3 to r
Setting 1 to n
Setting 4 to t
Setting 0 to g
Setting 5 to S
gnirtS
Plus d'une question d'entrevue que d'une question de devoirs, je dirais.
Le code sera comme ci-dessous:
public class RemoveString {
public static void main(String[] args) {
Scanner scanner=new Scanner(System.in);
String s=scanner.next();
String st="";
for(int i=s.length()-1;i>=0;i--){
st=st+s.charAt(i);
}
System.out.println(st);
}
}
public static void main(String[] args) {
String str = "hello world here I am";
StringTokenizer strToken = new StringTokenizer(str);
int token = strToken.countTokens();
String str1 [] = new String[token];
char chr[] = new char[str.length()];
int counter = 0;
for(int j=0; j < str.length(); j++) {
if(str.charAt(j) != ' ') {
chr[j] = str.charAt(j);
}else {
str1[counter++] = new String(chr).trim();
chr = new char[str.length()];
}
}
str1[counter++] = new String(chr).trim();
for(int i=str1.length-1; i >= 0 ; i--) {
System.out.println(str1[i]);
}
}
O/P est: je suis ici monde bonjour
Cela peut être fait de cette façon aussi
char c[]=str.toCharArray();
int i=c.lenght-1;
public void printReverseString(char[] c, int i){
if(i==-1) return;
System.out.println(c[i]);
printReverseString(c,--i);
}