PROCEDURE ObtenerNota(propuesta, codigo: TipoCodigo; VAR buenos, regulares: RangoBR);

void ObtenerNota(TipoCodigo propuesta, TipoCodigo codigo, RangoBR &buenos, RangoBR &regulares) {

PROGRAM MasterMind (input, output);
CONST
	MAXIMO_INTENTOS = 20;
	LARGO_CODIGO = 6;
	PRIMERA_LETRA = 'A';
	ULTIMA_LETRA = 'H';
TYPE
	RangoCodigo = 1..LARGO_CODIGO;
	TipoCodigo = ARRAY [RangoCodigo] OF Char;
 
	RangoBR = 0..LARGO_CODIGO;
	TRegistroNota = RECORD
						codigo: TipoCodigo;
						buenos,
						regulares: RangoBR
					END;
 
    THistoria = RECORD
					info: ARRAY [1..MAXIMO_INTENTOS] OF TRegistroNota;
					tope: 0..MAXIMO_INTENTOS
				END;
 
	ListaNotas = ^CeldaNota;
	CeldaNota = RECORD
					codigo: TipoCodigo;
					buenos,
					regulares: RangoBR;
					turno: 1..MAXIMO_INTENTOS;
					siguiente: ListaNotas
				END;
VAR
	secreto, codigo: TipoCodigo;
	historia: THistoria;
	buenos, regulares: RangoBR;
	i, intentos: Integer;
	exito, fracaso: Boolean;	
	lista: ListaNotas;
 
FUNCTION EsValido(codigo: TipoCodigo): Boolean;
VAR
	i: Integer;
BEGIN
	i := 1;
	WHILE (i <= LARGO_CODIGO) AND (codigo[i] >= PRIMERA_LETRA) AND (codigo[i] <= ULTIMA_LETRA) DO
		i := i + 1;
	EsValido :=  i > LARGO_CODIGO	
END;
 
PROCEDURE ObtenerNota(propuesta, codigo: TipoCodigo; VAR buenos, regulares: RangoBR);
VAR
	i, j, max: Integer;
	propuestacopia: TipoCodigo;
BEGIN
	buenos := 0;
	FOR i := 1 TO LARGO_CODIGO DO
	BEGIN
		IF propuesta[i] = codigo[i] THEN
			buenos := buenos + 1;
		propuestacopia[i] := propuesta[i]
	END;
	max := 0;
	FOR i := 1 TO LARGO_CODIGO DO
	BEGIN
		j := 1;
		WHILE (j <= LARGO_CODIGO) AND (codigo[i] <> propuestacopia[j]) DO
			j := j + 1;
		IF j <= LARGO_CODIGO THEN
		BEGIN
			max := max + 1;
			propuestacopia[j] := ' '
		END
	END;
	regulares := max - buenos
END;
 
PROCEDURE IniciarHistoria(VAR historia: THistoria);
BEGIN
	WITH historia DO
		tope := 0
END;
 
PROCEDURE GuardarNota(VAR historia: THistoria;
						codigo: TipoCodigo;
						buenos, regulares: RangoBR);
VAR
	i: Integer;
BEGIN
	WITH historia DO
	BEGIN
		tope := tope + 1;
		FOR i := 1 TO LARGO_CODIGO DO
			info[tope].codigo[i] := codigo[i];
		info[tope].buenos := buenos;
		info[tope].regulares := regulares
	END
END;
 
FUNCTION ListaOrdenada(historia: THistoria): ListaNotas;
VAR
	i, j: Integer;
	p, actual, anterior, lista: ListaNotas;
BEGIN
	lista := NIL;
	FOR i := 1 TO historia.tope DO
	BEGIN
		new(p);
		FOR j := 1 TO LARGO_CODIGO DO
			p^.codigo[j] := historia.info[i].codigo[j];
		p^.buenos := historia.info[i].buenos;
		p^.regulares := historia.info[i].regulares;
		p^.turno := i;
 
		actual := lista;
		anterior := lista;
		WHILE (actual <> NIL) AND (10 * actual^.buenos + actual^.regulares <= 10 * p^.buenos + p^.regulares) DO
		BEGIN
			anterior := actual;
			actual := actual^.siguiente
		END;
		IF (anterior = NIL) OR (anterior = actual) THEN
		BEGIN
			p^.siguiente := anterior;
			lista := p
		END
		ELSE
		BEGIN
			p^.siguiente := actual;
			anterior^.siguiente := p
		END
	END;
	ListaOrdenada := lista
END;
 
PROCEDURE GenerarCodigo(VAR codigo: TipoCodigo);
VAR
	i: Integer;
	ordprim, ordult: Integer;
BEGIN
	ordprim := ord(PRIMERA_LETRA);
	ordult  := ord(ULTIMA_LETRA);
	FOR i := 1 TO LARGO_CODIGO DO
		codigo[i] := chr(ordprim + random(ordult - ordprim + 1))
END;
 
PROCEDURE LeerCodigo(VAR codigo: TipoCodigo);
VAR
	i: Integer;
BEGIN
	FOR i := 1 TO LARGO_CODIGO DO
		Read(codigo[i]);
	ReadLn
END;
 
	(* ------ Programa Principal ------ *)
BEGIN
	Randomize;
	IniciarHistoria(historia);
	GenerarCodigo(secreto);
	intentos := 0;
	exito := false;
	fracaso := false;
	WriteLn('He pensado un codigo, intenta adivinarlo.');
	WriteLn('*Pista: tiene ', LARGO_CODIGO, ' letras y estas estan entre la ', PRIMERA_LETRA, ' y la ', ULTIMA_LETRA);
	WriteLn('Las letras pueden repetirse o no aparecer en mi codigo, y solo tienes ', MAXIMO_INTENTOS, ' intentos.');
	WriteLn;
	REPEAT
		LeerCodigo(codigo);
		WHILE NOT EsValido(codigo) DO
		BEGIN
			WriteLn('El codigo no es valido, intentalo de nuevo.');
			LeerCodigo(codigo)
		END;
		intentos := intentos + 1;
		ObtenerNota(codigo, secreto, buenos, regulares);
		IF buenos = LARGO_CODIGO THEN
			exito := true
		ELSE IF intentos = MAXIMO_INTENTOS THEN
				fracaso := true
			ELSE
			BEGIN
				Write('B: ', buenos, '   R: ', regulares);
				WriteLn('                      Te quedan ', MAXIMO_INTENTOS - intentos, ' intentos')
			END;
		GuardarNota(historia, codigo, buenos, regulares)
	UNTIL exito OR fracaso;
	WriteLn;
	WriteLn;
	IF exito THEN
		WriteLn('***** FELICIDADES, has ganado. *****')
	ELSE
	BEGIN
		WriteLn('--- Demasiados intentos, perdiste. ---');
		Write  ('    El codigo secreto era: ');
		FOR i := 1 TO LARGO_CODIGO DO
			Write(secreto[i])
	END;
	WriteLn;
	WriteLn;
	lista := ListaOrdenada(historia);
	WHILE lista <> NIL DO
	BEGIN
		FOR i := 1 TO LARGO_CODIGO DO
			Write(lista^.codigo[i]);
		Write(' -->  Bs = ', lista^.buenos, ',  Rs = ', lista^.regulares, ' (Turno: ', lista^.turno, ')');
		WriteLn;
		lista := lista^.siguiente
	END;
	ReadLn
END.

#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#include <time.h>
 
const int MAXIMO_INTENTOS = 20;
const int LARGO_CODIGO = 6;
const char PRIMERA_LETRA = 'A';
const char ULTIMA_LETRA = 'H';
 
typedef char TipoCodigo[LARGO_CODIGO + 1];
 
bool EsValido(TipoCodigo codigo) {
	// Devuelve true si el codigo es valido.
	int i = 1;
	while (i <= LARGO_CODIGO && codigo[i] >= PRIMERA_LETRA && codigo[i] <= ULTIMA_LETRA)
		i++;
	// Es valido si todos los elementos del codigo estan en el rango.
	return i > LARGO_CODIGO;
}
 
void ObtenerNota(TipoCodigo propuesta, TipoCodigo codigo, unsigned int &buenos, unsigned int &regulares) {
	// Obtener cantidad de buenos y regulares entre dos codigos.
	TipoCodigo propuestacopia;
	buenos = 0;
	for (int i = 1; i <= LARGO_CODIGO; i++) {
		if (propuesta[i] == codigo[i]) buenos++;
		propuestacopia[i] = propuesta[i];
	}
	int max = 0;
	// Hallar la "maxima" cantidad de buenos.
	for (int i = 1; i <= LARGO_CODIGO; i++) {
		int j = 1;
		while (j <= LARGO_CODIGO && codigo[i] != propuestacopia[j]) j++;
		if (j <= LARGO_CODIGO) {
			// Borrar la letra para no volver a usar la misma.
			propuestacopia[j] = ' ';
			max++;
		}
	}
	regulares = max - buenos;
}
 
void GenerarCodigo(TipoCodigo &codigo) {
	// Generar codigo aleatorio
	int ord_prim = (int)PRIMERA_LETRA;
	int ord_ult = (int)ULTIMA_LETRA;
	for (int i = 1; i <= LARGO_CODIGO; i++)
		codigo[i] = ord_prim + rand() % (ord_ult - ord_prim + 1);
}
 
void LeerCodigo(TipoCodigo &codigo) {
	char c;
	for (int i = 1; i <= LARGO_CODIGO; i++) {
		scanf("%c", &c);
		codigo[i] = toupper(c);
	}
	do {
		c = getchar();
	} while (c != '\n');
}
 
int main() {
	srand(time(NULL));
	TipoCodigo secreto;
	GenerarCodigo(secreto);
	int intentos = 0;
	bool exito = false;
	bool fracaso = false;
	printf("He pensado un codigo, intenta adivinarlo.\n");
	printf("*Pista: tiene %d letras y estas estan entre la %c y la %c\n", LARGO_CODIGO, PRIMERA_LETRA, ULTIMA_LETRA);
	printf("Las letras pueden repetirse o no aparecer en el codigo, y solo tienes %d intentos.\n\n", MAXIMO_INTENTOS);
	do {
		TipoCodigo codigo;
		LeerCodigo(codigo);
		while (!EsValido(codigo)) {
			printf("El codigo no es valido, intentalo de nuevo.\n");
			LeerCodigo(codigo);
		}
		intentos++;
		unsigned int buenos, regulares;
		ObtenerNota(codigo, secreto, buenos, regulares);
		if (buenos == LARGO_CODIGO) exito = true;
		else if (intentos == MAXIMO_INTENTOS) fracaso = true;
		else {
			printf("B: %d   R: %d", buenos, regulares);
			printf("                      Te quedan %d intentos\n", MAXIMO_INTENTOS - intentos);
		}
	} while (!(exito || fracaso));
 
	printf("\n\n");
	if (exito) printf("***** FELICIDADES, has ganado. *****\n");
	else {
		printf("--- Demasiados intentos, perdiste. ---\n");
		printf("El codigo secreto era: ");
		for (int i = 1; i <= LARGO_CODIGO; i++) printf("%c", secreto[i]);
	}
	printf("\n");
}