Script que define um TDA (tipo de dados abstracto) chamado RATIONAL para manipular frações (números racionais). Um número racional é qualquer número representado pela razão entre dois intereiros A e B, na forma A/B. O programa implementa funções para criar um número racional a partir de dois inteiros, somar, subtrair, dividir, multiplicar e simplificar.

Compilar com:

gcc -o rational rational.c -Wall -lm

• Download rational.c
• Enviar nova versão

Esconder código-fonte

/* rational.c
 * gcc -o rational rational.c -Wall -lm
 *
 *    (C) 2017 - Enzo Ferber, <enzoferber@gmail.com>
 */
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <math.h>

#define MIN(a,b)      (a < b ? a : b)
#define BUF_SIZE      32

struct rational {
   int n; /* numerator */
   int d; /* denominator */
};

typedef struct rational RATIONAL;

void *xmalloc(size_t n)
{
   void *p = malloc(n);
   if(!p) {
      perror("malloc");
      exit(EXIT_FAILURE);
   }
   return p;
}

int GCD(int a, int b)
{
   register int i;

   /* if any is zero, return 1 */
   if(!a || !b) return 1;

   for(i = MIN(a,b); i >= 1; i--) 
      if(!(a % i) && !(b % i)) break;

   return i;
}

RATIONAL *make_rational(int n, int d)
{
   RATIONAL *r = xmalloc(sizeof *r);
   r->n = n;
   r->d = d;
   return r;
}

RATIONAL *simplify_rational(RATIONAL *r)
{
   int m = GCD(r->n, r->d);

   r->n /= m;
   r->d /= m;

   /* just for consistency */
   return r;
}

RATIONAL *add_rational(RATIONAL *a, RATIONAL *b)
{
   RATIONAL *r = xmalloc(sizeof *r);

   r->n = (a->n * b->d) + (b->n * a->d);
   r->d = a->d * b->d;

   return simplify_rational(r);
}

RATIONAL *subtract_rational(RATIONAL *a, RATIONAL *b)
{
   RATIONAL *r = xmalloc(sizeof *r);

   r->n = (a->n * b->d) - (b->n * a->d);
   r->d = a->d * b->d;

   return simplify_rational(r);
}

RATIONAL *divide_rational(RATIONAL *a, RATIONAL *b)
{
   RATIONAL *r = xmalloc(sizeof *r);

   r->n = a->n * b->d;
   r->d = a->d * b->n;

   return simplify_rational(r);
}

RATIONAL *multiply_rational(RATIONAL *a, RATIONAL *b)
{
   RATIONAL *r = xmalloc(sizeof *r);

   r->n = a->n * b->n;
   r->d = a->d * b->d;

   return simplify_rational(r);
}

int read_int(char *label) {
   char buffer[BUF_SIZE];
   fprintf(stderr, label);
   fgets(buffer, BUF_SIZE, stdin);
   return atoi(buffer);
}

RATIONAL *get_rational(void)
{
   int a, b;

   a = read_int("Numerador  : ");
   b = read_int("Denominador: ");

   return make_rational(a, b);
}

void print_rational(char *label, RATIONAL *r)
{
   printf("%s: %d/%d\n", label, r->n, r->d);
}

int main(int argc, char *argv[])
{
   RATIONAL *a, *b, *add, *sub, *mul, *div;

   a = get_rational();
   b = get_rational();

   add = add_rational(a, b);
   sub = subtract_rational(a, b);
   mul = multiply_rational(a, b);
   div = divide_rational(a, b);

   print_rational("A  ", a);
   print_rational("B  ", b);
   print_rational("add", add);
   print_rational("sub", sub);
   print_rational("mul", mul);
   print_rational("div", div);

   free(a);
   free(b);
   free(add);
   free(sub);
   free(mul);
   free(div);

   return 0;
}
/* EoF */

Filas

Busca do código do produto-Vetores----

Também enche a memória, porém desta vez com processos

Usando medidas de comprimento

Um pouco de fisica