Develop Reference

How to sort a String and check for anagrams?

I'm supposed to write an algorithm that tests two Strings to check if they're anagrams of each other and I have to use either BubbleSort, SelectionSort or InsertionSort.
So I used SelectionSort to sort the Strings, which I converted to char arrays beforehand, but it doesn't work and I cannot find my mistake.
public static void selectionSort(char[] arr) {
for (int i = 0; i < arr.length - 1; i++) {
int least = i;
for (int j = i + 1; j < arr.length; j++) {
if (arr[j] < arr[least])
least = j;
if (least != i) {
int swap = arr[i];
arr[i] = arr[least];
arr[least] = (char) swap;
}
}
}
}
public static boolean anagramCheck(String x, String y) {
x.trim();
y.trim();
x.toLowerCase();
y.toLowerCase();
char xarr[] = x.toCharArray();
char yarr[] = y.toCharArray();
if (x.length() != y.length())
return false;
selectionSort(xarr);
System.out.println(xarr); // I used this to check if the Strings are sorted correctly
selectionSort(yarr);
System.out.println(yarr);
if (xarr == yarr) {
System.out.println("It's an anagram.");
return true;
} else {
return false;
}
}
I'm supposed to ignore capital letters and spaces, that's why I used trim() and toLowerCase(). But it neither trims the spaces nor changes capital letters to lower case letters. Additionally, when I use more than 5 letters, it doesn't sort the given Strings alphabetically. Only one of both is sorted correctly, the other one is messed up.
I am new to Java programming so I might need some help here.
Thanks in advance

Check where I did the modification:
public static void selectionSort(char[] arr) {
for (int i = 0; i < arr.length - 1; i++) {
int least = i;
for (int j = i + 1; j < arr.length; j++) {
if (arr[j] < arr[least])
least = j;
}
if (least != i) {
int swap = arr[i];
arr[i] = arr[least];
arr[least] = (char) swap;
}
}
}
In anagramCheck function:
x = x.trim(); // it returns trim string
y = y.trim();
x = x.toLowerCase(); // return lower-case string
y = y.toLowerCase();

This should work. But I used bubbleSort
class HelloWorld {
public static void main(String[] args) {
System.out.println(anagramCheck("listen", "silent"));
}
public static boolean anagramCheck(String x, String y) {
x = x.trim();
y = y.trim();
x = x.toLowerCase();
y = y.toLowerCase();
char xarr[] = x.toCharArray();
char yarr[] = y.toCharArray();
if (x.length() != y.length())
return false;
x = bubbleSort(xarr);
System.out.println(xarr); // I used this to check if the Strings are sorted correctly
y = bubbleSort(yarr);
System.out.println(yarr);
if (x.equals(y)) {
System.out.println("It's an anagram.");
return true;
} else {
return false;
}
}
public static String bubbleSort(char[] arr) {
int n = arr.length;
for (int i = 0; i < n-1; i++){
for (int j = 0; j < n-i-1; j++){
if (arr[j] > arr[j+1])
{
// swap arr[j+1] and arr[j]
char temp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = temp;
}
}
}
return String.valueOf(arr);
}
}

java, how to find the amount of letter in a string without repeats

I'm trying to build a function, that gets a string of letters, and prints the amount of each letter in the string.
for example:
input: String = "aaabbaccxyxyx"
output: 4a2b2c3x2y
This is what I've come up with:
public class Q1 {
public static String numLetters(String s){
String end = new String();
int counter = 0;
char c,d;
for(int i=0; i<s.length();i++){
c = s.charAt(i);
for(int j=0; j<s.length();j++){
d = s.charAt(j);
if(c == d){
counter++;
}
}
end = end + counter+c;
counter = 0;
}
return end;
}
but, this is the output: 4a4a4a2b2b4a2c2c3x2y3x2y3x
A lot of repeats..
Any help how to make it right?
Keep in mind, the function needs to return a string, not just prints it out.
Thanks! =)

I would make an int array to keep the count of each letter in in the string. Because there are 26 letters, the length of the array should be 26:
public static String numLetters(String s) {
int[] count = new int[26];
for (int i = 0; i < s.length(); i++) {
char c = s.charAt(i);
count[(int)(c - 'a')]++;
}
String ans = "";
for (int i = 0; i < 26; i++) {
if (count[i] != 0) {
ans += String.valueOf(count[i]) + (char)(i + 'a');
}
}
return ans;
}

A straightforward variant could look like this:
public static String countChars(String arg) {
String res = "";
boolean[] counted = new boolean[arg.length()];
for (int i = 0; i < counted.length; i++) {
if (!counted[i]) {
char c = arg.charAt(i);
int counter = 1;
for (int j = i + 1; j < counted.length; j++) {
if (arg.charAt(j) == c) {
counter++;
counted[j] = true;
}
}
res += counter + "" + c;
}
}
return res;
}

