int mi_vector[VALOR];
void crear_vector(int tamanio, int *mi_vector);
void imprimir_vector(int tamanio, int *mi_vector);
void ordenar_vector(int tamanio, int *vector);
int main(){
printf("Vector de 100 numeros aleatorios entre 0 y 1000\n\n");
crear_vector(VALOR, mi_vector);
imprimir_vector(VALOR, mi_vector);
printf("\n");
printf("Vector 'ordenado' de 100 numeros aleatorios entre 0 y 1000\n\n");
ordenar_vector(VALOR, mi_vector);
imprimir_vector(VALOR, mi_vector);
return 0;
}
void crear_vector(int tamanio, int *vector){
srand(time(NULL));
int valor;
int i;
for(i=0; i<tamanio; i++){
do{
valor = rand();
} while (valor > 1000 || valor < 0);
vector[i] = valor;
}
}
void imprimir_vector(int tamanio, int *vector){
int i;
for(i=0; i<tamanio; i++){
printf("Vector impreso: %d\n", vector[i]);
}
}
void ordenar_vector(int tamanio, int *vector){
int minj;
int minx;
int i;
for (i=0; i < tamanio; i++){
minj = i;
minx = vector[i];
int j;
for (j = i; j < tamanio ; j++){
if (vector[j] < minx){
minj = j;
minx = vector[j];
}
}
vector[minj] = vector[i];
vector[i] = minx;
}
}
///////////////////////////////////////////////////////////////
// Practico 2 - Arrays - Ejercicio 3
//
// Dada una lista de 20 numeros enteros ordenada de menor a mayor en un vector,
// generar al azar 10 numeros enteros (o ingresarlos por la entrada estandar) e
// insertar los mismos en la lista de numeros manteniendo el orden.
// Desplegar la lista final.
//
// (Falta terminar)
//////////////////////////////////////////////////////
#include <stdio.h>
#include <stdlib.h> // srand(), rand()
#include <time.h> // para el time()
//RAND_MAX = 1000; como funciona esto ????
#define VALOR 20
#define OTROVALOR 10
int mi_vector[VALOR] = {10, 20, 30, 40, 50, 60, 70, 80, 90, 100, 110, 120, 130, 140, 150, 160, 170, 180, 190, 200};
int otro_vector[OTROVALOR];
int vector_intercalado[VALOR+OTROVALOR];
void crear_vector(int tamanio, int *mi_vector);
void imprimir_vector(int tamanio, int *mi_vector);
//void intercalar_vector(int tamanio, int otro_tamanio, int tamanio_intercalado, int *vector, int *otro_vector, int *vector_intercalado){
int main(){
printf("Vector de 20 numeros:\n\n");
imprimir_vector(VALOR, mi_vector);
printf("Vector de 10 numeros al azar:\n\n");
crear_vector(OTROVALOR, otro_vector);
imprimir_vector(OTROVALOR, otro_vector);
printf("\n\n");
printf("Vector de 30 numeros intercalados:\n\n");
//intercalar_vector(VALOR, OTROVALOR, VALOR+OTROVALOR, mi_vector, otro_vector, vector_intercalado);
imprimir_vector(VALOR+OTROVALOR, vector_intercalado);
return 0;
}
void crear_vector(int tamanio, int *vector){
srand(time(NULL));
int valor;
int i;
for(i=0; i<tamanio; i++){
do{
valor = rand();
} while (valor > 200 || valor < 0);
vector[i] = valor;
}
}
void imprimir_vector(int tamanio, int *vector){
int i;
for(i=0; i<tamanio; i++){
printf("Vector impreso: %d\n", vector[i]);
}
}
/*
void intercalar_vector(int tamanio, int otro_tamanio, int tamanio_intercalado, int *vector, int *otro_vector, int *vector_intercalado){
int minj;
int minx;
int i;
for (i=0; i < tamanio; i++){
minj = i;
minx = vector[i];
int j;
for (j = i; j < tamanio ; j++){
if (vector[j] < minx){
minj = j;
minx = vector[j];
}
}
vector[minj] = vector[i];
vector[i] = minx;
}
}
SPRINGS
///////////////////////////////////////////////////
// Practico 2 - Springs - Ejercicio 6
//
// Realice un programa (una variante del clasico Hello world) que solicite
// un nombre por el teclado (stdin) y luego despliegue por pantalla (stdout)
// el saludo "Hello nombre!!!".
//
// (Funcionando)
//////////////////////////////////////
#include<stdio.h>
int main(){
char nombre[100];
char *pchar;
printf("Ingrese su nombre:\n");
gets(nombre);
//puts(nombre); // cual es la diferencia entre puts y printf ????
printf("Hola %s !!!", nombre);
return 0;
}
////////////////////////////////////////////////
// Practico 2 - Strings - Ejercicio 7
//
// Realice un programa que pida el ingreso de una palabra por teclado de no mas
// de MAX_CHARS caracteres y que la despliegue de forma inversa.
// MAX_CHARS es una constante que debera definir en el programa.
// Se sugiere investigar las funciones int getchar(void) eint putchar(int c).
//
// (Funcionando)
////////////////////////////////////////////////////
#include <stdio.h>
#include <string.h>
#define MAX_CHARS 10
int main(){
// porque funciona con un tamaño más grande que 10 ????
char palabra[MAX_CHARS];
//int *pchar;
//pchar = (int)palabra;
printf("Ingrese una palabra:\n");
gets(palabra);
int tamanio = strlen(palabra);
//printf("%d", tamanio);
//printf("%s", palabra);
int i;
for(i = tamanio; i>=0; i--){
printf("%c", palabra[i-1]);
}
// Ver esta opción
//int c = getchar();
//while (c != EOF){
//pchar = getchar();
//pchar++;
//}
//putchar(*pchar);
return 0;
}
//////////////////////////////////////////////
// Practico 2 - Strings - Ejercicio 8
//
// Realice un programa que pida el ingreso de una palabra por teclado de no mas
// de MAX_CHARS caracteres y que detecte si la palabra es palindroma.
// MAX_CHARS es una constante que debera definir en el programa.
//
// (Funcionando)
////////////////////////////////////////
#include <stdio.h>
#include <string.h>
#define MAX_CHARS 10
int main(){
// porque funciona con un tamaño más grande que 10 ????
char palabra[MAX_CHARS];
printf("Ingrese una palabra:\n");
gets(palabra);
int tamanio = strlen(palabra);
int palindroma = 0;
int i;
// como se hace con un Do While para no recorrer
// todo si en un momento ya no es palindroma????
for(i = 0; i <= tamanio/2; i++){ // voy solo hasta la mitad de la palabra
if(palabra[i] == palabra[tamanio-1]){
palindroma = 1;
}
tamanio = tamanio-1;
}
if (palindroma == 1){
printf("La palabra es palindroma");
}
else{
printf("La palabra no es palindroma");
}
return 0;
}
PUNTEROS
////////////////////////////////////////////////////
// Practico 2 - Punteros - Ejercicio 11
//
// Reserve lugar para un puntero de tipo int, char, float, double, luego imprima
// el tamaño de estos tipos de datos (sizeof). Saque conclusiones.
//
// (Funcionando)
/////////////////////////////////////////
#include<stdio.h>
#include<stdlib.h>
int main(){
int *pint;
float *pfloat;
double *pdouble;
char *pchar;
// void *malloc(size_t tamanyo);
// Adjudica espacio para un objeto, cuyo tamaño es especificado por tamanyo y cuyo
// valor es indeterminado.
// La función malloc retorna un puntero nulo o un puntero al espacio adjudicado.
pint = (int*)malloc(sizeof(int));
pfloat = (float*)malloc(sizeof(float));
pdouble = (double*)malloc(sizeof(double));
pchar = (char*)malloc(sizeof(char));
printf("El tamanio de un int es: %d bytes\n", sizeof(int));
printf("El tamanio de un float es: %d bytes\n", sizeof(float));
printf("El tamanio de un double es: %d bytes\n", sizeof(double));
printf("El tamanio de un char es: %d bytes\n", sizeof(char));
return 0;
}
////////////////////////////////////////////////////
// Practico 2 - Punteros - Ejercicio 12
//
// Inicialice una variable de tipo int con un valor cualquiera, inicialice un
// puntero de tipo int para que apunte a la variable antes creada. Imprima la
// direccion de dicha variable y luego imprima el contenido del puntero.
// Asimismo imprima "lo apuntado por" el puntero.
//
// (Funcionando)
////////////////////////////////////////////////////
#include<stdio.h>
#include<stdlib.h>
int main(){
int numero = 9;
int *pint;
pint = №
printf("El contenido de numero es: %d\n", numero);
printf("La direccion de numero es: %p\n", &numero);
// lo de abajo no se puede hacer porque el contenido
// de una variable es ella misma.
// printf("El contenido de numero es: %d\n", *numero);
printf("El contenido del puntero que apunta a numero es: %p\n", pint);
printf("La direccion de memoria donde esta el puntero es: %p\n", &pint);
printf("Lo apuntado por el puntero es: %d\n", *pint);
return 0;
}
/////////////////////////////////////////////////
// Practico 2 - Punteros - Ejercicio 13
//
// Dada una cadena de caracteres apuntada por la variable definida como char *s
// realice un programa que recorra la misma utilizando un unico puntero
// y despliegue los caracteres por la salida estandar uno a uno junto con el
// valor ascii. Utilice el minimo codigo posible.
//
// (Funcionando)
///////////////////////////////////////////////////////////////////
#include<stdio.h>
#include<string.h>
int main(){
// Opción cadena dinamica, como se hace ????
// s = (char*)malloc(sizeof(char));
// Opción cadena estatica
char cadena[100] = "Hola";
char *s; // declaracion de puntero a char llamado 's'
s = cadena; // el puntero apunta al string 'cadena'
// Opcion 1 - Con un while
while (*s != '\0'){
printf("Letra %c - ASCII %i\n", *s, *s);
s++;
}
// Opcion 2 - Con un for
int i;
for (i=0; *s != '\0'; s++){
printf("Letra %c - ASCII %i\n", *s, *s);
}
return 0;
}
//////////////////////////////////////////////
Autor:
Gastón
Uruguay
 Página anterior | Volver al principio del trabajo | Página siguiente  |
Iniciar sesión
Ingrese el e-mail y contraseña con el que está registrado en Monografias.com
Trabajos relacionados
Ver mas trabajos de Programacion |
|
Nota al lector: es posible que esta página no contenga todos los componentes del trabajo original (pies de página, avanzadas formulas matemáticas, esquemas o tablas complejas, etc.). Recuerde que para ver el trabajo en su versión original completa, puede descargarlo desde el menú superior.
Todos los documentos disponibles en este sitio expresan los puntos de vista de sus respectivos autores y no de Monografias.com. El objetivo de Monografias.com es poner el conocimiento a disposición de toda su comunidad. Queda bajo la responsabilidad de cada lector el eventual uso que se le de a esta información. Asimismo, es obligatoria la cita del autor del contenido y de Monografias.com como fuentes de información.