[RETO] Ordenar caracteres (Dificultad=media)

qanwPVEAwnmSViNjTOLZPRRSaTAECnbArUjPmELcsWhdVMXYfdYLUGLpjLdOMdzvAEgfhXWNvRJZqMhlwocRPHKcwbUFJVjBjmLOwPVqjoYHLTtixQAnBHwuvfxDMPnAbpHBRNYTpKSzxLTWOusljvXidQjqbqjgcvpFMLbPPOkHdTTJbkswfdEeeFTbllerqvbFMpO

Dim ABC (25)
Cadena = LCase(InputBox("Inserte cadena a analizar","RETO"))
For X = 1 To Len (Cadena)
    Letra = mid(Cadena,x,1)
    NumLetra = asc(Letra)-97
    ABC(NumLetra) = ABC(NumLetra) & Letra
Next

For x = 24 To 0 Step -1
    For y = 0 to x
        If Len(ABC(y)) > Len(ABC(y + 1)) Then
            temp = ABC(y+1)
            ABC(y + 1) = ABC(y)
            ABC(y) = temp
        End If
    Next
Next 

Do 
    Flag = True
    For x = 0 to 24
        If Len(ABC(x))=Len(abc(x+1)) Then
            If Asc(Right(ABC(x),1)) < Asc(Right(ABC(x + 1),1)) Then
                temp = ABC(x)
                ABC(x) = ABC(x + 1)
                ABC(x + 1) = temp
                Flag = Flase
            End If
        End If
    Next
Loop Until Flag

For X = 0 to 25
    Out = Out & RIGHT(ABC(x),1)
Next

Inputbox "Resultado", "RETO", strreverse(Out)

#include <iostream>
#include <string>

using namespace std;

void seleccion(string&);
void insercion(string&);
void ordenacion_shell (string &);
void quicksort( string&, int, int );

int main()
{

    string str = "qanwPVEAwnmSViNjTOLZPRRSaTAErCnbArUjPmELcsWhdVMXYfdYLUGLpjLdOMdzvAEgfhXWNvRJZqMhlwocRPHKcwbUFJVjBjmcsWhdVMXYfdYLUGLpjLdOMdzvAEgfhXWNvRJZqMhlwocRPHK";

//Cambiar a minusculas  todas las letras
    string::size_type l;
    for (l = 0; l < str.length(); l++)
    {
        str[l] = tolower(str[l]);
    }
//~ Fin minusculas

//METODOS DE ORDENACION

        //Ordenación por selección
    //seleccion(str);

        //Ordenación por inserción
    //insercion(str);

        //Ordenación por shell
    //ordenacion_shell(str);

        //Ordenación rápida QUICKSOFT
    quicksort(str, 0, str.length()-1);

//~ FIN METODOS ORDENACION


//Contador
    int contador = 0;
    char letra = 'a';

    for (int i = 0; i < str.length(); i++)
    {
        if(str[i] == str[i+1]){
            contador++;
        }else{
            cout << letra << ": " << contador+1 << endl;
            contador = 0;
            letra++;
        }
    }
//~ Fin contador

    return 0;
}

//Ordenación por selección
void seleccion(string &str){

    string::size_type i, j, k;
    for(i = 0; i < str.length(); i++){
        for(k= i, j = i +1; j < str.length(); j++){

            if (str[j] < str[k]){

                char aux = str[i];
                str[i] = str[j];
                str[j] = aux;

            }
        }
    }
}

//Ordenacion por insercion
void insercion(string &str)
{
    char tmp;
    int j = 0;
    for (int i = 1; i < str.length(); i++){
        tmp = str[i];
        j = i -1;
        while( j>=0 && tmp < str[j])
        {
            str[j+1] = str[j];
            j--;
        }
        str[j+1] = tmp;
    }
}


//Ordenacion por shell
void ordenacion_shell (string &str)
{
    int incr = str.length()/2, p, j;
    char tmp;
    do
    {
        for (p = incr; p < str.length(); p++)
        {
            tmp = str[p];
            j = p - incr;
            while ((j >= 0) && (tmp < str[j]))
            {
                str[j + incr] = str[j];
                j -= incr;
            }
            str[j + incr] = tmp;
        }
        incr /= 2;
    }
    while (incr > 0);
}


//Ordenacion rapida QUICKSORT
void quicksort(string &array, int start, int end)
{
    int pivote, left, right;
    char temp;

    if (start < end){
       

        pivote = start;
        left = start;
        right = end;
        while(left < right)
        {
            while(array[right] > array[pivote]){
                right--;
            }
            while(left<right && array[left] <= array[pivote]){
                left++;
            }

            if (left < right){
                temp = array[left];
                array[left] = array[right];
                array[right] = temp;
            }
        }

        temp = array[right];
        array[right] = array[pivote];
        array[pivote] = temp;

        pivote = right;


        quicksort(array, start, pivote-1);
        quicksort(array, pivote+1, end);
    }
}

#stringtoConvert= raw_input("\n[+] Reto underc0de\nEnter string, please: ")
stringtoConvert= "qanwPVEAwnmSViNjTOLZPRRSaTAECnbArUjPmELcsWhdVMXYfdYLUGLpjLdOMdzvAEgfhXWNvRJZqMhlwocRPHKcwbUFJVjBjmLOwPVqjoYHLTtixQAnBHwuvfxDMPnAbpHBRNYTpKSzxLTWOusljvXidQjqbqjgcvpFMLbPPOkHdTTJbkswfdEeeFTbllerqvbFMpO"
stringtC= stringtoConvert.lower()
diccio= {}
resultado= ""
dicOrdenado= []
cMax= 0

for a in stringtC:
	if not diccio.has_key(a):
		diccio[a] = 1
	elif diccio.has_key(a):
		cont = (diccio[a]) + 1
		diccio[a] = cont
	if diccio[a] > cMax:
		cMax = diccio[a]
ldic= diccio.items()
cDin= cMax

while len(dicOrdenado) != len(diccio):
	cont= 0
	for letra in ldic:
		if letra[1] == cDin:
			dicOrdenado.append(letra)
		cont= cont + 1
	cDin = cDin - 1
cDin= cMax

while len(resultado) != len(dicOrdenado):
	mismoEquipo= []
	for letra in dicOrdenado:
		if letra[1] == cDin:
			mismoEquipo.append(letra[0])
			mismoEquipo= sorted(mismoEquipo)
	for leter in mismoEquipo:
		resultado= resultado +leter
	cDin = cDin - 1
print resultado