Ejercicios Progra_18-i

//////////////////////////// LISTAS Y OPERACIONES CON LISTAS /////////////////////////////

como el código de listas y eso es muy largo, lo pongo aparte en esta dirección:
http://tiny.cc/ListasProgra18i
o en esta otra
https://pastebin.com/CytiLRLn

//////////////////////////////// TAREA 5 //////////////////////////////////////////////////
/**        Tarea N°5
** Desarrollar función que "resta" las letras de cadena B de la cadena A.
** La función resta_cad copia a C todo contenido de A excepto aquellos símbolos que se encuentran en B.
** La función main debe pedir del operador contenido de A y de B, luego llamar resta_cad para construir C
** y luego imprimir contenido de resultante cadena C.
** Alumno: Guerra Esquivel Angel        correo: [email protected]
** Grupo: CTG04     Matrícula: 2173038752
**/

#include "stdafx.h"

#define TAM_A 50
#define TAM_B 50

void restar_cad(char *pA, char *pB, char *pC);

int main()
{
    char A[TAM_A], B[TAM_B], C[TAM_A];

    printf("Ingrese una cadena 'A' de max. 20 caracteres: ");
    fflush(stdin);
    gets_s(A);  // uso la nueva implementación de gets porque no me deja usar la anterior
    printf("Ingrese una cadena 'B' de max. 20 caracteres: ");
    fflush(stdin);
    gets_s(B);
    restar_cad(A,B,C);
    puts(C);
    return 0;
}


void restar_cad(char *pa, char *b, char *pc)
{
    char *pb; // solo declaro este puntero a parte porque es el que cambiará de valor

    pb = b;

    while (*pa != '\0')        // por alguna razón en el debugger, compara los elementos nulos de la cadena
    {                        // hace un recorrido de la cadena A comparando cada elemento con todos los elementos
                            // de la cadena B, si son iguales, sólo descarta esa letra y aumenta la posición del
                            // arreglo A y vuelve a comparar
        while (*pb != '\0')
        {


            if (*pa == *pb)
            {
                pa++;        // si son iguales, salta esa letra y reinicia la posicion del arreglo B
                pb = b;
            }
            else
                pb++;        // si no son iguales, checa el siguiente elemento
        }
                        // si recorrió el arreglo B y ninguno fue igual, entonces asigna la letra al arreglo C
        *pc = *pa;
        pc++;
        pb = b;        // reinicia la posición del arreglo B para buscar otra vez
        pa++;        // busca en el siguiente elemento del arreglo A
    }

    *pc = '\0';        // al copiar todas las letras, agrega el elemento nulo para poder usar puts
}
////////////////////////////////////////// FUNCIONAMIENTO DE ESTRUCTURAS CON PUNTEROS /////////////////////
/////////////  programa que crea una "agenda telefonica" de 5 elementos

#include "stdafx.h"
#include <stdio.h>
#include <stdlib.h>
                                //typedef genera un sinónimo para un tipo de dato, o sea, en vez de escribir al declarar una variable de tipo estrucura, solo escribes el sinónimo
                                //por ejemplo en vez de escribir struct Registro reg1  (variable llamada reg1 de tipo struct Registro), solo escribes registro reg1
typedef struct Registro{
    char nombre[15];
    char apellidos[25];
    char direccion[40];
    char cod_pos[8];
    char tel[15];
    char email[30];
    char facebook[30];
}registro; // sinónimo que queremos

