== code(c) |
procedura Analizeaza(Pozitie P)

  cauta P in lista de pozitii deja analizate
  daca P nu exista in lista
    expandeaza P si afla cea mai buna mutare M
    adauga P la lista de pozitii analizate
    intoarce M
  altfel
    intoarce valoarea M atasata pozitiei P gasite in lista

    cauta P in lista de pozitii deja analizate
    daca P nu exista in lista
        expandeaza P si afla cea mai buna mutare M
        adauga P la lista de pozitii analizate
        intoarce M
    altfel
        intoarce valoarea M atasata pozitiei P gasite in lista

sfarsit
==

Iata primul set de proceduri de gestionare a unui Hash.
== code(c) |

#define M 1000 // numarul de "intrari" //

const int M = 1000;

typedef int Hash[M];
typedef int DataType;
Hash H;

void InitHash1(Hash H)
{
  for (int i=0; i<M; H[i++]=0);

void InitHash1(Hash H) {
    for (int i=0; i<M; H[i++]=0);

}

inline int h(DataType K)
{
  return K;

inline int h(DataType K) {
    return K;

}

int Search1(Hash H, DataType K)
/* Intoarce -1 daca elementul nu exista in hash
   sau indicele in hash daca el exista */
{
  return H[h(K)] ? h(K) : -1;

int Search1(Hash H, DataType K) {
    /* Intoarce -1 daca elementul nu exista in hash
     * sau indicele in hash daca el exista */
    return H[h(K)] ? h(K) : -1;

}

void Add1(Hash H, DataType K)
{
  H[h(K)]=1;

void Add1(Hash H, DataType K) {
    H[h(K)]=1;

}

void Delete1(Hash H, DataType K)
{
  H[h(K)]=0;

void Delete1(Hash H, DataType K) {
    H[h(K)]=0;

}
==

== code(c) |
#include <stdio.h>
#include <stdlib.h>

#define M 1000 // numarul de "intrari"

 
const int M = 1000;

typedef struct _List {

          long P;
          struct _List * Next;
        } List;
typedef List * Hash[M];

    long P;
    struct _List *Next;
} List;
typedef List* Hash[M];

Hash H;

void InitHash2(Hash H)
{
  for (int i=0; i<M; H[i++]=NULL);
}
 
int h2(int K)
{
  return K%M;
}
 
int Search2(Hash H, int K)
/* Intoarce 0 daca elementul nu exista in hash
   sau 1 daca el exista */
{
  List *L;
  for (L=H[h2(K)]; L && (L->P != K); L = L->Next);
  return L!=NULL;
}
 
void Add2(Hash H, int K)
{
  List *L = malloc(sizeof(List));
  L->P = K;
  L->Next = H[h2(K)];
  H[h2(K)] = L;

void InitHash2(Hash H){
    for (int i=0; i<M; H[i++]=NULL);
}
 
int h2(int K) {
    return K % M;
}
 
int Search2(Hash H, int K) {
    /* Intoarce 0 daca elementul nu exista in hash
     * sau 1 daca el exista */
    List *L;
    for (L=H[h2(K)]; L && (L->P != K); L = L->Next);
    return L!=NULL;
}
 
void Add2(Hash H, int K) {
    List *L = (List *) malloc(sizeof(List));
    L->P = K;
    L->Next = H[h2(K)];
    H[h2(K)] = L;

}
==

In incheiere, prezentam un exemplu de functie de dispersie pentru cazul tablei de sah.
== code(c) |

#define M 9973 // numarul de "intrari"

const int M = 9973; /* numarul de "intrari" */

typedef struct {

          char b_T[8][8];
            /* tabla de joc, cu 0<= T[i][j] <=12 */
          char b_CastleW, b_CastleB;
            /*  ultimii doi biti ai lui b_CastleW
                indica daca albul are dreptul de a
                efectua rocada mare, respectiv pe cea
                mica. Analog pentru b_CastleB */
          char b_Side;
            /* 0 sau 1, dupa cum la mutare este albul
               sau negrul */
          char b_EP;
            /* 0..8, indicand coloana (0..7) pe care
               partea la mutare poate efectua o
               captura "en passant". 8 indica ca nu
               exista aceasta posibilitate */
          int b_NMoves;
            /* Numarul de mutari efectuate */
        } Board;

    char b_T[8][8];
    /* tabla de joc, cu 0 <= T[i][j] <= 12 */
    char b_CastleW, b_CastleB;
    /* ultimii doi biti ai lui b_CastleW
     * indica daca albul are dreptul de a
     * efectua rocada mare, respectiv pe cea
     * mica. Analog pentru b_CastleB */
    char b_Side;
    /* 0 sau 1, dupa cum la mutare este albul
     * sau negrul */
    char b_EP;
    /* 0..8, indicand coloana (0..7) pe care
     * partea la mutare poate efectua o
     * captura "en passant". 8 indica ca nu
     * exista aceasta posibilitate */
    int b_NMoves;
    /* Numarul de mutari efectuate */
} Board;

Board B;

int h3(Board *B)
{
  int i,j;
  /* Valoarea initiala a lui S este un numar pe 17 biti care
     inglobeaza toate variabilele suplimentare pe langa T.
     S se va lua apoi modulo M */
  long S = (B->b_NMoves           /* 8 biti */
          +(B->b_CastleW << 8)    /* 2 biti */
          +(B->b_CastleB << 10)   /* 2 biti */
          +(B->b_Side << 12)      /* 1 bit */
          +(B->b_EP << 13)) % M;      /* 4 biti */
 
  for (i=0; i<=7; i++)
    for (j=0; j<=7; j++)
      S=(16*S+B->b_T[i][j])%M;

int h3(Board *B) {
    int i, j;
    /* Valoarea initiala a lui S este un numar pe 17 biti care
     * inglobeaza toate variabilele suplimentare pe langa T.
     * S se va lua apoi modulo M */
    long S = (B->b_NMoves           /* 8 biti */
            +(B->b_CastleW << 8)    /* 2 biti */
            +(B->b_CastleB << 10)   /* 2 biti */
            +(B->b_Side << 12)      /* 1 bit  */
            +(B->b_EP << 13)) % M;  /* 4 biti */
 
    for (i=0; i<=7; i++)
        for (j=0; j<=7; j++) {
            S = (16*S + B->b_T[i][j]) % M;
        }

  return S;

    return S;

}
==

* "UVA 10815 - Andy's First Dictionary":http://icpcres.ecs.baylor.edu/onlinejudge/external/108/10815.html
* 'UVA 10887 - Concatenation of Languages':http://icpcres.ecs.baylor.edu/onlinejudge/external/108/10887.html
* 'UVA 704 - Colour Hash':http://icpcres.ecs.baylor.edu/onlinejudge/external/7/704.html

 
*Feedback (Stefan):* E nevoie de mai multe exemple sau mai multe detalii pentru anumite probleme?