Develop Reference

Multiplication of two Binary Numbers given as Strings

so I have a code that should multiplicate two Binary Numbers as String without using ParseInt. My code actually works by far but it's multiplicating as decimal numbers. Something in the part where it should do the addition is wrong.
Thanks for any kind of help!
public static String multiply(String binary1, String binary2)
String b1 = new StringBuilder(binary1).reverse().toString();
String b2 = new StringBuilder(binary2).reverse().toString();
int[] m = new int[binary1.length()+binary2.length()];
for (int i = 0; i < binary1.length(); i++) {
for (int j = 0; j < binary2.length(); j++) {
m[i+j] += (b1.charAt(i)-'0')*(b2.charAt(j)-'0');
}
}
StringBuilder sb = new StringBuilder();
for(int i=0; i < m.length; i++) {
int mod = m[i]%10;
int carry = m[i]/10;
if (i+1 < m.length) {
m[i + 1] = m[i + 1] + carry;
}
sb.insert(0, mod);
}
// delete leading zeros
while (sb.charAt(0) == '0' && sb.length() > 1) {
sb.deleteCharAt(0);
}
return sb.toString();
}
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
System.out.print("1. Faktor: ");
String input1 = scan.next("(0|1)*");
System.out.print("2. Faktor: ");
String input2 = scan.next("(0|1)*");
scan.close();
System.out.println("Ergebnis: " + multiply(input1, input2));
}
}

You may not use Integer.parseInt but nobody forbid you to implement your own parser:
private static int parseBinaryString(String s) {
int binary = 0;
for (int i = s.length() - 1, c; i >= 0; i--) {
binary <<= 1;
c = s.charAt(i);
if (c == '1') {
binary++;
} else if (c != '0') {
throw new NumberFormatException(s);
}
}
return binary;
}
Which can then be simply used like this in your multiply method:
private static String multiply(String a, String b) {
return Integer.toBinaryString(parseBinaryString(a) * parseBinaryString(b));
}
And if you can't use Integer.toBinaryString you can implement that method yourself:
private static String toBinaryString(int i) {
StringBuilder binary = new StringBuilder();
for (int t = i; t != 0; t >>= 1) {
binary.append((i & t) != 0 ? 1 : 0);
}
return binary.toString();
}

How to add a number in String without using the StringBuilder

Say I have A String s = "HOWAREYOU". I want to add number 2 after every two letters so s becomes "HO2AR2EY2OU2". I managed to do it on my own by using the StringBuilder but need to do it without using it.
public static void main(String[] args) {
StringBuilder str = new StringBuilder("HelloHowAreYou");
int i = 2;
while (i <= str.length()) {
str.insert(i, "2");
i = i + 3;
}
System.out.println(str.toString());
}

Try this:
public static void main(String[] args) {
String str = "HelloHowAreYou";
int frequency = 2;
String insertCharacter = "2";
String newString = "";
for (int i = 0; i < str.length(); i++) {
if ((i + 1) % frequency == 0) {
newString += str.substring(i, i + 1) + insertCharacter;
} else {
newString += str.substring(i, i + 1);
}
}
System.out.println(newString);
}

Here is Code:
public static void main(String[] args)
{
String str = "HelloHowAreYou";
int i = 1;
int j = 2;
while ( i <= str.length() )
{
if(i%j == 0){
str = str.substring(0, i)+"2"+str.substring(i, str.length());
j = j+3;
}
i++;
}
System.out.println( str );
}

You can do it using some methods provided by String class.
String s = "HOWAREYOU";
s = String.join("2", s.split("(?<=\\G..)")); \\HO2WA2RE2YO2U

Reverse a String without affecting special characters

Why is it throwing an error? Any help would be appreciated
public class RAWS
{
public String rawsc(String ori)
{
String temp="";
for(int i=0;i<ori.length();i++)
{
char c=ori.charAt(i);
if(((c>=65)&&(c<=90))||((c>=97)&&(c<122)))
temp=c+temp;
}
for(int i=0;i<ori.length();i++)
{
char c=ori.charAt(i);
if(((c>=65)&&(c<=90))||((c>=97)&&(c<122)))
ori.replace(c, temp.charAt(i));
}
for(int i=0;i<ori.length();i++)
{
System.out.println(ori.charAt(i));
}
return(ori);
}
public static void main(String[] args)
{
String str="a,b$c";
RAWS ob=new RAWS();
String new1=ob.rawsc(str);
for(int i=0;i<new1.length();i++)
{
System.out.print(new1.charAt(i)+" ");
}
}
}
Editor:
Exception in thread "main" java.lang.StringIndexOutOfBoundsException: String index out of range: 4
at java.lang.String.charAt(String.java:658)
at arraygs.RAWS.rawsc(RAWS.java:22)
at arraygs.RAWS.main(RAWS.java:30)

