Algoritmica y Programación

Busqueda Incremental

2013-11-29T11:38:00.001-04:30

Estaba algo lleno de polvo desde mi último post. Pero con el poder creativo activado.
Hace poco tuve la necesidad de implementar una búsqueda incremental, como soy programador en Lazarus, se me ocurrió desarrollar un componente que facilitara esta labor. Pero pienso que falta pulirlo. Deseo y espero que alguno pueda ayudarme en esta labor y mejorar el componente para que sea los mas eficiente posible. A continuación les dejo el código:

unit Zambusqueda;

{$mode objfpc}{$H+}

interface

uses
  Classes, SysUtils, LResources, Forms, Controls, Graphics, Dialogs, DbCtrls, db,
  DBGrids, StdCtrls;

type
  TZambusqueda = class(TCustomControl)
  private
    { Private declarations }
    FFuenteDatos: TDataSource;
    FCampoDatos: String;

    FBusquedaDatos: TDataSource;
    FCampoBusqueda: String;

    FDBedit: TDBEdit;
    FDBGrid: TDBGrid;

    function GetFuenteDeDatos: TDataSource;
    procedure SetFuenteDeDatos(Value: TDataSource);

    function GetCampoDatos: string;
    procedure SetCampoDatos(const Value: string);

    function GetFuenteDeDatos2: TDataSource;
    procedure SetFuenteDeDatos2(Value: TDataSource);

    function GetCampoDatos2: string;
    procedure SetCampoDatos2(const Value: string);

    procedure DBEditChange(Sender: TObject);
    procedure DBGridCellClick(Column: TColumn);

    procedure DSStateChange(Sender: TObject);
  protected
    { Protected declarations }
     property Edit: TDBEdit read FDBEdit write FDBEdit;
     property DBGrid: TDBGrid read FDBGrid write FDBGrid;
  public
    { Public declarations }
    constructor Create(AOwner: TComponent); override;
    destructor Destroy; override;

  published
    { Published declarations }
    property FuenteDatos: TDataSource read GetFuenteDeDatos write SetFuenteDeDatos;
    //property CampoDatos: String read GetCampoDatos write SetCampoDatos;
    property CampoDatos: String read FCampoDatos write SetCampoDatos;

    property BusquedaDatos: TDataSource read GetFuenteDeDatos2 write SetFuenteDeDatos2;
    //property CampoBusqueda: String read GetCampoDatos2 write SetCampoDatos2;
    property CampoBusqueda: String read FCampoBusqueda write SetCampoDatos2;

  end;

procedure Register;

implementation

procedure Register;
begin
  RegisterComponents('Zambrano Controls',[TZambusqueda]);
end;

procedure TZambusqueda.DSStateChange(Sender: TObject);
begin
   FDBGrid.Visible:= (FDBEdit.DataSource.State in dsEditModes) and FDBedit.Focused;
   inherited;
end;

constructor TZambusqueda.Create(AOwner: TComponent);
begin
  inherited Create(AOwner);
  with GetControlClassDefaultSize do SetInitialBounds(0,0,150,150);

  FDBEdit := TDBEdit.Create(Self);
  FDBEdit.Caption := '';
  FDBEdit.Text    := '';
  FDBEdit.Visible  := True;
  FDBedit.CharCase := ecUppercase;
  FDBEdit.Parent   := Self;
  FDBedit.SetSubComponent(True); //Indica al IDE almacenar las propiedades modificadas
  FDBedit.ControlStyle := FDBedit.ControlStyle - [csNoDesignSelectable];
  FDBEdit.Align    := alTop;
  FDBEdit.OnChange := @DBEditChange;

  FDBGrid := TDBGrid.Create(Self);
  FDBGrid.Visible := False;
  FDBGrid.Parent  := Self;
  FDBGrid.Left := 0;
  FDBGrid.Options    := [dgTabs,dgAlwaysShowSelection,dgConfirmDelete,dgCancelOnExit];
  FDBGrid.ScrollBars := ssAutoVertical;
  FDBGrid.Top   := FDBedit.Height+2;
  FDBGrid.Anchors := [akTop,akLeft,akRight,akBottom];
  FDBGrid.Align := alBottom;
  FDBGrid.SetSubComponent(True);
  FDBGrid.ControlStyle := FDBGrid.ControlStyle - [csNoDesignSelectable];
  FDBGrid.OnCellClick:=@DBGridCellClick;
end;

destructor TZambusqueda.Destroy;
begin
  FDBedit.Destroy;
  FDBGrid.Destroy;
  inherited Destroy;
end;


function TZambusqueda.GetFuenteDeDatos: TDataSource;
begin
  Result := FFuenteDatos;
end;

procedure TZambusqueda.SetFuenteDeDatos(Value: TDataSource);
begin
    if Value=nil then SetCampoDatos('');

    FFuenteDatos := Value;
    FDBedit.DataSource := FFuenteDatos;
    FDBEdit.DataSource.OnStateChange:=@DSStateChange;
end;

function TZambusqueda.GetCampoDatos: string;
begin
  Result := FCampoDatos;
end;

procedure TZambusqueda.SetCampoDatos(const Value: string);
begin
  FCampoDatos := Value;
  FDBEdit.DataField := Value;
end;

procedure TZambusqueda.DBEditChange(Sender: TObject);
var
  Filtro: String;
begin
   FDBGrid.DataSource.DataSet.FilterOptions :=[foCaseInsensitive];
   FDBGrid.DataSource.DataSet.Filtered      :=False;
   if (Length(FDBEdit.Text)>0) and (FDBedit.DataSource.DataSet.State in dsWriteModes)
   then begin
     FDBGrid.Visible:=True;
     Filtro:=FCampoBusqueda + ' like ' + QuotedStr('*'+Trim(FDBEdit.Text)+'*');
     FDBGrid.DataSource.DataSet.Filter   := Filtro;
     FDBGrid.DataSource.DataSet.Filtered := true;
   end
   else begin
     FDBGrid.Visible:=False;
   end;
   inherited;
end;

procedure TZambusqueda.DBGridCellClick(Column: TColumn);
begin
  if not Assigned(FFuenteDatos) then exit;
  if not (FDBedit.DataSource.DataSet.State in dsWriteModes) then Exit;
  FDBEdit.Field.AsString := Trim(FDBGrid.Columns.Items[0].Field.Text);
  FDBGrid.Visible:=false;
end;

function TZambusqueda.GetFuenteDeDatos2: TDataSource;
begin
  Result := FBusquedaDatos;
end;

procedure TZambusqueda.SetFuenteDeDatos2(Value: TDataSource);
begin
    if Value=nil
    then begin
         SetCampoDatos2('');
    end;

    FBusquedaDatos := Value;
    FDBGrid.DataSource := FBusquedaDatos;
end;

function TZambusqueda.GetCampoDatos2: string;
begin
  Result := FCampoBusqueda;
end;

procedure TZambusqueda.SetCampoDatos2(const Value: string);
begin
  FCampoBusqueda := Value;
end;

end.

Función para calcular edad con MySQL

2011-11-02T10:23:00.000-04:30

Lo siguiente es el script SQL para crear una función almacena para MySQL que permite calcular la edad

ejemplo de uso:

SELECT edad('1972-12-31','2011-11-02');

el resultado es 38;

