Simples exemplo de manipulação de vetores

Este é um simples exemplo de manipulação de vetores.

Primeiro é criado um vetor A onde são informados 15 elementos. Logo após é criado um vetor B contendo o fatorial de cada elemento de A.

Este programa inclui algumas sequências de escape para colorir as palavras.
thiagoamm
Por Thiago em 22/11/2010
Hits: 5.787 Categoria: C/C++ Subcategoria: Introdução
Descrição

Download c.c Enviar nova versão
Esconder código-fonte
/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32melementos/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0m do /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mvetor A/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mA/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m[/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;31m%d/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m]/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;36mAVISO: /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0mProcessando o /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mvetor A /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0me criando o /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mvetor B/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0m, /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;35mcontendo o fatorial de cada elemento de /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mA/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mvetores A/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0m e /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mB/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mA/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m[/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;31m%d/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m]/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0m\t=\t/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32m%d\t/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;34mB/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m[/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;31m%d/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m]/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0m\t=\t/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;34m%d/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32melementos/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32melementos/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0m do /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mvetor A/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mA/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m[/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;31m%d/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m]/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;36mAVISO: /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0mProcessando o /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mvetor A /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0me criando o /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mvetor B/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0m, /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;35mcontendo o fatorial de cada elemento de /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mA/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mvetores A/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0m e /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mB/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mA/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m[/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;31m%d/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m]/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0m\t=\t/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32m%d\t/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;34mB/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m[/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;31m%d/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m]/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0m\t=\t/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;34m%d/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0m do /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32melementos/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0m do /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mvetor A/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mA/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m[/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;31m%d/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m]/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;36mAVISO: /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0mProcessando o /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mvetor A /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0me criando o /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mvetor B/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0m, /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;35mcontendo o fatorial de cada elemento de /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mA/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mvetores A/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0m e /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mB/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mA/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m[/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;31m%d/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m]/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0m\t=\t/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32m%d\t/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;34mB/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m[/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;31m%d/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m]/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0m\t=\t/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;34m%d/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mvetor A/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32melementos/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0m do /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mvetor A/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mA/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m[/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;31m%d/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m]/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;36mAVISO: /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0mProcessando o /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mvetor A /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0me criando o /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mvetor B/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0m, /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;35mcontendo o fatorial de cada elemento de /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mA/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mvetores A/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0m e /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mB/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mA/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m[/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;31m%d/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m]/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0m\t=\t/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32m%d\t/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;34mB/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m[/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;31m%d/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m]/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0m\t=\t/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;34m%d/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32melementos/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0m do /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mvetor A/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mA/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m[/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;31m%d/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m]/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;36mAVISO: /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0mProcessando o /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mvetor A /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0me criando o /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mvetor B/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0m, /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;35mcontendo o fatorial de cada elemento de /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mA/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mvetores A/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0m e /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mB/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mA/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m[/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;31m%d/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m]/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0m\t=\t/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32m%d\t/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;34mB/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m[/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;31m%d/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m]/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0m\t=\t/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;34m%d/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mA/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32melementos/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0m do /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mvetor A/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mA/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m[/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;31m%d/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m]/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;36mAVISO: /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0mProcessando o /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mvetor A /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0me criando o /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mvetor B/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0m, /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;35mcontendo o fatorial de cada elemento de /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mA/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mvetores A/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0m e /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mB/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mA/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m[/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;31m%d/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m]/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0m\t=\t/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32m%d\t/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;34mB/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m[/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;31m%d/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m]/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0m\t=\t/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;34m%d/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m[/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32melementos/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0m do /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mvetor A/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mA/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m[/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;31m%d/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m]/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;36mAVISO: /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0mProcessando o /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mvetor A /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0me criando o /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mvetor B/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0m, /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;35mcontendo o fatorial de cada elemento de /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mA/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mvetores A/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0m e /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mB/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mA/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m[/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;31m%d/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m]/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0m\t=\t/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32m%d\t/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;34mB/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m[/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;31m%d/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m]/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0m\t=\t/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;34m%d/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;31m%d/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32melementos/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0m do /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mvetor A/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mA/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m[/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;31m%d/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m]/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;36mAVISO: /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0mProcessando o /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mvetor A /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0me criando o /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mvetor B/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0m, /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;35mcontendo o fatorial de cada elemento de /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mA/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mvetores A/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0m e /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mB/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mA/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m[/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;31m%d/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m]/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0m\t=\t/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32m%d\t/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;34mB/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m[/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;31m%d/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m]/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0m\t=\t/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;34m%d/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m]/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32melementos/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0m do /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mvetor A/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mA/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m[/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;31m%d/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m]/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;36mAVISO: /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0mProcessando o /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mvetor A /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0me criando o /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mvetor B/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0m, /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;35mcontendo o fatorial de cada elemento de /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mA/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mvetores A/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0m e /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mB/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mA/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m[/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;31m%d/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m]/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0m\t=\t/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32m%d\t/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;34mB/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m[/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;31m%d/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m]/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0m\t=\t/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;34m%d/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32melementos/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0m do /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mvetor A/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mA/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m[/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;31m%d/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m]/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;36mAVISO: /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0mProcessando o /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mvetor A /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0me criando o /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mvetor B/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0m, /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;35mcontendo o fatorial de cada elemento de /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mA/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mvetores A/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0m e /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mB/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mA/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m[/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;31m%d/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m]/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0m\t=\t/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32m%d\t/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;34mB/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m[/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;31m%d/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m]/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0m\t=\t/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;34m%d/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;36mAVISO: /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32melementos/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0m do /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mvetor A/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mA/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m[/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;31m%d/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m]/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;36mAVISO: /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0mProcessando o /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mvetor A /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0me criando o /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mvetor B/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0m, /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;35mcontendo o fatorial de cada elemento de /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mA/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mvetores A/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0m e /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mB/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mA/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m[/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;31m%d/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m]/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0m\t=\t/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32m%d\t/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;34mB/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m[/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;31m%d/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m]/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0m\t=\t/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;34m%d/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0mProcessando o /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32melementos/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0m do /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mvetor A/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mA/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m[/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;31m%d/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m]/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;36mAVISO: /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0mProcessando o /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mvetor A /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0me criando o /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mvetor B/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0m, /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;35mcontendo o fatorial de cada elemento de /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mA/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mvetores A/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0m e /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mB/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mA/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m[/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;31m%d/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m]/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0m\t=\t/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32m%d\t/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;34mB/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m[/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;31m%d/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m]/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0m\t=\t/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;34m%d/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mvetor A /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32melementos/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0m do /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mvetor A/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mA/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m[/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;31m%d/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m]/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;36mAVISO: /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0mProcessando o /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mvetor A /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0me criando o /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mvetor B/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0m, /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;35mcontendo o fatorial de cada elemento de /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mA/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mvetores A/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0m e /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mB/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mA/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m[/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;31m%d/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m]/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0m\t=\t/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32m%d\t/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;34mB/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m[/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;31m%d/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m]/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0m\t=\t/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;34m%d/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0me criando o /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32melementos/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0m do /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mvetor A/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mA/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m[/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;31m%d/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m]/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;36mAVISO: /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0mProcessando o /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mvetor A /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0me criando o /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mvetor B/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0m, /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;35mcontendo o fatorial de cada elemento de /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mA/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mvetores A/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0m e /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mB/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mA/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m[/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;31m%d/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m]/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0m\t=\t/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32m%d\t/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;34mB/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m[/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;31m%d/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m]/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0m\t=\t/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;34m%d/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mvetor B/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32melementos/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0m do /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mvetor A/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mA/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m[/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;31m%d/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m]/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;36mAVISO: /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0mProcessando o /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mvetor A /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0me criando o /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mvetor B/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0m, /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;35mcontendo o fatorial de cada elemento de /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mA/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mvetores A/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0m e /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mB/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mA/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m[/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;31m%d/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m]/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0m\t=\t/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32m%d\t/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;34mB/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m[/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;31m%d/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m]/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0m\t=\t/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;34m%d/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0m, /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32melementos/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0m do /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mvetor A/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mA/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m[/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;31m%d/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m]/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;36mAVISO: /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0mProcessando o /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mvetor A /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0me criando o /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mvetor B/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0m, /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;35mcontendo o fatorial de cada elemento de /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mA/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mvetores A/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0m e /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mB/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mA/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m[/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;31m%d/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m]/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0m\t=\t/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32m%d\t/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;34mB/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m[/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;31m%d/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m]/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0m\t=\t/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;34m%d/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;35mcontendo o fatorial de cada elemento de /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32melementos/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0m do /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mvetor A/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mA/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m[/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;31m%d/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m]/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;36mAVISO: /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0mProcessando o /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mvetor A /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0me criando o /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mvetor B/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0m, /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;35mcontendo o fatorial de cada elemento de /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mA/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mvetores A/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0m e /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mB/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mA/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m[/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;31m%d/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m]/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0m\t=\t/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32m%d\t/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;34mB/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m[/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;31m%d/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m]/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0m\t=\t/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;34m%d/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mA/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32melementos/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0m do /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mvetor A/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mA/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m[/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;31m%d/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m]/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;36mAVISO: /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0mProcessando o /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mvetor A /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0me criando o /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mvetor B/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0m, /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;35mcontendo o fatorial de cada elemento de /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mA/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mvetores A/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0m e /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mB/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mA/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m[/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;31m%d/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m]/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0m\t=\t/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32m%d\t/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;34mB/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m[/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;31m%d/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m]/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0m\t=\t/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;34m%d/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32melementos/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0m do /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mvetor A/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mA/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m[/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;31m%d/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m]/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;36mAVISO: /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0mProcessando o /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mvetor A /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0me criando o /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mvetor B/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0m, /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;35mcontendo o fatorial de cada elemento de /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mA/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mvetores A/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0m e /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mB/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mA/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m[/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;31m%d/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m]/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0m\t=\t/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32m%d\t/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;34mB/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m[/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;31m%d/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m]/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0m\t=\t/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;34m%d/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mvetores A/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32melementos/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0m do /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mvetor A/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mA/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m[/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;31m%d/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m]/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;36mAVISO: /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0mProcessando o /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mvetor A /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0me criando o /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mvetor B/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0m, /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;35mcontendo o fatorial de cada elemento de /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mA/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mvetores A/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0m e /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mB/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mA/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m[/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;31m%d/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m]/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0m\t=\t/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32m%d\t/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;34mB/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m[/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;31m%d/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m]/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0m\t=\t/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;34m%d/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0m e /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32melementos/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0m do /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mvetor A/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mA/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m[/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;31m%d/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m]/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;36mAVISO: /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0mProcessando o /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mvetor A /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0me criando o /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mvetor B/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0m, /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;35mcontendo o fatorial de cada elemento de /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mA/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mvetores A/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0m e /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mB/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mA/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m[/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;31m%d/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m]/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0m\t=\t/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32m%d\t/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;34mB/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m[/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;31m%d/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m]/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0m\t=\t/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;34m%d/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mB/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32melementos/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0m do /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mvetor A/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mA/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m[/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;31m%d/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m]/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;36mAVISO: /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0mProcessando o /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mvetor A /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0me criando o /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mvetor B/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0m, /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;35mcontendo o fatorial de cada elemento de /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mA/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mvetores A/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0m e /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mB/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mA/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m[/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;31m%d/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m]/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0m\t=\t/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32m%d\t/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;34mB/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m[/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;31m%d/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m]/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0m\t=\t/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;34m%d/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32melementos/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0m do /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mvetor A/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mA/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m[/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;31m%d/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m]/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;36mAVISO: /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0mProcessando o /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mvetor A /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0me criando o /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mvetor B/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0m, /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;35mcontendo o fatorial de cada elemento de /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mA/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mvetores A/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0m e /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mB/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mA/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m[/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;31m%d/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m]/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0m\t=\t/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32m%d\t/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;34mB/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m[/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;31m%d/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m]/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0m\t=\t/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;34m%d/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mA/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32melementos/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0m do /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mvetor A/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mA/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m[/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;31m%d/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m]/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;36mAVISO: /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0mProcessando o /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mvetor A /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0me criando o /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mvetor B/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0m, /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;35mcontendo o fatorial de cada elemento de /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mA/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mvetores A/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0m e /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mB/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mA/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m[/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;31m%d/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m]/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0m\t=\t/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32m%d\t/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;34mB/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m[/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;31m%d/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m]/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0m\t=\t/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;34m%d/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m[/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32melementos/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0m do /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mvetor A/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mA/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m[/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;31m%d/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m]/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;36mAVISO: /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0mProcessando o /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mvetor A /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0me criando o /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mvetor B/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0m, /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;35mcontendo o fatorial de cada elemento de /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mA/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mvetores A/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0m e /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mB/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mA/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m[/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;31m%d/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m]/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0m\t=\t/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32m%d\t/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;34mB/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m[/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;31m%d/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m]/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0m\t=\t/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;34m%d/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;31m%d/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32melementos/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0m do /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mvetor A/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mA/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m[/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;31m%d/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m]/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;36mAVISO: /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0mProcessando o /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mvetor A /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0me criando o /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mvetor B/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0m, /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;35mcontendo o fatorial de cada elemento de /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mA/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mvetores A/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0m e /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mB/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mA/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m[/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;31m%d/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m]/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0m\t=\t/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32m%d\t/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;34mB/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m[/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;31m%d/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m]/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0m\t=\t/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;34m%d/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m]/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32melementos/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0m do /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mvetor A/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mA/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m[/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;31m%d/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m]/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;36mAVISO: /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0mProcessando o /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mvetor A /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0me criando o /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mvetor B/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0m, /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;35mcontendo o fatorial de cada elemento de /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mA/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mvetores A/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0m e /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mB/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mA/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m[/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;31m%d/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m]/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0m\t=\t/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32m%d\t/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;34mB/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m[/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;31m%d/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m]/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0m\t=\t/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;34m%d/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0m\t=\t/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32melementos/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0m do /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mvetor A/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mA/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m[/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;31m%d/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m]/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;36mAVISO: /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0mProcessando o /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mvetor A /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0me criando o /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mvetor B/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0m, /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;35mcontendo o fatorial de cada elemento de /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mA/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mvetores A/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0m e /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mB/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mA/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m[/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;31m%d/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m]/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0m\t=\t/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32m%d\t/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;34mB/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m[/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;31m%d/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m]/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0m\t=\t/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;34m%d/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32m%d\t/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32melementos/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0m do /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mvetor A/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mA/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m[/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;31m%d/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m]/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;36mAVISO: /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0mProcessando o /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mvetor A /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0me criando o /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mvetor B/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0m, /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;35mcontendo o fatorial de cada elemento de /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mA/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mvetores A/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0m e /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mB/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mA/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m[/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;31m%d/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m]/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0m\t=\t/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32m%d\t/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;34mB/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m[/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;31m%d/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m]/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0m\t=\t/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;34m%d/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;34mB/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32melementos/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0m do /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mvetor A/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mA/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m[/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;31m%d/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m]/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;36mAVISO: /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0mProcessando o /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mvetor A /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0me criando o /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mvetor B/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0m, /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;35mcontendo o fatorial de cada elemento de /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mA/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mvetores A/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0m e /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mB/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mA/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m[/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;31m%d/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m]/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0m\t=\t/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32m%d\t/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;34mB/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m[/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;31m%d/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m]/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0m\t=\t/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;34m%d/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m[/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32melementos/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0m do /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mvetor A/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mA/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m[/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;31m%d/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m]/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;36mAVISO: /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0mProcessando o /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mvetor A /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0me criando o /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mvetor B/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0m, /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;35mcontendo o fatorial de cada elemento de /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mA/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mvetores A/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0m e /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mB/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mA/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m[/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;31m%d/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m]/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0m\t=\t/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32m%d\t/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;34mB/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m[/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;31m%d/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m]/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0m\t=\t/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;34m%d/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;31m%d/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32melementos/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0m do /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mvetor A/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mA/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m[/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;31m%d/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m]/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;36mAVISO: /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0mProcessando o /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mvetor A /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0me criando o /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mvetor B/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0m, /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;35mcontendo o fatorial de cada elemento de /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mA/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mvetores A/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0m e /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mB/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mA/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m[/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;31m%d/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m]/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0m\t=\t/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32m%d\t/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;34mB/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m[/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;31m%d/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m]/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0m\t=\t/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;34m%d/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m]/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32melementos/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0m do /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mvetor A/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mA/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m[/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;31m%d/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m]/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;36mAVISO: /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0mProcessando o /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mvetor A /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0me criando o /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mvetor B/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0m, /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;35mcontendo o fatorial de cada elemento de /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mA/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mvetores A/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0m e /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mB/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mA/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m[/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;31m%d/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m]/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0m\t=\t/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32m%d\t/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;34mB/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m[/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;31m%d/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m]/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0m\t=\t/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;34m%d/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0m\t=\t/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32melementos/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0m do /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mvetor A/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mA/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m[/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;31m%d/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m]/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;36mAVISO: /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0mProcessando o /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mvetor A /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0me criando o /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mvetor B/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0m, /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;35mcontendo o fatorial de cada elemento de /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mA/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mvetores A/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0m e /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mB/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mA/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m[/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;31m%d/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m]/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0m\t=\t/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32m%d\t/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;34mB/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m[/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;31m%d/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m]/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0m\t=\t/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;34m%d/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;34m%d/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32melementos/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0m do /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mvetor A/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mA/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m[/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;31m%d/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m]/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;36mAVISO: /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0mProcessando o /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mvetor A /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0me criando o /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mvetor B/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0m, /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;35mcontendo o fatorial de cada elemento de /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mA/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mvetores A/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0m e /*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mB/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32mA/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m[/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;31m%d/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m]/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0m\t=\t/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;32m%d\t/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;34mB/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m[/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;31m%d/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;33m]/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0m\t=\t/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
33[0;34m%d/*
 * Desenvolvedor: Thiago Alexandre
 * Data: 05/11/2010
 *
 * DESCRICAO:
 *
 *  Programa que le uma matriz A do tipo vetor com 15 elementos. Constroi uma matriz B
 *  de mesmo tipo sendo que cada elemento da matriz B seja o fatorial do elemento
 *  correspondente da matriz A.
 *
*/

