Develop Reference

Reverse words without changing capitals or punctuation

Create a program with the lowest amount of characters to reverse each word in a string while keeping the order of the words, as well as punctuation and capital letters, in their initial place.
By "Order of the words", I mean that each word is split by an empty space (" "), so contractions and such will be treated as one word. The apostrophe in contractions should stay in the same place. ("Don't" => "Tno'd").
(Punctuation means any characters that are not a-z, A-Z or whitespace*).
Numbers were removed from this list due to the fact that you cannot have capital numbers. Numbers are now treated as punctuation.
For example, for the input:
Hello, I am a fish.
it should output:
Olleh, I ma a hsif.
Notice that O, which is the first letter in the first word, is now capital, since H was capital before in the same location.
The comma and the period are also in the same place.
More examples:
This; Is Some Text!
would output
Siht; Si Emos Txet!
I've tried this:
public static String reverseWord(String input)
{
String words[]=input.split(" ");
StringBuilder result=new StringBuilder();
for (String string : words) {
String revStr = new StringBuilder(string).reverse().toString();
result.append(revStr).append(" ");
}
return result.toString().trim();
}

I have tried to solve your problem. It's working fine for the examples I have checked :) Please look and let me know :)
public static void main(String[] args) {
System.out.println(reverseWord("This; Is Some Text!"));
}
public static boolean isAlphaNumeric(String s) {
return s != null && s.matches("^[a-zA-Z0-9]*$");
}
public static String reverseWord(String input)
{
String words[]=input.split(" ");
StringBuilder result=new StringBuilder();
int startIndex = 0;
int endIndex = 0;
for(int i = 0 ; i < input.length(); i++) {
if (isAlphaNumeric(Character.toString(input.charAt(i)))) {
endIndex++;
} else {
String string = input.substring(startIndex, endIndex);
startIndex = ++endIndex;
StringBuilder revStr = new StringBuilder("");
for (int j = 0; j < string.length(); j++) {
char charToAdd = string.charAt(string.length() - j - 1);
if (Character.isUpperCase(string.charAt(j))) {
revStr.append(Character.toUpperCase(charToAdd));
} else {
revStr.append(Character.toLowerCase(charToAdd));
}
}
result.append(revStr);
result.append(input.charAt(i));
}
}
if(endIndex>startIndex) // endIndex != startIndex
{
String string = input.substring(startIndex, endIndex);
result.append(string);
}
return result.toString().trim();
}
Call the reverseWord with your test string.
Hope it helps. Don't forget to mark it as right answer, if it is :)

Here is a proposal that follows your requirements. It may seem very long but its just comments and aerated code; and everybody loves comments.
public static String smartReverseWords(String input) {
StringBuilder finalString = new StringBuilder();
// Word accumulator, resetted after each "punctuation" (or anything different than a letter)
StringBuilder wordAcc = new StringBuilder();
int processedChars = 0;
for(char c : input.toCharArray()) {
// If not a whitespace nor the last character
if(!Character.isWhitespace(c)) {
// Accumulate letters
wordAcc.append(c);
// Have I reached the last character? Then finalize now:
if(processedChars == input.length()-1) {
reverseWordAndAppend(wordAcc, finalString);
}
}
else {
// Was a word accumulated?
if(wordAcc.length() > 0) {
reverseWordAndAppend(wordAcc, finalString);
}
// Append non-letter char to final string:
finalString.append(c);
}
processedChars++;
}
return finalString.toString();
}
private static void reverseWordAndAppend(StringBuilder wordAcc, StringBuilder finalString) {
// Then reverse it:
smartReverse(wordAcc); // a simple wordAcc.reverse() is not possible
// Append word to final string:
finalString.append(wordAcc.toString());
// Reset accumulator
wordAcc.setLength(0);
}
private static class Marker {
Integer position;
String character;
}
private static void smartReverse(StringBuilder wordAcc) {
char[] arr = wordAcc.toString().toCharArray();
wordAcc.setLength(0); // clean it for now
// Memorize positions of 'punctuation' + build array free of 'punctuation' in the same time:
List<Marker> mappedPosOfNonLetters = new ArrayList<>(); // order matters
List<Integer> mappedPosOfCapitals = new ArrayList<>(); // order matters
for (int i = 0; i < arr.length; i++) {
char c = arr[i];
if(!Character.isLetter(c)) {
Marker mark = new Marker();
mark.position = i;
mark.character = c+"";
mappedPosOfNonLetters.add(mark);
}
else {
if(Character.isUpperCase(c)) {
mappedPosOfCapitals.add(i);
}
wordAcc.append(Character.toLowerCase(c));
}
}
// Reverse cleansed word:
wordAcc.reverse();
// Reintroduce 'punctuation' at right place(s)
for (Marker mark : mappedPosOfNonLetters) {
wordAcc.insert(mark.position, mark.character);
}
// Restore capitals at right place(s)
for (Integer idx : mappedPosOfCapitals) {
wordAcc.setCharAt(idx,Character.toUpperCase(wordAcc.charAt(idx)));
}
}
EDIT
I've updated the code to take all your requirements into account. Indeed we have to make sure that "punctuation' stay in place (and capitals also) but also within a word, like a contraction.
Therefore given the following input string:
"Hello, I am on StackOverflow. Don't tell anyone."
The code produces this output:
"Olleh, I ma no WolfrEvokcats. Tno'd llet enoyna."

