Juan Carlos Espinosa Ceniceros

sábado, 13 de noviembre de 2010

TIPOS DE DATOS - Presentacion 4

Lenguajes de Programacón - Semana 13

Espero les guste mi presentacion:

DESCARGA DEL CODIGO FUENTE: agenda.c

ANTES DE . . .

Antes de ejecutar el código, asegurense de crear una carpeta llamada agenda en donde descarguen el archivo, si no lo hacen el programa lanzara error porque lo primero que realiza es buscar dicha carpeta para generar el archivo de texto donde se guardarán los registros.

Comentarios, dudas, sugerencias son bienvenidas!!! ^_^ Participen para ganar puntos :p

C - Listas Enlazadas

Lenguajes de Programacón - Semana 12 - PUNTOS EXTRA

Esta aplicacion que escribí el semestre pasado nos permite realizar de una forma simple una lista enlazada. Primero se crea un nodo inicial el cual despues de llena con la información que nos es pedida, despues se nos pregunta si queremos seguir agregando nodos, esto se hace repetiviamente hasta que decidimos no agregar mas datos a la lista, al llegar a este punto la lista se imprime mostrandonos todos los datos incluidos.

// Programa que arma una lista doblemente enlazada

# include 

typedef struct nodoN{
  int info;
  int cabecera;
  struct nodoN *prev;
  struct nodoN *next;
} NODO;

int main(void){
  char pregunta;
  int i = 1;
  NODO *list, *p, *q;
  list=(NODO*)malloc(sizeof(NODO));
  list->info = 0;
  list->cabecera = 1;
  list->prev = NULL;
  q = list;
  p = (NODO*)malloc(sizeof(NODO));
  list->next=p;
  do{
      ++list->info;
      printf("Dame un dato para la lista -> ");
      scanf("%d", &p->info);
      p->cabecera = 0;
      p->prev = q;
      p->next = NULL;
      printf("Deseas seguir (s/n)");
      scanf("%s", &pregunta);
      if(pregunta == 's' || pregunta == 'S'){
          q = p;
          p = (NODO*)malloc(sizeof(NODO));
          q->next = p;
      }
  } while(pregunta != 'n' && pregunta != 'N');
  q = list;
  printf("los nodos de la lista son %d\n", q->info);
  do{
      if(q == list){
          q = list->next;
      } else {
          q = q->next;
      }
      printf("%d.-\t %d\n", i, q->info);
      i++;
  } while(q->next != NULL);
  return 0;
}

DESCARGA: lista.c

Para compilar: gcc -o lista lista.c
Para ejecutar: ./lista

EJECUCION:

La lista utiliza punteros y su tamaño es definido por la funcion malloc. Es un ejemplo basico de una lista, de este esqueleto podemos hacer otras mas extensas y con mas funcionalidad

SALUDOS!!! ^_^

C - Pilas y Colas

Lenguajes de Programación - Semana 12 - PUNTOS EXTRA

Esta vez tambien traigo unos programitas que concluí en estos dias, se tratan se unas aplicaciones que simulan las estructuras de datos: pilas y colas.

PILA

Esta aplicación permite mediante un menú ejecutar diferentes tareas a la pila, claro que para ello primero hay que rellenarla con algunos datos, podemos imprimir los elementos, sacar elementos, meter elementos. Además es posible realizar operaciones con los 2 elementos de hasta arriba de la pila.
Se realiza con arreglos y realmente no es nada complicado de entender:

#include 
#define FALSE -1
#define TRUE 1

void cabecera(void) {
  int i;
  printf("|");
  for(i = 0; i < 50; i++) printf("-");
  printf("|\n|");  
  printf("\t\tEJEMPLO DE PILA\t\t\t   |\n");
  printf("|");
  for(i = 0; i < 50; i++) printf("-");
  printf("|\n");
  return;
} 

int empty(int top) {
  if(top > -1)
    return FALSE;
  return TRUE;
}

int menu(void) {
  int op; 
  printf("\n\t1. Push data\n");
  printf("\t2. Pop data\n");
  printf("\t3. Stacktop\n");
  printf("\t4. Empty\n");
  printf("\t5. Print\n");
  printf("\t6. Operador\n");
  printf("\t7. Exit\n\n");
  printf("    Selecciona una opcion ->  ");
  scanf("%d", &op); 
  return (op); 
} 