#include <stdio.h>

int main(void)
{
  int register i;
  int register cont;
  long fatorial = 1;  
  int a[15], b[15];
  
  system("clear");
  
  printf("Informe os {FONTE}33[0;32melementos{FONTE}33[0m do {FONTE}33[0;32mvetor A{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t", i);
    scanf("%d", &a[i]);
  }
  
  printf("\n{FONTE}33[0;36mAVISO: {FONTE}33[0mProcessando o {FONTE}33[0;32mvetor A {FONTE}33[0me criando o {FONTE}33[0;32mvetor B{FONTE}33[0m, {FONTE}33[0;35mcontendo o fatorial de cada elemento de {FONTE}33[0;32mA{FONTE}33[0m\n");
  sleep(5);
  
  printf("\nApresentando os {FONTE}33[0;32mvetores A{FONTE}33[0m e {FONTE}33[0;32mB{FONTE}33[0m\n");
  for(i = 0; i < 15; i++)
  {
    cont = a[i];
    while(cont >= 1)
    {
      fatorial *= cont;
      cont--;
    }
    b[i] = fatorial;
    fatorial = 1;
    printf("{FONTE}33[0;32mA{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;32m%d\t{FONTE}33[0;34mB{FONTE}33[0;33m[{FONTE}33[0;31m%d{FONTE}33[0;33m]{FONTE}33[0m\t=\t{FONTE}33[0;34m%d{FONTE}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}33[0m\n", i, a[i], i, b[i]);
  }    
  printf("\n");
  
  return(0);
}
Simples exemplo de manipulação de vetores

Descrição

Leitura recomendada

Comentários

Contribuir com comentário
