Archivo de Noviembre 2007

ciclos, dos ejemplos (números primos, número perfecto)

Noviembre 29, 2007

/* primos.c, cantidad de primos menores que n
   (primo: solo divisible por 1 y n; como 2, 3, 5, 7, 11 , 13, 17)
*/

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

int primos(int n);
int primo(int n);

int main() {
   int lim, can; // limite, cantidad de primos

   printf(“Obtiene cantidad de primos menores que n.\n\n”);

   printf(“Limite (mayor que uno): “);
   scanf(“%d”, &lim);

   can = primos(lim);

   printf(“\nCantidad de primos: %d\n\n”, can);
 
   system(“pause”);  
   return 0;
}

int primos(int n) {
   /* obtiene los primos menores que n */
   int cp = 1; // cantidad de primos
   int c; // contador de 3 a n-1

      for (c = 3; c < n; c++)
         if (primo(c)) cp++;
 
   return cp;
}

int primo(int n) {
   /* determina si n es primo (mayor que 2) */
   int sp = 1; // si n es primo (1 = si, 0 = no)
   int d; // divisor (posible factor)

      for (d = 2; sp && d <= n/2; d++)
         if (n%d == 0) sp = 0;

   return sp;
}

* * * * * * *

/* perfecto.c, determina si un numero es perfecto
   (igual a la suma de sus factores propios, como 6 = 1 + 2 + 3; 28 = 1 + 2 + 4 + 7 +14)
*/

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

int perfecto(int n);

int main() {
   int num, siPer; // numero, si perfecto

   printf(“Determina si un entero positivo es perfecto.\n\n”);

   printf(“Numero: “);
   scanf(“%d”, &num);

   siPer = perfecto(num);

      if (siPer == 1)
           printf(“\n%d es perfecto.\n\n”, num);
         else
           printf(“\n%d NO es perfecto.\n\n”, num);

   system(“pause”);
   return 0;
}

* * * * * * *

Nota:

     Pongan el énfasis en las funciones, el código reciclable.

ecabrera.

para redactar el prototipo de una función C

Noviembre 28, 2007

Se puede seguir el suguiente algoritmo para redactar el prototipo de una función C:

    0. Determinar si la función retorna algo.

    1. Si retorna algo, determinar si es un sólo un valor o son varios.

    2. Si retorna un único valor, determinar qué tipo básico C lo aproxima mejor (int, float, char, double)  y este es el tipo de la función.

    3. Si la función no retorna valor, o retorna más de uno, el tipo es entonces void.

    4. Luego de especificado el tipo (o void) se asigna un nombre, de una sola palabra, que aluda al uso de la función.

    5. Si la función retorna más de una valor, se especifican sus tipos y nombres locales entre paréntesis, separados por comas.

    6. Si recibe algún valor, se especifica su tipo (o tipos) y nombre, y luego de los valores que retorna (si los hay),  separados por comas.

   7. Para cada valor escalar (un sólo valor) que retorna se precede el nombre de la variable con un asterisco (*).

   8. Para cada conjunto de valores (arreglo) que retorna (se asume que también llega) se asigna el nombre variable y se sigue con dos corchetes ([ ]).

Por ejemplo, una función que descompone en factores primos  un número entero positivo podría tener el prototipo:

    void factoresPrimos(int f[], int fr[], int *nf, int n);

La función es void porque retorna varios valores: Los factores en el arreglo f, las frecuencias de los factores en el arreglo fr, y el número de factores en el escalar nf; recibe al número n.

ecabrera.  

   

palabras, palabras, palabras… tan sólo palabras (Lissette Alvarez)

Noviembre 28, 2007

// palabras.c, funciones manejan palabras

typedef struct {
int numPal; /* numero de palabras */
char pals[100][50]; /* palabras */
} PALS;

int numCar(char c[]) {
/* numero caracteres en frase */
int ln = 0; /* longitud */
char nul = ”; /* nulo */
while (c[ln++] != nul);
return –ln;
}

int numPal(char c[]) {
/* numero ‘palabras’ frase */
int np = 0; /* numero de palabras */
int p = 0; /* posicion en frase */
char nul = ”; /* nulo */
char esp = ‘ ‘; /* espacio en blanco */
int ant = 1, act; /* anterior, actual ( 1 = es espacio, 0 = no */
while (c[p] != nul) {
act = (c[p] == esp) ? 1 : 0;
if (ant && !act) np++;
ant = act;
p++;
}
return np;
}