If you want to keep your original structure, I suggest using a StringBuilder so that you can delete characters that you have already seen. In case you delete a character, you have to adjust your indexes i and j.
public static String numLetters(String str){
StringBuilder s = new StringBuilder(s);
String end = new String();
int counter = 0;
char c,d;
for(int i=0; i<s.length();i++){
c = s.charAt(i);
for(int j=0; j<s.length();j++){
d = s.charAt(j);
if(c == d){
s.deleteCharAt(j);
if (i >= j) i--;
j--;
counter++;
}
}
end = end + counter+c;
counter = 0;
}
return end;
}

Try this:
int count = StringUtils.countMatches("a.b.c.d", ".");

Calculating the number of times every letter of the alphabet appears in a series of strings in an ArrayList [duplicate]

This question already has answers here:
Counting the number of a certain letter appears in series of strings in an ArrayList
(4 answers)
Closed 6 years ago.
I have an ArrayList that stores strings, or notes, in the form of "walk the dog". I have a notes class with a method that prints the number of times each letter appears in the entire ArrayList. I'm supposed to declare and use a primitive array of ints of size 26 and turn each letter in the notebook into a char using the charAt method in the String class. Then I have to use that char to index into the appropriate location in the low-level array. This is my method so far but it's not finished:
public void printLetterDistribution() {
ArrayList<Integer> aList = new ArrayList<Integer>();
for (int i = 0; i < notes.size(); i++) {
String note = notes.get(i);
for (int j = 0; j < note.length(); j++) {
char letter = note.charAt(j);
int code = (int)letter;
aList.add(code);
}
}
Collections.sort(aList);
}
I've hit a wall and I don't know how to continue. As you can see, I've tried to convert the letters to their character code but it's probably not the best way to do it and I'm still getting stuck. Can anybody help?
EDIT - Here is the entire notes class:
public class Notebook {
private ArrayList<String> notes;
public Notebook() { notes = new ArrayList<String>(); }
public void addNoteToEnd(String inputnote) {
notes.add(inputnote);
}
public void addNoteToFront(String inputnote) {
notes.add(0, inputnote);
}
public void printAllNotes() {
for (int i = 0; i < notes.size(); i++) {
System.out.print("#" + (i + 1) + " ");
System.out.println(notes.get(i));
}
System.out.println();
}
public void replaceNote(int inputindex, String inputstring) {
int index = inputindex - 1;
if (index > notes.size() || index < 0) {
System.out.println("ERROR: Note number not found!");
} else {
notes.set(index, inputstring);
}
}
public int countNotesLongerThan(int length) {
int count = 0;
for (int i = 0; i < notes.size(); i++) {
String temp = notes.get(i);
if (temp.length() > length) {
count++;
}
}
return count;
}
public double averageNoteLength() {
int sum = 0;
for (int i = 0; i < notes.size(); i++) {
String temp = notes.get(i);
int length = temp.length();
sum += length;
}
double average = (double)(sum / notes.size());
return average;
}
public String firstAlphabetically() {
String min = "";
for (int i = 0; i < notes.size(); i++) {
for (int j = i + 1; j < notes.size(); j++) {
if ((notes.get(i)).compareTo(notes.get(j)) < 0) {
min = notes.get(i);
} else {
min = notes.get(j);
}
}
}
return min;
}
public void removeNotesBetween(int startnote, int endnote) {
int start = startnote - 1;
int end = endnote - 1;
for (int i = end - 1; i > start; i--) {
notes.remove(i);
}
}
public void printNotesContaining(String findString) {
for (int i = 0; i < notes.size(); i++) {
if (notes.get(i).contains(findString)) {
System.out.println("#" + i + " " + notes.get(i));
}
}
}
public int countNumberOf(String letter) {
int count = 0;
for (int i = 0; i < notes.size(); i++) {
String note = (notes.get(i));
for (int j = 0; j < note.length(); j++) {
if (note.charAt(j) == letter.charAt(0)) {
count++;
}
}
}
return count;
}
public void findAndReplaceFirst(String old, String newWord) {
for (int i = 0; i < notes.size(); i++) {
String note = notes.get(i);
if (note.contains(old)) {
int loc = note.indexOf(old);
int len = old.length();
String temp = note.substring(0, loc ) + note.substring(loc + len, note.length());
String newString = temp.substring(0, loc) + newWord + temp.substring(loc, temp.length());
notes.set(i, newString);
} else {
String newString = note;
notes.set(i, newString);
}
}
}
public void printLetterDistribution() {
int[] p = new int[26];
for (int i = 0; i < 26; i++) {
p[i] = 0;
}
for (int i = 0; i < notes.size(); i++) {
String note = notes.get(i);
note = note.toLowerCase();
for (int j = 0; j < note.length(); j++) {
char letter = note.charAt(j);
p[letter - 'a']++;
}
}
System.out.println(p);
}
}