The problematic part is the call temp.charAt(i) in
for(int i=0;i<ori.length();i++){
char c=ori.charAt(i);
if(((c>=65)&&(c<=90))||((c>=97)&&(c<122)))
ori.replace(c, temp.charAt(i));
}
The string temp may not have the length of ori. The reason for this is the if-condition in the first loop
for(int i=0;i<ori.length();i++) {
char c=ori.charAt(i);
if(((c>=65)&&(c<=90))||((c>=97)&&(c<122)))
temp=c+temp;
}
So accessing the position i in temp (as part of the second loop) may result in the java.lang.StringIndexOutOfBoundsException.

public class PracticeJava{
public static void main(String []args){
String str = "\"Str!ng\"";
System.out.println("Actual str: "+str);
System.out.println("Reverse str: "+reverseStrSpecial(str));
}
public static String reverseStrSpecial(String str) {
int len = str.length();
char[] revStrArr = new char[len];
int j = len-1;
for (int i=0; i <= j; ) {
if(!Character.isAlphabetic(str.charAt(i))) {
revStrArr[i] = str.charAt(i);
i++;
} else if (!Character.isAlphabetic(str.charAt(j))) {
revStrArr[j] = str.charAt(j);
j--;
} else {
revStrArr[j] = str.charAt(i);
revStrArr[i] = str.charAt(j);
j--;
i++;
}
}
return new String(revStrArr);
}
}

public class Solution {
public static void main(String[] args) {
System.out.println(reverseString("a,b$c"));
}
/**
* Reverse string with maintaining special character in place
*
* Algorithm:
* 1. create temporary array
* 2. copy all character from original array excluding special character
* 3. reverse the temporary array
* 4. start copying temporary array into original if element is an alphabetic character
* #param input
* #return
*/
public static String reverseString(String input) {
char[] inputArr = input.toCharArray();
char[] tempArr = new char[input.length()];
int i=0;
int j=0;
for (char ch:inputArr){
if(Character.isAlphabetic(ch)){
tempArr[i] = ch;
i++;
}
}
i--;
while(j<i){
char temp = tempArr[i];
tempArr[i]= tempArr[j];
tempArr[j]=temp;
j++;
i--;
}
for(i=0,j=0;i<input.length();i++){
if(Character.isAlphabetic(inputArr[i])){
inputArr[i]= tempArr[j++];
}
}
return new String(inputArr);
}
}

public class Ex {
public static void main(String[] args) {
String ss= "Hello###+dnksjaf#+43####";
char[] c=new char[ss.length()];
String spclCharLessString="";
String spclCharLessStringrev="";
for(int i=0;i<ss.length();i++) {
if(((ss.charAt(i)>='A'&&ss.charAt(i)<='Z')|(ss.charAt(i)>='a'&&ss.charAt(i)<='z')|(ss.charAt(i)>='0'&&ss.charAt(i)<='9'))) {
spclCharLessString+=ss.charAt(i);
}
c[i]=ss.charAt(i);
}
for(int i=spclCharLessString.length()-1;i>=0;i--) {
spclCharLessStringrev+=spclCharLessString.charAt(i);
}
int spclCharSpace=0;
for(int i=0;i<ss.length();i++) {
if(((ss.charAt(i)>='A'&&ss.charAt(i)<='Z')|(ss.charAt(i)>='a'&&ss.charAt(i)<='z')|(ss.charAt(i)>='0'&&ss.charAt(i)<='9'))) {
c[i]=spclCharLessStringrev.charAt(i-spclCharSpace);
}else {
spclCharSpace++;
}
}
System.out.println(spclCharLessStringrev);
for(char c1:c) {
System.out.print(c1);
}
}
}