void ignEsp(PALS *pals, char c[]) {
/* ignora espacios (y separa ‘palabras’ */
int p = 0; /* posicion en frase */
int nl; // numero de letras en palabra actual */
char nul = ”; /* nulo */
char esp = ‘ ‘; /* espacio en blanco */
pals->numPal = -1; /* numero de palabras */
int ant = 1, act; /* anterior, actual ( 1 = es espacio, 0 = no */
while (c[p] != nul) {
act = (c[p] == esp) ? 1 : 0;
if (ant && !act) {
pals->numPal++;
pals->pals[pals->numPal][0] = c[p];
nl = 1;
}
if (!ant && !act) pals->pals[pals->numPal][nl++] = c[p];
if (!ant && act) pals->pals[pals->numPal][nl] = nul;
ant = act;
p++;
}
pals->numPal++;
}

int siLet(char c) {
/* si c es una letra */
int sl = 0; /* si letra (1 = si, 0 = no) */
char lts[ ] = “aáAÁbBcCdDeéEÉfFgGhHiíIÍjJkKlLmMnNñÑoóOÓpPqQrRsStTuúüUÚÜvVwWxXyYzZ”;
int p = 0; /* posicion en lts */
char nul = ”; /* nulo */
int hll = 0; /* hallado */
while (!hll && lts[p] != nul) {
if (c == lts[p]) hll = 1;
p++;
}
return hll;
}

void sepPal(PALS *pals, char c[]) {
/* separa palabras (solo letras) */
int p = 0; /* posicion en frase */
int nl; // numero de letras en palabra actual */
char nul = ”; /* nulo */
pals->numPal = -1; /* numero de palabras */
int ant = 0, act; /* anterior, actual ( 1 = es letra, 0 = no */
while (c[p] != nul) {
act = siLet(c[p]);
if (!ant && act) {
pals->numPal++;
pals->pals[pals->numPal][0] = c[p];
nl = 1;
}
if (ant && act) pals->pals[pals->numPal][nl++] = c[p];
if (ant && !act) pals->pals[pals->numPal][nl] = nul;
ant = act;
p++;
}
pals->numPal++;
}

int main() {
PALS pl;
int p;
sepPal(&pl, ” ??intec, ***tu ***mejor decisión…”);
for (p = 0; p < pl.numPal; p++)
printf(“%s\n”, pl.pals[p]);
printf(“\n”);
system(“pause”);
return 0;
}

Reflexión: ¿Se podrían usar rutinas como éstas para crear interfases en modo de texto más ‘inteligentes’, digamos como oráculos que no impongan un esuqme visual tan cargado y estructurado? Se puede opinar sobre esto en cualquiera de las respectivas bitácoras.

ecabrera.

homogismo

Noviembre 23, 2007

Silogismo:
   Todo animal es mortal.
   Todo hombre es un animal.
   Por tanto, todo hombre es mortal.

Silogismo:
   Toda relación sexual con uno del mismo sexo es homosexual.
   La masturbación es una relación sexual con uno mismo.
   Luego, la masturbación es una relación homosexual.

Nota: Pueden aportar sobre estos silogismos en cualquiera de las bitácoras.
      Los  aportes deben ser fundamentados en evidencias, no ser simples
      opiniones, sin evidencia de investigación previa.

par(), varias versiones de una misma función

Noviembre 23, 2007

int par(int n) {
if (n % 2 == 0)
return 1;
else
return 0;
}

int par(int n) {
int s;
if (n % 2 == 0)
s = 1;
else
s = 0;
return s;
}

int par(int n) {
int s = 0;
if (n % 2 == 0) s = 1;
return s;
}

int par(int n) {
int s = 0;
if (n % 2) s = 1;
return s;
}

int par(int n) {
return !(n%2);
}

Moraleja: Pueden haber muchas formas de resolver un mismo problema.

lógica, programa de lógica de programación

Noviembre 9, 2007

elementos, programa de laboratorio

Noviembre 9, 2007

elementos, programa de teoría

Noviembre 9, 2007

discusión, una crítica al tecnocentrismo en el pensamiento acerca de la escuela del futuro

Noviembre 9, 2007

Leer y comentar este artículo:

aCritiqueOfTechnocentrismInThinkingAboutTheSchoolOfTheFuture.doc

Cada comentario debe tener entre 50 y 100 palabras.

Identifícate con tu nombre, matrícula, asignatura y sección.

ecabrera.

discusión, computadoras en educación, por qué, cuándo, cómo

Noviembre 9, 2007

Leer y comentar este artículo:

computersInEducationWhyWhenHow.doc

Cada comentario debe tener entre 50 y 100 palabras.

Identifícate con tu nombre, matrícula, asignatura y sección.

ecabrera.