int main()
{
    int exit=0, i;
    registro reg[3]; // arreglo de 3 elementos de tipo struct Registro
    registro *ap;  // apuntador a tipo de dato registro o tipo de dato struct Registro
    do
    {

        ap=reg;  // el apuntador apunta al primer elemento del arreglo de estructuras
        for(i=0;i<3;i++)
        {
            printf("\n AGENDA, REGISTRO #%d\n", i+1);
            printf("Ingrese el nombre: ");
            setbuf(stdin, NULL);  // esto es para "limpiar" el buffer de entrada, para que no entre basura en la cadena que se escriba
            gets(reg->nombre);   // cuando se usan apuntadores, para acceder al elemento ya no es *ap si no ap-> cuando se trata de estructuras
            printf("Ingrese los apellidos: ");
            setbuf(stdin, NULL);
            gets(reg->apellidos);
            printf("Ingrese el direccion: ");
            setbuf(stdin, NULL);
            gets(reg->direccion);
            printf("Ingrese el codigo postal: ");
            setbuf(stdin, NULL);
            gets(reg->cod_pos);
            printf("Ingrese el telefono: ");
            setbuf(stdin, NULL);
            gets(reg->tel);
            printf("Ingrese el email: ");
            setbuf(stdin, NULL);
            gets(reg->email);
            printf("Ingrese el facebook: ");
            setbuf(stdin, NULL);
            gets(reg->facebook);
            ap++; // se mueve una posicion, ahora apunta a reg[i+1]
        }
        ap=reg; // se vuelve a apuntar ap al inicio del arreglo de registro
        for(i=0;i<3;i++)
        {
            printf("\n");
            printf("\n AGENDA, REGISTRO #%d\n", i+1);
            printf("Nombre: %s \n", reg->nombre);
            printf("Apellidos: %s\n", reg->apellidos);
            printf("Direccion: %s\n", reg->direccion);
            printf("Codigo Postal: %s\n", reg->cod_pos);
            printf("Telefono: %s\n", reg->tel);
            printf("Email: %s\n", reg->email);
            printf("Facebook: %s\n", reg->facebook);
            printf("\n");
            ap++;
        }

        exit=1;
    }while(exit!=1);
    return 0;
}
//////////////////////////////////////// FUNCIONAMIENTO ESTRUCTURAS SIN PUNTEROS //////////////////////////
/////////////  programa que crea una "agenda telefonica" de 3 elementos y luego la imprime

#include "stdafx.h"
#include <stdio.h>
#include <stdlib.h>
                                //typedef genera un sinónimo para un tipo de dato, o sea, en vez de escribir al declarar una variable de tipo estrucura, solo escribes el sinónimo
                                //por ejemplo en vez de escribir struct Registro reg1  (variable llamada reg1 de tipo struct Registro), solo escribes registro reg1
typedef struct Registro{
    char nombre[15];
    char apellidos[25];
    char direccion[40];
    char cod_pos[8];
    char tel[15];
    char email[30];
    char facebook[30];
}registro; // sinónimo que queremos

int main()
{
    int exit=0, i;
    registro reg[3]; // arreglo de 3 elementos de tipo struct Registro
    do
    {


        for(i=0;i<3;i++)
        {
            printf("\n AGENDA, REGISTRO #%d\n", i+1);
            printf("Ingrese el nombre: ");
            setbuf(stdin, NULL);  // esto es para "limpiar" el buffer de entrada, para que no entre basura en la cadena que se escriba
            gets(reg[i].nombre);
            printf("Ingrese los apellidos: ");
            setbuf(stdin, NULL);
            gets(reg[i].apellidos);
            printf("Ingrese el direccion: ");
            setbuf(stdin, NULL);
            gets(reg[i].direccion);
            printf("Ingrese el codigo postal: ");
            setbuf(stdin, NULL);
            gets(reg[i].cod_pos);
            printf("Ingrese el telefono: ");
            setbuf(stdin, NULL);
            gets(reg[i].tel);
            printf("Ingrese el email: ");
            setbuf(stdin, NULL);
            gets(reg[i].email);
            printf("Ingrese el facebook: ");
            setbuf(stdin, NULL);
            gets(reg[i].facebook);
        }

        for(i=0;i<3;i++)
        {
            printf("\n");
            printf("\n AGENDA, REGISTRO #%d\n", i+1);
            printf("Nombre: %s \n", reg[i].nombre);
            printf("Apellidos: %s\n", reg[i].apellidos);
            printf("Direccion: %s\n", reg[i].direccion);
            printf("Codigo Postal: %s\n", reg[i].cod_pos);
            printf("Telefono: %s\n", reg[i].tel);
            printf("Email: %s\n", reg[i].email);
            printf("Facebook: %s\n", reg[i].facebook);
            printf("\n");
        }

        exit=1;
    }while(exit!=1);
    return 0;
}

