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
  1. -visualbasic
  2. -VB.net
  3. -C#
  4. -c++
  5. -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;
}
}
}
}
}



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 <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();
}