Descargar

Programación de bajo nivel – Lenguaje c (página 2)

Enviado por Gast�n


Partes: 1, 2

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 1000nn");

            crear_vector(VALOR, mi_vector);

            imprimir_vector(VALOR, mi_vector);

           

            printf("n");

            printf("Vector 'ordenado' de 100 numeros aleatorios entre 0 y 1000nn");

           

            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: %dn", 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:nn");

            imprimir_vector(VALOR, mi_vector);

           

            printf("Vector de 10 numeros al azar:nn");

            crear_vector(OTROVALOR, otro_vector);

            imprimir_vector(OTROVALOR, otro_vector);

           

            printf("nn");

           

            printf("Vector de 30 numeros intercalados:nn");

            //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: %dn", 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 bytesn", sizeof(int));

            printf("El tamanio de un float es: %d bytesn", sizeof(float));

            printf("El tamanio de un double es: %d bytesn", sizeof(double));

            printf("El tamanio de un char es: %d bytesn", 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 = &numero;

           

            printf("El contenido de numero es: %dn", numero);

            printf("La direccion de numero es: %pn", &numero);

           

            // lo de abajo no se puede hacer porque el contenido

            // de una variable es ella misma.

            // printf("El contenido de numero es: %dn", *numero);

           

            printf("El contenido del puntero que apunta a numero es: %pn", pint);

            printf("La direccion de memoria donde esta el puntero es: %pn", &pint);

            printf("Lo apuntado por el puntero es: %dn", *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 != ''){

                       

                        printf("Letra %c – ASCII %in", *s, *s);

                        s++;

            }

                       

            // Opcion 2 – Con un for

           

            int i;

            for (i=0; *s != ''; s++){

                       

                        printf("Letra %c – ASCII %in", *s, *s);

            }

           

            return 0;

}

 

//////////////////////////////////////////////

 

 

Autor:

Gastón

Uruguay

Partes: 1, 2
 Página anterior Volver al principio del trabajoPágina siguiente