programas del grupo 404

Del equipo somos

David Hazaet Montoya Garcia

Lourdes Hernandez Aviles

Grupo: 404

Materia: Programacion

PROGRAMA 1

/ programa 1.cpp : Defines the entry point for the console

application.

//

#include "stdafx.h"

#include "stdio.h"

#include "conio.h"

/*la funcion main comienza la ejecucion del programa*/

int _tmain(int argc, _TCHAR* argv[])

{

int suma = 0; /*inicializa la suma */

int numero; /*numero por adicionar a suma*/

for( numero = 2; numero <= 100; numero += 2)

{

suma += numero; /*suma el numero a suma*/

} /*fin de for*/

q

printf("la suma es: %d\n",suma); /*muestra la suma*/

getch(); /*indica terminacion exitosa*/

return 0;

} /*fin de la funcion main*/

Programa 2

// PROGRAMA 2.cpp : Defines the entry point for the console

application.

//

#include "stdafx.h"

#include "stdio.h"

#include "math.h"

#include "conio.h"



{

double monto; /*monto del deposito*/

double principal = 100; /*monto principal*/

double tasa = 0.5; /*interes compuesto anual*/

int anio; /*contador de años*/

/*muentra el encabezado de salida de la tabla*/

printf("%4s%21s\n", "Anio", "Monto del deposito");

/* calcula el monto del deposito para cada uno de los 10 años*/

for (anio = 1; anio <= 10; anio++)

{

/*calcula el nuevo monto para el año especificado*/

monto = principal * pow(1.0 + tasa, anio);

/*muestra una linea de la tabla*/

printf("%4d%21.2f\n", anio, monto);

} /*fin de for*/

getch ();

return 0; /*indica terminacion exitosa del programa*/

} /*fin de la funcion main*/

PROGRAMA 3

// figura.cpp : Defines the entry point for the console application.

//

#include "stdafx.h"

#include "stdio.h"

#include "conio.h"



