Arrange char array in sequence

Question

I came across a post showing how to arrange char array by alphabet order. seeing this can be done, I want to output the alphabetical order of each character of the input string, in order of the characters of the input string.

I'm a bit stuck. I can get the string reordered alphabetically, but I don't know what to do next.

example is 'monkey' to '354216'

because 'ekmnoy' e is alphabetically first from the set of given characters so e = 1 , k is the second alpha char when sorted so k = 2, and so on.

if you cannot understand I can provide more example to make things clear out.

Code

    String str = "airport";
        Character[] chars = new Character[str.length()];
        for (int z = 0; z < chars.length; z++) {
            chars[z] = str.charAt(z);
        }


        Arrays.sort(chars, new Comparator<Character>() {
            public int compare(Character c1, Character c2) {
                int cmp = Character.compare(
                        Character.toLowerCase(c1.charValue()),
                        Character.toLowerCase(c2.charValue()));
                if (cmp != 0) {
                    return cmp;
                }
                return Character.compare(c1.charValue(), c2.charValue());
            }
        });


        StringBuilder sb = new StringBuilder(chars.length);
        for (char c : chars) {
            sb.append(c);
        }
        str = sb.toString();

        System.out.println(sb);

Output

aioprrt

expected output

Orange -> aegnOr
561432 -  123456

Monkey -> ekMnoy
354216 -> 123456

Answer 1

I dont know what you want to do with double characters, but if you add this few lines to your code at the end you are getting the right result. Iterate over the sorted String and replace the charakters in the original String with their indices in the sorted String.

String originalStr = "airport";
for(int i = 0; i<str.length(); i++) {
    originalStr = originalStr.replace(str.charAt(i), String.valueOf(i+1).charAt(0));
}
System.out.println(originalStr);

Output: 1254357

If you want to get the output: 1254367 use replaceFirst:

 originalStr = originalStr.replaceFirst(String.valueOf(str.charAt(i)), String.valueOf(i+1));


Input:Orange
Output:561432

Input:Monkey
Output:354216

The whole code:

    String str = "airport";
    String originalStr = str; //creat a backup of str because you change it in your code
    Character[] chars = str.toCharArray();


    Arrays.sort(chars, new Comparator<Character>() {
        public int compare(Character c1, Character c2) {
            int cmp = Character.compare(
                    Character.toLowerCase(c1.charValue()),
                    Character.toLowerCase(c2.charValue()));
            if (cmp != 0) {
                return cmp;
            }
            return Character.compare(c1.charValue(), c2.charValue());
        }
    });

    str = String.valueOf(chars);
    System.out.println(str);


    //Iterate over the sorted String and replace the charakters in the original String with their indices in the sorted String
    for(int i = 0; i<str.length(); i++) {
        originalStr = originalStr.replaceFirst(String.valueOf(str.charAt(i)), String.valueOf(i+1));
    }
    System.out.println(originalStr);

Answer 2

You can use this below code:

package Test;

import java.util.Collections;
import java.util.Comparator;
import java.util.LinkedList;
import java.util.List;

public class Arrange {
    public static void main(String[] args) {
        String str = "money";
        List<Test> strs=new LinkedList<Test>();
        List<Test> final_result=new LinkedList<Test>();
        for(int i=0;i<str.length();i++)
        {
            Test t=new Test(i, ""+str.charAt(i), 0);
            strs.add(t);
        }
        Collections.sort(strs,new Comparator<Test>() {
               @Override
               public int compare(Test o1, Test o2) {
                   return (o1.getS().compareToIgnoreCase(o2.getS()));
               }
           });
        Integer i=1;
        for (Test st : strs) {
           st.setJ(i);
           final_result.add(st);
           i++;
       }
        Collections.sort(final_result,new Comparator<Test>() {
            @Override
            public int compare(Test o1, Test o2) {
                return (o1.getI().compareTo(o2.getI()));
            }
        });
        for (Test test : final_result) {
            System.out.println(test.getJ());
        }
   }
}

class Test{
    private Integer i;
    private String s;
    private Integer j;
    public Test() {
        // TODO Auto-generated constructor stub
    }
    public Test(Integer i, String s, Integer j) {
        super();
        this.i = i;
        this.s = s;
        this.j = j;
    }
    public Integer getI() {
        return i;
    }
    public void setI(Integer i) {
        this.i = i;
    }
    public String getS() {
        return s;
    }
    public void setS(String s) {
        this.s = s;
    }
    public Integer getJ() {
        return j;
    }
    public void setJ(Integer j) {
        this.j = j;
    }

    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + ((i == null) ? 0 : i.hashCode());
        result = prime * result + ((j == null) ? 0 : j.hashCode());
        result = prime * result + ((s == null) ? 0 : s.hashCode());
        return result;
    }
    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        Test other = (Test) obj;
        if (i == null) {
            if (other.i != null)
                return false;
        } else if (!i.equals(other.i))
            return false;
        if (j == null) {
            if (other.j != null)
                return false;
        } else if (!j.equals(other.j))
            return false;
        if (s == null) {
            if (other.s != null)
                return false;
        } else if (!s.equals(other.s))
            return false;
        return true;
    }
}

Answer 3

Once you have arranged the characters in order (in a different array from the original) then create a third array by walking the original string and choosing the index of each character from te sorted string.

input:  edcba
sorted: abcde
index:  01234

Pseudocode...

for( int i = 0; i < input.length(); i++ ) {
    index[i] = sorted.indexOf(input[i]);
}

Result should be 43210 with the given input.

Note that strings with more than 10 characters will result in ambiguous output, which can be handled by inserting spaces in the output. Example:

abcdefghijk -> 
012345678910