Po wypełnieniu tablicy jej zawartość jest wyświetlana w  oknie konsoli wraz z wartościami haszu. Jeśli wartość haszu różni się od indeksu tablicy, to dany łańcuch został zapisany w innej komórce, ponieważ jego komórka była zajęta przez inny łańcuch.

W drugiej części program generuje wszystkie łańcuchy 4-znakowe z  liter A i B, a następnie wyszukuje je w tablicy haszowanej, wyświetlając kolejno: łańcuch, wartość haszu hf( ), liczbę obiegów pętli wyszukującej c oraz informację o pozycji łańcucha w tablicy, jeśli się tam znajduje. Zwróć uwagę na pozycje, dla których liczba obiegów c jest równa zero – te łańcuchy znaleziono od razu za pierwszym podejściem.

// Haszowanie z próbkowaniem liniowym
// Data: 16.06.2013
// (C)2013 mgr Jerzy Wałaszek
//-----------------------------------

program hashing;

// Funkcja haszująca
//------------------
function hf(s : string) : integer;
var
  h, i : integer;
begin
  h := 0;
  for i := 1 to length(s) do
    h := 2*h+1-(ord(s[i]) and 1);
  hf := h mod 10;
end;

// Funkcja tworzy łańcuch 4 znakowy z A i B
// na podstawie wartości bitów x
//-----------------------------------------
function s4(x : integer) : string;
var
  m : integer;
  s : string;
begin
  s := '';
  m := 8;  // Maska bitowa
  while m > 0 do
  begin
    if x and m = 0 then
      s := s+'A'
    else
      s := s+'B';
    m := m shr 1;
  end;
  s4 := s;
end;

//**********************
//*** PROGRAM GŁÓWNY ***
//**********************
var
  T : array [0..9] of string;
  i, j, h, c, p : integer;
  s : string;
begin
  randomize;

  // Zerujemy tablicę haszowaną
  for i := 0 to 9 do T[i] := '';

  // Tablicę wypełniamy łańcuchami
  for i := 0 to 9 do
  begin

    // Generujemy losowy łańcuch z 4 znaków A, B
    s := s4(random(16));

    // Łańcuch umieszczamy w tablicy haszowanej
    h := hf(s);
    j := h;
    while true do
    begin
      if T[j] = '' then
      begin
        T[j] := s;
        break;
      end;
      if T[j] = s then break;
      j := (j+1) mod 10;
      if j = h then break;
    end;
  end;

  // Wyświetlamy zawartość tablicy
  // wraz z wartością funkcji haszującej
  for i := 0 to 9 do
  begin
    write ('T[', i, '] = ');
    if T[i] <> '' then
      writeln(T[i], ' hf() = ', hf(T[i]))
    else
      writeln('-');
  end;

  writeln;

  // Sprawdzamy obecność łańcuchów
  // w tablicy haszowanej
  for i := 0 to 15 do
  begin
    s := s4(i); // Łańcuch
    h := hf(s); // Hasz łańcucha
    c := 0;     // Licznik obiegów
    j := h;
    p := -1;
    while true do
    begin
      if T[j] = '' then break;
      if T[j] = s then
      begin
        p := j; break;
      end;
      j := (j+1) mod 10;
      if j = h then break;
      inc(c);
    end;

    // Wyświetlamy wyniki
    write(s, ' hf() = ', h, ' c = ', c, ' ');
    if p > -1 then
      writeln('is in T[', p, '] ')
    else
      writeln('-');
  end;
  writeln;
end.

// Haszowanie z próbkowaniem liniowym
// Data: 16.06.2013
// (C)2013 mgr Jerzy Wałaszek
//-----------------------------------

#include <iostream>
#include <string>
#include <cstdlib>
#include <ctime>

using namespace std;

// Funkcja haszująca
//------------------
int hf(string s)
{
  unsigned int h, i;

  h = 0;
  for(i = 0; i < s.length(); i++)
    h = 2*h+1-(s[i]&1);
  return h%10;
}

// Funkcja tworzy łańcuch 4 znakowy z A i B
// na podstawie wartości bitów x
//-----------------------------------------
string s4(int x)
{
  string s = "";
  int m = 8; // Maska bitowa
  while(m)
  {
    s += (x&m)?'B':'A';
    m >>= 1;
  }
  return s;
}

//**********************
//*** PROGRAM GŁÓWNY ***
//**********************
int main()
{
  string T[10], s;
  int i, j, h, c, p;

  srand(time(NULL));

  // Zerujemy tablicę haszowaną
  for(i = 0; i < 10; i++) T[i] = "";

  // Tablicę wypełniamy łańcuchami
  for(i = 0; i < 10; i++)
  {
    // Generujemy losowy łańcuch z 4 znaków A, B
    s = s4(rand()%16);

    // Łańcuch umieszczamy w tablicy haszowanej
    h = hf(s);
    j = h;
    while(true)
    {
      if(T[j] == "")
      {
        T[j] = s;
        break;
      }
      if(T[j] == s) break;
      j = (j+1)%10;
      if(j == h) break;
    }
  }

  // Wyświetlamy zawartość tablicy
  // wraz z wartością funkcji haszującej
  for(i = 0; i < 10; i++)
  {
    cout << "T[" << i << "] = ";
    if(T[i] != "")
      cout << T[i] << " hf() = " << hf(T[i]);
    else
      cout << "-";
    cout << endl;
  }

  cout << endl;

  // Sprawdzamy obecność łańcuchów
  // w tablicy haszowanej
  for(i = 0; i < 16; i++)
  {
    s = s4(i); // Łańcuch
    h = hf(s); // Hasz łańcucha
    c = 0;     // Licznik obiegów
    j = h;
    p = -1;
    while(true)
    {
      if(T[j] == "") break;
      if(T[j] == s)
      {
        p = j; break;
      };
      j = (j+1)%10;
      if(j == h) break;
      c++;
    }

    // Wyświetlamy wyniki
    cout << s << " hf() = " << h
         << " c = " << c << " ";
    if(p > -1)
      cout << "is in T[" << p << "] ";
    else
      cout << "-";
    cout << endl;
  }

  cout << endl;

  return 0;
}

