Wykład 5. Operacje na tablicach

Wykład 5. Operacje na tablicach
1. Opis i deklarowanie zmiennej tablicowej
Tablica jest strukturą danych, zawierająca stałą liczbę elementów. Każdy
z tych elementów jest jednakowego typu.
Typem elementu tablicy może być typ znakowy, jeden z typów liczbowych, lub typ strukturalny. Można także utworzyć tablicę, której elementy także są tablicami – będzie to tablica dwuwymiarowa.
Na rysunku 1 pokazano tablicę, która zawiera 6 elementów typu int.
Adresy
elementów
FFDC
FFDE
FFE0
FFE2
FFE4
FFE6
Przykładowa
zawartość
Odwołania
do elementów
-1
tab[0]
4
tab[1]
-10
tab[2]
8
tab[3]
17
tab[4]
2
tab[5]
Rys. 1. Struktura zmiennej tablicowej int tab[6]
Deklaracja zmiennej tablicowej ma ogólną postać:
typ_elementów_tablicy nazwa_zmiennej_tablicowej [rozmiar_tablicy];
Rozmiaru tablicy, czyli liczby jej elementów, nie można zmieniać
w czasie wykonywania programu. Jest to wartość stała, którą można
zapisać w postaci stałej jawnej lub stałej definiowanej. Definiując stałą
dla rozmiaru tablicy posługujemy się typem całkowitym, lub specjalnie
do tego przeznaczonym typem size_t. Na przykład tablica z rysunku 8.1
będzie zadeklarowana następująco:
const int R=6; // lub: const size_t R=6;
int tab[R];
2
Tablicę można zapełnić z klawiatury, lub za pomocą odpowiednich
instrukcji programu. Początkowe wartości elementów można zainicjować
przy deklarowaniu tablicy:
int tab[R]={-1,4,-10,8,17,2};
Jak widać, wartości elementów wpisuje się po znaku ‘=’, w postaci
ich listy, ujętej w nawiasy klamrowe. Warto podkreślić, że liczba wpisanych wartości nie może być większa od rozmiaru tablicy. Jeżeli wpiszemy mniej niż R wartości, to pozostałe elementy tablicy będą równe zeru.
2. Odwoływanie się do elementów tablicy
Chcąc odnieść się w jakimś wyrażeniu do określonego elementu
tablicy, piszemy nazwę zmiennej tablicowej, a za nią, w nawiasach kwadratowych, numer pozycji, zwany indeksem. Na przykład, chcąc zapisać
zero na pozycji 2 zmiennej tablicowej tab, napiszemy:
tab[2]=0;
Indeksem pierwszego elementu tablicy zawsze jest liczba 0.
Ostatni element ma indeks R-1, gdzie R to rozmiar tablicy.
Indeks elementu tablicy jest typu całkowitego.
Może być stałą jawną, stałą definiowaną, zmienną, wyrażeniem.
Przykład:
Zamiana miejscami wartości na dwóch początkowych pozycjach tablicy
tab:
int tab[6],j=0,buf;
buf=tab[j];
tab[j]=tab[j+1];
tab[j+1]=buf.
Uwaga: Nie wolno przekraczać definiowanego zakresu indeksów!
3. Wskaźnikowe odwołania do elementów
W języku C++ nazwa zmiennej tablicowej jest stałą wskaźnikową, która
jest równa jest adresowi tej zmiennej:
tab==&tab[0]
3
Adresy kolejnych elementów tablicy są odpowiednio przesunięte względem adresu elementu początkowego.
Adres k-tego elementu tablicy o nazwie tab to:
tab+k
Pamiętajmy, że symbol ‘+’ użyty w tym wyrażeniu nie oznacza dodawania, lecz przesunięcie o k elementów typu int względem adresu elementu
początkowego &tab[0]. Pokazuje to rysunek 2.
Względne
adresy
elementów
tab
tab+1
tab+2
tab+3
tab+4
tab+5
Przykładowa
zawartość
Odwołania
wskaźnikowe
-1
* tab
4
* (tab+1)
-10
* (tab+2)
8
* (tab+3)
17
* (tab+4)
2
* (tab+5)
Rys. 2. Wskaźnikowe odwołania do tablicy int tab[6]
Za pomocą wskaźników można odwoływać się do wskazywanych
przez nie zmiennych, pisząc przed wskaźnikiem symbol * .
Dwa sposoby odwołania się do k–tego elementu tablicy:
tab[k]=0;
//odwołanie przez indeks
*(tab+k)=0; //odwołanie przez wskaźnik
4
4. Tablica jako argument funkcji
Argument tablicowy może mieć postać indeksową lub wskaźnikową.
Przykład:
Funkcja znajduje w tablicy tab[] liczbę elementów równych x. Wynik
ile jest przekazywany przez referencję. Nagłówek funkcji:
void policz(int tab[],int r,int x,int &ile)
lub:
void policz(int *tab,int r,int x,int &ile)
Przez argument r przekazuje się rozmiar tablicy. Dzięki temu funkcja
może operować na tablicach o różnej liczbie elementów.
5. Zapełnianie losowe tablicy i drukowanie jej zawartości.
Przykład:
Program z funkcjami własnymi operującymi na tablicy
(zapełnianie losowe, wyprowadzanie na ekran)
#include
#include
#include
#include
<stdio.h>
<conio.h>
<stdlib.h>
<time.h>
void zaptablos(int[],int,int);
void poktab(int[],int);
int main(void)
{
const int R=10;
int tab[R]k;
zaptablos(tab,R,100);
poktab(tab,R);
getch();
return 0;
}
void zaptablos(int tab[],int r,int z)
{
int j;
srand(time(NULL));
//odwołania indeksowe
for (j=0; j<r; j++)
tab[j]=rand()%z;
}
5
void poktab(int *tab,int n)
{
printf("\n\nOto liczby w tablicy:\n\n");
//odwołania wskaźnikowe
for (int j=0; j<n; j++)
printf("%4d",*(tab+j));
}
/* void poktab(int *tab,int n)
{
printf("\n\nOto liczby w tablicy:\n\n");
//odwołania wskaźnikowe z operatorem ++
for (int j=0; j<n; j++)
printf("%4d",*tab++);
}
*/
Argument tablicowy jest typu wskaźnikowego, jednak w instrukcji
wywołanie przed identyfikatorem tab nie ma operatora adresu &.
Nazwa tablicy z definicji jest adresem zmiennej tablicowej, dlatego
operator & jest zbyteczny.
6. Sumowanie wartości elementów tablicy
Przykład: Znajdowanie sumy elementów tablicy
#include <conio.h>
#include <stdio.h>
long sumtab(int[],int);
int main(void)
{
const int R=10;
int tab[R]={9,7,4,6,8,1,3,7,0,2};
printf("\nSuma elementow: %ld",sumtab(tab,R));
getch();
return 0;
}
long sumtab(int t[],int r)
{
long s=0;
for (int j=0;j<r;) s+=t[j++];
return s;
}
6
7. Zliczanie elementów o zadanych cechach
Przykład poniżej pokazuje funkcję
odd_even, która sprawdza, ile jej tablica wejściowa t zawiera wartości
parzystych, a ile nieparzystych. Wyniki są przekazywane przez dwa
argumenty wskaźnikowe p oraz n. Argumenty te służą jednocześnie jako
liczniki elementów parzystych i nieparzystych. Dzięki temu nie trzeba
deklarować dodatkowych zmiennych licznikowych.
Przykład:
Zliczanie elementów tablicy o wartościach parzystych i nieparzystych
#include<stdio.h>
#include<conio.h>
void odd_even(int*,int,int*,int*);
int main()
{
const int R=12;
int tab[R]={1,3,4,12,6,10,8,16,9,7,2,5};
int parz, nieparz;
odd_even(tab,R,&parz,&nieparz);
printf("\nLiczba parzystych: %d",parz);
printf("\nLiczba nieparzystych: %d",nieparz);
getch();
return 0;
}
void odd_even(int *t,int r,int *p,int *n)
{
*n=*p=0;
for(int j=0;j<r;j++)
if(*(t+j)%2) (*n)++;
else (*p)++;
}
8. Znajdowanie maksimum i minimum
Znajdowanie w tablicy tab o rozmiarze r maksymalnej spośród pamiętanych w niej wartości przebiega według prostego algorytmu, pokazanego
poniżej.
int max=tab[0];
for (int j=1; j<r; j++)
if (tab[j]>max) max=tab[j];
7
Przykład:
Znajdowanie największego i najmniejszego elementu
oraz liczby ich wystąpień w tablicy
#include<stdio.h>
#include<conio.h>
void max_min(int[],int,int&,int&,int&,int&);
int main()
{
const int R=12;
int tab[R]={1,3,4,16,6,1,8,16,9,7,16,5};
int max,min,ilemax,ilemin;
max_min(tab,R,max,min,ilemax,ilemin);
printf("\nMaksimum: %3d Wystapien: %d",max,ilemax);
printf("\nMinimum: %3d Wystapien: %d",min,ilemin);
getch();
return 0;
}
void max_min(int t[],int r,int &max,int &min,
int &ilemax,int &ilemin )
{
max=min=t[0];
ilemax=ilemin=1;
for(int j=1;j<r;j++)
{
if (t[j]==max) ilemax++;
else if(t[j]>max)
{
ilemax=1;
max=t[j];
}
if (t[j]==min) ilemin++;
else if(t[j]<min)
{
ilemin=1;
min=t[j];
}
}
}
9. Przesunięcie cykliczne zawartości tablicy
Przesunięciem cyklicznym zawartości tablicy o jedną pozycję w prawo
nazywamy taką zmianę jej zawartości, po której każdy element zajmuje
miejsce jego sąsiada po prawej stronie, przy czym element ostatni zajmuje miejsce zerowego.
Dla int tab[r] można to zrealizować za pomocą trzech instrukcji:
8
int buf=tab[r-1];
for (int j=r-1;j>0;j--) tab[j]=tab[j-1];
tab[0]=buf;
Zmienna pomocnicza buf jest konieczna. Musimy w niej przejściowo
zapamiętać ostatni element tablicy – w przeciwnym przypadku jego
wartość zostałaby utracona w wyniku zapisania do niego wartości elementu poprzedzającego. A przecież jest ona potrzebna, bo ma znaleźć się
na zerowej pozycji tablicy.
Chcąc przesunąć zawartość pozycji o p pozycji, trzeba pokazaną wyżej
trójkę instrukcji powtórzyć p razy za pomocą zewnętrznej pętli for.
tab[0] tab[1] tab[2] tab[3] tab[4] tab[5]
1
2
3
4
5
6
tab[0] tab[1] tab[2] tab[3] tab[4] tab[5]
6
1
2
3
4
5
Rys. 3. Przesunięcie cykliczne zawartości tablicy o jedną pozycję w prawo
Przykład: Przesuwanie cykliczne zawartości tablicy w prawo
#include<stdio.h>
#include<conio.h>
void cykl_prawo(int*,int,int);
void poktab(int[],int);
int main()
{
const int R=8;
int tab[R]={1,2,3,4,5,6,7,8};
int p;
printf("O ile pozycji? ");
scanf("%d",&p);
poktab(tab,R);
cykl_prawo(tab,R,p);
poktab(tab,R);
getch();
return 0;
}
void poktab(int t[],int r)
{
printf("\n\nOto liczby w tablicy:\n\n");
for (int j=0; j<r; j++)
printf("%4d",*(t+j));
}
9
void cykl_prawo(int *t,int r,int p)
{
int buf;
for (int k=0;k<p;k++)
{
buf=*(t+r-1);
for(int j=r-1;j>0;j--)
*(t+j)=*(t+j-1);
*t=buf;
}
}
10. Sortowanie bąbelkowe tablicy
Sortowaniem nazywamy porządkowanie zawartości tablicy w taki sposób, by kolejne elementy tablicy zawierały wartości uszeregowane
w porządku rosnących lub malejących wartości.
Przykład poniżej zawiera funkcję własną bubblesort. Funkcja ta
realizuje sortowanie bąbelkowe tablicy, przekazanej jako argument t.
Sortowanie przebiega w porządku rosnącym lub malejącym, w zależności
od wartości argumentu p.
Przykład: Sortowanie bąbelkowe tablicy
#include<stdio.h>
#include<conio.h>
void poktab(int*,int);
void bubble(int[],int,int);
int main()
{
const int R=8;
int tab[R]={10,2,3,15,6,5,7,13};
int p;
poktab(tab,R);
printf("\nJaki porzadek? <1> rosnacy, <0> malejacy: ");
scanf("%d",&p);
bubble(tab,R,p);
poktab(tab,R);
getch();
return 0;
}
10
void poktab(int *t,int r)
{
printf("\n\nOto liczby w tablicy:\n\n");
for (int j=0; j<r; j++)
printf("%4d",*(t+j));
printf("\n");
}
void bubble(int t[],int r,int p)
{
int kopia,war;
for (int j=0; j<r-1; j++)
for (int k=j+1; k<r; k++)
{
if (p!=0) war=t[j]>t[k];
else war=t[j]<t[k];
if (war)
{
kopia=t[j];
t[j]=t[k];
t[k]=kopia;
}
}
}
11. Sortowanie rekurencyjne tablicy – quick sort
Podstawą algorytmu quick sort jest następujący pomysł: Jeden z elementów sortowanej tablicy wyróżnia się jako tzw. element osiowy. Pozostałe
elementy dzielimy na dwie grupy. Do jednej z nich przenosimy elementy
mniejsze od osiowego. Drugą grupę tworzą pozostałe elementy, większe
od elementu osiowego lub mu równe.
Następnie proces ten kontynuujemy rekursywnie, dzieląc w podobny
sposób każdą z obu grup na podgrupy względem im właściwych elementów osiowych. Te podgrupy dzielimy dalej, dopóki kolejna podgrupa nie
stanie się pojedynczym elementem – wtedy dalszy podział jest niemożliwy.
Algorytm quick sort jest znacznie bardziej efektywny od algorytmu
bąbelkowego. Dla quick sort liczba operacji jest proporcjonalna do wyrażenia n*log(n), natomiast dla bubble sort wzrasta ona proporcjonalnie do
n2, gdzie symbol n oznacza rozmiar sortowanej tablicy.
Poniżej pokazano sekwencję instrukcji, dzielącą tablicę na dwie grupy względem elementu t[0], który pełni rolę elementu osiowego.
Zmienna j jest licznikiem indeksów, powiększanym o wartość 1 w
każdym kolejnym cyklu pętli for.
Zmienna m wskazuje numer elementu, który podlega kolejnej zamianie w procesie podziału grupy na dwie podgrupy.
11
Po kolei sprawdza się, czy j-ty element tablicy jest mniejszy od
osiowego. Jeżeli ma to miejsce, następuje inkrementacja licznika m, a
następnie element t[j] jest zamieniany miejscami z elementem t[m].
int t[12]={8,13,5,2,15,1,30,4,0,16,7,28};
int m=0;
for(int j=1;j<12;i++)
if(t[j]<t[0])
{
m++;
zamiana(t[m],t[j]);
}
zamiana(t[m],t[0]);
Ostatnia zamiana elementów, dokonywana już po zakończeniu instrukcji for, ma na celu przesunięcie elementu osiowego na właściwą
pozycję.
Przykład poniżej zawiera pełny program z rekurencyjną funkcją sortującą
qsort. Po zakończeniu kolejnego podziału tablicy na dwa fragmenty
względem elementu osiowego, funkcja qsort dwukrotnie wywołuje samą
siebie, dzieląc względem odpowiednich elementów osiowych dwa fragmenty, otrzymane podczas pierwszego podziału. Proces ten jest kontynuowany rekursywnie tak długo, dopóki końcowe fragmenty nie zostaną
zredukowane do pojedynczych elementów (rys. 4).
Przykład: Program sortujący tablicę zgodnie z algorytmem quick sort
#include <conio.h>
#include <stdio.h>
void poktab(int[],int,int);
void zamiana(int &,int &);
void qsort(int[],int,int);
int main()
{
const int N=12;
int t[N]={8,13,5,2,15,1,30,4,0,16,7,28};
poktab(t,0,N-1);
qsort(t,0,N-1);
poktab(t,0,N-1);
getch();
return 0;
}
void poktab(int t[],int p,int k)
{
12
for(int j=p;j<=k;j++)
printf("%4d",t[j]);
printf("\n\n");
}
void zamiana(int &a, int &b)
{
int buf=a;
a=b;
b=buf;
}
void qsort(int t[],int left,int right)
{
if (left<right)
{
int m=left;
for(int i=left+1;i<=right;i++)
if (t[i]<t[left]) zamiana(t[++m],t[i]);
zamiana(t[left],t[m]);
qsort(t,left,m-1);
qsort(t,m+1,right);
}
}
Początkowa postać tablicy:
t[0]
t[1]
t[2]
t[3]
t[4]
t[5]
t[6]
t[7]
t[8]
t[9]
t[10]
t[11]
8
13
5
2
15
1
30
4
0
16
7
28
Porządkowanie wg elementów osiowych
t[0]
t[1]
t[2]
t[3]
t[4]
t[5]
t[6]
t[7]
t[8]
t[9]
t[10]
t[11]
7
5
2
1
4
0
8
15
13
16
30
28
t[0]
t[1]
t[2]
t[3]
t[4]
t[5]
t[7]
t[8]
t[9]
t[10]
t[11]
0
5
2
1
4
7
13
15
16
30
38
t[0]
t[1]
t[2]
t[3]
t[4]
t[9]
t[10]
t[11]
0
5
2
4
1
16
30
28
t[1]
t[2]
t[3]
t[4]
t[10]
t[11]
4
2
1
5
28
30
t[1]
t[2]
t[3]
1
2
4
t[1]
t[2]
1
2
Końcowa postać tablicy:
13
t[0]
t[1]
t[2]
t[3]
t[4]
t[5]
t[6]
t[7]
t[8]
t[9]
t[10]
t[11]
0
1
2
4
5
7
8
13
15
16
28
30
Rys.4. Kolejne podziały fragmentów tablicy w czasie pracy
funkcji qsort
12. Tablica dwuwymiarowa
Struktura i sposób deklarowania
const int LW=3, LK=4;
int tab[LW][LK]={{ 0, 1, 2, 3},
{10,11,12,13},
{20,21,22,23}};
int tab[3][4];
tab[0]
tab[1]
tab[2]
tab[0][0]
tab[0][1]
tab[0][2]
tab[0][3]
0
1
2
3
tab[1][0]
tab[1][1]
tab[1][2]
tab[1][3]
10
11
12
13
tab[2][0]
tab[2][1]
tab[2][2]
tab[2][3]
20
21
22
23
Rys.5. Tablica dwuwymiarowa
Odwoływanie się do elementów
Odwołanie za pomocą indeksów:
tab[j][k]=0;
gdzie j – numer wiersza; k – numer kolumny.
14
Odwołania wskaźnikowe:
Interpretując j-ty wiersz jako jednowymiarową tablicę o nazwie tab[j],
odwołamy się do elementu znajdującego się w j–tym wierszu i k–tej
kolumnie, jak następuje:
*(tab[j]+k)=0;
Ponieważ odwołanie tab[j] zapisuje się wskaźnikowo jako *(tab+j),
odwołanie wskaźnikowe do elementu tab[j][k] przyjmie ostatecznie postać:
*(*(tab+j)+k)=0;
Funkcje operujące na tablicy dwuwymiarowej
Dla tablicy dwuwymiarowej argument tablicowy może mieć postać,
jak w poniższym nagłówku funkcji:
void poktab(int tab[][LK])
Występują tu dwie pary nawiasów kwadratowych.
Zawartość pierwszej pary może być pusta; można też do nie wpisać liczbę
wierszy tablicy.
W drugiej parze nawiasów koniecznie należy wpisać liczbę kolumn (stała
LK).
Instrukcja wywołania funkcji poktab w main będzie wyglądać następująco:
poktab(tab);
W instrukcji wywołania przed nazwą tablicy nie ma operatora adresu,
ponieważ ta nazwa jest właśnie przekazywanym adresem tablicy.
Argument tablicowy może mieć postać wskaźnika na początkowy
element tablicy:
void poktab(int *t, int lw, int lk)
Jako dodatkowe argumenty wykorzystano liczbę wierszy lw i liczbę
kolumn lk.
Takie podejście jest wygodniejsze, bo funkcja może operować na tablicach o dowolnej liczbie wierszy lub kolumn.
Wywołanie funkcji poktab w main ma teraz postać:
15
poktab(&tab[0][0],LW,LK);
Jak widać, w instrukcji wywołania wpisujemy po prostu adres początkowego elementu tablicy.
W przykładzie poniżej pokazano proste funkcje stosujące oba rodzaje
argumentów tablicowych i różne sposoby odwoływania się do elementów.
Wspólną cechą jest to, że odwołują się do wszystkich elementów tablicy,
wykorzystując dwie zagnieżdżone pętle for
.
Odwołania:
Adresy
Względne
tab[0]
int
*t=&tab[0][0];
tab[0][0]
*(*(tab+0)+0)
0
t
tab[0][1]
*(*(tab+0)+1)
1
(t+1)
tab[0][2]
*(*(tab+0)+2)
2
(t+2)
tab[0][3]
*(*(tab+0)+3)
3
(t+3)
tab[1][0]
*(*(tab+1)+0)
10
(t+4)
tab[1][1]
*(*(tab+1)+1)
11
(t+5)
tab[1][2]
*(*(tab+1)+2)
12
(t+6)
tab[1][3]
*(*(tab+1)+3)
13
(t+7)
tab[2][0]
*(*(tab+2)+0)
20
(t+8)
tab[2][1]
*(*(tab+2)+1)
21
(t+9)
tab[2][2]
*(*(tab+2)+2)
22
(t+10)
tab[2][3]
*(*(tab+2)+3)
23
(t+11)
tab[1]
tab[2]
Rys. 6. Ułożenie elementów tablicy dwuwymiarowej w pamięci
16
Przykład: Trzy różne funkcje wyprowadzające na ekran
zawartość tablicy dwuwymiarowej i ich wywołania w main.
#include <conio.h>
#include <stdio.h>
const int LW=3, LK=4; //stałe globalne
void poktab1(int [][LK]);
void poktab2(int [][LK]);
void poktab3(int *,int,int);
int main()
{
int tab[LW][LK]= {{ 0, 1, 2, 3},
{10,11,12,13},
{20,21,22,23}};;
poktab1(tab);
poktab2(tab);
poktab3(&tab[0][0],LW,LK);
getch();
return 0;
}
void poktab1(int t[][LK])
{
for(int j=0;j<LW;j++)
{
for(int k=0;k<LK; k++)
printf("%4d",t[j][k]);
printf("\n");
}
printf("\n");
}
void poktab2(int t[][LK])
{
for(int j=0;j<LW;j++)
{
for(int k=0;k<LK; k++)
printf("%4d",*(*(t+j)+k));
printf("\n");
}
printf("\n");
}
void poktab3(int *t,int lw,int lk)
{
for(int j=0;j<lw;j++)
{
for(int k=0;k<lk;k++)
printf("%4d",*t++);
printf("\n");
}
printf("\n");
}
17
Przykład: Program pokazujący tablicę mnożenia liczb od 1 do 16
w zapisie dziesiętnym, ósemkowym lub szesnastkowym
#include <conio.h>
#include <stdio.h>
char dane();
void poktab(int *,int,int,char);
void zaptab(int *,int,int);
int main()
{
const int LW=16, LK=16;
int tab_2[LW][LK];
zaptab(&tab_2[0][0],LW,LK);
poktab(&tab_2[0][0],LW,LK,dane());
getch();
return 0;
}
char dane()
{
printf("\nWybierz podstawe zapisu.\n");
printf("p=10 - <d>, p=8 - <o>, p=16 - <x> : ");
char b;
do
scanf("%c",&b);
while (b!='o'&&b!='d'&&b!='x');
return b;
}
void zaptab(int *m,int lw,int lk)
{
for(int j=0;j<lw;j++)
for(int k=0;k<lk;k++)
*(m++)=(j+1)*(k+1);
}
void poktab(int *m,int lw, int lk, char b)
{
char s[4]={'%','4',b,'\0'};
printf("\nTablica mnozenia\n\n");
for(int j=0;j<lw;j++)
{
for(int k=0;k<lk;k++)
printf(s,*m++);
printf("\n");
}
}
18
Wybierz podstawe zapisu.
p=10 - <d>, p=8 - <o>,
Tablica mnozenia
p=16 - <x> : x
1
2
2
4
3
6
4
8
5
a
6
c
7
e
8
10
9
12
a
14
b
16
c
18
d
1a
e
1c
f
1e
10
20
3
4
6
8
9
c
c
10
f
14
12
18
15
1c
18
20
1b
24
1e
28
21
2c
24
30
27
34
2a
38
2d
3c
30
40
5
6
a
c
f
12
14
18
19
1e
1e
24
23
2a
28
30
2d
36
32
3c
37
42
3c
48
41
4e
46
54
4b
5a
50
60
7
8
e
10
15
18
1c
20
23
28
2a
30
31
38
38
40
3f
48
46
50
4d
58
54
60
5b
68
62
70
69
78
70
80
9
a
12
14
1b
1e
24
28
2d
32
36
3c
3f
46
48
50
51
5a
5a
64
63
6e
6c
78
75
82
7e
8c
87
96
90
a0
b
c
16
18
21
24
2c
30
37
3c
42
48
4d
54
58
60
63
6c
6e
78
79
84
84
90
8f
9c
9a
a8
a5
b4
b0
c0
d
1a
27
34
41
4e
5b
68
75
82
8f
9c
a9
b6
c3
d0
e
f
1c
1e
2a
2d
38
3c
46
4b
54
5a
62
69
70
78
7e
87
8c
96
9a
a5
a8
b4
b6
c3
c4
d2
d2
e1
e0
f0
10
20
30
40
50
60
70
80
90
a0
b0
c0
d0
e0
f0 100
Rys. 7. Wydruk tablicy mnożenia w zapisie szesnastkowym