viernes, 30 de mayo de 2014
jueves, 29 de mayo de 2014
miércoles, 28 de mayo de 2014
proyectos del programa visual studio 28 de mayo de 2014
creacion de un saludo
Public
Class Form1
Private Sub Button1_Click ( ByVal
Remitente Como. . Sistema de objetos ,
ByVal e Como
Sistema. EventArgs ) Maneja
Button1.Click
TextBox1.Text = "buenos dias"
End Sub
Private Sub Button2_Click ( ByVal
Remitente Como. . Sistema de objetos ,
ByVal e Como Sistema. EventArgs ) Maneja
Button2.Click
TextBox1.Text = ""
End Sub
Private Sub Button3_Click ( ByVal
Remitente Como. . Sistema de objetos ,
ByVal e Como
Sistema. EventArgs ) Maneja
Button3.Click
Final
End Sub
End Class
Numeros Creacion De Una Suma de DOS
Public
Class Form1
Private Sub Button1_Click ( ByVal
Remitente Como. . Sistema de objetos ,
ByVal e Como
Sistema. EventArgs ) Maneja
Button1.Click
Dim a, b Como Entero
A = TextBox1.Text
b = TextBox2.Text
TextBox3.Text = a + b
End Sub
Private Sub Button2_Click ( ByVal
Remitente Como. . Sistema de objetos ,
ByVal e Como
Sistema. EventArgs ) Maneja
Button2.Click
TextBox1.Text = ""
TextBox2.Text = ""
TextBox3.Text = ""
End Sub
Private Sub Button3_Click ( ByVal
Remitente Como. . Sistema de objetos ,
ByVal e Como
Sistema. EventArgs ) Maneja
Button3.Click
Final
End Sub
End Class
martes, 20 de mayo de 2014
RESULTADO DE APRENDIZAJE 2.2
Resultado de aprendizaje 2.2 MATP
Elabora rutinas en pseudocodigo con base en clases y herencia para su aplicacion en lenguajes de programacion y ortientada a objetos.
a) IDENTIFICACION DE ELEMENTOS DE PROGRAMACION ORIENTADA A OBJETOS
-Concepto
-caracteristicas
-abstraccion
-ocultacion
-palifornisma
-herencia
-encapsulamente
-leguajes
b) PROGRAMACION ORIENTADA OBJETOS
-objeto
-clase
-aplicacion de rutinas en pseudocodigo
-herencia
RUBRICA 2.2
Indicador Porcentaje
-Desarrollo del programa 45%
-propuesta de solucion 35%
-Presentacion de resultados 10%
-Actitudes 10%
Elabora rutinas en pseudocodigo con base en clases y herencia para su aplicacion en lenguajes de programacion y ortientada a objetos.
a) IDENTIFICACION DE ELEMENTOS DE PROGRAMACION ORIENTADA A OBJETOS
-Concepto
-caracteristicas
-abstraccion
-ocultacion
-palifornisma
-herencia
-encapsulamente
-leguajes
- -visualbasic
- -VB.net
- -C#
- -c++
- -java
b) PROGRAMACION ORIENTADA OBJETOS
-objeto
-clase
-aplicacion de rutinas en pseudocodigo
-herencia
RUBRICA 2.2
Indicador Porcentaje
-Desarrollo del programa 45%
-propuesta de solucion 35%
-Presentacion de resultados 10%
-Actitudes 10%
viernes, 16 de mayo de 2014
PROGRAMAS 16/05/14
PROGRAMA QUE MUETRA LOS PAGOS QUE RECIBIRAUN TRABAJADOR
#include<stdio.h>
#include<conio.h>
void main()
{
int salir,saliryesno;
salir=0;
while(salir==0){
clrscr();/*Llamando la funcion limpiar pantalla.*/
printf("\n\t\tHORARIO\t\t\t PAGO\n\n");
printf("\t
8:00 AM - 4:00 PM\t\tPAGO BASE\n");
printf("\t
4:00 PM - 8:00 PM\t\t 25 POR CIENTO EXTRA\n");
printf("\t
8:00 PM - 12:00 AM\t 50 POR CIENTO EXTRA\n");
printf("\t
12:00 AM - 8:00 AM\t\t PAGO DOBLE\n\n");
int
horas_trab,horas_trab25,horas_trab50,horas_doble;
float
pago_base,pago_extra25,pago_extra50,pago_doble,suma_base,pago,sueldo_total,pago_extra,suma_extra;
printf(" SUELDO BASE POR HORA TRABAJADA: ");
scanf("%f",&pago);
printf("\nNumerode horas trabajadas de 8:00 am a4:00
pm: ");
scanf("%d",&horas_trab);
pago_base=(horas_trab*pago);
printf("Numero de horas trabajadas de 4:00 pm a 8:00
pm: ");
scanf("%d",&horas_trab25);
pago_extra25=(horas_trab25*(1.25)*pago);
printf("Numero de horas trabajadas de 8:00 pm a 12:00
pm: ");
scanf("%d",&horas_trab50);
pago_extra50=(horas_trab50*(1.50)*pago);
printf("Numero de horas trabajadas de 12:00 am a 8:00 am: ");
scanf("%d",&horas_doble);
pago_doble=(horas_doble*(2.0)*pago);
suma_base=pago*horas_trab;
suma_extra=(pago_extra25+pago_extra50+pago_doble);
sueldo_total=suma_extra+pago_base;
printf("\nEL PAGO TOTAL QUE RECIBIRA EL
TRABAJADOR:$%.2f\n\n",sueldo_total);
printf("EL SALARIO DEL TRABAJADOR POR HORAS DE OFICINA
ES:$%.2f\n",suma_base);
printf("EL SALARIO DEL TRABAJADOR POR HORAS EXTRAX
ES:$%.2f\n",suma_extra);
if(suma_extra>suma_base)
{
printf("\nEL TRABAJADOR GANO MAS DINERO POR HORAS
EXTRAS QUE POR HORAS DE OFICINA\n\n");
}
else
{
if(suma_extra==suma_base)
{
printf("EL TRABAJADOR GANO EL MISMO SALIRIO POR HORAS
EXTRAS QUE POR HORAS DE OFICINA\n\n");
}
else{/*pago_base es mayor que sume_extra*/
printf("EL TRABAJADOR GANO MAS DINERO POR HORAS DE
OFICINA QUE POR HORAS EXTRAS\n\n");
}
}
printf("SE DESEA SALIR PRESIONE 1 O DE LO CONTRARIO
PRESIONE OTRO NUMERO: ");
scanf("%d",&saliryesno);
if(saliryesno==1){
salir=1;
}
}
}
PROGRAMA QUE IRA PREGUNTANDO LA CANTIDAD DE BILETES
#include"stdio.h"
#include<conio.h>
void main()
{
int salir,saliryesno;
salir=0;
while(salir==0){
int cambiarmoneda;
float
total_bill1,total_bill5,total_bill10,total_bill20,total_bill50,total_bill100,total_cent1,total_cent5,total_cent10,total_cent25,total_bill,total_cent,total_dinero,quetzal,lempira,euro;
printf("\nCantidad de billetes de un dolar: ");
scanf("%f",&total_bill1);
printf("\nCantidad debilletes cinco dolares: ");
scanf("%f",&total_bill5);
printf("\nCantidad debilletes de dies dolares: ");
scanf("%f",&total_bill10);
printf("\nCantidad debilletes veinte dolares: ");
scanf("%f",&total_bill20);
printf("\nCantidad debilletes cincuenta dolares: ");
scanf("%f",&total_bill50);
printf("\nCantidad debilletes cien dolares: ");
scanf("%f",&total_bill100);
total_bill=(total_bill1*(1)+total_bill5*(5)+total_bill10*(10)+total_bill20*(20)+total_bill50*(50)+total_bill100*(100));
printf("\nCantidad monedas de un centavo: ");
scanf("%f",&total_cent1);
printf("\nCantidad monedas de cinco centavos: ");
scanf("%f",&total_cent5);
printf("\nCantidad monedas de diez centavos: ");
scanf("%f",&total_cent10);
printf("\nCantidad monedas de veinticinco centavos: ");
scanf("%f",&total_cent25);
total_cent=(total_cent1*(0.01)+total_cent5*(0.05)+total_cent10*(0.10)+total_cent25*(0.25));
printf("\nLA CANTIDAD DE DINERO QUE HAY EN BILLETES ES:$%.2f\n",total_bill);
printf("\nLA CANTIDAD DE DINERO QUE HAY EN MONEDAS ES:$%.2f\n",total_cent);
total_dinero=(total_bill+total_cent);
printf("LA CANTIDAD TOTAL DE DINERO QUE HAY ES:$%.2f\n\n",total_dinero);
printf("\t\tMONEDA\t\tCODIGO\n");
printf("\t\tQUETZAL\t\t 1\n");
printf("\t\tLEMPIRA\t\t 2\n");
printf("\t\tEURO\t\t 3\n\n");
printf("introdusca el codigo de la moneda a la que desea convertir los $%.2f:",total_dinero);
scanf("%d",&cambiarmoneda);
quetzal=total_dinero*7.95270;
lempira=total_dinero*19.71674;
euro=total_dinero*0.82396;
if(cambiarmoneda==1){
printf("\n$%.2f EQUIVALE A %.2f QUETZALES\n\n",total_dinero,quetzal);
printf("SI DESEAS SALIR PRESIONE 1 O DE LO CONTRARIO PRECIONE OTRO NUMERO: ");
scanf("%d",&saliryesno);
if(saliryesno==1){
salir=1;
}
}
else{
if(cambiarmoneda==2){
printf("\n$%.2f EQUIVALE A %.2f LEMPIRAS\n\n",total_dinero,lempira);
printf("SI DESEAS SALIR PRESIONE 1 O DE LO CONTRARIO PRECIONE OTRO NUMERO: ");
scanf("%d",&saliryesno);
if(saliryesno==1){
salir=1;
}
}
else{/*cambiarmoneda==3*/
printf("\n$%.2f EQUIVALE A %.2f EUROS\n\n",total_dinero,euro);
printf("SI DESEAS SALIR PRESIONE 1 O DE LO CONTRARIO PRECIONE OTRO NUMERO: ");
scanf("%d",&saliryesno);
if(saliryesno==1){
salir=1;
}
}
}
}
}
#include<conio.h>
void main()
{
int salir,saliryesno;
salir=0;
while(salir==0){
int cambiarmoneda;
float
total_bill1,total_bill5,total_bill10,total_bill20,total_bill50,total_bill100,total_cent1,total_cent5,total_cent10,total_cent25,total_bill,total_cent,total_dinero,quetzal,lempira,euro;
printf("\nCantidad de billetes de un dolar: ");
scanf("%f",&total_bill1);
printf("\nCantidad debilletes cinco dolares: ");
scanf("%f",&total_bill5);
printf("\nCantidad debilletes de dies dolares: ");
scanf("%f",&total_bill10);
printf("\nCantidad debilletes veinte dolares: ");
scanf("%f",&total_bill20);
printf("\nCantidad debilletes cincuenta dolares: ");
scanf("%f",&total_bill50);
printf("\nCantidad debilletes cien dolares: ");
scanf("%f",&total_bill100);
total_bill=(total_bill1*(1)+total_bill5*(5)+total_bill10*(10)+total_bill20*(20)+total_bill50*(50)+total_bill100*(100));
printf("\nCantidad monedas de un centavo: ");
scanf("%f",&total_cent1);
printf("\nCantidad monedas de cinco centavos: ");
scanf("%f",&total_cent5);
printf("\nCantidad monedas de diez centavos: ");
scanf("%f",&total_cent10);
printf("\nCantidad monedas de veinticinco centavos: ");
scanf("%f",&total_cent25);
total_cent=(total_cent1*(0.01)+total_cent5*(0.05)+total_cent10*(0.10)+total_cent25*(0.25));
printf("\nLA CANTIDAD DE DINERO QUE HAY EN BILLETES ES:$%.2f\n",total_bill);
printf("\nLA CANTIDAD DE DINERO QUE HAY EN MONEDAS ES:$%.2f\n",total_cent);
total_dinero=(total_bill+total_cent);
printf("LA CANTIDAD TOTAL DE DINERO QUE HAY ES:$%.2f\n\n",total_dinero);
printf("\t\tMONEDA\t\tCODIGO\n");
printf("\t\tQUETZAL\t\t 1\n");
printf("\t\tLEMPIRA\t\t 2\n");
printf("\t\tEURO\t\t 3\n\n");
printf("introdusca el codigo de la moneda a la que desea convertir los $%.2f:",total_dinero);
scanf("%d",&cambiarmoneda);
quetzal=total_dinero*7.95270;
lempira=total_dinero*19.71674;
euro=total_dinero*0.82396;
if(cambiarmoneda==1){
printf("\n$%.2f EQUIVALE A %.2f QUETZALES\n\n",total_dinero,quetzal);
printf("SI DESEAS SALIR PRESIONE 1 O DE LO CONTRARIO PRECIONE OTRO NUMERO: ");
scanf("%d",&saliryesno);
if(saliryesno==1){
salir=1;
}
}
else{
if(cambiarmoneda==2){
printf("\n$%.2f EQUIVALE A %.2f LEMPIRAS\n\n",total_dinero,lempira);
printf("SI DESEAS SALIR PRESIONE 1 O DE LO CONTRARIO PRECIONE OTRO NUMERO: ");
scanf("%d",&saliryesno);
if(saliryesno==1){
salir=1;
}
}
else{/*cambiarmoneda==3*/
printf("\n$%.2f EQUIVALE A %.2f EUROS\n\n",total_dinero,euro);
printf("SI DESEAS SALIR PRESIONE 1 O DE LO CONTRARIO PRECIONE OTRO NUMERO: ");
scanf("%d",&saliryesno);
if(saliryesno==1){
salir=1;
}
}
}
}
}
martes, 13 de mayo de 2014
programacion funcional con recursividad
Programación funcional con recursividad
Sistema
de tipos
Un sistema de tipos define como
un lenguaje de programación clasifica los valores y las expresiones en tipos,
cómo se pueden manipular estos tipos y cómo interactúan. Un tipo indica un
conjunto de valores que tienen el mismo significado genérico o propósito
(aunque algunos tipos, como los tipos de datos abstractos y tipos de datos
función, tal vez no representen valores en el programa que se está ejecutando).
Los sistemas de tipificación varían significativamente entre lenguajes, siendo
quizás las más importantes variaciones las que estén en sus implementaciones de
la sintáctica en tiempo de compilación y la operativa en tiempo de ejecución.
Se entiende bajo el término
sistema a un conjunto de elementos que están relacionadas entre sí para
alcanzar algún determinado objetivo.
Pueden clasificarse tomando en cuenta diversos criterios, algunos de
ellos son los siguientes:
- Según la relación que establecen con el
medio ambiente:
Sistemas cerrados: se caracterizan por su hermetismo, que hace que no
ocasionen ningún intercambio con el ambiente que se encuentra a su alrededor,
por lo que no se ven afectados por el mismo.
Esto hace que tampoco los sistemas ejerzan influencia alguna en el medio
ambiente que los rodea. Los sistemas cerrados entonces, se caracterizan por
poseer un comportamiento totalmente programado y determinado y la materia y
energía que intercambian con el ambiente que los rodea es mínima.
Sistemas abiertos: estos sí establecen
intercambios con el medio ambiente que los rodea. Para lograr esto se
valen de salidas y entradas por medio de las que intercambian, de manera
constante, energía y materia con el medio ambiente. Este vínculo que se
establece hace que los sistemas abiertos deban ser sumamente adaptativos a las
cualidades del ambiente del cual dependen, sino es así, no logran la
supervivencia. Esta dependencia con lo ajeno hace que no puedan existir de
forma aislada y que deban adaptarse por medio de la organización y del
aprendizaje a los cambios externos.
- Según su constitución:
Sistemas conceptuales: están constituidos por conceptos que son ajenos
a la realidad y que resultan meramente abstractos.
Sistemas físicos: los elementos que los componen, en cambio, son
concretos y palpables, es decir que se los puede captar por medio del tacto.
- Según su origen:
Sistemas artificiales: se caracterizan por ser producto de la creación
humana, por lo que dependen de la presencia de otros para poder existir.
Sistemas naturales: estos en cambio, no dependen de la mano de obra
del hombre para originarse.
- Según su movimiento:
Sistemas dinámicos: estos sistemas se caracterizan por presentar
movimiento.
Sistemas estáticos: como su nombre indica, carecen de movimiento
alguno.
- Según la complejidad de los elementos que
los conforman:
Sistemas complejos: se caracterizan por estar compuestos por una serie
de subsistemas, lo que vuelve difícil la tarea de identificar los distintos
elementos que los componen.
Sistemas simples: a diferencia de los anteriores, éstos no cuentan con
subsistemas, lo que permite identificar fácilmente a los elementos
constitutivos de los mismos.
- Según su naturaleza:
Sistemas inertes: carece de vida alguna.
Sistemas vivos: estos, en cambio, si poseen vida.
PROGRAMACION II. RECURSIVIDAD
Recursividad:
La recursividad es una técnica de programación que se utiliza para
realizar una llamada a una
función desde ella misma, de allí su nombre. El ejemplo más utilizado
por su fácil comprensión es
el cálculo de números factoriales. El factorial de 0 es, por
definición, 1. Los factoriales de números
mayores se calculan mediante la multiplicación de 1 * 2 * ...,
incrementando el número de 1 en 1
hasta llegar al número para el que se está calculando el factorial.
Un algoritmo recursivo es un algoritmo que expresa la solución de un
problema en términos de
una llamada a sí mismo. La llamada a sí mismo se conoce como llamada
recursiva o recurrente.
#include <iostream>
#include <cstdlib>
using namespace std;
int Factorial(int n);
int main(){
int valor;
system("clear");
cout << "Introduzca
numero a calcular: ";
cin >> valor;
cout << "\nEl
Factorial de " << valor << " es: " <<
Factorial(valor) << endl;
return 0;
}
int Factorial(int n){
if (n < 0){
cout << “No existe el
factorial de un numero negativo.\n”;
}else if(n < 2){
return 1;
}else
return n * Factorial(n-1);
}
Generalmente, si la primera
llamada al subprograma se plantea sobre un problema de tamaño u orden N, cada
nueva ejecución recurrente del mismo se planteará sobre problemas, de igual naturaleza
que el original, pero de un tamaño menor que N. De esta forma, al ir reduciendo
progresivamente la complejidad del problema a resolver, llegará un momento en
que su resolución sea más o menos trivial (o, al menos, suficientemente
manejable como para resolverlo de forma no recursiva). En esa situación diremos
que estamos ante un caso base de la recursividad.
Es frecuente que los algoritmos
recurrentes sean más ineficientes en tiempo que los iterativos aunque suelen ser
mucho más breves en espacio.
Recursividad directa vs indirecta.
Cuando en una subrutina hay llamadas a ella
misma se habla de recursividad directa en contraposición, cuando se tienen
varias subrutinas y éstas se llaman unas a otras formando ciclos se dice que la
recursión es
indirecta
.Subrutina_A → Subrutina_A →
Subrutina_A
Subrutina_A → Subrutina_B → Subrutina_C
→ Subrutina_D → Subrutina_A
Propiedades
de las definiciones o algoritmos recursivos:
No debe generar una secuencia
infinita de llamadas así mismo, dicho de otro modo ha de existir al menos un
caso base.
PROGRAMACION
II. RECURSIVIDAD
Una función recursiva debe
definirse en términos que no impliquen a al menos en un argumento o grupo de
argumentos.
Debe existir una
"salida" de la secuencia de llamadas recursivas.
Cada llamada recurrente se debería definir sobre un problema de menor
complejidad (algo
más fácil de resolver).
Programación Recursiva:
Es mucho mas difícil desarrollar una solución recursiva en un lenguaje
determinado para resolver
un problema especifico cuando no se tiene un algoritmo. No es solo el
programa sino las
definiciones originales y los algoritmos los que deben desarrollarse.
En general, cuando encaramos
la tarea de escribir un programa para resolver un problema no hay
razón para buscar una solución
recursiva. La mayoría de los problemas pueden resolverse de una manera
directa usando métodos
no recursivos. Sin embargo, otros pueden resolverse de una manera mas
lógica y elegante mediante la recursión. Volviendo a examinar la función
factorial. El factor es, probablemente, un ejemplo fundamental de un problema
que no debe resolverse de manera recursiva, dado que su solución iterativa es
directa y simple. Sin embargo, examinaremos los elementos que permiten dar una
solución recursiva. Antes que nada, puede reconocerse un gran número de casos
distintos que se deben resolver. Es decir, quiere escribirse un programa para
calcular 0!, 1!, 2! Y así sucesivamente. Puede identificarse un caso
"trivial" para el cual la solución no recursiva pueda obtenerse en
forma directa. Es el caso de 0!, que se define como 1. El siguiente paso es
encontrar un método para resolver un caso "complejo" en términos de
uno mas "simple", lo cual permite la reducción de un problema
complejo a uno mas simple. La transformación del caso complejo al simple
resultaría al final en el caso trivial. Esto significaría que el caso complejo
se define, en lo fundamental, en términos del mas simple. En el modelo de
evaluacion de los lenguajes funcionales, el usuario introduce una expresion que
es evaluada por el sistema. La evaluacion consiste en bus-car subexpresiones
dentro de la expresi ́on que puedan transformarse utilizando
las funciones predefinidas y las funciones definidas por el usuario.
Cuando no es posible realizar m ́as transformaciones se dice que se ha
alcanzado la forma normal
.Existen dos estrategias fundamentales de evaluaci ́on:
evaluacion aplicativa y evaluacion normal
.En la evaluaci ́on aplicativa, se eligen las subexpresiones m ́as
internas de la
expresi ́on, mientras que en la evaluaci ́on normal, se eligen las
subexpresiones m ́as externas. Sup ́ongase que se definen las funciones
La estrategia de evaluaci ́on aplicativa tambi ́en se conoce como
llamada por valor
(call by value). Ya que se eval ́uan primero los argumentos de la
funci ́on y
se le pasan a la funci ́on sus valores.La estrategia de evaluaci ́on
normal se conoce como
llamada por nombre(call by name), indicando que se pasan las expresiones,
en lugar de sus valores. Dichas expresiones no son evaluadas si no se necesita
su valor.
En ocasiones, la llamada por nombre puede hacer que ciertas
subexpresionesse evaluen mas de una vez
El sistema de tipos de Haskell posee una
característica que lo distingue de otros lenguajes de
programación. El tipo de polimorfismo del que hemos
tratado hasta ahora es denominado polimorfismo paramétrico.
Existe otro tipo de polimorfismo llamado ad hoc o sobrecarga. Estos son algunos
ejemplos de polimorfismo ad hoces una descripción
informal1 de alto nivel de un algoritmo informático
de programación, compacto e informal, que utiliza las
convenciones estructurales de un lenguaje de programación
verdadero2 , pero que está diseñado para la lectura humana en lugar de la
lectura mediante máquina, y con independencia de cualquier otro
lenguaje de programación.
aplicaciones en rutinas de pseudocodigo:
programas del 9 de mayo 2014
programa 1
#include <conio.h>
#include <conio.h>
#include
<stdio.h>
main()
{
int cont,valor ,fact=1;
printf("Factorial de un numero
\n");
printf("Dame un numero \n");
scanf("%d",&
valor);
for(cont=1;cont<=valor;cont++)
{
fact=fact*cont;
}
printf("El factorial es:
%d",fact);
getch ();
}
Programe
numero 2:
#include
<stdio.h>
#include
<stdlib.h>
#include
<conio.h>
#include
<dos.h>
int
multiplicar(int a,int b);
main()
{
int a,b;
printf("Ingrese el 1er numero:");
scanf("%d",&a);
printf("Ingrese el 2do numero");
scanf("%d",&b);
printf("%d\n",multiplicar(a,b));
return 0;
}
int
multiplicar(int a,int b)
{
int acu=0;
switc(b){
case 0:
return 0;
case 1:
return a;
default:
if(b>1){
return
a+multiplicar(a,b-1);
}
else
return
-a+multiplicar(a,b+1);
}
}
programa 3
#include
<conio.h>
#include
<stdio.h>
main()
{
int
num,y=0,x=0,divi,resi[30];
printf("Conversion
decimal/Binario\n");
printf("Dame un numero:\n");
scanf("%d"&num);
do
{
divi=num/2;
resi[x]=num%2;
num=divi;
x++;
}
while(num>0);
printf("\nbinario");
for(y=x-1;y>=0;y--)
printf("%d,resi[y]);
printf("(2)");
getch();
}
Suscribirse a:
Entradas (Atom)