Miscellany

#include <stdio.h>
#include <stdlib.h>
#include <math.h>

int placas[10000][2];
int a[40];
int n_a;
int n_quadrados;

int ints_get (int *a)
{
  int result = 0;
  while (scanf ("%d", &a[result]) != EOF)
    result++;
  return result;
}

int ints_get_some (int *a, int n)
{
  int i;
  for (i = 0; i < n; i++)
    scanf ("%d", &a[i]);
  return n;
}

void ints_put (int *a, int n, char *separator)
{
  if (n>0)
  {
    int i;
    printf ("%d", a[0]);
    for (i = 1; i < n; i++)
      printf ("%s%d", separator, a[i]);
  }
}



void ints_show (int *a, int n)
{
  printf ("%d", n);
  if (n > 0)
  {
    printf (" ");
    ints_put (a, n, " ");
  }
  printf ("\n");}



int max(int * a, int x) //util para me dar o maior elemento do par de cada placa
{
    int a1=a[x*2];
    int b1=a[x*2+1];
    if(a1>b1)
    return a1;
    else
    return b1;
}

int min(int * a, int x)
{
    int a1=a[x*2];
    int b1=a[x*2+1];
    if(a1>b1)
    return b1;
    else
    return a1;
}


//int p=0; prof aconselhou a criar outra variavel para contar o numero deos quadrados, para nao estar o x como indice
void calc_quadrados(int x, int y)
{

int n_quadrados=y/x;

//printf("x->%d\ny->%d\nn_quadrados->%d\nx%y->%d\n",x,y,n_quadrados,y%x);
placas[x][0]=x;
placas[x][1]+=n_quadrados; //adiciona ao tamanho x, o numero de quadrados desta placa.

//for ()
//n_quadrados=p
//p++
if(y%x!=0)
calc_quadrados(y%x,x); //é recursivo, pois ele vai sempre avaliando se a divisão da para fazer o quadrado, se der soma mais um quadrado
                    //notar que os argumentos trocam, no calc_quadrados(), pois no rectangulo que sobra, o X passa a Y,
                        //e o Y passa a X, devido ao virar o rectangulo que sobra, depois é aplicar o mesmo algaritmo, até
}                       // a divisão dar resto 0.

void bubblesort(int n)
{
int i;
int j;
for (i= 1; i< n; i++)
  for (j = n-1; j >= i; j--)
   if (placas[j-1][0] < placas[j][0] )//desceding order
   {
    int m = placas[j-1][0]; //ordenar coluna 0
    placas[j-1][0] = placas[j][0];
    placas[j][0] = m;
    int m2=placas[j-1][1];           //ordenar coluna 1 , tem que ser feito, pois isto vai junto com toda a linha
    placas[j-1][1] = placas[j][1]; //se a coluna 0 vai ordenada, a coluna 1 também tem que ir atrás.
    placas[j][1] = m2;

   }
}


void metais (void)
{
int n=0;
int n_tamanhos=0; //contagem das dimensões dos quadrados
//int k=0;
int i;
int j=0;
n_a = ints_get(a);//array input
for(i=0;i<n_a/2;i++) //cada placa do input(por isso está dividido por metade)
{
    if(max(a,i)>n)
    n=max(a,i); //util para evitar que o bublesort vá ate ao fim do array, vai só ao essencial
    calc_quadrados (min(a,i),max(a,i)); // e calcula o numero de quadrados num rectangulo
}                 //aqui garanto o max a Y


bubblesort(n);//ordena a matriz em função do tamanho da placa
int l=0;
while(placas[l++][0]!=0)  //conta os tamanhos que não sejam zero
n_tamanhos++;
for(j=0;j<n_tamanhos;j++) // e mostra a matriz até ai(ser zero)
printf("%d %d\n", placas[j][0], placas[j][1]);

}

int main()
{
    metais();
    return 0;
}