How do I get the numbers and alphabets from a string?

I'm trying to work out a way of splitting up a string in java that follows a pattern like so:
String a = "24ab4h";
The results from this should be the following:
st[0] = "24";
st[1] = "a";
st[2] = "b";
st[3] = "4";
st[4] = "h";
However, I'm completely stumped as to how I can achieve this. Please, can someone help me out? I have tried searching online for a similar problem, however, it's very difficult to phrase it correctly in a search.

If you use a split() function you'll loose the elements which are used as delimiters so I think use a Pattern is better :
public static void main(String args[]) {
Matcher m = Pattern.compile("\\d+|[a-zA-Z]").matcher("24ab4h");
List<String> res = new ArrayList<>();
while (m.find()) {
res.add(m.group());
}
}
The pattern will detect all group of digits OR alpabet char alone, then it will add all into a List (better than array because you don't know the size)
If you really want an array at the end, 2 solutions for List<String> ->String[] :
String[] array = res.toArray(new String[res.size()]);
String[] array = res.stream().toArray(String[]::new);

Try to process your String in a loop, char by char.
String a = "24ab4h";
If focused char (2) is number - check next char (4). If next char is also a number - continue scanning. If next char differs from number - save focused char (or focused char sequence, in this example it is - 24).
The same logic for alphabet chars.

public static void main(String[] args) {
/*
* Stack stack = new Stack(5); stack.push("10"); stack.push("20");
* stack.push("20"); stack.push("20"); stack.push("20");
* stack.push("20"); stack.push("20"); stack.displayStack();
*/
String a = "24ab4h";
System.out.println(Arrays.deepToString(splitString(a)));
}
private static String[] splitString(String a) {
char[] result = new char[a.length()];
StringBuilder sb = new StringBuilder();
for (int i = 0; i < a.length(); i++) {
if (isNumber(a.charAt(i))) {
if (i != 0 && !isNumber(a.charAt(i - 1)))
sb.append(" ");
sb.append(a.charAt(i));
} else {
sb.append(" ");
sb.append(a.charAt(i));
}
}
return sb.toString().split(" ");
}
private static boolean isNumber(char c) {
try {
Integer i = Integer.parseInt(String.valueOf(c));
} catch (NumberFormatException nfe) {
return false;
}
return true;
}

Ouput of Reversing words of String does not come as expected [duplicate]

This question already has answers here:
Reverse a given sentence in Java
(14 answers)
Closed 7 years ago.
Given a String with words.Reverse words of String.
Sample Input 1
Hello World
Sample Output
World Hello
MyApproach
To reverse words I first counted how many spaces are there.After that I stored their space index in an array.Using lastIndex, I printed the last elements of the array.After that I printed the last 2 words of the array.
static String reverseWords(String inputString)
{
int l1=inputString.length();
int count=1;
for(int i=0;i<l1;i++)
{
char ch=inputString.charAt(i);
if(ch==' ')
{
count++;
}
}
int k=0;
int[] spaceindex=new int[count];
spaceindex[0]=0;
k++;
for(int i=0;i<l1;i++)
{
char ch=inputString.charAt(i);
if(ch==' ')
{
spaceindex[k++]=i+1;
}
}
int p=spaceindex.length-1;
String strnew="";
for(int j=spaceindex[p];j<l1;j++)
{
char c=inputString.charAt(j);
strnew=strnew+c;
}
p--;
while(p>=0)
{
for(int j=spaceindex[p];;j++)
{
char c=inputString.charAt(j);
if(c==' ')
{
break;
}
strnew=strnew+c;
}
}
return strnew;
}
InputParameters ActualOutput Expected Output
Hello World WorldHelloWorldHello(Infinite loop) WorldHello
#Edit I asked Why the code I wrote is wrong.I tried without using any inbuilt functions(which was necessary for me).In that way I think It is not Duplicate Ans according to me.
Can anyone guide me what went wrong in my code.

The issue within your code was the while loop:
while(p>=0) {
strnew = strnew + " ";
for(int j=spaceindex[p];;j++) {
char c=inputString.charAt(j);
if(c==' '){
break;
}
strnew=strnew+c;
}
p--;
}
Adding the p-- will prevent the loop for occurring infinitely. Also inserting the strnew = strnew + " "; after the while loop ensures a space in between each word.

It's possible without using another arrays, splits or any additional strucure.
Having array of characters ( convert if needed as String is immutable), first reverse all characters in the array. Secondly loop over spaces and for each word reverse characters in the word.

Simple solution :
public static void main(String[] args) {
String x = "Hello World";
String[] xArray = x.split(" ");
String result = "";
for (int i = xArray.length - 1; i >= 0; i--) {
result += xArray[i] + " ";
}
System.out.println(result.trim()); // World Hello
}

You can use a StringTokenizer to convert the string into tokens or String.split function. You can push this collection into a Stack and extract the elements in a reverse order. To join the strings back you could use a StringBuilder or a StringBuffer.
To do this more efficiently you could convert the string to a character array and StringBuilders
String myString = "Here is the String";
char[] myChars = myString.toCharArray();
StringBuilder word = new StringBuilder();
StringBuilder newString = new StringBuilder();
for(int i = myChars.length - 1; --i >= 0;) {
char c = myChars[i];
if(c == ' ') {
newString.append(c);
newString.append(word);
word = new StringBuilder();
} else {
word.append(c);
}
}

I would base an implementation on String.lastIndexOf(int) and String.substring(int, int). I'd got with a StringBuilder to construct the output "sentence" and a while loop to iterate the words in reverse order. Something like,
static String reverseWords(String in) {
StringBuilder sb = new StringBuilder(in.length());
int space;
while ((space = in.lastIndexOf(' ')) > 0) {
sb.append(in.substring(space + 1, in.length())).append(' ');
in = in.substring(0, space);
}
sb.append(in);
return sb.toString();
}
Which I tested with your provided sample
public static void main(String[] args) {
System.out.println(reverseWords("Hello World"));
}
Getting (as expected)
World Hello

Remove characters at certain position at string

I want to remove certain characters at specific positions of the String. I have the positions, but I am facing problems removing the characters.
what i am doing is:
if (string.subSequence(k, k + 4).equals("\n\t\t\t")){
string = string.subSequence(0, k) + "" + s.subSequence(k, s.length());
}
I need to remove "\n\t\t\t" from string

Use StringBuilder:
StringBuilder sb = new StringBuilder(str);
sb.delete(start, end);
sb.deleteCharAt(index);
String result = sb.toString();

Use StringBuilder
String str=" ab a acd";
StringBuilder sb = new StringBuilder(str);
sb.delete(0,3);
sb.deleteCharAt(0);
String result = sb.toString();
System.out.println(result);

public static String remove(int postion, String stringName) {
char [] charArray = stringName.toCharArray();
char [] resultArray = new char[charArray.length];
int count = 0;
for (int i=0; i< charArray.length; i++) {
if (i != postion-1) {
resultArray[count] = charArray[i];
count++;
}
}
return String.valueOf(resultArray);
}

Use String.ReplaceAll() instead of this.
But if you only want to remove specific element only you can use substring().
Now you want to know position which you already know.

Put your points in a HashSet called set
StringBuilder sb=new StringBuilder();
for(int i=0;i<string.length();i++){
if(!set.contains(string.charAt(i)))
sb.append(string.charAt(i));
}
String reformattedString=sb.toString();

First you have to put \ in front of the special characters in order to do the matching of the two string, thus you will have .equals("\"\\n\\t\\t\\t\""), otherwise the substring is not going to be recognized inside the string. Then the other thing which you have to fix is the position of the index begin and end inside .subSequence(k,k+10) since the first and the last character are 10 positions apart and not 4. Note also that when you patch the string you go from position 0 to k and from k+10 to str.length(). If you go from 0 --> k and k --> length() you just join the old string together :).
Your code should work like this, I have tested it already
if(str.substring(k, k+10).equals("\"\\n\\t\\t\\t\""))
{
newstr = str.substring(0,k)+str.substring(k+10,(str.length()));
}
also you don't need +" "+ since you are adding strings. Whoever wants to see the effect of this can run this simple code:
public class ReplaceChars_20354310_part2 {
/**
* #param args the command line arguments
*/
public static void main(String[] args) {
String str = "This is a weird string containg balndbfhr frfrf br brbfbrf b\"\\n\\t\\t\\t\"";
System.out.println(str); //print str
System.out.println(ReplaceChars(str)); //then print after you replace the substring
System.out.println("\n"); //skip line
String str2 = "Whatever\"\\n\\t\\t\\t\"you want to put here"; //print str
System.out.println(str2); //then print after you replace the substring
System.out.println(ReplaceChars(str2));
}
//Method ReplaceChars
public static String ReplaceChars (String str) {
String newstr ="";
int k;
k = str.indexOf("\"\\n\\t\\t\\t\""); //position were the string starts within the larger string
if(str.substring(k, k+10).equals("\"\\n\\t\\t\\t\""))
{
newstr = str.substring(0,k)+str.substring(k+10,(str.length())); //or just str
}
return newstr;
}//end method
}