using regex seems to be a good idea.here is my javascript solution.
var reverseOnlyLetters = function(S) {
let arr = S.split('')
let regex = /^[a-zA-Z]{1}$/
let i=0,j=arr.length-1;
while(i<j){
if(regex.test(arr[i]) && regex.test(arr[j])){
let temp = arr[i]
arr[i]=arr[j]
arr[j]=temp
i++;j--
}else{
if(!regex.test(arr[i])) i++
if(!regex.test(arr[j])) j--
}
}
return arr.join('')
};

str=input("enter any string")
l=[]
s=""
list=list(str)
for i in str:
k=ord(i)
if((k>=48 and k<=57) or (k>=65 and k<=90) or(k>=97 and k<=122)):
l.append(i)
l.reverse()
print(s.join(l))
by sreevidhya bontha

public static void main(String[] args) {
String str = "fed#cb%a!";
char arr[] = new char[str.length()];
for (int i = 0; i < str.length(); i++) {
if (str.charAt(i) < 48 || (str.charAt(i) > 57 && str.charAt(i) < 65) || (str.charAt(i) > 90 && str.charAt(i) < 97) || str.charAt(i) > 122)
arr[i] = str.charAt(i);
else
arr[i] = '0';
}
Stack<Character> stack = new Stack<>();
for (int i = 0; i < str.length(); i++) {
stack.push(str.charAt(i));
}
int i=0;
while(!stack.isEmpty()){
char pop = stack.pop();
if (!(pop < 48 || (pop > 57 && pop < 65) || (pop > 90 && pop < 97) || pop > 122)){
arr[i] = pop;
++i;
}
if(arr[i]!='0'){
++i;
}
}
for ( i = 0; i < str.length(); i++) {
System.out.print(arr[i]);
}
}
Time complexity: O(n)

public static void main(String[] args) {
String a = "ab$cd";
char[] b = a.toCharArray();
int c = b.length;
for (int i = 0; i < c / 2; i++) {
if (Character.isAlphabetic(b[i]) || Character.isDigit(b[i])) {
char temp = b[i];
b[i] = b[c - i - 1];
b[c - i - 1] = temp;
}
}
System.out.println(String.valueOf(b));
}

public class MuthuTest {
static Map list = new HashMap();
/*
* public static int fact(int n) { if(n>1) return n*fact(n-1); else return 1; }
*/
#SuppressWarnings("deprecation")
public static void main(String[] args) {
String j = "muthu is a good boy.";
int v = 0;
String[] s = j.split(" ");
for (int h = 0; h < s.length; h++) {
String y;
y = s[h].replaceAll("[A-Za-z0-9]", "");
list.put(h, y);
}
// MuthuTest.li(s);
for (int u = s.length - 1; u >= 0; u--) {
if (u == 0) {
s[u] = s[u].replaceAll("[^A-Za-z0-9]", "");
System.out.print(s[u] + list.get(v));
} else {
s[u] = s[u].replaceAll("[^A-Za-z0-9]", "");
System.out.print(s[u] + list.get(v) + " ");
}
v++;
}
}
}

[Java] Simple way to reverse only alphabets without affecting special chars.
public class StringReverse {
public static void main(String[] args) {
reverseString("T#E$J#A%S");
}
//S#A$JE#T
private static void reverseString(String s){
int len = s.length();
char[] arr = new char[len];
for(int i=0; i<len; i++){
char ch = s.charAt(i);
if(Character.isAlphabetic(ch)){
arr[len-1-i] = ch;
}else{
arr[i] = ch;
}
}
System.out.println(new String(arr));
}
}

import java.util.HashMap;
import java.util.Map.Entry;
public class ReverseString {
public static void main(String[] args) {
HashMap<Character, Integer> map = new HashMap<>();
String s = "S#3jakd*nd%4*ksdkj12";
String str = "";
int len = s.length();
for (int i = len - 1; i >= 0; i--) {
char ch = s.charAt(i);
if (Character.isAlphabetic(ch) || Character.isDigit(ch)) {
str = str + s.charAt(i);
} else {
map.put(s.charAt(i), new Integer(s.indexOf(s.charAt(i))));
}
}
for (Entry<Character, Integer> entry : map.entrySet()) {
str = str.substring(0, entry.getValue()) + entry.getKey() + str.substring(entry.getValue(), str.length());
}
System.out.println(str);
}
}