You can use an int array of 26 length and increment the count of the index letter-'a';
int[] p = new int[26];
for(int i = 0; i < 26; i++) p[i] = 0;
for (int i = 0; i < notes.size(); i++) {
String note = notes.get(i);
for (int j = 0; j < note.length(); j++) {
char letter = note.charAt(j);
if(letter>= 'a' && letter <= 'z')
p[letter-'a']++;
}
PS: I am assuming that the notes are in lowercase only. If it is not the case, use note.toLowerCase() to make them lower.
Since in your notes you can have spaces, I have updated the code.

Getting All Possibilities - Schoolwork

What I need to do is take a String array with each element having an exact length of 2, and find all possible combinations of the the elements, using each character within each String. By that I mean the String array {"Ss", "Ff"} returns "SF", "Sf", "sF", "sf". I have already tried a loop method that counts the iteration and then chooses a letter based on that, but it only works for arrays with a single element:
public String [] generatePossibilities(String [] s)
{
if(s[0].length() != 2)
throw new IllegalArgumentException();
String [] r = new String [s.length * 2];
for(int i = 0; i < r.length; i++)
{
r[i] = getPossibility(i, s);
}
return r;
}
private String getPossibility(int iteration, String [] source)
{
int [] choose = new int [source.length];
for(int i = 0; i < choose.length; i++)
{
choose[i] = 0;
}
for(int i = choose.length - 1; i >= 0; i--)
{
if(iteration < 1)
break;
choose[i] = 1;
iteration--;
}
String result = "";
for(int i = 0; i < source.length; i++)
result += source[i].substring(choose[i], choose[i] + 1);
return result;
}
Solved Thanks Sven!
public String [] generatePossibilities(String [] s)
{
if(s[0].length() != 2)
throw new IllegalArgumentException();
ArrayList<String> ra = new ArrayList<String>();
for(int i = s.length - 1; i >= 0; i--)
{
for(int j = 0; j < s[i].length(); j++)
{
String c = s[i].substring(j, j + 1);
if(ra.size() < 2)
{
ra.add(c);
}
else
{
for(int k = 0; k < ra.size(); k++)
{
String s1 = ra.get(k);
if(s1.substring(0, 1).equalsIgnoreCase(c))
continue;
else
{
s1 = c + s1;
ra.add(s1);
}
}
}
}
for(int j = 0; j < ra.size(); j++)
{
if(ra.get(j).length() != s.length - i)
{
ra.remove(j);
j--;
}
}
}
String [] r = new String [ra.size()];
for(int i = 0; i < r.length; i++)
{
r[i] = ra.get(i);
}
return r;
}

I would iterate the array of character tuples from last element to first. In each step you append to each current character the possibilities of the last iteration. You therefore double the elements in each step.
So for your example in the first iteration you have {Ff} and this would result to the two strings "F" and "f". In the next step you take each character of {Ss} and append each string of the last step to it getting "SF", "Sf", "sF" and "sf". You could then continue with further character tuples.

Looking for a O(N) sort for an array with only 3 possible values

I am trying to extend the following code to sort the array if I added a third value 'C'. Would this be possible to do while retaining only one loop. The following code will sort an array with two possible values 'A' and 'B'.
public class TestSort
{
public static void main(String args[])
{
char f[] = {'A','B','B','A','B','B','A','B','A','A','B'};
int k = 0, t = f.length-1;
while(k < t)
{
if(f[k] == 'A')
k = k + 1;
else if(f[k] == 'B')
{
char m = f[t];
f[t] = f[k];
f[k] = m;
t = t - 1;
}
}
System.out.print("\nSorted List\n");
for(char i : f)
System.out.print(i + ", ");
System.out.println();
}
}
Here is an attempt. I don't know if I'm on the right track.
public class TestSort
{
static char f[] = {'C','A','B','A','C','B','A','B','C','C','B','A','B'};
//static char f[] = {'A','A','A','A','A','C','A','C','A','A','C','A','C'};
//static char f[] = {'C','B','B','B','C','B','B','B','C','C','B','C','B'};
//static char f[] = {'A','B','B','B','A','B','C','B','A','A','B','A','B'};
public static void main(String args[])
{
int j = 0, k = 0, t = f.length-1, l = f.length-1;
while(t >= 0)
{
if(f[k] == 'A')
k = k + 1;
else if(f[k] == 'B')
{
char m = f[j];
f[j] = f[k];
f[k] = m;
j = j + 1;
}
else if(f[k] == 'C')
{
char m = f[l];
f[l] = f[k];
f[k] = m;
l = l - 1;
}
for(char i : f)
System.out.print(i + ", ");
System.out.println();
}
}
}

Maybe something like:
public sort(char[] array) {
int[] frequencies = new int[3];
for(char c : array) {
if (c == 'A')
frequencies[0]++;
if (c == 'B')
frequencies[1]++;
if (c == 'C')
frequencies[2]++;
}
int index = 0;
for (int i = 0; i < frequencies[0]; i++) {
array[index++] = 'A';
}
for (int i = 0; i < frequencies[1]; i++) {
array[index++] = 'B';
}
for (int i = 0; i < frequencies[2]; i++) {
array[index++] = 'C';
}
}

Is the requirement "keep it O(n)", or "keep one loop" ?
Adding a second (non-nested) loop wouldn't change the O(n) quality. then you could do it in two steps: first push all the 'A's to the start and a second one to push all the 'C's to the end.