' Haszowanie z próbkowaniem liniowym
' Data: 16.06.2013
' (C)2013 mgr Jerzy Wałaszek
'-----------------------------------

' Funkcja haszująca
'------------------
Function hf(ByRef s As String) As Integer

  Dim As Integer h, i

  h = 0
  For i = 1 To Len(s)
    h = 2*h+1-(Asc(Mid(s, i, 1)) And 1)
  Next
  return h Mod 10
End Function

' Funkcja tworzy łańcuch 4 znakowy z A i B
' na podstawie wartości bitów x
'-----------------------------------------
Function s4(x As Integer) As String

  Dim As String s = ""
  Dim As Integer m = 8 ' Maska bitowa
  While m > 0
    if(x And m) = 0 Then
    	s += "A"
    Else
      s += "B"
    End If
    m Shr= 1
  Wend
  s4 = s
End Function

'**********************
'*** PROGRAM GŁÓWNY ***
'**********************

Dim As String T(9), s
Dim As Integer i, j, h, c, p

Randomize

' Zerujemy tablicę haszowaną
For i = 0 To 9: T(i) = "": Next

' Tablicę wypełniamy łańcuchami
For i = 0 To 9

  ' Generujemy losowy łańcuch z 4 znaków A, B
  s = s4(Int(Rnd()*16))

  ' Łańcuch umieszczamy w tablicy haszowanej
  h = hf(s)
  j = h
  while 1
    If T(j) = "" Then
      T(j) = s
      Exit While
    End If
    If T(j) = s Then Exit While
    j = (j+1) Mod 10
    If j = h Then Exit While
  Wend
Next

' Wyświetlamy zawartość tablicy wraz
' z wartością funkcji haszującej
For i = 0 To 9
  Print Using "T[&] = ";i;
  If T(i) <>  "" Then
    Print Using "& hf() = &";T(i);hf(T(i))
  Else
    Print "-"
  End If
Next

Print

' Sprawdzamy obecność łańcuchów
' w tablicy haszowanej
For i = 0 To 15
  s = s4(i) ' Łańcuch
  h = hf(s) ' Hasz łańcucha
  c = 0     ' Licznik obiegów
  j = h
  p = -1
  While 1
    if T(j) = "" Then Exit While
    If T(j) = s Then
      p = j
      Exit While
    End If
    j = (j+1) Mod 10
    If j = h Then Exit While
    c += 1
  Wend

  ' Wyświetlamy wyniki
  Print Using "& hf() = & c = & ";s;h;c;
  If p > -1 Then
    Print Using "is in T[&] ";p
  Else
    Print "-"
  End If
Next
Print
End

# Haszowanie z próbkowaniem liniowym
# Data: 6.04.2024
# (C)2024 mgr Jerzy Wałaszek
# ----------------------------------

import random


# Funkcja haszująca
#------------------
def hf(s):
    h = 0
    for i in s:
        h = 2*h+1-(ord(i)&1)
    return h%10


# Funkcja tworzy łańcuch 4 znakowy z A i B
# na podstawie wartości bitów x
#-----------------------------------------
def s4(x):
    s = ""
    m = 8 # Maska bitowa
    while m > 0:
        if x & m > 0:
            s += "B"
        else:
            s += "A"
        m >>= 1
    return s


#**********************
#*** PROGRAM GŁÓWNY ***
#**********************

t, s = [], ""

# Zerujemy tablicę haszowaną
t = ['' for i in range(10)]
# Tablicę wypełniamy łańcuchami
for i in range(10):
    # Generujemy losowy łańcuch z 4 znaków A, B
    s = s4(random.randrange(16))
    # Łańcuch umieszczamy w tablicy haszowanej
    h = hf(s)
    j = h
    while True:
        if(t[j] == ""):
            t[j] = s
            break
        if t[j] == s:
            break
        j = (j+1)%10
        if j == h: break
# Wyświetlamy zawartość tablicy
# wraz z wartością funkcji haszującej
for i in range(10):
    print("T[%d] = " % i, end="")
    if t[i] != "":
        print(t[i], "hf() =", hf(t[i]))
    else:
        print("-")
print()
# Sprawdzamy obecność łańcuchów
# w tablicy haszowanej
for i in range(16):
    s = s4(i) # Łańcuch
    h = hf(s) # Hasz łańcucha
    c = 0     # Licznik obiegów
    j = h
    p = -1
    while True:
        if t[j] == "": break
        if t[j] == s:
            p = j
            break
        j = (j+1)%10
        if j == h:
            break
        c += 1
    # Wyświetlamy wyniki
    print(s, "hf() =", h, "c =", c, end=" ")
    if p > -1:
        print("is in T[%d]" % p)
    else:
        print("-")
print()