Reverse a String without affecting any special chars. Note that it is just for a String but not combination of Strings that would eventually be an array of Strings.
Code :
public class Info {
// Input : str = "Ab,c,de!$" o/p : ed,c,bA!$
public static void main(String[] args) {
String input = "Ab,c,de!$";
char[] inputCharArray = input.toCharArray();
reverseIgnoreSpecialCharacters(inputCharArray);
}
public static void reverseIgnoreSpecialCharacters(char[] charArray) {
int j = charArray.length-1;
int k = 0;
for(int i = charArray.length-1; i>=0; i--) {
if(!(charArray[i] >= 65 && charArray[i] <=90) || !(charArray[i] >= 97 && charArray[i] <=122)) {
charArray[j] = charArray[i];
System.out.print(charArray[j]);
j--;
}
else {
charArray[k] = charArray[i];
System.out.print(charArray[k]);
k++;
}
}
}
}
for multiple Strings, you could something like below :
Code :
public class Info {
// Input : str = "Ab,c,de!$" o/p : ed,c,bA!$
public static void main(String[] args) {
String input = "Ab,c,de!$ Abhi$hek";
String[] inputStringArray = input.split("\\ ");
for(int i = inputStringArray.length-1; i>=0; i--) {
char[] strArray = inputStringArray[i].toCharArray();
reverseIgnoreSpecialCharacters(strArray);
System.out.print(" ");
}
}
public static void reverseIgnoreSpecialCharacters(char[] charArray) {
int j = charArray.length-1;
int k = 0;
for(int i = charArray.length-1; i>=0; i--) {
if(!(charArray[i] >= 65 && charArray[i] <=90) || !(charArray[i] >= 97 && charArray[i] <=122)) {
charArray[j] = charArray[i];
System.out.print(charArray[j]);
j--;
}
else {
charArray[k] = charArray[i];
System.out.print(charArray[k]);
k++;
}
}
}
}

Simplest Way to Do it..
String name = "Ma#hb$oobSi#ddi$qui";
char oldchararr[] = name.toCharArray();
String newStr = new StringBuffer(name.replaceAll("[^A-Za-z0-9]", "")).reverse().toString();
char newchar[] = newStr.toCharArray();
int j = 0;
for (int i = 0; i < oldchararr.length; i++) {
if (Character.isAlphabetic(oldchararr[i]) || Character.isDigit(oldchararr[i])) {
oldchararr[i] = newchar[j];
j++;
}
}
for (char c : oldchararr) {
System.out.print(c);
}

Extracting Ints from Strings in Java

I'm trying to write a method which takes a String, looks for Ints in it
and then adds them together.
for example:
String s = "five5six66"
should return 5+66 = 71 or:
String s = "1ciao2three3"
should return 1+2+3 = 6
The following is what I wrote already, but when I run it I get a
NumberFormatException
code (Update 1):
public static int addNumbers(String s) {
String numbers="";
int addNumbers = 0;
int i;
char c;
for (i=0; i<s.length(); i++) {
if (s.charAt(i)>='0' && s.charAt(i)<='9') {
c = s.charAt(i);
while (i<s.length()-1) {
if (s.charAt(i+1)>='0' && s.charAt(i+1)<='9')
numbers = numbers.valueOf(c + s.charAt(i+1));
addNumbers = addNumbers + Integer.parseInt(numbers);
}
addNumbers = addNumbers + Character.getNumericValue(c);
}
}
return addNumbers;
}
Hopefully you can help me fix this code and please, let me understand what I did wrong!
Also can I expand it so if I have a String like:
String s = "hi123and27"
I can get 123+27 = 150?
Because my code is limited to a 2 digit number as it is now.

I would suggest using REGEX to address your requirements:
you will need:
the REGEX pattern: "\d+"
an accumulator that is concatenating the value you get of the given String
Example:
public static void main(String[] args) {
String s = "hi123and27";
Pattern p = Pattern.compile("\\d+");
Matcher m = p.matcher(s);
int accumulator = 0;
while (m.find()) {
accumulator += Integer.parseInt(m.group());
}
System.out.println("final result: " + accumulator );
}