int main(void) {
  int opcion = 0, temp, i, temp2[2];
  int pila [15], tope = -1;
  char operador;
  cabecera();
  while (opcion < 7) {  
    switch(opcion = menu()) {            
    case 1: {
      printf("\n\tIntroduce un dato ->  ");
      scanf("%d", &temp);
      tope++;
      pila[tope] = temp;
      break; 
    } 
      
    case 2: {
      printf("\n");
      if(empty(tope) == FALSE) {
         printf("\t\tElemento retirado -> [%d]\n\n", pila[tope]);
         tope = tope -1; 
      } else 
         printf("\t\tPILA VACIA\n\n");
      break;
    }
      
    case 3: {
      printf("\n");
      for(i = tope; i == tope; i++)
          printf("\tElemento en el tope -> [%d]\n\n", pila[i]); 
      break;
    }
      
    case 4: {
      if(empty(tope) == TRUE)
         printf("\n\tLA PILA ESTA VACIA\n\n"); 
      else
         printf("\n\tLA PILA NO ESTA VACIA\n\n");
      break;
    }
      
    case 5: {
      printf("\n\tELEMENTOS EN PILA\n\n");
      for(i = tope; i >= 0; i--)
         printf("\t\t[%d]\n",pila[i]);
      printf("\n");
      break;     
    }
      
    case 6: {
      while (getchar() != '\n') continue;
      printf("Que operacion quieres realizar?\n\n");
      printf("\tSUMA -> +\n\tRESTA -> -\n\tMULTIPLICACION -> *\n\tDIVISION -> /\n");
      scanf("%c", &operador);
      
      switch(operador) {
      case '*': { 
          if(empty(tope) == FALSE) { 
             temp2[0]=pila[tope];
             tope = tope -1;
             if(empty(tope) == FALSE) {
                temp2[1]=pila[tope];
                tope = tope; 
                pila[tope] = temp2[0] * temp2[1];
                break;
             }
          }
      }
 
      case '/': {
         if(empty(tope) == FALSE) {
            temp2[0]=pila[tope];
            tope = tope -1;
            if(empty(tope) == FALSE) {
               temp2[1]=pila[tope];
               tope = tope; 
               pila[tope] = temp2[0] / temp2[1];
               break;
            }
         }
      }
 
      case '+': {
         if(empty(tope) == FALSE) {
            temp2[0]=pila[tope];
            tope = tope -1;
            if(empty(tope) == FALSE) {
               temp2[1]=pila[tope];
               tope = tope; 
               pila[tope] = temp2[0] + temp2[1];
               break;
            }
         }
      }
 
      case '-': {
         if(empty(tope) == FALSE) {
            temp2[0]=pila[tope];
            tope = tope -1;
            if(empty(tope) == FALSE) {
               temp2[1]=pila[tope];
               tope = tope; 
               pila[tope] = temp2[0] - temp2[1];
               break;
            }
         }
      }
      } 
    }         
    }
  }    
  return 0;  
}

DESCARGA: pila.c

Para compilar: gcc -o pila pila.c
Para ejecutar: ./pila

EJECUCIÓN

COLA DE DATOS

En escencia se trata casi del mismo código anterior pero no es igual, ya que ahora se emula lo que sería una cola de datos, de igual forma se incluye un menú con las operaciones que se pueden realizar en una cola de datos, en este ejemplo no podemos realizar operaciones aritmeticas.

#include 
#define FALSE -1
#define TRUE 1

void cabecera(void) {
  int i; 
  printf("|");
  for(i = 0; i < 50; i++) printf("-");
  printf("|\n|");  
  printf("\t\tEJEMPLO DE COLA DE DATOS\t   |\n");
  printf("|");
  for(i = 0; i < 50; i++) printf("-");  
  printf("|\n"); 
  return;
} 

int empty(int frente, int fondo) {
  if(frente > fondo)
    return FALSE;   
  return TRUE;
}

int menu(void) {
  int op; 
  printf("\n\t1. Insertar elemento\n");
  printf("\t2. Retirar elemento\n");
  printf("\t3. Elemento de incio\n");
  printf("\t4. Verificar cola de datos\n");
  printf("\t5. Imprimir cola de datos\n");
  printf("\t6. Operador\n");
  printf("\t7. Salir\n\n");
  printf("    Selecciona una opcion ->  ");
  scanf("%d", &op); 
  return (op);
} 