Alternating string of characters and digits

I was given this problem to solve. I have only the slightest idea on how it should be implemented, and I'm all too new with programming and stuffs, and would love to hear your comments on this.
Say given a string in the form "abc1234defgh567jk89", and I must create a new string "a1b2c3d5e6f7j8k9".
Note that there are corresponding [digits] & [characters] group and since there may be more of one type over the other, the output has only matching sequence and ignore extra digits or characters in this case '4' & 'g' & 'h'.
I know I will have to use 2 sets of queues to store both types of elements, but I do not know how else to proceed from here.
Would appreciate if you could share a pseudocode or a Java(prefably) version, since I am learning thru this language now.
Thank you.

Pseudocode:
Queue letterQueue;
Queue numberQueue;
for (every character in the string) {
if (it's a letter) {
if (numberQueue is not empty) {
add the letters alternating into the buffer (stringbuilder), and purge buffers
}
add newest letter to letterqueue
}
if (it's a number) {
add newest letter to numberqueue
}
}
add any remaining unprocessed letters to the queue (this will happen most of the time)
return contents of string buffer
You will need:
Queue, probably a LinkedList
StringBuilder
String.toCharArray
Character
Code:
import java.util.LinkedList;
import java.util.Queue;
public class StringTest {
private static String str ="abc1234defgh567jk89";
private static String reorganize(String str) {
Queue<Character> letterQueue = new LinkedList<>();
Queue<Character> numberQueue = new LinkedList<>();
StringBuilder s = new StringBuilder();
for (char c : str.toCharArray()) {
if(Character.isLetter(c)) {
if (!numberQueue.isEmpty()) processQueues(letterQueue, numberQueue, s);
letterQueue.offer(c);
} else if(Character.isDigit(c)) {
numberQueue.offer(c);
}
}
processQueues(letterQueue, numberQueue, s);
return s.toString();
}
private static void processQueues(Queue<Character> letterQueue, Queue<Character> numberQueue, StringBuilder s) {
while(!letterQueue.isEmpty() && !numberQueue.isEmpty()) {
s.append(letterQueue.poll());
s.append(numberQueue.poll());
}
letterQueue.clear();
numberQueue.clear();
}
public static void main(String... args) {
System.out.println(reorganize(str));
}
}

See this hint:
String str = "abc1234defgh567jk89";
String c = str.replaceAll("\\d", ""); // to store characters
String d = str.replaceAll("\\D", ""); // to store digits
Try this:
public static void main(String[] args) {
String str = "abc1234defgh567jk89";
String c = str.replaceAll("\\d", "");
String d = str.replaceAll("\\D", "");
String result = "";
int j = 0, k = 0;
int max = Math.max(c.length(), d.length());
for (int i = 0; i < max; i++) {
if (j++ < c.length())
result = result + c.charAt(i);
if (k++ < d.length())
result = result + d.charAt(i);
}
System.out.println(result);
}
Output:
a1b2c3d4e5f6g7h8j9k