Regex + Java 8 streams:
public static int addNumbers(String str) {
return Arrays.stream(str.replaceAll("[^0-9]", " ").split(" "))
.filter(s -> !s.isEmpty())
.mapToInt(Integer::parseInt)
.sum();
}
EDIT regarding recommendations is the comments:
public static int addNumbers(String str) {
return Arrays.stream(str.split("[^0-9]+"))
.filter(s -> !s.isEmpty())
.mapToInt(Integer::parseInt)
.sum();
}

Try this
public static void main(String [] args){
String string = "hi123and27";
int size = string.length();
int sum = 0;
StringBuilder val = new StringBuilder();
for (int idx = 0; idx < size; idx++) {
Character character = string.charAt(idx);
if (Character.isDigit(character)) {
val.append(character);
//if last character is a digit
if((idx+1 == size) && val.length() > 0)
sum += Integer.parseInt(val.toString());
}else{
if(val.length() > 0)
sum += Integer.parseInt(val.toString());
//reset the val for digits between characters for it to store the next sequence
val.setLength(0);
}
}
System.out.println("The sum is : " + sum);
}

You should try this one.
public static int addNum(String text){
String numbers = "";
int finalResult = 0;
for(int i=0;i < text.length();i++){
if(isNumeric(text.substring(i, i + 1)))
{
numbers += text.substring(i, i + 1);
if(i==text.length()-1) {
finalResult += Integer.parseInt(numbers);
}
}else {
if(!numbers.equals("")){
finalResult += Integer.parseInt(numbers);
numbers = "";
}
}
}
return finalResult;
}
public static boolean isNumeric(String str)
{
try{
int d = Integer.parseInt(str);
}
catch(NumberFormatException ex){
return false;
}
return true;
}

Java compressing Strings

I need to create a method that receives a String and also returns a String.
Ex input: AAABBBBCC
Ex output: 3A4B2C
Well, this is quite embarrassing and I couldn't manage to do it on the interview that I had today ( I was applying for a Junior position ), now, trying at home I made something that works statically, I mean, not using a loop which is kind of useless but I don't know if I'm not getting enough hours of sleep or something but I can't figure it out how my for loop should look like. This is the code:
public static String Comprimir(String texto){
StringBuilder objString = new StringBuilder();
int count;
char match;
count = texto.substring(texto.indexOf(texto.charAt(1)), texto.lastIndexOf(texto.charAt(1))).length()+1;
match = texto.charAt(1);
objString.append(count);
objString.append(match);
return objString.toString();
}
Thanks for your help, I'm trying to improve my logic skills.

Loop through the string remembering what you last saw. Every time you see the same letter count. When you see a new letter put what you have counted onto the output and set the new letter as what you have last seen.
String input = "AAABBBBCC";
int count = 1;
char last = input.charAt(0);
StringBuilder output = new StringBuilder();
for(int i = 1; i < input.length(); i++){
if(input.charAt(i) == last){
count++;
}else{
if(count > 1){
output.append(""+count+last);
}else{
output.append(last);
}
count = 1;
last = input.charAt(i);
}
}
if(count > 1){
output.append(""+count+last);
}else{
output.append(last);
}
System.out.println(output.toString());

You can do that using the following steps:
Create a HashMap
For every character, Get the value from the hashmap
-If the value is null, enter 1
-else, replace the value with (value+1)
Iterate over the HashMap and keep concatenating (Value+Key)

use StringBuilder (you did that)
define two variables - previousChar and counter
loop from 0 to str.length() - 1
each time get str.charat(i) and compare it to what's stored in the previousChar variable
if the previous char is the same, increment a counter
if the previous char is not the same, and counter is 1, increment counter
if the previous char is not the same, and counter is >1, append counter + currentChar, reset counter
after the comparison, assign the current char previousChar
cover corner cases like "first char"
Something like that.

The easiest approach:- Time Complexity - O(n)
public static void main(String[] args) {
String str = "AAABBBBCC"; //input String
int length = str.length(); //length of a String
//Created an object of a StringBuilder class
StringBuilder sb = new StringBuilder();
int count=1; //counter for counting number of occurances
for(int i=0; i<length; i++){
//if i reaches at the end then append all and break the loop
if(i==length-1){
sb.append(str.charAt(i)+""+count);
break;
}
//if two successive chars are equal then increase the counter
if(str.charAt(i)==str.charAt(i+1)){
count++;
}
else{
//else append character with its count
sb.append(str.charAt(i)+""+count);
count=1; //reseting the counter to 1
}
}
//String representation of a StringBuilder object
System.out.println(sb.toString());
}