int main(void) {    
  int opcion = 0, temp, i, temp2[2];
  int cola [15], frente = 0, fondo = -1;
  char operador;
  cabecera();
  while(opcion < 6) { 
    switch(opcion = menu()) {   
    case 1: {
      printf("\n\tDame el dato a ingresar ->  ");
      scanf("%d", &temp);
      fondo++;
      cola[fondo] = temp;
      break;
    } 
      
    case 2: {
      printf("\n");
      if(empty(frente, fondo) == FALSE) {
        printf("\t\tElemento retirado -> [%d]\n\n", cola[frente]);
        frente = frente +1;                
      } else
          printf("\t\tCOLA DE DATOS VACIA\n\n");
      break;
    }
 
    case 3: {
      if(empty(frente, fondo) == FALSE)
         printf("Elemento al frente es %d\n", cola[frente]); 
      else
         printf("LA COLA DE DATOS ESTA VACIA\n");
      break;
    }
                
    case 4: {
      if(empty(frente, fondo)==TRUE)
          printf("\n\tLA COLA DE DATOS ESTA VACIA\n\n");
      else
          printf("\n\tLA COLA DE DATOS NO ESTA VACIA\n\n");
      break;
    }
      
    case 5: {
      printf("\n\tELEMENTOS EN COLA\n\n");
      printf("INICIO");
      for(i=frente;i<=fondo;i++)
            printf(" <- [%d]",cola[i]);
      printf(" <- FIN\n\n");
      break;            
    }           
    }
  }    
  return 0;
}

DESCARGA: cola.c

Para compliar: gcc -o cola cola.c
Para ejecutar: ./cola

EJECUCIÓN

Espero y les sirvan para comprender estos dos conceptos con los que batallamos tanto el semestre pasado

SALUDOS!!! ^_^

C - Calculadora de Fracciones

Lenguajes de Programación - PUNTOS EXTRA

Termine de escribir este código que lo había dejado pendiente desde el semestre pasado, se trata de una calculadora que suma fracciones por medio una estructura, o mas bien, un nuevo tipo de dato definido por mi que toma la forma de una fracción y realiza las operaciones de la aritmética básica.

Esta es la definición de mi nuevo tipo de dato:

typedef struct fraccion {
     int num;
     int den;
} frac;

Un tipo de dato "fraccion" al cual me referire durante el programa como "frac", mi tipo de dato solo esta compuesto por el numerador y el denominador, ambos son enteros.

Este es el constructor del dato:

frac construye(int a, int b) {
  frac temp;
  temp.num = a;
  if(b==0){
      printf("El denominador no puede ser cero");
      temp.den = 1;
      return(temp);      
  }
  temp.den = b;
  return(temp);
}

Toma los parámetros enviados desde main, el numerador y denominador, y los fusiona en un solo tipo de dato; si el denominador el 0, la función regresa una fracción entera ademas de una advertencia. El constructor se visita 2 veces, porque las operaciones se realizan por parejas de datos.

Estas son los algoritmos para realizar las operaciones:

// Para sumar

frac add(frac a, frac b) {
 frac temp;
 temp.den = a.den * b.den;
 temp.num = (a.num * b.den) + (a.den * b.num);
 return(temp);
}

//Funcion para multiplicar

frac mult(frac a, frac b) {
 frac temp;
 temp.num = a.num * b.num;
 temp.den = a.den * b.den;
 return(temp);
}

//Funcion para div

frac div(frac a, frac b) {
 frac temp;
 temp.num = a.num * b.den;
 temp.den = a.den * b.num;
 return(temp);
}

// Para restar
frac res(frac a, frac b) {
 frac temp;
 b.num = b.num * -1;
 temp = add(a, b);
 return(temp);
}

Por si no se acuerdan: la suma es la adición de la multiplicación cruzada de los numeradores y denominadores, los denominadores se multiplican directo; la resta es igual solo cambiamos el signo de un numerador. La multiplicación es directa numerador x numerador, denominador x denominador; mientras que para la división se realiza una multiplicación cruzada.

Para imprimir los datos utilizo esta rutina:

void imprime (frac a, char op, frac b, frac c) {
 printf("\n");
 toprint(a);
 printf(" %c ", op);
 toprint(b);
 printf(" = ");
 toprint(c);
 printf("\n");
 return;  
}

Esta rutina imprime las fracciones construidas con su resultado.

La funcion main pide los datos de una forma especial, no hace falta hacer elecciones ni nada, el formato de entrada de datos es el siguiente: num/den + num/den, mas grafico: 1/2+1/4
La funcion reconoce los datos y los envía al constructor y reconoce el operador aritmético para realizar determinada accion:

