#include "stdafx.h"

#include <stdio.h>
#include <stdlib.h>
#include <conio.h>


/*Simulacro de examen parcial 2 
corresponde a 
http://newton.uam.mx/xgeorge/uea/Intro_Pro/MUESTRAS_EXAMENES/Ex_2/PE_ex_2_21_P.doc
*/

//burbuja para cadena de literales implementada como funcion
void ordenamiento_caracteres(char *b /*b[]*/) {
	bool desorden;
	do {
		desorden = false;
		puts(b);
		int i = 0;
		while (*(b + i) /*b[i]*/ != '\0'
			&& *(b + i + 1) /*b[i + 1]*/ != '\0')
		{
			if (*(b + i) /*b[i]*/ >
				*(b + i + 1) /*b[i + 1]*/) {
				desorden = true;
				char aux = *(b + i) /*b[i]*/;
				*(b + i) /*b[i]*/ = *(b + i + 1) /*b[i + 1]*/;
				*(b + i + 1) /*b[i + 1]*/ = aux;
			}
			i++;
		}
	} while (desorden == true);
}

#define L 40
char gen_letra() {
	char alfabeto[] = { 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i' };
	return alfabeto[rand() % 9];
}

/*generar cadena de literales
de longitud aleatoria menor que dim*/
void gencad(char *c /*c[]*/, int dim) {
	int i, N = rand() % (dim - 1);
	for (i = 0; i < N; i++)
		*(c + i) /*c[i]*/ = gen_letra();
	*(c + i) /*c[i]*/ = '\0';
}//fin gencad


 /*funcion regresa posicion de la ultima letra
 en una cadena de literales*/
int ultima_letra(char* pA)
{
	int pos = 0;
	while (*(pA + pos) != '\0')
		pos++;
	return pos;
}

/*funcion para copiar simbolos de A[] a B[]
en el orden invertido*/
void invertir(char* pA, char* pB)
{
	int pos_ult = ultima_letra(pA),
		pos = pos_ult - 1, i;
	for (i = 0; i < pos_ult; i++, pos--)
		*(pB + i) = *(pA + pos);

	*(pB + i) = '\0'; //clausurar B[] con fin de cadena
}

/*funcion copia simbolos de B[] a D[]
excepto aquellos que pertencen a C[]*/
void copiaralgo(char* pB, char* pC, char* pD)
{ /*pB sera modificada para representar
  corriente posicion de letra en B[]*/

	int iD = 0; //para representar corriente
				//posicion en D[]

	while (*pB != '\0')
	{
		/*revisar la letra corriente en B[]
		sobre pertenecia a C[]*/

		bool no_pertenece_a_C = true;
		int i = 0;
		while (*(pC + i) != '\0')
		{
			if (*pB == *(pC + i)) {
				no_pertenece_a_C = false;
				/*al detectar que letra corriente de B[]
				pertenece a C[], interrumpimos ciclo*/
				break;
			}
			i++;
		}
		if (no_pertenece_a_C == true)
		{
			/*copiar letra de B[] a D[]*/
			*(pD + iD) = *pB;
			iD++;
		}
		pB++; //ir a la siguiente letra de B[]
	}
	*(pD + iD) = '\0';//clausurar cadena D[]
}

int main()
{
	char A[L], B[L], C[L], D[L];

	char control;
	do {
		gencad(A /*c[]*/, L - 1);
		puts("A:\n");
		puts(A);
		invertir(A, B);
		puts("B es invertida A:\n");
		puts(B);
		puts("dame C menor que L-1 simbolo:\n");
		gets_s(C);
		puts("C para restar de B:\n");
		puts(C);
		copiaralgo(B, C, D);
		puts("D es la resta B-C:\n");
		puts(D);
		ordenamiento_caracteres(D);
		puts("\nD ordenada:\n");
		puts(D);
		printf("oprimes una letra diferente de 't' ");
		printf(" para continuar\n");
		printf("oprimes 't' para terminar\n");
		control = _getch();
	} while (control != 't');

	return 0;
}