//////////////////////////////// FUNCIONAMIENTO PUNTEROS /////////////////////////////////
#include "stdafx.h"
void imprimir(int *v, int *p, int c[]);


int main()
{

    int var, *puntero, C[]={10, 11, 12, 13, 14, 15};
    printf("\tvariable\tdireccion\tvalor\t\tindireccion\n");
    var=5;
    puntero=&var;
    imprimir(&var, puntero, C);

    printf("\n\n");
    printf("Haciendo 'puntero=C' y luego '*puntero=20'\n");
    puntero=C;
    imprimir(&var, puntero, C);


    printf("\n\n");
    *puntero=20;
    imprimir(&var, puntero, C);
    return 0;
}

void imprimir(int *v, int *p, int c[])
{
    int i;
    printf("\tvar\t\t%x\t\t%d\t\tN//A\n", v, *v);
    printf("\tpuntero\t\t%x\t\t%x\t\t%d\n", &p, p, *p);
    for(i=0;i<5;i++)
    {
        printf("\tC[%d]\t\t%x\t\t%d\t\tN//A\n", i, &c[i], c[i]);
    }
}

////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////// SIMULACION EXAMEN 14-P ////////////////////////////////////
// (i)Generar dos cadenas de literales y almacenarlas en arreglos A y B, respectivamente;
//(ii)Concatenar A con B y el resultado escribir al arreglo C.
//(iii) Mapear cada letra de C a un número correspondiente ('a' 0, 'b' 1, etc.) y a través de ello mapear todo contenido de C al //contenido de un arreglo numérico D;
//(iv) y, finalmente, graficar D en la ventana de consola
//

#include "stdafx.h"
#include <stdlib.h>

#define TAM_A 5
#define TAM_B 5
#define TAM_C TAM_A+TAM_B

void gen_cad(char a[], char b[]);
void imprimir(char t[], int tam);
void concatenar(char a[], char b[], char c[]);
int letra_a_entero(char l);
void gen_D(char c[], int d[]);

int main()
{
    char A[TAM_A], B[TAM_B], C[TAM_C];
    int D[TAM_C], i;

    gen_cad(A,B);
    imprimir(A,TAM_A);
    imprimir(B, TAM_B);
    concatenar(A,B,C);
    imprimir(C, TAM_C);
    gen_D(C,D);

    for(i=0;i<TAM_C;i++)
        printf("%d", D[i]);
    printf("\n");

    return 0;
}

void gen_cad(char a[], char b[])
{
    int i=0;
    for(i=0;i<TAM_A;i++)
        a[i]=97+rand()%(122-97);
    for(i=0;i<TAM_B;i++)
        b[i]=97+rand()%(122 - 97);

}

void imprimir(char t[], int tam)
{
    int i;
    for(i=0;i<tam;i++)
        putc(t[i], stdout);
    printf("\n");
}

void concatenar(char a[], char b[], char c[])
{
    int i=0;

        for(i=0;i<TAM_A; i++)
            c[i]=a[i];

        for(i=0;i<TAM_B; i++)
            c[i+TAM_B]=b[i];


}

int letra_a_entero(char l)
{
    int i;
    i=l-97;
    return i;
}

void gen_D(char c[], int d[])
{
    int i;
    for(i=0;i<TAM_C;i++)
        d[i]=i;//letra_a_entero(c[i]);

}
//////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////  TAREA 4 - Movimiento de un texto //////////////////////////////
//
//