int main(int argc, char** args) {
 char f, op;
 int an, bn;
 frac A, B, C;
 f = 's';
 printf("\t\tPROGRAMA PARA REALIZAR CALCULOS CON FRACCIONES\n\n");
 do{
   printf("Dame los datos\n");
   scanf("%d/%d", &an, &bn);
   A = construye(an, bn);
   scanf("%c", &op);
   scanf("%d/%d", &an, &bn);
   B = construye(an, bn);
   if(op == '+')
C = add(A, B);   
   if(op == '*')
C = mult(A, B);
   if(op == '/')
C = div(A, B);
   if(op == '-')
C = res(A, B);
   imprime(A, op, B, C);
   scanf("%c", &f);
 } while(f!='f');
 return 0;
}

PROGRAMA COMPLETO: fracciones.c

Para compilar: gcc -o fracciones fracciones.c
Para ejecutar: ./fracciones

EJECUCIÓN

PD: Para salir del programa escriben "f"

SALUDOS!!! ^_^

lunes, 8 de noviembre de 2010

C - Ejemplos sencillos

Lenguajes de Programación - Semana 12- PUNTOS EXTRA

Estas con algunas aplicaciones pequeñas escritas en C para pasar el rato :) que me gustaria compartirles

FRASE AL REVES

Toma una frase escrita desde el teclado, la almacena en un arreglo y despues utilizando la funcion strlen de la libreria string.h y con la ayuda de un ciclo for giramos la frase al reves.

//Leer una frase y escribirla al reves

#include 
#include 

int main(void) {
  char frase[100];
  int n;
 
  printf("Introduce una frase y la escribire al reves [255 letras]\n");
  printf("Cuando termines pulsa ENTER\n\n");
  scanf("%[^\n]", frase);
  printf("\n");
  
  for (n=strlen(frase)-1; n>=0; n--)
    printf("%c", frase[n]);
 
  printf("\n\n");
  return 0;    
}

DESCARGA: frase.c

Para compilar: gcc -o frase frase.c
Para ejecutar: ./frase

EJECUCION

MULTIPLICACION

Este programa genera multiplicaciones aleatorias con la ayuda de la funcion rand y la libreria time.h que nos ayuda a variar los datos generados.

#include 
#include 

void multiplicar(void);

int main(void) {
  multiplicar();
  return 0;
}

void multiplicar(void) {
    int x, y, resultado=0;
    printf("\n-1 en el resultado para salir.\n");
    
    srand(time(NULL));
    while(resultado != -1) {
         x = rand()%10;
         y = rand()%10;
         
         printf("\n%d X %d = ", x, y);
         scanf("%d", &resultado);
         
         while((resultado != -1) && (resultado != x*y)) {
              printf("\nEquivocado, pruebe otra vez -> ");
              scanf("%d", &resultado);
         }
         if(resultado != -1)
              printf("Correcto.\n");
    }
    printf("Saliendo . . . . .\n");
}

DESCARGA: multaleatoria.c

Para compilar: gcc -o multaleatoria multaleatoria.c
Para ejecutar: ./multaleatoria

EJECUCION

RAIZ "X" DE UN NUMERO

Este programa resuelve la raiz "n" del numero que demos, por un metodo llamado de aproximacion.

// Programa para calcular una Raiz Cuadrada "x" de un numero "n"

#include 

double absoluto(double x){
  if(x < 0) 
    return(-1.0 * x);
  return(x);
}

double potencia(double x, int n) {
  int i;
  double resultado = 1.0;
  for(i = 0; i < n; i++)
    resultado = resultado * x;     
  return(resultado);
}

double raizn(double R, int n) {
  double x = 1.0, y = 2.0;
  while(absoluto(x - y) > .00001) {
    y = x;
    x = (1.0 / n) * (((n - 1) * x) + (R / potencia(x, (n - 1))));
  }
  return(x);
}

int main(void) {
  
  double raiz, valor, resultado;
  
  printf("\t\t\tPROGRAMA PARA CALCULAR UNA RAIZ\n\n");
  printf("Dame el numero para saber su raiz cuadrada -> ");
  scanf("%lf", &valor);
  printf("Dame el valor de la raiz -> ");
  scanf ("%lf", &raiz);
  
  resultado = raizn(valor, raiz);
  
  printf("\nLa raiz %1.1lf del numero %1.1lf en = %1.2lf\n\n", raiz, valor, resultado);
  return 0;
}

DESCARGA: raiz.c

Para compilar:gcc -o raiz raiz.c
Para ejecutar: ./raiz

