Uma solução da folha extra de exercícios

Exercício 1.==============================================================
/* Movimento browniano
    - distancia `a origem depois de n passos
    - "probabilidade de ficar no 1o quadrante, x>0, y>0                  */

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

typedef struct pt{
  int x;
  int y;
} ponto;

ponto move(ponto);
/*------------------------------------------------------------------------*/
main(){
  int n,m,t,i,no1;
  float dist;
  ponto p;
  srand(getpid());
  printf("Passos? ");
  scanf("%d",&n);
  printf("Testes? ");
  scanf("%d",&t);
  no1=0;
  dist=0.0;
  for(m=0;m<t;m++){
    p.x=0;
    p.y=0;
    for(i=0;i<n;i++)
      p = move(p);
    dist += sqrt(p.x*p.x+p.y*p.y);
    if(p.x>0 && p.y>0)
      no1++;
  }
  printf("Distancia media = %-8.2f, Fraccao no 1 quad = %-8.6f \n",
	  dist/t, ((double)no1)/t);
}

/*-- Movimento: um passo -----------------------------------------*/

int aleatorio(int a,int b);

ponto move(ponto p){
  p.x += aleatorio(-1,1);
  p.y += aleatorio(-1,1);
  return(p);
}

int aleatorio(int a,int b){
  return(a+(int) ((b-a+1.0)*rand()/(RAND_MAX+1.0)));
}

/*
Distancia media = 32.67   , Fraccao no 1 quad = 0.244000 
*/

Exercício 2.==============================================================
#include <stdio.h>
#define MAX 100

typedef struct pt{
  int x;
  int y;
} ponto;
int maxx=-1,maxy=-1;

int dir[MAX][MAX] = {0};  /* arestas para a direita */
int cim[MAX][MAX] = {0};  /* arestas para cima      */

void dados(void);
int quadrados(ponto); /* para cima e direita        */




/*--------------------------------------------------*/
main(){
  int x,y,nq=0;
  ponto p;
  dados();
  for(x=0;x<=maxx;x++)
    for(y=0;y<=maxy;y++){
      p.x=x;
      p.y=y;
      nq += quadrados(p);
    }
  printf("Ha' %-3d quadrados\n",nq);
}




/*----- Ler dados ----------------------------------*/
int dx[256]={0}, dy[256]={0};
void iniciad();
int getsimb(void);

void dados(void){
  int x,x0,y,y0,let,letra;
  iniciad();
  while(1){
    scanf("%d",&x);
    if(x<0)
      return;
    letra='x';
    scanf("%d",&y);
    if(x>maxx)
      maxx=x;
    if(y>maxy)
      maxy=y;
    while((let=getsimb())!='\n'){
      if(let!=letra){
	x0=x;
	y0=y;
      }
      letra=let;
      if(let=='d')
	dir[x0][y0]=1;
      if(let=='c')
	cim[x0][y0]=1;
      if(let=='e')
	dir[x0-1][y0]=1;
      if(let=='b')
	cim[x0][y0-1]=1;
      x0 += dx[let];
      y0 += dy[let];
    }
  }
}

void iniciad(){
  dx['d']= 1; dy['d']=-0; 
  dx['e']=-1; dy['e']= 0; 
  dx['c']= 0; dy['c']= 1; 
  dx['b']= 0; dy['b']=-1; 
}

int space(int);

int getsimb(void){
  int ch;
  while(space(ch=getchar()));
  return(ch);
}

int space(int t){
  return(!(t>='a' && t<='z' || t=='\n'));
}





/*---- Contar quadrados ---------------------------------*/

int quadrado(ponto,int);

int quadrados(ponto p){
  int nq=0,tam;
  for(tam=1;p.x+tam<=maxx;tam++){
    if(quadrado(p,tam)){
      printf("Quadrado com origem em (%d,%d) e tamanho %d\n",p.x,p.y,tam);
      nq++;
    }
  }
  return(nq);
}

int quadrado(ponto p,int n){
  int i;
  for(i=0;i<n;i++)
    if(!dir[p.x+i][p.y])
      return(0);
  for(i=0;i<n;i++)
    if(!cim[p.x][p.y+i])
      return(0);
  for(i=0;i<n;i++)
    if(!dir[p.x+i][p.y+n])
      return(0);
  for(i=0;i<n;i++)
    if(!cim[p.x+n][p.y+i])
      return(0);
  return(1);
}


Exercício 3.==============================================================
/*--- Correspondência inteiros <-> racionais  */
#include <stdio.h>
struct frac{
  int num;
  int den;
};

int inteiro(struct frac f);
struct frac racional (int n);

main(){
  struct frac x;
  int com,n;
  while(1){
    printf(" 0 (Q->I) or 1 (I->Q) ? ");
    scanf("%d",&com);
    if(com==0){
      printf("Num Den ? ");
      scanf("%d %d",&x.num,&x.den);
      printf("%d/%d is number %d\n",x.num,x.den,inteiro(x));
    }
    else{
      printf("Inteiro ? ");
      scanf("%d",&n);
      x = racional(n);
      printf("Fraccao numero %d = %d/%d\n",n,x.num,x.den);
    }
  }
}

struct frac next(struct frac);

/*-- inteiro correspondente ao racional f -------*/
int inteiro(struct frac f){
  struct frac x={1,1};
  int n=1;
  while(f.num!=x.num || f.den!=x.den){
    n++;
    x = next(x);
  }
  return(n);
}
 
/*-- racional correspondente ao inteiro n -------*/
struct frac racional (int n){
 struct frac f={1,1};
  int m=1;
  while(m!=n){
    m++;
    f = next(f);
  }
  return(f);
}

int gcd(int a, int b);

/*-- número racional seguinte -------------------*/
struct frac next(struct frac f){
  if(f.den==1){
    f.den=f.num+1;
    f.num=1;
    return(f);
  }
  do{
    f.num++;
    f.den--;
  }
  while(gcd(f.num,f.den)>1);
  return(f);
}

/*-- máximo divisor comum -----------------------*/
int gcd(int a, int b){
  if(b==0)
    return(a);
  return(gcd(b,a%b));
}