#include "stdafx.h"
#include <conio.h>
#include <stdlib.h>
#define TAM_LINEA 46
#define TAM_PALABRA 11

int gen_linea(char l[], char p[]);
int mov_der(char l[], int pos, char pal[]);
int mov_izq(char l[], int pos, char pal[]);



int main()
{
    char tecla, linea[TAM_LINEA], palabra[TAM_PALABRA];
    int pos;
    printf("Movimiento de una palabra\n\n");
    pos = gen_linea(linea, palabra);
    puts(linea);
    printf("'a': mover izquierda, 's': mover derecha, 'x': salir\n");

    //@TODO: remove this line
    printf("%s en pos %d\n", palabra, pos);

    do
    {
        tecla = getch();

        switch (tecla)
        {
        case 'a':
            {
                pos = mov_izq(linea, pos, palabra);
                puts(linea);
                break;
            }
        case 'd':
            {
                pos = mov_der(linea, pos, palabra);
                puts(linea);
                break;
            }
        default:
            break;
        }



    } while (tecla != 'x');

    return 0;
}

int gen_linea(char l[], char pal[])
{
    int i, pos = rand() % (TAM_LINEA - 2);
    char *pp;

    for (i = 0; i < TAM_LINEA - 1; i++)
        l[i] ='-';
    l[i] = '\0';

    for (i = 0; i < TAM_PALABRA - 1; i++)
        pal[i] = 'a' + rand() % ('a' - 'z' + 1);
    pal[i] = '\0';

    pp = pal;

    for (i = 0; i < TAM_PALABRA - 1; i++)
    {
        if (pos + i > TAM_LINEA - 2)
            pos = 0 - i;
        l[pos + i] = *pp;
        pp++;
    }
    if (pos < 0)
        pos = TAM_LINEA - 1 + pos;

    return pos;
}

int mov_der(char l[], int pos, char pal[])
{
    int i, n_pos = pos + 1;
    char *pp;

    pp = pal;
    l[pos] = '-';

    for (i = 0; i < TAM_PALABRA - 1; i++)
    {
        if (n_pos + i > TAM_LINEA - 2)
            n_pos = 0 - i;

        l[n_pos + i] = *pp;

        pp++;
    }
    if (n_pos < 0)
        n_pos = TAM_LINEA - 1 + n_pos;

    return n_pos;
}

int mov_izq(char l[], int pos, char pal[])
{
    int i, n_pos = pos - 1;
    char *pp;

    pp = pal;

    l[pos + TAM_LINEA - 1] = '*';
    for (i = 0; i < TAM_PALABRA - 1; i++)
    {
        if (n_pos + i < 0)
            n_pos = TAM_LINEA - 2 - i;
        if (n_pos + i > TAM_LINEA - 2)
            n_pos = 0 - i;

        l[n_pos + i] = *pp;
        pp++;
    }
    if (n_pos < 0)
        n_pos = TAM_LINEA - 1 + n_pos;

    return n_pos;
}




////////////////////////////////////////////////////////////////////////////////////////////
//////////////////  contador de caracteres en una cadena  ////////////////////////////////

#include "stdafx.h"
#define TAM 101


int conteo(const char texto[])  // recibe como parametro un arreglo de caracteres, const es para no modificar la cadena original
{
    int num=0;
    while(texto[num]!='\0')    // cuenta los espacios del arreglo hasta que encuentra el simbolo de fin de cadena '\0'
            num++;
    return num;                 //Regresa el numero de espacios contados
}



int main()
{
    char palabra[TAM];      // Inicializacion del arreglo donde se guardara el texto


    printf("Introduce un texto: \n ");
    gets(palabra);          // funcion para obtener una cadena de caracteres (palabra) // funciona mejor que scanf porque es especial
    printf("\nEl numero de letas ingresadas fueron: %d\n", conteo(palabra));
                            // ya que la funcion regresa un entero, se puede imprimir directamente
    return 0;
}

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