EJECUCION

NUMEROS PRIMOS

Este programita generara una serie que contiene n numeros primos, la cantidad de resultados se puede controlar desde la constante MAX en el codigo fuente.

/* Programa que imprime "n" numeros primos de acuerdo al numero especificado 
en la constante MAX */

#include 
#define MAX 50

int primo(int numero) {
  int i; 
  for(i = 2; i < numero; i++)
    if(numero % i == 0)
      return 0;
  return 1;
}

int main(void) {
  int primos[MAX], i = 2, k = 0;
  while(k < MAX) {
    if(primo(i) == 1) {
      primos[k] = i;
      k = k + 1;
    }
    i = i + 1;
  }
  printf("\n\t\t\t%d numeros primos\n\n", MAX);
  for(i = 0; i < MAX; i++)
    printf("%d\t", primos[i]);
  putchar('\n');
  return 0;
}

DESCARGA: primos.c

Para compilar: gcc -o primos primos.c
Para ejecutar: ./primos

EJECUCION

SALUDOS!!! ^_^

FORTRAN - Ejemplos

Lenguajes de Programacón - PUNTOS EXTRA

MÁXIMO COMÚN DIVISOR

Este programa calcula el máximo común divisor de una pareja de números utilizando el Algoritmo de Euclides. Como sabemos el algoritmo de Euclides se fundamenta en que el máximo común divisor de la pareja de números a,b es el mismo que el de b,r, siendo r el residuo de la division anterior, por ello intercambiamos los valores de a por r a lo largo de la ejecucion del programa mientras el numero menor no sea igual a 0.

Para compilar: gfortran -o mcd mcd.f
Ejecutar con: ./mcd

Codigo

C ****** PROGRAMA QUE CALCULA EL ******
C ******* MAXIMO COMUN DIVISOR ********
C =====================================
    PROGRAM mcd
    REAL m, n, r, aux
    PRINT*, 'Dame M: '
    READ(*,*) m
    PRINT*, 'Dame N: '
    READ(*,*) n
    PRINT*, 'Maximo Comun Divisor de:'
    PRINT*, m, n
    IF (m.LT.n) THEN
       aux = m
       m = n
       n = aux
    ENDIF
    DO WHILE (r.NE.0)
       r = MOD(m,n)
       m = n
       n = r
    ENDDO
    PRINT*, 'es',m
    STOP
    END

EJECUCION

Para verificar que los resultados son correctos, pueden hacerlo en esta página o calcular el MCD ustedes mismos Calcular MCD

DESCARGA: mcd.f

CALCULO DE LA FUERZA MAGNETICA APLICADA A SUS TRES VARIANTES

Como lo dice el tÍtulo, este algoritmo calcula la fuerza magnetica aplicada ya sea a una particula en movimiento, generada en un conductor o en un solenoide.
Tuve un pequeno problema con el calculo del angulo ya que fortran lo pedia en radianes, aplicando una formula de conversion resolvi el problema :)

Para compilar: gfortran -o fisica fisica.f
Para ejecutar: ./fisica

Codigo

C ******** PROGRAMA QUE CALCULA ************
C ******** LA FUERZA MAGNETICA *************
C ********  EN SUS TRES CASOS **************
C ==========================================
      PROGRAM fisica

      REAL x, q, v, b, i, l, n, o, theta, fb, a 
      PRINT*, 'Calcular la magnitud de la fuerza magnetica para: '
      PRINT*, '1. Particulas en movimiento'
      PRINT*, '2. Conductores'
      PRINT*, '3. Solenoides'
      PRINT*, '4+. Salir'
      READ(*,*) x
      IF (x.EQ.1) THEN
         PRINT*, 'Dame la carga de la particula (Columb) '
         READ(*,*) q
         PRINT*, 'Dame la velocidad de la particula (Metros x seg.)'
         READ(*,*) v
         PRINT*, 'Dame la magnitud del campo magnetico (Teslas) '
         READ(*,*) b
         PRINT*, 'Dame el angulo de los vectores V X B (grados)'
         READ(*,*) o
         theta = ( o * 3.14159 ) / 180
         fb = abs(q)*v*b*sin(theta)
         PRINT*, 'La fueza magnetica para esta particula es',fb,'N'
      ENDIF
      IF (x.EQ.2) THEN
         PRINT*, 'Dame la intensidad de la corriente (Amperes)'
         READ(*,*) i
         PRINT*, 'Dame la longitud del conductor (metros)'
         READ(*,*) l
         PRINT*, 'Dame la magnitud del campo magnetico (Teslas)'
         READ(*,*) b
         PRINT*, 'Dame el angulo de los vectores I X B (Grados)'
         READ(*,*) o
         theta = ( o * 3.14159 ) / 180
         fb = i*l*b*sin(theta)
         PRINT*, 'La fuerza magnetica para este conductor es',fb,'N'
      ENDIF
      IF (x.EQ.3) THEN
         PRINT*, 'Dame el numero de vueltas del solenoide'
         READ(*,*) n
         PRINT*, 'Dame la intensidad de la corriente (Amperes)'
         READ(*,*) i
         PRINT*, 'Dame el area del solenoide (metros cuadrados)'
         READ(*,*) a
         PRINT*, 'Dame la magnitud del campo magnetico (Teslas)'
         READ(*,*) b
         PRINT*, 'Dame el angulo de los vectores V X B (Grados)'
         READ(*,*) o
         theta = ( o * 3.14159 ) / 180
         fb = n*i*a*b*(sin(theta))
         PRINT*, 'La fuerza magnetica para este solenoide es',fb,'N'
      ENDIF
      IF (x.GT.3) THEN
         PRINT*, 'Saliendo . . . . .'
      ENDIF
      STOP
      END