In the count=... line, lastIndexOf will not care about consecutive values, and will just give the last occurence.
For instance, in the string "ABBA", the substring would be the whole string.
Also, taking the length of the substring is equivalent to subtracting the two indexes.
I really think that you need a loop.
Here is an example :
public static String compress(String text) {
String result = "";
int index = 0;
while (index < text.length()) {
char c = text.charAt(index);
int count = count(text, index);
if (count == 1)
result += "" + c;
else
result += "" + count + c;
index += count;
}
return result;
}
public static int count(String text, int index) {
char c = text.charAt(index);
int i = 1;
while (index + i < text.length() && text.charAt(index + i) == c)
i++;
return i;
}
public static void main(String[] args) {
String test = "AAABBCCC";
System.out.println(compress(test));
}

Please try this one. This may help to print the count of characters which we pass on string format through console.
import java.util.*;
public class CountCharacterArray {
private static Scanner inp;
public static void main(String args[]) {
inp = new Scanner(System.in);
String str=inp.nextLine();
List<Character> arrlist = new ArrayList<Character>();
for(int i=0; i<str.length();i++){
arrlist.add(str.charAt(i));
}
for(int i=0; i<str.length();i++){
int freq = Collections.frequency(arrlist, str.charAt(i));
System.out.println("Frequency of "+ str.charAt(i)+ " is: "+freq);
}
}
}

Java's not my main language, hardly ever use it, but I wanted to give it a shot :]
Not even sure if your assignment requires a loop, but here's a regexp approach:
public static String compress_string(String inp) {
String compressed = "";
Pattern pattern = Pattern.compile("([\\w])\\1*");
Matcher matcher = pattern.matcher(inp);
while(matcher.find()) {
String group = matcher.group();
if (group.length() > 1) compressed += group.length() + "";
compressed += group.charAt(0);
}
return compressed;
}

This is just one more way of doing it.
public static String compressor(String raw) {
StringBuilder builder = new StringBuilder();
int counter = 0;
int length = raw.length();
int j = 0;
while (counter < length) {
j = 0;
while (counter + j < length && raw.charAt(counter + j) == raw.charAt(counter)) {
j++;
}
if (j > 1) {
builder.append(j);
}
builder.append(raw.charAt(counter));
counter += j;
}
return builder.toString();
}

The following can be used if you are looking for a basic solution. Iterate through the string with one element and after finding all the element occurrences, remove that character. So that it will not interfere in the next search.
public static void main(String[] args) {
String string = "aaabbbbbaccc";
int counter;
String result="";
int i=0;
while (i<string.length()){
counter=1;
for (int j=i+1;j<string.length();j++){
System.out.println("string length ="+string.length());
if (string.charAt(i) == string.charAt(j)){
counter++;
}
}
result = result+string.charAt(i)+counter;
string = string.replaceAll(String.valueOf(string.charAt(i)), "");
}
System.out.println("result is = "+result);
}
And the output will be :=
result is = a4b5c3

private String Comprimir(String input){
String output="";
Map<Character,Integer> map=new HashMap<Character,Integer>();
for(int i=0;i<input.length();i++){
Character character=input.charAt(i);
if(map.containsKey(character)){
map.put(character, map.get(character)+1);
}else
map.put(character, 1);
}
for (Entry<Character, Integer> entry : map.entrySet()) {
output+=entry.getValue()+""+entry.getKey().charValue();
}
return output;
}
One other simple way using Multiset of guava-
import java.util.Arrays;
import com.google.common.collect.HashMultiset;
import com.google.common.collect.Multiset;
import com.google.common.collect.Multiset.Entry;
public class WordSpit {
public static void main(String[] args) {
String output="";
Multiset<String> wordsMultiset = HashMultiset.create();
String[] words="AAABBBBCC".split("");
wordsMultiset.addAll(Arrays.asList(words));
for (Entry<String> string : wordsMultiset.entrySet()) {
if(!string.getElement().isEmpty())
output+=string.getCount()+""+string.getElement();
}
System.out.println(output);
}
}

