[Código] Major/PhonETic memory system

[guidjos 65]

Pra quem nunca ouviu falar, esse é um sistema de memorização que associa cada dígito em [0; 9] a um conjunto de fonemas consonantais. Dessa forma, podemos criar palavras e imagens a partir de números, que são conceitos menos abstratos, e, portanto, mais familiares a nossos cérebros. Podemos, então, nos lembrar de números imensos com facilidade.

 

A única "dificuldade" do método é se lembrar da tabela de dígitos / conjuntos de fonemas. Por isso, criei um programa que, dado um número inteiro, lista, em ordem, os fonemas que podem ser usados para representá-lo. Pensei em criar algo que listasse todas as possíveis permutações de fonemas, mas o próximo passo para me familiarizar com o método é ser capaz de fazer o processo sozinho, e escolher a melhor permutação, sem ser necessário escrever tudo.

 

Um exemplo de entrada e saída:

 

>major 23846


permutations for the translation of 23846:

 { n }  { m }  { v, f }  { r }  { sh, j, dg, (g), zh, (ch) }

O código está aqui, e há comentários que definem a tabela de conversão de dígitos para fonemas consonantais.

 

Informações sobre o sistema de memorização:

 

 http://www.mindtools.com/pages/article/newTIM_07.htm
 http://www.mindmagician.org/memmajor.aspx
 http://www.academictips.org/memory/majorsys.html

;)

[guidjos 65]

Como o link saiu do ar, segue o código aqui mesmo:

 

/*
* Exercise to learn the "Major Memory System", which associates each number
* with a set of phonetic units, in order to make it possible to create
* images from numbers, thus enabling us to extend other memory systems 
* to easily recall big, random digit combinations.
*
*
* This program will translate a positive integer input to its correspondent set
* of mnemonic permutations.
*
* The mnemonic table reads as follows:
*
* digit		mnemonic correspondent(s)
* -----		--------------------------
*
*  0			s, z, soft c
*
*  1			d, t, th
*
*  2			n
*
*  3			m
*
*  4			r
*
*  5			l
*
*  6			sh, j, soft ch, dg, zh, soft g
*
*  7			k, hard c, hard g, q, qu
*  
*  8			v, f
*
*  9			b, p
*
*
*		guidjos
*/

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

#define EOSEQUENCE 	-1	// defines the end of a digit sequence.
#define MAXDIGITS 	100 	// you will run out of memory a lot earlier than your machine.

void usage(char *executablename)
{
printf("\n\tUsage: %s [positive integer sequence]\n\n", executablename);
exit(1);
}




// Converts user input into an array of integers, and returns the array's value.
// The array's last element is EOSEQUENCE.

int *readdigits(char **argv)
{

if (!argv[1]) usage(argv[0]);

char *asciisequence = argv[1];

int i;
int *sequence = malloc(MAXDIGITS * sizeof *sequence);

for (i = 0; asciisequence[i] && i < 100; i++)
{
	if (!(asciisequence[i] >= 48 && asciisequence[i] <= 57))
		usage(argv[0]);

	sequence[i] = asciisequence[i] - 48;
}

sequence[i] = EOSEQUENCE;

return sequence;
}


int main(int argc, char **argv)
{

// Our translation table. Each index of the array of array of pointer to char (0 - 9)
// contains all the "string" values associated with that index' numerical representation.
//
// [x] means "hard x",
// (x) means "soft x".

char *mnemtable[][10] =
{
	{"s", "z", "(c)"},
	{"d", "t", "th"},
	{"n"},
	{"m"},
	{"r"},
	{"l"},
	{"sh", "j", "dg", "(g)", "zh", "(ch)"},
	{"k", "[c]", "[g]", "q", "qu"},
	{"v", "f"},
	{"b", "p"}
};



// each element of this array represents the number of elements of each corresponding
// array of pointers to char in the mnemonic table above. This will be used to iterate
// through each entry of our mnemonic translation table.

int nrofentries[] = {3, 3, 1, 1, 1, 1, 6, 5, 2, 2};


int *digits = readdigits(argv);
int i, j;

printf("\n\npermutations for the translation of %s:\n\n", argv[1]);

for (i = 0; digits[i] != EOSEQUENCE; i++)
{
	printf(" { ");
	for (j = 0; j < nrofentries[ digits[i] ]; j++)
	{
		printf("%s", mnemtable[ digits[i] ][j]);

		if (j + 1 < nrofentries[ digits[i] ]) printf(", ");
		else printf(" ");
	}
	printf("} ");
}

printf("\n\n");

return 0;
}