EJECUCION

DESCARGA: fisica.f

SALUDOS!!! ^_^

domingo, 7 de noviembre de 2010

LENGUAJES IMPERATIVOS - Programas Reporte 7

Lenguajes de Programación - Semana 12

FORTRAN

Fortran me inspiró bastante, asi que decidí aplicar algo de matemáticas para este lenguaje. Un programa que calcula las raices de una ecuación de segundo grado, incluyendo sus raices complejas. Para ello apliqué la fórmula general que todos conocemos y le agregue las condiciones para hallar las raices complejas, la cual es simple:

si el discriminante ( b^2 * 4*a*c ) es menor a 0, entonces la ecuación tendra raices complejas

Codigo:

C PROGRAMA QUE CALCULA LAS RAICES
C DE UNA ECUACION DE SEGUNDO GRADO
C --------------------------------------------
    PROGRAM raices
    REAL a, b, c, r, bc, rc, rc2, x, x1, x2
    PRINT*, 'Dame el valor de A: '
    READ(*,*) a
    PRINT*, 'Dame el valor de B: '
    READ(*,*) b
    PRINT*, 'Dame el valor de C: '
    READ(*,*) c

    r = ((b**2)-(4*a*c))
    PRINT*, r

    IF (r.GE.0) THEN
       x1 = (-b + (sqrt(r)))/(2*a)
       x2 = (-b - (sqrt(r)))/(2*a)
       PRINT*, 'x1 = ',x1
       PRINT*, 'x2 = ',x2
    ELSE
       rc = (sqrt(abs(r)))
       bc = -b / (2*a)
       rc2 = rc / (2*a)
       PRINT*, 'Solucion compleja x = ',bc,'+-',rc2,'i'
    ENDIF
    STOP
    END

DESCARGA: raices.f

Para compilar: gfortran -o raices raices.f

Para ejecutar: ./raices

BASIC

Para BASIC hice una calculadora sencilla, da la opción de seguir introduciendo operaciones hasta hartarte, no te permite dividir entre 0 y no acepta letras al momento de realizar una operacion, esto último ya es una funcionalidad del lenguaje. Para cada operación de 2 numeros, los valores se separan por una coma (ver imagen).

Codigo:

DECLARE SUB suma (a AS SINGLE, b AS SINGLE)
DECLARE SUB res (a AS SINGLE, b AS SINGLE)
DECLARE SUB mult (a AS SINGLE, b AS SINGLE)
DECLARE SUB div (a AS SINGLE, b AS SINGLE)
DECLARE SUB pot (a AS SINGLE, b AS SINGLE)
DECLARE SUB raiz (a AS SINGLE)