consider the below Solution in which the String s1 identifies the unique characters that are available in a given String s (for loop 1), in the second for loop build a string s2 that contains unique character and no of times it is repeated by comparing string s1 with s.
public static void main(String[] args)
{
// TODO Auto-generated method stub
String s = "aaaabbccccdddeee";//given string
String s1 = ""; // string to identify how many unique letters are available in a string
String s2=""; //decompressed string will be appended to this string
int count=0;
for(int i=0;i<s.length();i++) {
if(s1.indexOf(s.charAt(i))<0) {
s1 = s1+s.charAt(i);
}
}
for(int i=0;i<s1.length();i++) {
for(int j=0;j<s.length();j++) {
if(s1.charAt(i)==s.charAt(j)) {
count++;
}
}
s2=s2+s1.charAt(i)+count;
count=0;
}
System.out.println(s2);
}

It may help you.
public class StringCompresser
{
public static void main(String[] args)
{
System.out.println(compress("AAABBBBCC"));
System.out.println(compress("AAABC"));
System.out.println(compress("A"));
System.out.println(compress("ABBDCC"));
System.out.println(compress("AZXYC"));
}
static String compress(String str)
{
StringBuilder stringBuilder = new StringBuilder();
char[] charArray = str.toCharArray();
int count = 1;
char lastChar = 0;
char nextChar = 0;
lastChar = charArray[0];
for (int i = 1; i < charArray.length; i++)
{
nextChar = charArray[i];
if (lastChar == nextChar)
{
count++;
}
else
{
stringBuilder.append(count).append(lastChar);
count = 1;
lastChar = nextChar;
}
}
stringBuilder.append(count).append(lastChar);
String compressed = stringBuilder.toString();
return compressed;
}
}
Output:
3A4B2C
3A1B1C
1A
1A2B1D2C
1A1Z1X1Y1C

The answers which used Map will not work for cases like aabbbccddabc as in that case the output should be a2b3c2d2a1b1c1.
In that case this implementation can be used :
private String compressString(String input) {
String output = "";
char[] arr = input.toCharArray();
Map<Character, Integer> myMap = new LinkedHashMap<>();
for (int i = 0; i < arr.length; i++) {
if (i > 0 && arr[i] != arr[i - 1]) {
output = output + arr[i - 1] + myMap.get(arr[i - 1]);
myMap.put(arr[i - 1], 0);
}
if (myMap.containsKey(arr[i])) {
myMap.put(arr[i], myMap.get(arr[i]) + 1);
} else {
myMap.put(arr[i], 1);
}
}
for (Character c : myMap.keySet()) {
if (myMap.get(c) != 0) {
output = output + c + myMap.get(c);
}
}
return output;
}

O(n) approach
No need for hashing. The idea is to find the first Non-matching character.
The count of each character would be the difference in the indices of both characters.
for a detailed answer: https://stackoverflow.com/a/55898810/7972621
The only catch is that we need to add a dummy letter so that the comparison for
the last character is possible.
private static String compress(String s){
StringBuilder result = new StringBuilder();
int j = 0;
s = s + '#';
for(int i=1; i < s.length(); i++){
if(s.charAt(i) != s.charAt(j)){
result.append(i-j);
result.append(s.charAt(j));
j = i;
}
}
return result.toString();
}

The code below will ask the user for user to input a specific character to count the occurrence .
import java.util.Scanner;
class CountingOccurences {
public static void main(String[] args) {
Scanner inp = new Scanner(System.in);
String str;
char ch;
int count=0;
System.out.println("Enter the string:");
str=inp.nextLine();
System.out.println("Enter th Char to see the occurence\n");
ch=inp.next().charAt(0);
for(int i=0;i<str.length();i++)
{
if(str.charAt(i)==ch)
{
count++;
}
}
System.out.println("The Character is Occuring");
System.out.println(count+"Times");
}
}

public static char[] compressionTester( char[] s){
if(s == null){
throw new IllegalArgumentException();
}
HashMap<Character, Integer> map = new HashMap<>();
for (int i = 0 ; i < s.length ; i++) {
if(!map.containsKey(s[i])){
map.put(s[i], 1);
}
else{
int value = map.get(s[i]);
value++;
map.put(s[i],value);
}
}
String newer="";
for( Character n : map.keySet()){
newer = newer + n + map.get(n);
}
char[] n = newer.toCharArray();
if(s.length > n.length){
return n;
}
else{
return s;
}
}

