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.