Ajuda com Ordenação

[Thiago Serrilho]

Pessual, fiz esse código pra passar o tempo aqui, e agora quero melhorar ele. Ele gera numeros de jogos aleatórios para mega sena fazendo a contagem de cada número que se repetiu. O que eu quero fazer é ordenar os números que se repetiram do maior para o menor e imprimir eles na sequencia. Tipo 1 saiu 50 vez, 10 saiu 30 vezes 2 saiu 15 vezes etc.

Segue o código abaixo:

#include<stdio.h>
    #include<stdlib.h>
    #include<time.h>
    
    main()
    {
        int numero[60];     //armazena numeros aleatorio
        int cont_vezes[60]; //armazena os numeros repetidos
        int aux;            //variavel auxiliar para ordenação
        int i,j,k,v;        //contadores
        int jogos,casa=0;   //numero de jogadas 
         
        printf("Gerador de numeros para Sena\n");
        printf("==============================================================\n");
        printf("Informe a quantidade de jogos que devera ser feito: ");
        scanf("%d",&jogos); //numero de jogadas
        system("cls");
        printf("       *====================================================*\n");
        printf("       |             JOGOS GERADOS ALEATORIAMENTE           | \n");
        printf("       *====================================================*\n");      
        for(i=1;i<=60;i++) 
        {
            cont_vezes[i]=0; //zera o vetor de numeros repetidos
            numero[i]=0; //zera o vetor de numeros aleatorios
        }
         
        srand(time(NULL));//para não gerar sempre os mesmos números
        for(v=1;v<=jogos;v++)
        {
            printf("       | JOGO %-0.3d ",v);
            for(i=1;i<=6;i++)
            {
                casa++;
                numero[i]=rand()%60+1; //gera numeros aleatorios entre 1 e 60
                printf("|  %-0.2d  ",numero[i]); //exibe os números gerados
                if(casa==6)
                {
                    printf("|\n");//pula linha a cada 6 numeros
                    casa=0;
                    printf("       *----------*------*------*------*------*------*------*\n");
                }
                for(j=1;j<=60;j++)
                {
                    if(numero[i]==j) //verifica se o numero gerado é repetido
                    cont_vezes[j]=cont_vezes[j]+1;
                }
            }
        }
        printf("\n\n");
        printf("*---------*---------*     *---------*-------*     *---------*-------*\n");
        printf("|  Numero |  Vezes  |     |  Numero | Vezes |     |  Numero | Vezes |\n");
        printf("*---------*---------*     *---------*-------*     *---------*-------*\n");
        for(i=1;i<=20;i++)
        {
            j=i+20;
            k=i+40;
             printf("|    %-0.2d   |   %-0.3d   |     |    %0.2d   |  %0.3d   |     |    %0.2d   |  %0.3d   |\n",i,cont_vezes[i],j,cont_vezes[j],k,cont_vezes[k]);
        }
        printf("*---------*---------*     *---------*-------*     *---------*-------*\n");
        getchar();
        getchar();
    }</font>

Editado Julho 28, 2008 por Thiago Serrilho

[== Douplus ==]

Boa noite, Thiago, e bem vindo ao fórum.

Dei uma olhadela no seu código... De repente, me lembrei de pilhas! Heh.

Eu pensei mas não testei, na minha cabeça funciona. Veja o que acha.

Vamos direto no exemplo:

/* DEFINIÇÃO DA PILHA */
struct stack_node {
  int num;
  int times;
  stack_node *next;
};
typedef stack_node *Stack;
/* FIM DA DEFINIÇÃO DA PILHA */

/* FUNÇÕES DA PILHA */
  // Inicializa a pilha com NULL
  void init(Stack stk) { stk = NULL; }

  // Insere um elemento no topo da pilha
  void push(Stack, int val, int repetitions);

  // Retira um elemento do topo da pilha
  void pop(Stack, int val*, int repetition*);

  // Retorna 1 se a pilha está vazia
  short isEmpty(Stack stk) { return (stk) ? 1 : 0; }
/*FIM DAS FUNÇÕES DA PILHA */

int main(void)
{
...
  Stack stk;  // Instancia uma pilha cujo topo armazenará o número com mais repetições 
  init(stk); // Inicializa a pilha 
...
...
// Começo do loop:
  for (i = 1; i <= 60; i++) {
    int val, rep;  // Variáveis auxiliares -> valor, repetições
    Stack tmpstk;  // Declara uma pilha no escopo do loop
    init(tmpstk);  // tmpstk = NULL

    if (!isEmpty(stk)) {
      while (cont_vezes[i] <= stk->times) { // Se nº de repetições for maior que o último maior:
        pop(stk, &val, &rep);
        push(&tmpstk, val);                 // Desempilha e guarda na outra pilha (ordem inversa).
      }

      while (!isEmpty(tmpstk)) {
        pop(tmpstk(&val, &rep));
        push(stk, val, rep);                // Reempilha
      }
      if (cont_vezes[i] > stk->times)       // Se nº de repetições for menor que o último maior:
        push(stk, i, cont_vezes[i]);         // Guarda em cima.
    }
    else  // Se a pilha estiver vazia, isto é: numero 1
      push(stk, i, cont_vezes[i]); // Coloca o 1
  }
//FIm do loop.

//Mostra os valores
  printf("\nValores: ");
  while (!isEmpty(stk))
    ptintf("%d ", pop(stk));

  return 0;
}

Funciona assim, pegando seu exemplo:

Tipo 1 saiu 50 vez, 10 saiu 30 vezes 2 saiu 15 vezes etc.

temos o loop, nele são inserindo os valores na pilha, suponha só os numeros que você usou como exemplo e vamos analisar que acontece:

PUSH-> insere [1(numero), 50(repetição)] no topo
  (15 < 50)  // Número 2
    POP-> retira [1,50] do topo e põe na pilha temporária
    PUSH-> insere [2, 15] no topo
    PUSH-> insere [1, 50] no topo
  (30 < 50)  // Número 10
    POP-> retira[1, 50] do topo
    (30 > 15)
      PUSH-> insere[10, 30] no topo
    PUSH-> insere[1, 50] no topo

.HISTÓRICO DA PILHA:
                                                                                   [1, 50]
                                              [1, 50]                  [10,30]     [10,30]
VAZIO     [1, 50]      VAZIO     [2, 15]      [2, 15]      [2, 15]     [2, 15]     [2, 15]

Desempilha quando o úmero de repetições for maior ou igual ao que está sendo testado até que este se torne maior que o do topo. Reempilha os valores retirados. P. S.: Na linha

while (cont_vezes[i] <= stk->times) { // Se nº de repetições for maior que o último maior:

a condição é "<=" para que se haja dois valores com o mesmo numero de repetições sejam empilhados em ordem, de maneira que o valor mais acima seja o menor.

Editado Julho 28, 2008 por == Douplus ==

[Thiago Serrilho]

valeu == Douplus ==,

Num tem uma maneira mais simples não? Eu até tentei fazer utilizando pilhas, mas foi tudo por agua abaixo hehehe. Na verdade sou meio ruim em pilhas.