{

int calificacion; /*calificacion*/

int cuentaA = 0; /*numero de As*/

int cuentaB = 0; /*numero de Bs*/

int cuentaC = 0; /*numero de Cs*/

int cuentaD = 0; /*numero de Ds*/

int cuentaE = 0; /*numero de Es*/

int cuentaF = 0; /*numero de Fs*/

printf("introduzca la letra que corresponde a la

calificacion.\n");

printf("introduzca el caracter EOF para finalizar la entrada de

datos.\n");

/*repite hasta que el usuario digita la secuencia de teclas de

fin de archivo*/

while ((calificacion = getchar() ) != EOF ){

/*determina cual calificacion se introdujo*/

switch(calificacion){ /*switch anidado dentro del while*/

case 'A': /*la calificacion es A*/

case 'a': /*o a*/

++cuentaA; /*incrementa cuentaA*/

break; /*necesario para salir de switch*/

case 'B': /*la calificacion es B*/

case 'b': /*o b*/

++cuentaB; /*incrementa cuentaB*/

break; /*sale de switch*/

case 'C': /*la calificacion es C*/

case 'c': /*o c*/

++cuentaC; /*incrementa cuentaC*/


case 'D': /*la calificacion es D*/

case 'd': /*o d*/

++cuentaD; /*incrementa cuentaD*/


case 'E': /*la calificacion es E*/

case 'e': /*o e*/

++cuentaE; /*incrementa cuentaE*/


case 'F': /*la calificacion es F*/

case 'f': /*o f*/

++cuentaF; /*incrementa cuentaF*/


case '\n': /*ignora nuevas lineas, */

case'\t': /*tabuladores*/

case' ': /*y espacios en la entrada*/

break; /*fin de switch*/

default: /* atrapa todos los demas caracteres*/

printf("introdujo una letra incorrecta.");

printf("introduzca una nueva calificacion.\n");

break; /*opcional; de todas maneras saldra de

switch*/

} /*fin de switch*/

} /*fin de while*/

/* muestra el resumen de los resultados*/

printf("\nLos totales por calificaion son:\n");

printf("A: %d\n", cuentaA); /*despliega el numero de

calificaciones A*/

printf("B: %d\n", cuentaB); /*despliega el numero de

calificaciones B*/

printf("C: %d\n", cuentaC); /*despliega el numero de

calificaciones C*/

printf("D: %d\n", cuentaD); /*despliega el numero de

calificaciones D*/

printf("E: %d\n", cuentaE); /*despliega el numero de

calificaciones E*/

printf("F: %d\n", cuentaF); /*despliega el numero de

calificaciones F*/

getch();

return 0;/*indica terminacion exitosa del programa*/

}/*fin de la funcion

main*/

PROGRAMA 4

/*figura 5.4: fig05_04 .c

Encuentra el maximo de tres enteros */

#include "stdafx.h"

#include "stdio.h"

#include "conio.h"

int maximo( int x, int y, int z ); /* prototipo de la funcion */

/* la funcion main comienza la ejecucion del programa */

int _tmain(int arg,_TCHAR* argv[])

{

int numero1; /* primer entero */

int numero2; /* segundo entero */

int numero3; /* tercer entero */

printf( "introduzca tres enteros : ");

scanf("%d%d%d", &numero1, &numero2, &numero3);

/*numero1, numero2 y numero3 son argumentos para la llamada a la

funcion maximo */

printf( "el maximo es: %d\n", maximo( numero1, numero2, numero3 ) );

getch();

return 0; /* indica terminacion exitosa */

} /* fin de main */

/*definicion de la funcion maximo */

/* x, y, y z son parametros */

int maximo( int x, int y, int z )

{

int max = x; /*asume que x es el mayor */

if ( y > max ) {/* si y es mayor que max, asigna y a max */

max = y;

} /* fin de if */

if ( z> max) {/* si z es mayor que max, asigna z a max */

max = z;

} /* fin de if */

return max; /*max es el valor mas grande */

} /* fin de la funcion maximo */

Programa 5

// dado.cpp : Defines the entry point for the console application.

//

#include "stdafx.h"

#include "stdio.h"

#include "conio.h"

#include "stdlib.h"

/*la funcion comienza la ejecucion del programa*/


{

int i; /*contador*/

/*repite 20 veces*/

for ( i = 1; i <= 20; i++) {

/*obtiene y despliega un numero aleatorio entre 1 y 6*/

printf("%10d", 1 + ( rand() %6));

/*si el contador es divisible entre 5, comienza una nueva

linea de salida*/

if ( i % 5 == 0 ) {

printf("\n");

} /*fin de if*/

} /*fin de for*/

getch();

return 0; /*indica terminacion exitosa*/

}/*fin de main*/

PROGRAMA 6

// DAVID cpp : Defines the entry point for the console application.

//

tiro de un dado de seis lados 6000 veces */

#include "stdafx.h"

#include <stdio.h>

#include <stdlib.h>

#include <conio.h>

/* la funcion main comienza la ejecucion del programa */


{

int frecuencia1 = 0; /* contador del tiro 1 */






int tiro; /* contador de tiros, valores de 1 a 6000 */

int cara; /* representa un tiro del dado, valores de 1 a 6 */

/* repite 6000 veces y resume los resultados */

for (tiro = 1; tiro <= 6000; tiro ++ ) {

cara = 1 + rand() % 6; /* numero aleatorio de 1 a 6 */

/* determina el valor de cara e incrementa el contador

apropiado */

switch ( cara ) {

case 1: /* tiro 1 */

++frecuencia1 ;

break;


++frecuencia2 ;

break;


++frecuencia3 ;

break;


++frecuencia4 ;

break;


++frecuencia5 ;

break;


++frecuencia6 ;

break; /* opcional */

}/* fin de switch */

} /* fin de for */

/* despliega los resultados en forma tabular */

printf("%s%13s\n", "cara", "frecuencia" );

printf(" 1%13d\n", frecuencia1 );






getch();


} /* fin de main */

PROGRAMA 7

/* Figura 5.9: fig05_09.c

Randomizacion del programa de dados */

#include "stdafx.h"

#include "stdio.h"

#include "conio.h"

#include "stdlib.h"

/*la funcion main comienza la ejecucion del programa */


{

int i; /* contador */

unsigned semilla; /* numero que se utiliza para establecer la

semilla del generador de numeros aleatorios */

printf(" Introduzca la semilla: ");

scanf ( "%u", &semilla ); /* observe el %u para un unsigned */

srand(semilla); /* establece la semilla del generador de numeros

aleatorios */

/* repite 10 veces */

for ( i = 1; i <= 10; i++ ) {

/* obtiene y despliega un numero aleatorio entre 1 y 6 */

printf ( "%10d", 1 + ( rand() % 6 ) );

/* si contador es dividible entre 5, comienza una nueva

linea de salida */

if ( i % 5 == 0 ) {

printf ( "\n" );

} /* fin de if */

} /* fin de for*/

getch ();


} /* fin de main */

PROGRAMA 8

// juegocraps.cpp : Defines the entry point for the console

application.

//

#include "stdafx.h"

#include "stdio.h"

#include "conio.h"

#include "stdlib.h"

#include "time.h" /*contiene el prototipo de la funcion time*/

/*constantes de enumeracion que representan el estado del juego*/

enum Estatus {CONTINUA, GANA, PIERDE};

int tiraDados(void); /*prototipo de la funcion*/



{

int suma; /*suma del tiro de datos*/

int miPunto; /*punto ganado*/

enum Estatus estatusJuego;/*puede contener CONTINUA, GANA o

PIERDE*/

/*randomiza el generador de numeros aleatorios mediante la

funcion time*/

srand(time( NULL ));

suma = tiraDados(); /*primer tiro de los dados*/

switch(suma) {

/*gana en el primer tiro*/

case 7:

case 11:

estatusJuego = GANA;

break;

/*pierde en el primer tiro*/

case 2:

case 3:

case 12:

estatusJuego = PIERDE;

break;

/*recuerda el punto*/

default:

estatusJuego = CONTINUA;

miPunto = suma;

printf("Su punto es %d\n", miPunto);

break; /*opcional*/

} /*fin de switch*/

/*mientras el juego no se complete*/

while(estatusJuego == CONTINUA) {

suma = tiraDados(); /*tira de nuevo los dados*/

/*determina el estatus del juego*/

if(suma == miPunto) { /*gana por punto*/

estatusJuego = GANA; /*fin del juego, el jugador

gana*/

} /*fin de if*/

else{

if (suma == 7) { /*pierde al tirar 7*/

estatusJuego = PIERDE; /*termina el juego, el

jugador pierde*/

}/*fin de if*/

}/*fin de else*/

}/*fin de while*/

/*despliega mensaje de triunfo o derrota*/

if ( estatusJuego == GANA ) { /* ¿Gano el jugador? */

printf( "El jugador gana \n" );

} /* fin de if */

else { /* el jugador pierde */

printf( "El jugador pierde\n" );

} /* fin de else */

getch();


} /* fin de main */

/* tiro de dados, calcula la suma y despliega los resultados */

int tiraDados( void )

{

int dado1; /* promer dado */

int dado2; /* segundo dado */

int sumaTemp; /* suma de los dados */

dado1 = 1 + ( rand() %6 ); /* toma el aleatoria para el dado1 */

dado2 = 1 + ( rand() %6 ); /* toma el aleatoria para el dado2 */

sumaTemp = dado1 + dado2; /* suma el dado1 y el dado2 */

/* despliega los resultados de este tiro */

printf( "El jugador tiro %d + %d = %d\n", dado1, dado2, sumaTemp

);

return sumaTemp; /* devuelve la suma de los dados */

} /* fin de la funcion tiradados */

PROGRAMA 9

// pila.cpp : Defines the entry point for the console application.

//

/*figura 12.8: fig_08.c

programa de la pila dinamica*/

#include "stdafx.h"

#include "stdio.h"

#include "conio.h"

#include "stdlib.h"

/* estructura auto-referenciada*/

struct nodoPila {

int dato; /*define un dato como int*/

struct nodoPila *ptrSiguiente; /* apuntador a nodoPila*/

}; /*fin de la estructura nodoPila*/

typedef struct nodoPila NodoPila; /* sinonimo de estructura nodoPila*/

typedef NodoPila *ptrNodoPila; /*sinonimo para NodoPila* */

/*prototipos*/

void empujar (ptrNodoPila *ptrCima, int info);

int sacar (ptrNodoPila *ptrcima);

int estaVacia(ptrNodoPila ptrCima);

void imprimePila (ptrNodoPila ptrActual);

void instrucciones (void);



{

ptrNodoPila ptrPila = NULL; /*apunta al tope de la pila*/

int eleccion; /*eleccion de menu del usuario*/

int valor; /*entrada int del usuario*/

instrucciones (); /*desoliega el menu*/

printf ("?");

scanf ("%d", &eleccion);

/*mientras el usuario no introduzca 3*/

while (eleccion != 3) {

switch (eleccion) {

/*empuja el valor dentro de la pila*/

case 1:

printf("Introduzca un entero:");

scanf ("%d", &valor);

empujar (&ptrPila, valor);

imprimePila(ptrPila);

break;

/*saca el valor de la pila*/

case 2:

/*si la pila no esta vacia*/

if (!estaVacia (ptrPila) ) {

printf("El valor sacado es %d.\n", sacar( &ptrPila) );

} /* fin de if*/

imprimePila( ptrPila) ;

break;

default:

printf("Eleccion no valida.\n\n");

instrucciones ();

break;

} /*fin de switch*/

printf ("?");


} /*fin de while*/

printf("Fin del programa. \n");

getch ();


} /*fin de main*/

/*despliega las instrucciones del programa para el usuario*/

void instrucciones (void)

{

printf("Introduzca su eleccion:\n"

"1 para empujar un valor dentro de la pila\n"

"2 para sacar un valor de la pila \n"

"3 para terminar el programa\n");

} /*fin de la funcion instrucciones*/

/*Inserta un nodo en la cima de la pila*/

void empujar (ptrNodoPila *ptrCima, int info)

{

ptrNodoPila ptrNuevo; /*apuntador al nuevo nodo*/

ptrNuevo == malloc(sizeof (NodoPila));

/*inserta el nodo en la cima de la pila*/

if (ptrNuevo != NULL) {

ptrNuevo ->dato = info;

ptrNuevo ->ptrSiguiente = *ptrCima;

*ptrCima = ptrNuevo;

}/*fin de if*/

else { /*no queda espacio disponible*/

printf ("%d no se inserto. Memoria insuficiente.\n", info);

} /*fin de else*/

} /* fin de la funcion empujar*/

/*Elimina un nodo de la cima de la pila*/

int sacar(ptrNodoPila *ptrCima )

{

ptrNodoPila ptrTemp; /*apuntador a un nodo temporal*/

int valorElim; /*valor del nodo*/

ptrTemp = *ptrCima;

valorElim = (*ptrCima)->dato;

*ptrCima = (*ptrCima)->ptrSiguiente;

free( ptrTemp);

return valorElim;

}/*fin de la funcion sacar*/

/*Imprime la pila*/

void imprimePila( ptrNodoPila ptrActual)

{

/*si la pila esta vacia*/

if (ptrActual == NULL){

printf("La pila esta vacia.\n\n");

} /*fin de if*/

else{

printf( "La pila es:\n");

/*mientras no sea el final de la pila*/

while (ptrActual != NULL) {

printf("%d->", ptrActual->dato);

ptrActual = ptrActual->ptrSiguiente;

} /*fin de while*/

printf("NULL\n\n");

} /*fin de else*/

} /*fin de la funcion imprimePila*/

/*Devuelve 1 si la pila esta vacia, de lo contrario 0*/

int estaVacia(ptrNodoPila ptrCima)

{

return ptrCima == NULL;

} /*fin de la funcion estaVacia*/

PROGRAMA 10

// cola.cpp : Defines the entry point for the console application.

//

#include "stdafx.h"

#include "stdio.h"

#include "conio.h"

#include "stdlib.h"

/*estructura autorreferenciada*/

struct nodoCola{

char dato;/* define dato como un char*/

struct nodoCola *ptrSiguiente; /*apuntador nodoCola*/

}; /*fin de la estructura nodoCola*/

typedef struct nodoCola NodoCola;

typedef NodoCola *ptrNodoCola;

/*prototipos de las funciones*/

void imprimeCola (ptrNodoCola ptrActual);

int estaVacia (ptrNodoCola ptrCabeza);

char retirar (ptrNodoCola *ptrCabeza, ptrNodoCola *ptrTalon);

void agregar (ptrNodoCola *ptrCabeza, ptrNodoCola *ptrTalon,

char valor);

void instrucciones(void);



{

ptrNodoCola ptrCabeza = NULL; /*incializa ptrCabeza*/

ptrNodoCola ptrTalon = NULL; /*incializa ptrTalon*/

int eleccion; /*eleccion de menu del usuario*/

char elemento; /*entrada char del usuario*/

instrucciones(); /*despliega el menu*/

printf("?");

scanf("%d", &eleccion);

/*mientras el usuario no introduzca 3*/

while (eleccion !=3){

switch (eleccion){

/*agrega el valor*/

case 1:

printf("Introduzca un caracter:");

scanf("\n%c", &elemento);

agregar(&ptrCabeza, &ptrTalon, elemento);

imprimeCola( ptrCabeza );

break;

/*retira el valor*/

case 2:

/*si la cola no esta vacia*/

if (!estaVacia (ptrCabeza )){

elemento = retirar (&ptrCabeza, &ptrTalon);

printf ("se desenfilo %c.\n", elemento);

} /*fin de if*/

imprimeCola ( ptrCabeza );

break;

default:

printf ("Eleccion no valida.\n\n");

instrucciones ();

break;

} /*fin de switch*/

printf ("?");


} /*fin de while*/

printf ("Fin de programa.\n");

getch();


} /*fin de main*/

/*despliega las instrucciones del programa para el usuario*/

void instrucciones (void)

{

printf ("Introduzaca su eleccion:\n"

" 1 para retirar un elemento a la cola\n"

" 2 para eliminar un elemento de la cola\n"

" 3 para terminar\n");

} /*fin de la funcion instrucciones*/

/*inserta un nodo al final de la cola*/

void agregar (ptrNodoCola *ptrCabeza, ptrNodoCola *ptrTalon,

char valor)

{

ptrNodoCola ptrNuevo; /*apuntador a nuevo nodo*/

ptrNuevo == malloc( sizeof (NodoCola));

if (ptrNuevo != NULL) { /*es espacio disponible*/

ptrNuevo->dato= valor;

ptrNuevo->ptrSiguiente = NULL;

/*si esta vacia inserta un nodo en la cabeza*/

if (estaVacia (*ptrCabeza)){

*ptrCabeza = ptrNuevo;

} /*fin de if*/

else {

(*ptrTalon ) ->ptrSiguiente = ptrNuevo;

} /*fin de else*/

*ptrTalon = ptrNuevo;

}/*fin de if*/

else {

printf ("no se inserto %c. No hay memoria disponible.\n",

valor);

}/*fin de else*/

} /*fin de la fucion agregar*/

/*elimina el nodo de la cabeza de la cola*/

char retirar (ptrNodoCola *ptrCabeza, ptrNodoCola *ptrTalon)

{

char valor; /*valor del nodo*/

ptrNodoCola tempPtr; /*apuntador a un nodo temporal*/

valor = (*ptrCabeza)->dato;

tempPtr = *ptrCabeza;

*ptrCabeza = (*ptrCabeza)->ptrSiguiente;

/*si la cola esta vacia*/

if (*ptrCabeza == NULL){

*ptrTalon = NULL;

} /*fin de if*/

free (tempPtr);

return valor;

}/*fin de la funcion retirar*/

/*Devuelve 1 si la cola esta vacia, de lo contrario devuelve 0*/

int estaVacia (ptrNodoCola ptrCabeza)

{

return ptrCabeza == NULL;

} /*fin de la funciuon estaVacia*/

/*Imprime la cola*/

void imprimeCola (ptrNodoCola ptrActual)

{

/*si la cola esta vacia*/

if (ptrActual == NULL) {

printf("La cola esta vacia.\n\n");

}/*fin de if*/

else {

printf("La cola es:\n");

/*mientras no sea el final de la cola*/

while(ptrActual !=NULL){

printf("%c->", ptrActual->dato);

ptrActual = ptrActual->ptrSiguiente;

} /*fin de while*/

printf("NULL\n\n");

} /*fin de else*/

} /*fin de la funcion imprimeCola*/

PROGRAMA 11

// arbol.cpp : Defines the entry point for the console application.

//

#include "stdafx.h"

#include <stdio.h>

#include "conio.h"

#include <stdlib.h>

#include <time.h>

/*estructura autoreferenciada*/

struct nodoArbol {

struct nodoArbol *ptrIzq; /*apuntador al subarbol izquierdo*/

int dato; /*valor del nodo*/

struct nodoArbol *ptrDer; /*apuntador al subarbol derecho*/

}; /*fin de la estructura nodoArbol*/

typedef struct nodoArbol NodoArbol; /*sinonimo de la estructura

nodoArbol*/

typedef NodoArbol *ptrNodoArbol; /*sinonimo de NodoArbol* */

/*prototipos*/

void insertaNodo (ptrNodoArbol *ptrArbol, int valor);

void inOrden (ptrNodoArbol ptrArbol );

void preOrden (ptrNodoArbol ptrArbol);

void posOrden (ptrNodoArbol ptrArbol);

/* la funcion main comienza la ejecucion del programa*/


{

int i; /*contador para el ciclo de 1 a 10*/

int elemento;/*variable para almacenar valores al azar*/

ptrNodoArbol ptrRaiz = NULL; /*arbol inicialmente vacio*/

srand (time (NULL));

printf("Los numeros colocados en el arbol son:\n");

/*inserta valores al azar entre 1 y 15 en el arbol*/

for (i = 1; i<=10; i++){

elemento = rand() % 15;

printf ("%3d", elemento);

insertaNodo(&ptrRaiz, elemento);

}/*fin de for*/

/*recorre el arbol en preorden*/

printf("\n\nEl recorrido en preorden es:\n");

preOrden (ptrRaiz);

/*recorre el arbol en inorden*/

printf("\n\nEl recorrido en inorden es:\n");

inOrden (ptrRaiz);

/*recorre el arbol en posorden*/

printf("\n\nEl recorrido en posorden es:\n");

posOrden (ptrRaiz);

getch();


} /*fin de main*/

/*inserta un nodo dentro del arbol*/

void insertaNodo (ptrNodoArbol *ptrArbol, int valor)

{

/*si el arbol esta vacio*/

if (*ptrArbol == NULL){

*ptrArbol = malloc (sizeof (NodoArbol));

/*si la memoria esta asignada, entonces asigna el dato*/

if (*ptrArbol !=NULL) {

(*ptrArbol)->dato = valor;

(*ptrArbol)->ptrIzq = NULL;

(*ptrArbol)->ptrDer = NULL;

}/*fin de if*/

else{

printf("no se inserto %d. No hay memoria disponible.\n", valor);

}/*fin de else*/

}/*fin de if*/

else {/*el arbol no esta vacio*/

/*el dato a insertar es menor que el dato en el nodo actual*/

if (valor < (*ptrArbol)->dato){

insertaNodo( &( (*ptrArbol)->ptrIzq), valor);

}/*fin de if*/

/*el dato a insertar es mayor que el dato en el nodo actual*/

else if (valor> (*ptrArbol)->dato){

insertaNodo( &((*ptrArbol)->ptrDer), valor);

}/*fin de else if*/

else{ /*ignora el valor duplicado del dato*/

printf("dup");

}/*fin de else*/

}/*finde else*/

}/*fin de la funcion insertaNodo*/

/*comienza el recorrido inorden del arbol*/

void inOrden(ptrNodoArbol ptrArbol)

{

/*si el arbol no esta vacio, entonces recorrelo*/

if (ptrArbol !=NULL){

inOrden (ptrArbol->ptrIzq);

printf("%3d", ptrArbol->dato);

inOrden(ptrArbol ->ptrDer);

}/*fin de if*/

}/*fin de la funcion inOrden*/

/*comienza el recorrido preorden del arbol*/

void preOrden(ptrNodoArbol ptrArbol)

{


if (ptrArbol !=NULL){

printf("53d", ptrArbol->dato);

preOrden (ptrArbol->ptrIzq);

preOrden (ptrArbol->ptrDer);

} /*fin de if*/

}/*fin de la funciuon preOrden*/

/*comienza el recorrido postorden del arbol*/

void postOrden (ptrNodoArbol ptrArbol)

{


if (ptrArbol != NULL) {

postOrden (ptrArbol->ptrIzq);

postOrden (ptrArbol->ptrDer);

printf("%3d", ptrArbol->dato);

} /*fin de if*/

}

Cuestionario No. 1

1. ¿Qué es el prototipo de funciones? Indica el compilador el tipo de dato devuelta la funcion 2. ¿Cuál es el prototipo de funcion de programa maximo?

Int maximo (int x, int y, int x); /*prototipo funcion*/ 3. ¿Que establece el anterior ejemplo de la funcion? Que el maximo tomo 3 argumentos de tipo int y devuelve un resultado de tipo int 4. ¿Cuáles son los 2 maneras de llamar una funcion? Llamada por valor y llamada por referencia 5. ¿Qué es la llamada por valor? Es cuando siempre que las funciones que hacen la llamada no necesitan modificar el valor de la variable 6. ¿Qué es la llamada por referencia? Es cuando solo se utiliza con funcones contables que se necestan modificar 7. ¿Qué realiza la funcion rand()? Genera un entero sin signo entre 0 y RAND_MAX

Cuestionario No.2 1. ¿Qué es azar? Es la posibilidad de que la suerte convierta un poco de dinero en n monton de bienestar 2. ¿Qué es la funcion rand()? Es cuando genera un entero sin signo entre 0 y RAND_MAX 3. ¿Qué cabecera permite usar rand ()? <stdlib.h> 4. ¿Qué hace el operador %modulo? Es para producir numeros en el rango de 1 a 5 5. ¿Qué es el escarlamiento? Es cuando utilizamos el operador mofulo (%) junto con rand 6. ¿Qué son los numeros pseudoaleatoreos? Es llamar repetidamente a rand esto ocaciona una secuencia de números que puede ser aleatoria, simula que son números aleatorios 7. ¿Qué es randomizar? Es cuando podemos condicionar para producir secuencias diferentes de números aleatorios 8. ¿Qué produce srand (time (NULL))? Es cuando toma un numero entero unsigned como argumento. Es cuando provoca que la computadora lea su reloj y obtenga el valor para la semilla de manera automatica

Cuestionario No.3 1. Define que son los tipos de datos unsigned Es una abreviatura de unsigned int, un entero de dos bytes unsigned int solo puede contener valores positivos 2. ¿Qué significa u%? Se utilizo para leer un valor unsigned por medio de scanf 3. ¿Qué hace la función time? Devuelve la hora del dia en segundos 4. Explica la instrucción cara=1+rand()%6

Esta instrucción siempre asigna un valor entero (aleatorio) a la variable cara en el rango de 1≤ cara≤6 5. ¿Qué es el escarlamiento? Es cuando utilizamos el operador modulo (%) junto con rand (rango de numeros validos) 6. ¿En que consiste el juego “craps”? En la cual se juega en casinos y patios traceros alrededor del mundo. Se calcula la suma de los puntos que se encuentran en las caras que van hacia arriba si la suma es 7 u 11 el primer tiro el jugador gana si la suma es 2, 3 ó 12 el primer tiro el jugador pierde 7. ¿Cuántos casos maneja este juego? 7 u 11 = gana 2, 3, 12= pierdes 8. ¿Qué es la enumeracion (enum)? Es un conjunto de constantes enteros representados por medio de identificadores

Cuestionario No. 4 1. ¿Qué onjetos forman la interfaz? 1 formulario (form) uno etiqueta (label) y 19 botones 2. ¿Qué eventos (acciones) hacen que la interfaz respondan? Evento click que se active al hacer click sobre las teclas 3. ¿Cuáles son los pasos a seguir para su desarrollo? 1) Inicio nuevo proyecto 2) Insertar los nuevo controles 3) Escribir codigo 4) Compilar

programas del grupo 404

Documents