''' Calculadora Sencilla
   DIM x AS SINGLE, y AS SINGLE, opcion AS INTEGER
   PRINT
   PRINT "===== CALCULADORA 1.0 ====="
   DO
       PRINT
    PRINT "1. Suma"
PRINT "2. Resta"
    PRINT "3. Multiplicacion"
    PRINT "4. Division"
    PRINT "5. Potencia"
    PRINT "6. Raiz Cuadrada"
    PRINT "7+. SALIR"
    PRINT
    INPUT "Elige la operacion -> ", opcion
       PRINT

    SELECT CASE opcion
           CASE 1
     INPUT "Dame los dos valores a sumar -> ", x, y
     suma x, y
           CASE 2
     INPUT "Dame los dos valores a restar -> ", x, y
     res x, y
           CASE 3
        INPUT "Dame los dos valores a multiplicar ->", x, y
        mult x, y
           CASE 4
        INPUT "Dame los dos valores a dividir -> ", x, y
        div x, y
           CASE 5
        INPUT "Dame la base y el exponente (respect.) -> ", x, y
        pot x, y
           CASE 6
        INPUT "Dame un numero para obtener su raiz cuadrada -> ", x
        raiz x
           CASE ELSE
               PRINT "Saliendo . . . . . "
       END SELECT
   LOOP WHILE opcion < b =" 0"> ", b
   WEND
   r = a / b
   PRINT
   PRINT "Resultado: "; r
END SUB

SUB pot (a AS SINGLE, b AS SINGLE)
   DIM i AS INTEGER
   DIM c AS SINGLE
   c = 1
   FOR i = 1 TO b
    c = c * a
   NEXT i
   PRINT
   PRINT "Resultado: "; c
END SUB

SUB raiz (a AS SINGLE)
   PRINT
   PRINT "Resultado: "; SQR(a)
END SUB

DESCARGA: calculadora.bas

Para compilar: fbc calculadora.bas

Para ejecutar: ./calculadora

PASCAL

En este lenguaje batalle un poco, al final les muestro este otro que sirve para practicar la recursion en este lenguaje, un menú utilzando CASES, para seleccionar fibonacci, potencias o factorial

Codigo

PROGRAM recursion;

uses
   crt;

Function fibonacci (x : Integer):LongInt;
Begin
  If x <= 1 Then       fibonacci := x    Else       fibonacci := (fibonacci(x-1) + fibonacci(x-2)); End; { fibonacci }  Function potencia (a , b : Integer):LongInt; Begin    If b = 0 Then       potencia := 1    Else       potencia := a * potencia(a , b-1); End;  Function factorial(m : Integer):LongInt; Begin    If m < recursion ="="="="="="="="');"> ');
  opcion := ReadKey;

  Case opcion of
    'a' : begin
Writeln('');
Writeln('');
Write('BASE -> ');
Readln(num1);
Write('EXPONENTE -> ');
Readln(num2);
Writeln('');
Writeln('RESULTADO = ',potencia(num1,num2));
Writeln('');
    end;
    'b' : begin
Writeln('');
Writeln('');
Write('Cantidad de valores en la serie -> ');
Readln(num1);
For num2 := 1 To num1 Do
   Write(fibonacci(num2),' | ');
Writeln('');
    end;
    'c' : begin
Writeln('');
Writeln('');
Write('Factorial de? -> ');
Readln(num1);
Writeln('');
Writeln(num1,'! = ',factorial(num1));
Writeln('');
    end;
  end; { case }
End.

DESCARGA: recursion.pas

Para compilar: fpc recursion.pas

Para ejecutar: ./recursion

C

En C hice este programita que calcula el salario de los trabajadores de una empresa, el programa solicita las horas trabajadas totales a las que se les aplica el sueldo base seleccionado. Tambien se calculan horas extra (si son mas de 40 horas) y se les aplica una tarifa especial.
Los impuestos se aplican de la siguiente forma:
15% a los primeros $500
16% a los siguientes $300
17% a lo que resta
Despues se suman los descuentos y se le restan a la percepcion asi se obtiene un sueldo neto.
Al final el programa imprime todo el desglose de descuentos, horas y sueldo neto. Todo se maneja por medio de constantes por lo que es fácilmente editable a otros impuestos y sueldos base

Codigo

/*Programa para calcular salario en diferentes esquemas de pago*/

#include <stdio.h>
#define BASE1 57.46   
#define BASE2 55.84
#define BASE3 54.47
#define BASE4 53.00
#define EXTRA 15.00
#define TAX1 0.15
#define TAX2 0.16
#define TAX3 0.17

int menu(void) {    
    int opcion = 0, i;        
    for(i=0; i<79; i++) printf("=");    
    printf("\n\n");
    printf("\t    SELECCIONA EN NUMERO CORRESPONDIENTE A LA TAZA DE PAGO\n\n");
    printf("\t1) $ %.2f hr \t\t\t\t", BASE1);
    printf("\t2) $ %.2f hr\n\n", BASE2);
    printf("\t3) $ %.2f hr\t\t\t\t", BASE3);
    printf("\t4) $ %.2f hr\n\n", BASE4);
    printf("\t5) Salir\n\n");
    for(i=0;i<79;i++) printf("=");    
    scanf("%d", &opcion);
    while(opcion > 5 || opcion == 0) {
        printf("Elige una opcion valida -> ");
 scanf("%d", &opcion);
    }
    return opcion;
}


float calculos(float x, float y) {
 float horas, hrbase, hrext=0.0, hrtot;
 float salariobase, temp=0.0, percepcion, sueldoneto;
 float temp1=0.0, temp2=0.0, temp3=0.0;
 float imp1=0.0, imp2=0.0, imp3=0.0, descuento; 
 hrbase = y;   
 if (y > 40) {
   hrbase = 40;
   hrext = y - 40;
   temp = hrext * EXTRA;
 }
 hrtot = hrbase + hrext;
 salariobase = hrbase * x;
 percepcion = salariobase + temp;
 if (percepcion <= 300.0)     imp1 = percepcion*TAX1;   if (percepcion > 300.0) {
     temp1 = 300.0;
     temp2 = percepcion - 300;
     if (temp2 > 150.0){
temp3 = temp2 - 150;
temp2 = 150;
     }
     imp1 = temp1 * TAX1;
     imp2 = temp2 * TAX2;
     imp3 = temp3 * TAX3;
 }

 descuento = imp1 + imp2 + imp3;
 sueldoneto = percepcion - descuento;
 printf("\nHORAS BASE    %1.2f\nHORAS EXTRA   %1.2f\nHORAS TOTALES %1.2f\n\n", hrbase, hrext, hrtot);
 printf("SALARIO BASE  $%1.2f\nPAGO EXTRA    $%1.2f\nPERCEPCION    $%1.2f\n\n", salariobase, temp, percepcion);
 printf("IMPUESTO 15%% -$%1.2f\nIMPUESTO 20%% -$%1.2f\nIMPUESTO 25%% -$%1.2f\nDESCUENTOS   -$%1.2f\n\n", imp1, imp2, imp3, descuento);
 return(sueldoneto);
}

int main(int argc, char** args) {       
 int opcion;
 float horas, salario;        
 while(( opcion = menu()) != 5) {    
   switch(opcion) {                      
   case 1: {
     printf("\n\t\tSistema para calcular el sueldo con base a $ %.2f x hr\n\n", BASE1);
     printf("\t\tHORA EXTRA [ $ %.2f ]  \n\n", EXTRA);
     printf("INTRODUCE LAS HORAS LABORADAS -> ");
     scanf("%f", &horas);   
     salario = calculos(BASE1, horas);
     printf("SUELDO NETO A PAGAR [ $%1.2f ]\n\n", salario);
     break;
   }          
   case 2: {
     printf("\n\t\tSistema para calcular el sueldo con base a $ %.2f x hr\n\n", BASE2);
     printf("\t\tHORA EXTRA [ $ %.2f ]  \n\n", EXTRA);
     printf("INTRODUCE LAS HORAS LABORADAS -> ");
     scanf("%f", &horas);   
     salario = calculos(BASE2, horas);
     printf("SUELDO NETO A PAGAR [ $%1.2f ]\n\n", salario);
     break;
   }
   case 3: {
     printf("\n\t\tSistema para calcular el sueldo con base a $ %.2f x hr\n\n", BASE3);
     printf("\t\tHORA EXTRA [ $ %.2f ]  \n\n", EXTRA);
     printf("INTRODUCE LAS HORAS LABORADAS -> ");
     scanf("%f", &horas);   
     salario = calculos(BASE3, horas);
     printf("SUELDO NETO A PAGAR [ $%1.2f ]\n\n", salario);
     break;
   }           
   case 4: {
     printf("\n\t\tSistema para calcular el sueldo con base a $ %.2f x hr\n\n", BASE4);
     printf("\t\tHORA EXTRA [ $ %.2f ]  \n\n", EXTRA);
     printf("INTRODUCE LAS HORAS LABORADAS -> ");
     scanf("%f", &horas);   
     salario = calculos(BASE4, horas);
     printf("SUELDO NETO A PAGAR [ $%1.2f ]\n\n", salario);
     break;
   }
   }
 }
 return 0;   
}

DESCARGA: salario.c

Para compilar: gcc -o salario salario.o

Para ejecutar: ./salario

Ejecucion

SALUDOS