DROP FUNCTION IF EXISTS edad
delimiter //
CREATE FUNCTION edad(fnac DATE,fact DATE) RETURNS INT
BEGIN
DECLARE aux INT;
IF YEAR(fnac)>YEAR(fact) THEN
SET aux = -1;
ELSE
SET aux = (YEAR(fact)-YEAR(fnac)) - (RIGHT(fact,5)<(RIGHT(fnac,5));
END IF;
RETURN aux;
END//
delimiter ;

Deseo le sirva de provecho, y no olvide de hacer sus comentarios.

Ing. Tom Zambrano
"El hombre inteligente no es aquel que lo sabe todo, sino aquel que sabe aplicar lo poco que sabe"
Zilver sTone
"El poder del hombre no radica en su fuerza, sino en el poder de su palabra"

Crear una base de datos con PHP5

2011-10-31T07:17:00.000-04:30

En las versiones anteriores a PHP5 para crear o eliminar una Base de datos de mysql se usaban las funciones mysql_create_db() y mysql_drop_db() respectivamente. Actualmente con PHP5 ya no se usan, mas bien se emplea una consulta sql para tal propósito, como muestra a continuación:

<?php
$bd = "iuty";
$host = 'localhost';
$pass = 'root';
$user = '123456';

if(!($link = mysql_connect($host,$pass,$user))){
    echo "No se ha podido conectar al servidor";
}
else{
    //Elimina la base de datos
    $eliminar = mysql_query("DROP DATABASE IF EXISTS $bd",$link);

    //crea la base de datos
    $crear = mysql_query("CREATE DATABASE $bd",$link);

    //string sql para crear la tabla estudiante
    $sql = "CREATE TABLE estudiante (expediente INT not null primary key, nombre VARCHAR(35), fec_nac DATETIME no null);";

    //selecciona la base de datos
    mysql_select_db($bd,$link);

    //crea la tabla
    if(mysql_query($sql,$link)){
        echo "base de datos creada correctamente";
    }
    else {
        echo "No se ha podido crear la base de datos";
    }
}

?>

esperar pulsado de tecla en C

2011-09-30T13:44:00.000-04:30

Esto es una articulo que encontré ya hace un tiempo, en un lugar que no recuerdo, y que copio tal cual lo encontré, respetando y dando crédito a las personas involucradas en el mismo

esperar pulsado de tecla en C

Leonardo Mosquera
Tue, 11 Sep 2007 14:01:46 -0700

On 9/11/07, Andorogynus ! <[EMAIL PROTECTED]> wrote:
>
> Como puedo hacer en C para simular un INKEY$ (que viejo !)
> Es decir, efectuar una pausa hasta que el tipo presione una tecla.
>
> Probe con getchar() pero no me permite abortar (Ctrl-C) el programa.
>

A continuacion te adjunto una contribucion que hizo alguien a la lista de mi
universidad una vez. Podes recortar todo lo que no sea getch() y su soporte.
Tene en cuenta la licencia, o al menos no copies/pegues sino que
"inspirate".

Nota: tradicionalmente se usa ncurses para eso que queres hacer, pero yo
mismo ya conclui que ncurses es demasiado armatoste si simplemente queres
pausar el programa por la duracion de exactamente 1 tecla.


------------------------------------------------------------------------

/* +++++++++++  conio.h de Porland (versión trucha del Borland  :-)
+++++++++++
 *
 * Autor: Omar Murray (Crux_)             Versión: 0.0.2
 * Licencia: GPL                Fecha: 05/06/07
 *
 * Esto intenta ser una recopilación de las funciones más utilizadas en
 * la librería <conio.h> de Borland para poder generar código y compilar
 * utilizando gcc en GNU/Linux, y luego poder correrlo en un entorno
 * Borland sin necesidad de modificar el código escrito. Mayormente son
trozos
 * de código obtenido de inet y recopilados en una sola librería. La
idea es
 * utilizarlo para fines educativos; está en absoluto estado alfa, así
que su
 * uso queda a riesgo de quien lo utilice.
 *
 * CHANGELOG
 * v 0.0.1    Se implemente funciones getch() y clrscr().
 * v 0.0.2    se agrega función gotoxy(), se ordena código.*/

#include <stdio.h>
#include <termios.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>

//******************FUNCION GETCH****************************
int getch( ) {
 struct termios oldt,
                newt;
 int            ch;
 tcgetattr( STDIN_FILENO, &oldt );
 newt = oldt;
 newt.c_lflag &= ~( ICANON | ECHO );
 tcsetattr( STDIN_FILENO, TCSANOW, &newt );
 ch = getchar();
 tcsetattr( STDIN_FILENO, TCSANOW, &oldt );
 return ch;
}

//******************FUNCION CLRSCR*****************************
void clrscr( ) {
system("clear");
}

//**************** **FUNCION GOTOXY*****************************
int gotoxy(int x, int y) {
char essq[100]; // String variable to hold the escape sequence
char xstr[100]; // Strings to hold the x and y coordinates
char ystr[100]; // Escape sequences must be built with characters

//   ** Convert the screen coordinates to strings
sprintf(xstr, "%d", x);
sprintf(ystr, "%d", y);

//    ** Build the escape sequence (vertical move)
essq[0] = '\0';
strcat(essq, "\033[");
strcat(essq, ystr);

//     ** Described in man terminfo as vpa=\E[%p1%dd
//     ** Vertical position absolute
strcat(essq, "d");

//     ** Horizontal move
//     ** Horizontal position absolute
strcat(essq, "\033[");
strcat(essq, xstr);

//     // Described in man terminfo as hpa=\E[%p1%dG
strcat(essq, "G");

//      ** Execute the escape sequence
//      ** This will move the cursor to x, y
printf("%s", essq);
return 0;
}

OpenOffice Macro para Impress

2011-03-14T09:52:00.010-04:30

Saludos seguidores;

Hacia algún tiempo que no dejaba un post por acá.
Bueno resulta que en nuestro trabajo, CBIT-Yaracuy se presento una situación para el desarrollo de software educativo para las Canaima empleado Impress, de como introducir texto en una caja de texto y validar éste.

Indagando, buscando e investigando se logro dar con una solución empleando Macros de OpenOffice, acá la solución desarrollada:
Y este es el código Basic de las macros empleadas:

REM ***** BASIC *****
REM Codigo desarrollado por Ing. Tom Zambrano
REM el CBIT "Prof. Ferdinando Manto"
REM Marzo 2011
REM Se autoriza el empleo de este código, puede copiarlo, estudiarlo, modificarlo, distribuirlo
REM siempre y cuando de crédito de la autoría del mismo
Option Explicit

global oDoc As Object 'Para obtener la instancia del documento Impress
global oPre As Object 'Para obtener la instancia de la presentación
global oPreContr As Object 'Para obtener el los controles de la presentación
global oPagAct1 As Object 'Para obtener la instancia de la diapositiva donde esta la actividad
global oCajaTexto As Object 'Obtiene la instancia de la caja de texto

Sub Main

End Sub

Sub validar
obtenerAreaTrabajo
if (ucase(oCajaTexto.String)="ALGO") then
msgbox "muy bien"
oPreContr.gotoNextSlide() 'Va a la proxima diapositiva
oCajaTexto.String = "" 'para garantizar que la caja de texto quede vacia
else
msgbox "revisa tu respuesta"
oPreContr.gotoSlide(oPagAct1)
End IF
End Sub

Sub obtenerAreaTrabajo
oDoc = ThisComponent
oPagAct1 = oDoc.DrawPages.getByName("actividad1") 'Puede emplearse tambien
oCajaTexto = oPagAct1.getLinks().getByName("cajatexto")
oCajaTexto.CharHeight = 44
oPre = oDoc.Presentation
oPreContr = oPre.getController()
End Sub

Sub Tecla1
obtenerAreaTrabajo
oCajaTexto.String = oCajaTexto.String + "1"
oPreContr.gotoSlide(oPagAct1)
End Sub

Sub Tecla2
obtenerAreaTrabajo
oCajaTexto.String = oCajaTexto.String + "2"
oPreContr.gotoSlide(oPagAct1)
End Sub

Sub Tecla3
obtenerAreaTrabajo
oCajaTexto.String = oCajaTexto.String + "3"
oPreContr.gotoSlide(oPagAct1)
End Sub

Sub Tecla4
obtenerAreaTrabajo
oCajaTexto.String = oCajaTexto.String + "4"
oPreContr.gotoSlide(oPagAct1)
End Sub

Sub Tecla5
obtenerAreaTrabajo
oCajaTexto.String = oCajaTexto.String + "5"
oPreContr.gotoSlide(oPagAct1)
End Sub

Sub Tecla6
obtenerAreaTrabajo
oCajaTexto.String = oCajaTexto.String + "6"
oPreContr.gotoSlide(oPagAct1)
End Sub

Sub Tecla7
obtenerAreaTrabajo
oCajaTexto.String = oCajaTexto.String + "7"
oPreContr.gotoSlide(oPagAct1)
End Sub

Sub Tecla8
obtenerAreaTrabajo
oCajaTexto.String = oCajaTexto.String + "8"
oPreContr.gotoSlide(oPagAct1)
End Sub

Sub Tecla9
obtenerAreaTrabajo
oCajaTexto.String = oCajaTexto.String + "9"
oPreContr.gotoSlide(oPagAct1)
End Sub

Sub Tecla0
obtenerAreaTrabajo
oCajaTexto.String = oCajaTexto.String + "0"
oPreContr.gotoSlide(oPagAct1)
End Sub

Sub TeclaBorrar
Dim L As integer

obtenerAreaTrabajo

L = len(oCajaTexto.String)
if L>0 then
oCajaTexto.String = Left(oCajaTexto.String,L-1)
End If

oPreContr.gotoSlide(oPagAct1)
End Sub

Sub TeclaQ
obtenerAreaTrabajo
oCajaTexto.String = oCajaTexto.String + "Q"
oPreContr.gotoSlide(oPagAct1)
End Sub

Sub TeclaW
obtenerAreaTrabajo
oCajaTexto.String = oCajaTexto.String + "W"
oPreContr.gotoSlide(oPagAct1)
End Sub

Sub TeclaE
obtenerAreaTrabajo
oCajaTexto.String = oCajaTexto.String + "E"
oPreContr.gotoSlide(oPagAct1)
End Sub

Sub TeclaR
obtenerAreaTrabajo
oCajaTexto.String = oCajaTexto.String + "R"
oPreContr.gotoSlide(oPagAct1)
End Sub

Sub TeclaT
obtenerAreaTrabajo
oCajaTexto.String = oCajaTexto.String + "T"
oPreContr.gotoSlide(oPagAct1)
End Sub

Sub TeclaY
obtenerAreaTrabajo
oCajaTexto.String = oCajaTexto.String + "Y"
oPreContr.gotoSlide(oPagAct1)
End Sub

Sub TeclaU
obtenerAreaTrabajo
oCajaTexto.String = oCajaTexto.String + "U"
oPreContr.gotoSlide(oPagAct1)
End Sub

Sub TeclaI
obtenerAreaTrabajo
oCajaTexto.String = oCajaTexto.String + "I"
oPreContr.gotoSlide(oPagAct1)
End Sub

Sub TeclaO
obtenerAreaTrabajo
oCajaTexto.String = oCajaTexto.String + "O"
oPreContr.gotoSlide(oPagAct1)
End Sub

Sub TeclaP
obtenerAreaTrabajo
oCajaTexto.String = oCajaTexto.String + "P"
oPreContr.gotoSlide(oPagAct1)
End Sub

Sub TeclaA
obtenerAreaTrabajo
oCajaTexto.String = oCajaTexto.String + "A"
oPreContr.gotoSlide(oPagAct1)
End Sub

Sub TeclaS
obtenerAreaTrabajo
oCajaTexto.String = oCajaTexto.String + "S"
oPreContr.gotoSlide(oPagAct1)
End Sub

Sub TeclaD
obtenerAreaTrabajo
oCajaTexto.String = oCajaTexto.String + "D"
oPreContr.gotoSlide(oPagAct1)
End Sub

Sub TeclaF
obtenerAreaTrabajo
oCajaTexto.String = oCajaTexto.String + "F"
oPreContr.gotoSlide(oPagAct1)
End Sub

Sub TeclaG
obtenerAreaTrabajo
oCajaTexto.String = oCajaTexto.String + "G"
oPreContr.gotoSlide(oPagAct1)
End Sub

Sub TeclaH
obtenerAreaTrabajo
oCajaTexto.String = oCajaTexto.String + "H"
oPreContr.gotoSlide(oPagAct1)
End Sub

Sub TeclaJ
obtenerAreaTrabajo
oCajaTexto.String = oCajaTexto.String + "J"
oPreContr.gotoSlide(oPagAct1)
End Sub

Sub TeclaK
obtenerAreaTrabajo
oCajaTexto.String = oCajaTexto.String + "K"
oPreContr.gotoSlide(oPagAct1)
End Sub

Sub TeclaL
obtenerAreaTrabajo
oCajaTexto.String = oCajaTexto.String + "L"
oPreContr.gotoSlide(oPagAct1)
End Sub

Sub TeclaNtilde
obtenerAreaTrabajo
oCajaTexto.String = oCajaTexto.String + "Ñ"
oPreContr.gotoSlide(oPagAct1)
End Sub

Sub TeclaZ
obtenerAreaTrabajo
oCajaTexto.String = oCajaTexto.String + "Z"
oPreContr.gotoSlide(oPagAct1)
End Sub

Sub TeclaX
obtenerAreaTrabajo
oCajaTexto.String = oCajaTexto.String + "X"
oPreContr.gotoSlide(oPagAct1)
End Sub

Sub TeclaC
obtenerAreaTrabajo
oCajaTexto.String = oCajaTexto.String + "C"
oPreContr.gotoSlide(oPagAct1)
End Sub

Sub TeclaV
obtenerAreaTrabajo
oCajaTexto.String = oCajaTexto.String + "V"
oPreContr.gotoSlide(oPagAct1)
End Sub

Sub TeclaB
obtenerAreaTrabajo
oCajaTexto.String = oCajaTexto.String + "B"
oPreContr.gotoSlide(oPagAct1)
End Sub

Sub TeclaN
obtenerAreaTrabajo
oCajaTexto.String = oCajaTexto.String + "N"
oPreContr.gotoSlide(oPagAct1)
End Sub

Sub TeclaM
obtenerAreaTrabajo
oCajaTexto.String = oCajaTexto.String + "M"
oPreContr.gotoSlide(oPagAct1)
End Sub

Sub TeclaSpace
obtenerAreaTrabajo
oCajaTexto.String = oCajaTexto.String + " "
oPreContr.gotoSlide(oPagAct1)
End Sub

A cada objeto, se le asigna un nombre, sobe todo a la caja de texto, y en la interacción de los objetos se le asocia la macro correspondiente

Deseo que este código les sea de utilidad y de provecho, no duden en dar crédito de su desarrollo, porque el conocimiento es de todos y todos tenemos derecho a el.

No olvides en hacer tus comentarios

fondo verde

2011-02-04T11:22:00.001-04:30

Ing. Tom Zambrano

"El hombre inteligente no es aquel que lo sabe todo, sino aquel que sabe aplicar lo poco que sabe"
Zilver sTone

"El poder del hombre no radica en su fuerza, sino en el poder de su palabra"

Arreglo de Objetos. Un poco de ayuda

2010-07-22T11:59:00.002-04:30

Creación de Objetos
Creamos un objeto mediante la siguiente sintaxis:

Objeto a(arg1, arg2); //Creo un objeto Objeto, usando el contructor de argumentos arg1 y arg2
Objeto b; //Creo un objeto Objeto, usando el constructor sin parámetros

En ambos casos, se creo un objeto en memoria estática. Es decir, la memoria asignada para la función o método donde se creo el objeto. Una vez que la función finaliza, el objeto se destruye.

Para crear un objeto en memoria dinámica usamos:

Objeto* a = new Objeto(arg1, arg2);
Objeto* b = new Objeto;

Si queremos crear un arreglo de objetos en memoria dinámica usamos:

Objeto* c = new Objeto[20] //Creo un arreglo de 20 espacios de Objeto.

Cuando definimos un objeto en memoria dinámica, esta memoria queda tomada por el resto de la ejecución del programa hasta que nosotros llamemos al destructor por medio de:

delete a;
delete b;
delete [] c; //Si al crear el objeto usamos [] (Hicimos un arreglo) entonces delete // se debe llamar con []

Debemos tener en cuenta que la memoria estática se obtiene en el momento en que se compila el programa. La memoria dinámica se asigna durante la ejecución. Es decir, podemos pedir la medida justa de memoria de acuerdo a parámetros que se pueden obtener en tiempo de ejecución. A cambio de este beneficio, debemos preocuparnos de liberar la memoria que pedimos. Cada vez que hacemos un new, debemos preocuparnos de hacer delete después. Edemas, en los destructores de la clase debemos preocuparnos de hacer delete en la memoria que hayamos pedido con new dentro del objeto.

un ejemplo de como hacer lo anteriormente descrito

main()
{

... // Aquí deberían estar declaradas algunas o las variables que se necesitan

int dim; //Dimensión del arreglo de objetos

alumno *p; //Crea un puntero a objeto alumno, Se asume que la clase alumno esta implementada
alumno *aux; //Puntero auxiliar tipo alumno (Solo por ejemplo pero no es necesario)

cout << "Cuantos alumnos tiene la clase? ";
cin >> dim; //Para cuantos objetos hay que liberar memoria? // es de ejemplo
cout << "\n";

p = new alumno[dim]; //Asigna memoria dinámicamente

if (p==0) //Si p=0 no hay memoria suficiente
{
cout << "Error no hay suficiente memoria";
return 0; //Sale del programa
};

aux=p; //Asignación de un puntero a otro del mismo tipo

do //estructura do...while
{ //que mantiene en el ciclo principal
cout << " \n";

... // aqui debería estar el menu de opciones

cin >> opcion;

switch (opcion)
{
case 1: (p+numero_objeto) -> ingresar(); //operador flecha en vez de operador punto
numero_objeto++;
break;
case 2: cout <<"\n";
cout <<"Lista de Estudiantes inscritos \n";
for (i=0;i<numero_objeto;i++)
{
cout << "Estudiante numero " << i;
cout << ": ";
(aux+i) -> mostrar_nombre();
cout << "\n";
}
break;
case 3: cout << "Ingrese el número de lista del estudiante a examinar \n";
cin >> n;
cout << "Alumno: ";
(p+n) ->mostrar_nombre();
cout << "\n";
(p+n) -> reporte();
break;
default: return 0; //Sale del programa
}
} while (opcion !=4); //sale del programa

delete [] p; //libera la memoria asignada a *p
}

Ing. Tom Zambrano

"El hombre inteligente no es aquel que lo sabe todo, sino aquel que sabe aplicar lo poco que sabe"
Zilver sTone

"El poder del hombre no radica en su fuerza, sino en el poder de su palabra"

Get news, entertainment and everything you care about at Live.com. Check it out!

Cómo convertir un número de base decimal a otra y no morir en el intento con C

2010-07-20T11:12:00.000-04:30

Saludos seguidores;

Acá les dejo un sencillo programa realizado en c++ para convertir un numero de base decimal a base binaria, octal o hexadecimal, solo hay que especificar con que base se desea trabajar. Deseo les sirva de orientación y ayuda...

#include <iostream>
#include <string.h>
using namespace std;

void invertir(char origen[], char destino[]){
    int j = strlen(origen)-1;

    destino[j+1] = '\0'; //colocar el fin de cadena
    for(int i=j;i>=0;i--){
        //cout<<origen[i];
        destino[j-i] = origen[i];
    }
}

/**
* numero: número decimal a convertir
* base: la base del numero a la cual convertir (2: binaria, 8: octal, 16: hexadecimal
* c[]: el número convertido
**/

void dec2base(int numero, int base, char c[]){
    int resto = 0;
    int n = numero;
    int i = 0;
    char aux[100];

    if (base!=2 && base!=8 && base!=16){ //validar que la base sea valida
        cout << "base no valida debe ser 2,8 o 16"<<endl;
        return;
    }
    strcpy(c, "");
    if (n==0){
        strcpy(c,"0");
    } else {
        while (n>0){
            resto = n % base; //Obtiene el resto de la division entera
            if (resto<10){
                c[i] = '0'+resto; //el ASCII de 0 es 48 y así sucesivamente
            } else {
                c[i] = '7'+resto; //el ASCII de A es 65 y así sucesivamente
            }

            n = n / base;     //división entera y se actualiza el valor de n
            i++;
        }
        c[i] = '\0';   //se coloca el fin de la cadena
        invertir(c,aux); // se invierte la cadena
        strcpy(c,aux); // se asigna aux a c
    }

}

int main(){
    char s[100],d[100];
    dec2base(1024,16,d);
    cout<<d;
    return 0;
}

Get news, entertainment and everything you care about at Live.com. Check it out!

Ejercicios prácticos propuestos

2010-07-14T16:35:00.003-04:30

Saludos;

Acá les dejo seis ejercicios prácticos evaluados, de los cuales deben resolver sólo cuatro.

1. Diseña la clase Circulo representado por el radio r con dos método que calculan su perímetro y su área. Implemente la clase junto con sus métodos en una aplicación funcional para obtener dichos valores.

2. Diseñe un calculadora básica la cual tiene como atributos dos operadores x e y de tipo float y como métodos las operaciones matemáticas básicas; suma, resta, multiplicación y división. Implemente la clase junto con sus métodos en un programa funcional para obtener dichos resultados.

3. Desarrolle una clase Fecha representado por el atributo día, el cual es un dato de tipo long y es introducido en el formato AAAA-MM-DD, por ejemplo 31 de diciembre sería 20101231, implemente los métodos para determinar el número de días transcurridos desde el día 1 de enero de ese año, cuál es el día anterior, cuál es el día siguiente.

4. Realizar una aplicación para gestionar cierta información de los empleados de una empresa. El diseño de la aplicación estará formado por dos clases: la clase empleado y la clase empleadoPorHoras (que hereda de empleado), junto con un programa principal que llama a las operaciones públicas de ambas clases. La Clase empleado: contiene como datos privados el nombre del empleado y su número de CI. Además, sus métodos públicos son: un constructor de la clase, dos operaciones obtenedoras (GetNombre y GetCI), y una operación destructora de la clase. La Clase empleadoPorHoras: contiene como datos privados el costo por hora de un empleado y el número de horas trabajadas durante la semana. Además, dispone de los siguientes métodos públicos: un constructor de la clase (que requiere de su clase base el nombre y la CI del empleado) y una operación llamada DevuelvePago (que calcula el pago del empleado multiplicando su costo por hora por el número de horas trabajadas en la semana).

5. Crear una clase base abstracta Vehículo que contenga una función virtual para mostrar los atributos de un objeto en pantalla y dos clases derivadas que deberán concretar la clase anterior: vehiculo_de_tierra y vehiculo_de_aire. La clase base definirá dos atributos: costo y año del vehículo y dos funciones para obtener sus valores. Las clases derivadas vehiculo_de_tierra y vehiculo_de_aire contienen los atributos kilometraje y horas de vuelo respectivamente. Además deberán ofrecer funciones para obtener y establecer esos atributos. Escriba una aplicación funcional que cree objetos de las clases derivadas y un apuntador de clase base que haga uso de la función virtual que se ha concretado en cada una de las clases derivadas.

6. Dada una clase llamada Figuras que tiene dos atributos, identificador que es un arreglo de char de 25 caracteres y area de tipo float. La clase Figuras implementa dos métodos virtuales Calcular_Area(), e Identificar(). Defina dos clases derivadas; Rectangulo y Triangulo donde son redefinidos estos métodos y calculan los valores correspondientes. A continuación la implementación de la clase Figuras:
class Figuras{

protected:

char identificar[25];
float area;

public:
// Definiendo las funciones virtuales en la clase base
virtual void Calcular_Area();
virtual void Identificar();
};
// Cuando se definen las funciones no es necesario utilizar virtual
void Figuras::Calcular_Area(){
}
void Figuras::Identificar(){
cout << "Nombre Figura:" << identificar << endl; cout << "El Area es:" << area << endl;

}

Configurar el NetBeans IDE para C/C++ / Fortran

2010-06-25T08:18:00.003-04:30

Saludos estudiantes, seguidores y seguidoras;

Acá les dejo una guia tomada y traducida de la página de netbeans.org en la cual les explica como configurar el netbeans para C/C++ con MinGW.

Deseo realmente les sirva este material. Pues sin más preambulo aqui el enlace a la guia traducida:

http://www.scribd.com/doc/33457512/Configurar-El-NetBeans-IDE-Para-C-C-Fortran

Aprovechen al máximo y no olviden de dejar sus comentarios

Proyecto de Paradigma de Programación

2010-06-22T11:42:00.004-04:30

Saludos estimados estudiantes;

Acá les dejo el enlace al enunciado del Proyecto de Paradigma de programación

http://www.scribd.com/doc/33416800/Enunciado-Proyecto-Paradigma-Programacion

Así que desde ya a ponerle muchas ganas y empeño.

Por favor no olviden de dejar sus comentarios, éstos son importantes para el crecimiento de este blog, su blog!!!!

Curso de CPP

2010-06-18T12:31:00.003-04:30

Saludos estudiantes y seguidores. aca les dejo un enlace donde pueden bajar un curso de CPP
tomado de http://www.conclase.net
y elaborado por Salvador Pozo Coronado

aprovechenlo al máximo

http://www.slideshare.net/comodoro/mediatom-nissimcursocpp

http://www.scribd.com/doc/33242753/cursocp

Ejercicios prácticos propuestos

2010-06-12T09:17:00.000-04:30

Paradigmas de la Programación
Ing. Tom Zambrano
A continuación se proponen tres ejercicios, de los cuales debe resolver dos. Los mismos deben ser entregados en formato físico y digital. Valor diez (10) puntos.
1. Construya una clase llamada Rectángulo que tenga miembros de datos en número de precisión doble llamados largo y ancho. La clase deberá tener una función miembro llamada perimetro() y area() para calcular el perímetro y el área de un rectángulo, una función miembro llamada setDatos() para establecer el largo y el ancho de los rectángulos y una función miembro llamada getDatos() que despliega el largo, ancho, perímetro y área de un rectángulo, así como el constructor correspondiente. Incluya la clase en un programa C++ funcional.

2. Construya una clase llamada Tiempo que tenga miembro de datos en número entero llamados segundos, minutos y horas. Construya la sección de implementación de clase para el constructor y los miembros de la funciones setTiempo() y getTiempo() correspondientes a la declaración. Incluya la clase en un programa C++ funcional.

3. Agregue una función miembro a la definición de clase Fecha que determine el día de la semana para cualquier objeto fecha. Emplee un algoritmo que se ajuste a la necesidad. Incorpore la definición de clase en un programa C++ funcional. La función main() deberá desplegar el nombre del día de la semana (Sab, Dom, Lun, Mar, etc.) para el objeto fecha que se esté probando.

esperar pulsado de tecla en C

2010-06-04T06:56:00.004-04:30

Saludos seguidores;

éste es un artículo enviado por Leonardo Mosquera de una lista de correo de programación (Programacion@listas.fi.uba.ar) el cual se tomo textualmente y respetando los creditos, deseo les sirva de ayuda a ustedes programadores:

On 9/11/07, Andorogynus ! <[EMAIL PROTECTED]> wrote:
>
> Como puedo hacer en C para simular un INKEY$ (que viejo !)
> Es decir, efectuar una pausa hasta que el tipo presione una tecla.
>
> Probe con getchar() pero no me permite abortar (Ctrl-C) el programa.
>

A continuacion te adjunto una contribucion que hizo alguien a la lista de mi
universidad una vez. Podes recortar todo lo que no sea getch() y su soporte.
Tene en cuenta la licencia, o al menos no copies/pegues sino que
"inspirate".

Nota: tradicionalmente se usa ncurses para eso que queres hacer, pero yo
mismo ya conclui que ncurses es demasiado armatoste si simplemente queres
pausar el programa por la duracion de exactamente 1 tecla.

------------------------------------------------------------------------

/* +++++++++++ conio.h de Porland (versión trucha del Borland :-)
+++++++++++
*
* Autor: Omar Murray (Crux_) Versión: 0.0.2
* Licencia: GPL Fecha: 05/06/07
*
* Esto intenta ser una recopilación de las funciones más utilizadas en
* la librería de Borland para poder generar código y compilar
* utilizando gcc en GNU/Linux, y luego poder correrlo en un entorno
* Borland sin necesidad de modificar el código escrito. Mayormente son
trozos
* de código obtenido de inet y recopilados en una sola librería. La
idea es
* utilizarlo para fines educativos; está en absoluto estado alfa, así
que su
* uso queda a riesgo de quien lo utilice.
*
* CHANGELOG
* v 0.0.1 Se implemente funciones getch() y clrscr().
* v 0.0.2 se agrega función gotoxy(), se ordena código.*/

#include < stdio.h >
#include < termios.h >
#include < unistd.h >
#include < stdlib.h >
#include < string.h >

//******************FUNCION GETCH****************************
int getch( ) {
struct termios oldt,
newt;
int ch;
tcgetattr( STDIN_FILENO, &oldt );
newt = oldt;
newt.c_lflag &= ~( ICANON | ECHO );
tcsetattr( STDIN_FILENO, TCSANOW, &newt );
ch = getchar();
tcsetattr( STDIN_FILENO, TCSANOW, &oldt );
return ch;
}

//******************FUNCION CLRSCR*****************************
void clrscr( ) {
system("clear");
}

//**************** **FUNCION GOTOXY*****************************
int gotoxy(int x, int y) {
char essq[100]; // String variable to hold the escape sequence
char xstr[100]; // Strings to hold the x and y coordinates
char ystr[100]; // Escape sequences must be built with characters

// ** Convert the screen coordinates to strings
sprintf(xstr, "%d", x);
sprintf(ystr, "%d", y);

// ** Build the escape sequence (vertical move)
essq[0] = '\0';
strcat(essq, "\033[");
strcat(essq, ystr);

// ** Described in man terminfo as vpa=\E[%p1%dd
// ** Vertical position absolute
strcat(essq, "d");

// ** Horizontal move
// ** Horizontal position absolute
strcat(essq, "\033[");
strcat(essq, xstr);

// // Described in man terminfo as hpa=\E[%p1%dG
strcat(essq, "G");

// ** Execute the escape sequence
// ** This will move the cursor to x, y
printf("%s", essq);
return 0;
}

_______________________________________________
Lista de correo Programacion.
Programacion@listas.fi.uba.ar
http://listas.fi.uba.ar/mailman/listinfo/programacion

Cómo calcular el valor de una resistencia?

2010-05-12T10:29:00.002-04:30

Saludos amigos y seguidores;

me preguntaban unos estudiantes como calcular la resistencia según su codificación de colores, aca les dejo un sencillo programa de como se hace:

http://www.scribd.com/doc/31258442

Deseo les sirva de utilidad y que los pueda ayudar....

La solución esta a un click de distancia!!!

2010-04-09T10:42:00.002-04:30

saludos estimados estudiantes y seguidores;

Hacia tiempo no dejaba algún post, ya hasta me estaban preguntado el por qué?
pero bueno, la respuesta algunos la conocen!!!!

Sin emabargo, retomaremos este espacio nuevamente para crear un sitio de discución y de construcción de conocimiento

porque recuerden que la solución esta a un click de distancia

Codigo Fuente de Lista Simple Con Cabecera

2010-01-28T12:19:00.001-04:30

Tipo Lista Con Cabecera
/***********************************************************/
/* Ejemplo de programa para manejar una: */
/* LISTA SIMPLEMENTE ENLAZADA CON CABECERA, */
/* como Estructura de Datos Dinámica (con punteros). */
/* Incluye: Primitivas de la lista y programa de prueba. */
/* Todo en el mismo fichero. */
/***************************************/
#include
#include
#include

/*Declaración del tipo base de la lista*/
struct element {
long num;
};
/* Tipos de la lista: */
/* Tipo de cada celda de la lista */
struct celda{
struct element elem;
struct celda *sig;
};
/* Tipo lista: Puntero a celda */
typedef struct celda *lista;

/***************************************/
/* Inicializa una lista simplemente enlazada y CON cabecera. */
/* Devuelve -1 en caso de ERROR. */
int Inicializar_lista(lista *list){
if (((*list)=(struct celda *) malloc(sizeof(struct celda))) == NULL)
return -1;
(*list)->sig=NULL;
return 0;
}
/***************************************/
/*Devuelve TRUE si la lista está vacía.*/
int Lista_vacia(lista list){
if (list->sig) return 0;
return 1;
}
/***************************************/
/* Inserta el elemento e en la posición pos de la lista ant. */
/* Si pos<=1 inserta en la primera posición. */
/* Si pos>longitud_lista, inserta en la última posición. */
/* Devuelve -1 si no hay memoria suficiente para la inserción. */
int Insertar_pos (lista ant, struct element e, long pos){
lista p, L=ant->sig;
long i=1;
if ((p=(struct celda *) malloc(sizeof(struct celda))) == NULL)
return -1;
p->elem=e;
while (L && i
ant=L;
L=L->sig;
i++;
}
ant->sig=p; /* Insertar elemento apuntado por p, entre anterior y L */
p->sig=L;
return 0;
}
/***************************************/
/* Inserta el elemento e en la lista ant ordenadamente por */
/* el campo elem.num */
/* Devuelve -1 si no hay memoria suficiente para la inserción. */
int Insertar_orden (lista ant, struct element e){
lista p, L=ant->sig;
unsigned i=1;
if ((p=(struct celda *) malloc(sizeof(struct celda))) == NULL)
return -1;
p->elem=e;
while (L && e.num>L->elem.num){ /* Hallar posición en la que insertar */
ant=L;
L=L->sig;
i++;
}
ant->sig=p; /* Insertar elemento apuntado por p, entre anterior y L */
p->sig=L;
return 0;
}
/***************************************/
/* Borra el elemento en la posición pos de la lista ant. */
/* Si la pos=1 borra el primer elemento. */
/* Devuelve -1 si no existe la posición: */
/* pila vacía, pos<1>long */
int Borrar_elemento(lista ant, long pos){
lista aux, L=ant->sig;
long i=1;
if (Lista_vacia(ant) || pos<1)
return -1; /* Posición NO válida */
while (L && i
ant=L;
L=L->sig;
i++;
}
if (L){
/* Borrar elemento apuntado por L, teniendo un puntero al anterior */
ant->sig=L->sig;
free(L);
return 0;
}
return -1; /* La lista tiene menos de pos elementos */
}
/***************************************/
/* Devuelve la longitud de la lista list (núm. de elementos). */
long Long_lista(lista list){
long i=0;
list=list->sig;
while (list) {
list=list->sig;
i++;
}
return i;
}
/***************************************/
/* Vacía la lista totalmente, dejándola inicializada. */
/* Tras esta operación NO es necesario inicializarla. */
void Vaciar_lista(lista list){
while (Borrar_elemento (list,1) != -1);
}
/***************************************/
/* Destruye la lista totalmente, liberando toda la memoria. */
/* Tras esto ES necesario Inicializar la lista para reusarla. */
void Destruir_lista(lista *list){
Vaciar_lista(*list);
free(*list); /* Liberar la cabecera */
*list=NULL;
}
/***************************************/
/* Devuelve en e, el elemento que está en la posición pos */
/* de la lista list. */
/* Si no existe esa posición, devuelve -1. En otro caso 0. */
int Leer_element (lista list, long pos, struct element *e){
long i=1;
if (Lista_vacia(list) || pos<1)
return -1;
list=list->sig; /* Nos saltamos la cabecera */
while (list && i
list=list->sig;
i++;
}
if (list){
*e=list->elem;
return 0;
}
return -1;
}
/*************************************/
/* Devuelve la posición de la primera ocurrencia del elemento */
/* e en la lista list, a partir de la posición pos (inclusive).*/
/* Esta ocurrencia será considerada por el campo elem.num */
/* Devuelve 0 si no ha sido encontrada. */
/* Con esta función, cambiando pos, podremos encontrar TODAS */
/* las ocurrencias de un elemento en la lista. */
long Posic_lista(lista list, struct element e, long pos){
long i=1;
list=list->sig; /* Saltar cabecera */
while (list && i
list=list->sig;
i++;
}
if (!list) return 0; /* No existe posición pos, luego... */
while (list && e.num!=list->elem.num) { /* Intentar encontrar el
elemento */
list=list->sig;
i++;
}
if (!list) return 0; /* No encontrado */
return i; /* Encontrado en la posición i */
}
/***************************************/
/* Actualiza la posición pos de la lista list con el elemento e*/
/* Devuelve -1 si no existe esa posición. */
int Actualiza_lista(lista list, struct element e, long pos){
long i=1;
if (Lista_vacia(list) || pos<1)>
list=list->sig; /* Saltar cabecera */
while (list && i
list=list->sig;
i++;
}
if (!list) return -1; /* Posición no existe */
list->elem=e; /* Actualización */
return 0;
}
/* FIN de las PRIMITIVAS de la LISTA SIMPLEMENTE ENLAZADA CON CABECERA */
/***************************************/
/* Imprime un elemento e por la Salida estándar. */
void Imprimir_elemento (struct element e){
printf("%li",e.num);
}
/***************************************/
/* Muestra todos los elementos de la lista list por su orden. */
void mostrar_lista(lista list){
struct element e;
unsigned i=1,tama=Long_lista(list);
while (i<=tama) {
printf("\nElemento %u: ",i);
Leer_element(list,i++,&e);
Imprimir_elemento(e);
}
}
/***************************************/
/* Muestra un menu de opciones. */
void menu(void){
puts("\n\t\t***** MENU *****\n");
puts("\tS. Destruir lista y SALIR.");
puts("\t1. Inicializar lista.");
puts("\t2. Insertar por orden.");
puts("\t3. Insertar por posición.");
puts("\t4. Mostrar lista.");
puts("\t5. Borrar elemento.");
puts("\t6. Longitud lista");
puts("\t7. Ver si está vacía.");
puts("\t8. Ver elemento n-ésimo.");
puts("\t9. Posición de un elemento a partir de una dada.");
puts("\t0. Modificar un elemento en una posición.");
printf("\n\tOpcion: ");
}
/***************************************/
void main(){
lista list;
struct element e;
char opcion='x';
long pos;
Inicializar_lista(&list);

while (opcion!='S' && opcion!='s'){
menu();
opcion=getche();
switch (opcion) {
case 's':
case 'S':Destruir_lista(&list);
break;
case '1':Vaciar_lista(list);
break;
case '2':printf("\nDame número: ");
scanf("%li",&(e.num));
if (Insertar_orden(list,e))
puts("\n\aERROR: No existe memoria suficiente.");
break;
case '3':printf("\nDame número: ");
scanf("%li",&(e.num));
printf("\nDame la posición: ");
scanf("%li",&pos);
if (Insertar_pos(list,e,pos))
puts("\n\aERROR: No existe memoria suficiente.");
break;
case '4':printf("\n----------------");
mostrar_lista(list);
puts("\n----------------");
getch();
break;
case '5':printf("\nDame posición a borrar: ");
scanf("%li",&pos);
if (Borrar_elemento(list,pos))
puts("\n\aERROR: No existe esa posición.");
break;
case '6':printf("\n- Longitud: %u.",Long_lista(list));
break;
case '7':if (Lista_vacia(list))
puts("\n- Lista VACIA.");
else puts("\n- Lista NO VACIA.");
break;
case '8':printf("\nDame posición a leer: ");
scanf("%li",&pos);
if (Leer_element(list,pos,&e))
puts("\n\aERROR: No existe esa posición.");
else
printf("\n- Elemento %li: %li.\n",pos,e.num);
break;

case '9':printf("\nDame número para buscar su posición: ");
scanf("%li",&(e.num));
printf("\nDame la posición a partir de la que buscar: ");
scanf("%li",&pos);
if (!(pos=Posic_lista(list,e,pos)))
puts(
"\n\aERROR: No existe ese elemento a partir de esa posición.");
else
printf(
"\n-La primera posición encontrada de ese elemento es: %i",
pos);
break;
case '0':printf("\nDame número para actualizar: ");
scanf("%li",&(e.num));
printf("\nDame la posición a modificar: ");
scanf("%li",&pos);
if (Actualiza_lista(list,e,pos))
puts("\n\aERROR: No existe esa posición. No se ha
modificado.");
break;
}
}
puts("\n\t***** FIN *****");
}

Estructuras de Datos Dinámicas

2010-01-28T11:24:00.005-04:30

Son aquellas cuyo tamaño (longitud, número de elementos...) varía en tiempo de ejecución. Las más famosas son: Listas simplemente enlazadas (con y sin cabecera), Listas doblemente enlazadas (con y sin cabecera), Pilas, Colas, Árboles y Grafos.

Las Listas
Las listas son estructuras de datos que son dinámicas, esto significa que adquieren espacio y liberan espacio a medida que se necesita. sin embargo, hay una advertencia. Como regla general siempre hay que tener cuidado al manejar direcciones de espacios de memoria, porque es posible que accedamos a una localidad de memoria de la cual no deseabamos cambiar su contenido.

Las listas son estructuras de datos que son dinámicas, esto significa que adquieren espacio y liberan espacio a medida que se necesita. sin embargo, hay una advertencia. Como regla general siempre hay que tener cuidado al manejar direcciones de espacios de memoria, porque es posible que accedamos a una localidad de memoria de la cual no deseabamos cambiar su contenido.

Una lista es un conjunto de nodos que están relacionados. Cada nodo consta de dos partes:
- una donde se almacena la información,
- otra donde se guarda una referencia al siguiente nodo.

La creación de los nodos es dinámica, es decir, se crean nodos (por tanto se reserva memoria para ellos) según se van necesitando. Estos nodos finalmente estarán relacionados por un puntero que los enlaza. Ventaja: como creamos los nodos según los necesitamos, no necesitamos saber a priori la cantidad de datos que se van a manejar.

Sintaxis de un nodo:
Un nodo es una estructura donde se almacena la información y que además tiene una referencia al siguiente nodo:
struct nodo
{
struct nombre_estructura información;
struct nodo *siguiente;
}

Si cada nodo tiene sólo una referencia al nodo siguiente, se dice que la lista está enlazada de forma simple. Si cada nodo tiene dos referencias, una al nodo siguiente y otra al nodo anterior, se dice que la lista está doblemente enlazada.

/*Lista simple*/
está formado por nodos como el siguiente:
struct nodo_articulo
{
art info_articulo;
struct nodo_articulo *sig;
}

/*Lista doble*/
está formado por nodos como el siguiente:
struct nodo_articulo
{
art info_articulo;
struct nodo_articulo *sig;
struct nodo_articulo *ant;
}

Lista Simple

Lista doblemente enlazada

Además si el puntero del último elemento de la lista apunta al principio de la lista, se dice que la lista es circular. Cuando esto no ocurre, el puntero del último elemento de la lista debe tener el valor NULL. Este valor concreto representa que el puntero no está apuntando a ninguna dirección válida.

Lista Circular

Ejemplo: Supongamos que tenemos una aplicación para un registro de estudiantes. En este caso el ejemplo de nodo corresponde al estudiante que va a contener como subcampos la cédula, el nombre, el apellido, la edad y el. indice académico.

Definimos la estructura estudiante:
struct estudiante
{
long cedula;
char *nombre;
char *apellido;
int edad;
float ia;
}

/*Definición de nodo en una lista simple*/
struct nodo_estudiante
{
struct estudiante info;
struct nodo_estudiante *sig;
}

/*Definición de nodo en una lista doblemente enlazada*/
struct nodo_estudiante
{
struct estudiante info;
struct nodo_estudiante *sig;
struct nodo_estudiante *ant;
}

Es importante tener siempre un puntero que referencie el principio de la lista, ya que si se pierde esa referencia se pierde el contenido de toda la lista.

Ejemplo para probar

2010-01-24T11:12:00.000-04:30

#include
#include
void main() {
int a, *b;
b = (int *) malloc(sizeof(int)); /* Reserva Mm para UN entero */
if (b == NULL)
printf("No hay memoria suficiente.");
else {
a=5;
*b=6;
printf("Dirección de a: %p. Valor de a: %d\n",&a, a);
printf("Dirección b: %p. valor al que apunta: %d\n",b, *b);
free(b); /* Importante: Liberar la memoria */
}
}

Recursividad

2009-11-05T14:05:00.003-04:30

La recursividad es una técnica de programación importante. Se utiliza para realizar una llamada a una función desde la misma función.
Se puede decir que la recursividad es la forma en la cual se especifica un proceso basado en su propia definición. Siendo un poco más precisos, y para evitar el aparente círculo sin fin en esta definición:
Un problema que pueda ser definido en función de su tamaño, sea este N, pueda ser dividido en instancias más pequeñas (menores que N) del mismo problema y se conozca la solución explícita a las instancias más simples, lo que se conoce como casos base ( o lo que llamo criterio de parada), se puede aplicar inducción sobre las llamadas más pequeñas y suponer que estas quedan resueltas.
La recursividad es un concepto importante en informática. Muchos algoritmos se pueden describir mejor en términos de recursividad.
Supongamos que P es un procedimiento que contiene una sentencia de Llamada a si mismo o una sentencia de Llamada a un segundo procedimiento que puede eventualmente llamar de vuelta al procedimiento original P. Entonces P se dice que es un procedimiento recursivo. Como el programa no ha de continuar ejecutandose indefinidamente, un procedimiento recursivo ha de tener las dos siguientes propiedades:

Debe existir un cierto criterio, llamado criterio base, por el que el procedimiento no se llama así mismo.
Cada vez que el procedimiento se llame a si mismo(directa o indirectamente), debe estar mas cerca del criterio base.

Un procedimiento recursivo con estas dos propiedades se dice que esta bien definido.

Análogamente, una función se dice que esta definida recursivamente si la definición de la función se refiere a si misma. De nuevo, para que la definición no sea circular, debe tener las dos siguientes propiedades:

Debe haber ciertos argumentos, llamados valores base, para los que la función no se refiera a si misma.
Cada vez que la función se refiera a si misma, el argumento de la función debe acercarse más al valor base.

Una función recursiva con estas dos propiedades se dice también que esta bien definida.

Tipos.

Podemos distinguir dos tipos de recursividad:
Directa: Cuando un subprograma se llama a si mismo una o mas veces directamente.
Indirecta: Cuando se definen una serie de subprogramas usándose unos a otros.

Características.

Un algoritmo recursivo consta de una parte recursiva, otra iterativa o no recursiva y una condición de terminación. La parte recursiva y la condición de terminación siempre existen. En cambio la parte no recursiva puede coincidir con la condición de terminación. Algo muy importante a tener en cuenta cuando se use la recursividad es que es necesario asegurarnos que llega un momento en que no hacemos más llamadas recursivas. Si no se cumple esta condición el programa no parará nunca.

Ventajas e inconvenientes

La principal ventaja es la simplicidad de comprensión y su gran potencia, favoreciendo la resolución de problemas de manera natural, sencilla y elegante; y facilidad para comprobar y convencerse de que la solución del problema es correcta.

El inconveniente es la ineficiencia tanto en tiempo como en memoria, dado que para permitir su uso es necesario transformar el programa recursivo en otro iterativo, que utiliza bucles y pilas para almacenar las variables.

Ejemplos

function factorial(n : integer): longint;
begin
if n=0 then factorial := 1 (** Criterio base o condici¢n de parada **)
else factorial := n*factorial(n-1); (** simplificaci¢n del problema **)
end;

/*Máximo comun divisor */

function MCD(m,n : integer): integer;
begin
if (m mod n)=0 then MCD := n (* Criterio base o condici¢n de parada **)
else MCD := MCD(n, m mod n); (** simplificaci¢n del problema **)
end;

Ejercicios de recuperación

2009-11-04T10:33:00.002-04:30

Para aquellos estudiantes que vienen con baja nota y desean recuperar, les propongo desarrollar uno y sólo uno de los dos ejercicios propuestos en la entrada anterior, especificamente el número 13 y el número 16, ustedes deciden cual hacer.

La entrega es estrictamente individual.
Debe ser entregado impreso o a mano y documentado.
Debe ser entregado para el dia 30/11/2009.

Ejercicios sobre cadenas (string) turbo pascal

2009-10-28T11:16:00.009-04:30

Saludos acá les dejo varios ejercicios tipo examen para que los desarrollen, practiquen y tomen fortalezas, adelante muchachos les invito a que los hagan todos y cada uno de ellos

Desarrolle una función que devuelva una cadena con un caracter repetido n veces.
Implemente una función que elimine los caracteres en blanco a la izquierda de una cadena y retorne esta sin los espacios en blanco a la izquierda.
Realice una función que elimine los caracteres en blanco a la derecha de una cadena y retorne ésta sin los blancos a la derecha.
Escriba una función que determine si una cadena esta vacia o no.
Desarrolle una función que elimine los espacios en blanco a ambos extremos de la cadena.
Implemente una función que devuelva una cadena invertida.
Un palíndromo es una palabra que se lee igual hacia adelante que hacia atras. Desarrolle una función que determine si una palabra es palíndrome o no.
Un número capicúo se refiere a cualquier número que se lee igual de izquierda a derecha y de derecha a izquierda. Escriba una función que determine si un número es capicúo o no.
Escriba una función que determine la cantidad de minusculas en una cadena.
Escriba una función que determine la cantidad de mayusculas en una cadena.
Desarrolle una función que calcule la cantidad de veces que se repite un caracter dado en una cadena.
Escriba una función que remplace un caracter por otro en una cadena.
desarrolle una función que lea caracter a caracter, mostrandolo por pantalla, mediante el teclado y que valide que el caracter pertenezca a un conjunto valido de caracteres devolviendo la cadena resultante.
Realice una función que compare dos cadenas y que devuelva 0 si cad1 es mayor que cad2, 1 si cad1 es igaul a cad2, y 2 si cad1 es mayor que cad2.
Desarrolle una función que devuelva una cadena en minusculas.
Elabore el conjunto de funciones necesarias para convertir de una base númerica a otra base. Es decir, decimal a binario, decimal a octal, decimal a hexadecimal, octal a binario, octal a hexadecimal, octal a decimal, hexadecimal a binario, hexadecimal a octal, hexadecimal a decimal, binario a decimal, binario a octal y binario a hexadecimal.

Si los desarrollan les aseguro que saldran bien..., les sugiero hacer el algoritmo primero y luego la implemtación

STRING (Cadena de caracteres)

2009-10-27T10:32:00.006-04:30

El tipo de datos STRING guarda información de texto. Una variable STRING puede tener de 1 a 255 caracteres de longitud, aunque ocupa un byte más que su longitud definida.

Por ejemplo, si se declara una variable STRING de 10 caracteres de longitud (cad:string[10];) la variable ocupa 11 bytes de memoria. Esto se debe a que el primer byte (byte de longitud) de cada variable STRING guarda la longitud de la cadena que en ese momento está contenida en la variable.

Si una variable STRING de 10 caracteres contiene la palabra "hola" el primer byte de memoria tendra el valor binario 4, indicando que la variable contiene cuatro caracteres. En ese caso, los últimos seis caracters de la variable son ignorados por los procedimientos de manipulación de cadenas de turbo pascal.

0 1 2 3 4 5 6 7 8 9 10
4 h o l a } # - X ¬ %

(00000100)Observe que el primer byte (el byte 0) no es el caracter "4", sino el número 4 en binario y que los últimos seis bytes contienen datos aleatorios.

Veamos algunos ejemplos visto en clases con manipulación de cadenas:

(* Funcion que devuelve la posición de un caracter en la cadena especificada *)
function poscar(cadena : string; cual : char) : byte;
var
pos, (* para devolver la posición de la cadena *)
i : byte; (* para recorrer cada caracter de la cadena *)
encontrado : boolean; (* para determinar si encontro el caracter buscado *)
begin
pos := 0;
encontrado := false;
i := 1;
(* ord(cadena[0]) devuelve la longitud de la cadena *)
while (not encontrado) and (i<ord(cadena[0])) do
begin
if (cadena[i]<>cual)
then begin
pos := i;
encontrado := true;
end
else i := i + 1;
end;
poscar := pos; (* retorna el valor de la funcion *)
end;

(* Funcion que cuenta cuantas veces se repite un caracter en una cadena*)
function contarcar(cadena : string; cual : char) : byte;
var
contador, (* para contar el caracter *)
i : byte; (* para recorrer cada caracter de la cadena *)
begin
contador := 0;
(* ord(cadena[0]) devuelve la longitud de la cadena *)
for i := 1 to ord(cadena[0]) do
begin
if (cadena[i]=cual)
then contador := contador + 1
else (* nada que hacer*);
end;
contarcar := contador; (* retorna el valor de la funcion *)
end;

Función Length

Para conocer la longitud de una cadena utilizamos la función Length, la longitud es la cantidad de caracteres que contiene la cadena en un momento determinado.

Su sintaxis es: Length (cadena);

La función regresa un valor entero.

Función Concat

La función concat produce los mismos resultados que la concatenación, es posible incluir cualquier número de cadenas que se necesiten concatenar.

La suma de las cadenas no deberá sobrepasar la longitud que la variable, a la cual se asignará dicha suma, puede manejar. Ejemplo:

Cadena := Concat (Cad1, cad2, cad3);

Función Pos

La función Pos nos sirve para localizar una determinada cadena dentro de otra, en otras palabras para verificar si una cadena es subcadena de otra segunda.

Los parámetros que requiere son: la cadena que se buscará y la cadena donde se buscará la primera:

Pos (Cadena1, Cadena2);

Ejemplo:
Cadena := 'Domingo Lunes Martes Miercoles Jueves Viernes Sabado';
WriteLn(Cadena);
WriteLn(Pos('Lunes', Cadena)); {Muestra 9}
WriteLn(Pos('Jueves', Cadena)); {Muestra 32}
WriteLn(Pos('Ayer', Cadena)); {Muestra 0}

Función Copy

La función copy regresa una subcadena de una variable o constante dada como parámetro. Su sintaxis es:

Copy (Cadena, Inicio, Cantidad);

Donde Cadena es la fuente de la subcadena, Inicio es la posición desde la cual se obtendrá la subcadena y Cantidad es el número de caracteres que se extraerán.

Los valores de Inicio y Cantidad deben ser de tipo entero.

Ejemplo:
Cadena := "Nuevos horizontes";
WriteLn (Copy(Cadena, 8, 10)); {Visualiza: horizontes}

Fución Insert

El procedimiento Insert sirve para insertar una cadena dentro de otra en alguna posición determinada. Sintaxis:

Insert (Cadena1, Cadena2, Posición)

Donde Cadena1 es la que se insertará, Cadena2 es donde se insertará y Posición es el lugar donde se insertará. El parámetro Posición debe ser de tipo entero.

Procedimiento Delete

Este procedimiento elimina un determinado número de caracteres de una cadena. Su sintaxis es:

Delete (Cadena, Inicio, Número)

Cadena es la variable en la cual se eliminarán los caracteres, Inicio es la posición del primer caracter a eliminar y Número es la cantidad de caracteres que se borrarán.

Fución UpCase

La función UpCase regresa la letra mayuscula correspondiente al caracter dado como parámetro. Es muy común trabajando con cadenas que se quiera convertir una que contiene un número a su valor numérico, para poder utilizarlo en operaciones matemáticas, así como convertir un número a su equivalente en una cadena.

Procedimiento Str

El procedimiento Str obtiene una cadena a partir de un valor numérico. Su sintaxis es:

Str(Valor, Cadena)

Donde valor es el número a convertir y Cadena es la variable donde se almacenará la cadena ya convertida.

Procedimiento Val

Este procedimiento convierte una cadena en un valor de tipo numérico, el problema con esta función es que si la cadena no esta formada exclusivamente de números siguiendo las reglas para el tipo de datos que se vallan a obtener se generará un error. Sintaxis:

Val (Cad, Num, Código)

Cadena contiene la cadena que será procesada, Num es la variable de tipo numérico donde se guardará el valor de la cadena y Código es una variable de tipo entero (Integer) que contendrá el valor de 0 si no hubo errores y un valor diferente en caso de que no se haya podido convertir la cadena, el valor de Código representa la posición de la cadena donde ocurrio el error.

Archivos

2009-10-14T11:01:00.000-04:30

Muchas de las aplicaciones que ustedes han programado se hicieron usando la memoria principal o memoria RAM como único medio de almacenamiento (usando variables, arreglos, registros o estructuras de datos mas complejas, las recuerdan ¿verdad?) , con los problemas que esto representa: la volatilidad de la memoria RAM; es decir, si se apaga la computadora se pierden los datos. De ahí surge la necesidad de almacenar dichos datos de forma permanente que permita retenerlos en ciertos dispositivos de almacenamiento secundario por un período de tiempo largo sin necesidad de suministrarles energía, de tal forma que permitan transportarlos y utilizarlos en otro equipo.

El procesamiento que realiza una computadora es tarea absoluta del microprocesador en conjunción con la memoria principal; es decir, los dispositivos de almacenamiento secundario (diskettes, discos duros, CDs, flash drives, etc.) no procesan datos, sólo los almacenan.

Esto repercute de manera significativa al momento de programar archivos, ya que para hacerle modificaciones a los datos de un registro previamente almacenado es necesario primero “cargarlo” en la memoria principal, es decir, localizar el registro en el archivo y leerlo para colocar sus datos en la memoria RAM, ahí modificarlo y posteriormente grabarlo en la misma posición en la que se encontraba.

Recordemos algunas definiciones vistas en clases:

Campo: características de ciertos objetos de estudio o condiciones particulares de situaciones dadas. Por ejemplo un producto tiene los siguientes campos: codigo, marca, peso, presentación, fecha de elaboración y fecha de vencimiento. Cada campo es definido por un tipo de dato.
Registro: una combinación de otros tipos de datos en un nuevo tipo de datos. Se puede decir además que es el conjunto completo de datos relacionados pertenecientes a una entrada.

sigamos recordando
Type
Tipo_registro = Record
no_prod : integer;
descrip : string[30];
cantidad: integer;
precio : real;
garantia: char;
End;

Var
Registro : Tipo_registro;

Así pues tenemos que un archivo en términos informáticos es una colección de datos que tiene un nombre y se guardan en dispositivos de almacenamiento secundario, los cuales pueden ser magnéticos, ópticos, electrónicos, etc. P. ejem. Diskettes, discos duros, CD´s, ZIP drives, flash drives, memory sticks, entre otros.

Clasificación por tipo de contenido:
Existen muchas clasificaciones de archivos de acuerdo a diferentes criterios o aplicaciones. Aquí se presenta una muy importante: de acuerdo al contenido de Texto y Binario.

Archivos de texto : Son aquellos que pueden contener cualquier clase de datos y de tal maneraque son “entendibles” por la gente. Los datos en un archivo de texto se almacenan usando el código ASCII, en el cual cada carácter es representado por un simple byte. Debido a que los archivos de texto utilizan el código ASCII, se pueden desplegar o imprimir. En este tipo de archivos, todos sus datos se almacenan como cadenas de caracteres, es decir, los números se almacenan con su representación ASCII y no su representación numérica.

Archivos binarios: En este tipo de archivos también se pueden almacenar diferentes tipos de datos incluyendo datos numéricos; sin embargo, cabe destacar que los datos numéricos se graban con su representación binaria (no con su representación ASCII), por tal razón, cuando se despliegan con un editor de textos o por medio de comandos del sistema operativo, aparecen caracteres raros que no se interpretan.

Clasificacion por tipo de acceso:

Archivos secuenciales: Como su nombre lo indica, en este tipo de archivos los registros se graban en secuencia o consecutivamente y deben accesarse de ese mismo modo, es decir, conforme se van insertando nuevos registros, éstos se almacenan al final del último registro almacenado; por lo tanto, cuando se desea consultar un registro almacenado es necesario recorrer completamente el archivo leyendo cada registro y comparándolo con el que se busca. En este tipo de archivo se utiliza una marca invisible que el sistema operativo coloca al final de los archivos: EOF (End of File), la cual sirve para identificar dónde termina el archivo.

Archivos directos : A diferencia de los archivos secuenciales, en los archivos directos no esnecesario recorrerlo completamente para acceder un registro en particular, sino se puede colocar el apuntador interno del archivo directamente en el registro deseado, permitiendo con esto mayor rapidez de acceso. Cabe destacar que para reposicionar este apuntador se utiliza el comando SEEK indicándole la dirección del registro que se desea.

Enlace de ínteres:
Manejo de archivos es pascal

Sesión de nivelación

2009-10-09T12:08:00.000-04:30

Saludos chicos;

Para los dias Lunes 19, Lunes 26 de octubre y Lunes 02 de noviembre luego de nuestra sesión de clases normal, se haran unas sesiones para nivelar sus conocimientos en algoritmica.

En este sentido les extiendo la invitación a participar en estas actividades y asi reforzar sus conocimientos, aclarar dudas y practicar un poco más.

Así que apunten sus comentarios y opiniones para esta idea.

NOTA: envien por correo la practica sobre arreglo de registros de la torrefactora, recuerden que deben indetificarla con sus nombre y apellidos, así como con número de expediente y cédula. deben hacerlo antes del día 12 de octubre del 2009.
mi correo es: tomzambrano@gmail.com

Atte Tom Zambrano

"El hombre inteligente no es aquel que lo sabe todo, sino aquel que sabe aplicar lo poco que sabe"

Zilver sTone