package com.tell.datetime;
import java.util.Stack;
public class StringCompression {
public static void main(String[] args) {
String input = "abbcccdddd";
System.out.println(compressString(input));
}
public static String compressString(String input) {
if (input == null || input.length() == 0)
return input;
String finalCompressedString = "";
String lastElement="";
char[] charArray = input.toCharArray();
Stack stack = new Stack();
int elementCount = 0;
for (int i = 0; i < charArray.length; i++) {
char currentElement = charArray[i];
if (i == 0) {
stack.push((currentElement+""));
continue;
} else {
if ((currentElement+"").equalsIgnoreCase((String)stack.peek())) {
stack.push(currentElement + "");
if(i==charArray.length-1)
{
while (!stack.isEmpty()) {
lastElement = (String)stack.pop();
elementCount++;
}
finalCompressedString += lastElement + "" + elementCount;
}else
continue;
}
else {
while (!stack.isEmpty()) {
lastElement = (String)stack.pop();
elementCount++;
}
finalCompressedString += lastElement + "" + elementCount;
elementCount=0;
stack.push(currentElement+"");
}
}
}
if (finalCompressedString.length() >= input.length())
return input;
else
return finalCompressedString;
}
}

public class StringCompression {
public static void main(String[] args){
String s = "aabcccccaaazdaaa";
char check = s.charAt(0);
int count = 0;
for(int i=0; i<s.length(); i++){
if(s.charAt(i) == check) {
count++;
if(i==s.length()-1){
System.out.print(s.charAt(i));
System.out.print(count);
}
} else {
System.out.print(s.charAt(i-1));
System.out.print(count);
check = s.charAt(i);
count = 1;
if(i==s.length()-1){
System.out.print(s.charAt(i));
System.out.print(count);
}
}
}
}

// O(N) loop through entire character array
// match current char with next one, if they matches count++
// if don't then just append current char and counter value and then reset counter.
// special case is the last characters, for that just check if count value is > 0, if it's then append the counter value and the last char
private String compress(String str) {
char[] c = str.toCharArray();
String newStr = "";
int count = 1;
for (int i = 0; i < c.length - 1; i++) {
int j = i + 1;
if (c[i] == c[j]) {
count++;
} else {
newStr = newStr + c[i] + count;
count = 1;
}
}
// this is for the last strings...
if (count > 0) {
newStr = newStr + c[c.length - 1] + count;
}
return newStr;
}

public class StringCompression {
public static void main(String... args){
String s="aabbcccaa";
//a2b2c3a2
for(int i=0;i<s.length()-1;i++){
int count=1;
while(i<s.length()-1 && s.charAt(i)==s.charAt(i+1)){
count++;
i++;
}
System.out.print(s.charAt(i));
System.out.print(count);
}
System.out.println(" ");
}
}

This is a leet code problem 443. Most of the answers here uses StringBuilder or a HashMap, the actual problem statement is to solve using the input char array and in place array modification.
public int compress(char[] chars) {
int startIndex = 0;
int lastArrayIndex = 0;
if (chars.length == 1) {
return 1;
}
if (chars.length == 0) {
return 0;
}
for (int j = startIndex + 1; j < chars.length; j++) {
if (chars[startIndex] != chars[j]) {
chars[lastArrayIndex] = chars[startIndex];
lastArrayIndex++;
if ((j - startIndex) > 1) {
for (char c : String.valueOf(j - startIndex).toCharArray()) {
chars[lastArrayIndex] = c;
lastArrayIndex++;
}
}
startIndex = j;
}
if (j == chars.length - 1) {
if (j - startIndex >= 1) {
j = chars.length;
chars[lastArrayIndex] = chars[startIndex];
lastArrayIndex++;
for (char c : String.valueOf(j - startIndex).toCharArray()) {
chars[lastArrayIndex] = c;
lastArrayIndex++;
}
} else {
chars[lastArrayIndex] = chars[startIndex];
lastArrayIndex++;
}
}
}
return lastArrayIndex;
}
}