No to jeszcze raz przepiszmy kod z Pythona na Free Pascala, linijka po linijce;
Pascal w przeciwieństwie do Pythona jest bardzo silnie typowany, więc najpierw należy zdefiniować typ dla macierzy liczb; Macierz tego typu będzie używana przez ten generator (jedna zmienna i dwa parametry):
type
TTab = array [0 .. 8, 0 .. 8] of Integer;
Standardowa macierz dwuwymiarowa, zawierająca tabliczkę 9x9 pól typu Integer; Teraz po kolei podam źródłowe linie oraz moje tłumaczenie na Pascala;
def test(x,y,r,tab):
function Test(X, Y, R: Integer; Tab: TTab): Integer;
Funkcja `Test` równie dobrze mogła by zwracać wartość logiczną; Zmienne w **Pascalu** muszą być najpierw zadeklarowane, więc blok deklaracji to pięć zmiennych liczbowych:
```delphi
var
K, A, B, I, J: Integer;
for k in range(9):
for K in [0 .. 8] do
Dla `k` od `0` do `8` - `range` powinno dać dla iteratora liczby od `0` do `8`;
____
```python
if tab[x][k]==r or tab[k][y]==r:
if (Tab[X, K] = R) or (Tab[K, Y] = R) then
Jeśli wartość komórkek `x,k` lub `k,y` jest równa `r`;
____
```python
return 0;
Exit(0);
Przerywamy działanie funkcji i zwracamy wartość `0`;
____
```python
a=x-x%3;
b=y-y%3
A := X - X mod 3;
B := Y - Y mod 3;
Tego raczej nie trzeba opisywać;
for i in range(a,a+3):
for I in [A .. A + 3] do
Dla `i` od wartości zmiennej `a` do wartości `a + 3`;
____
```python
for j in range(b,b+3):
for J in [B .. B + 3] do
To samo, tyle że dla wartości zmiennej `b`;
____
```python
if tab[i][j]==r:
if Tab[I, J] = R then
Jeśli komórka `i,j` ma wartość równą `r`;
____
```python
return 0
Exit(0);
Przerywamy działanie funkcji i zwracamy wartość `0`;
____
```python
return 1
Result := 1;
W przeciwnym razie zwracamy wartość `1` - na koniec funkcji;
____
```python
def pole(tab):
procedure Pole(Tab: TTab);
`pole` nie zwraca żadnej wartości, więc niech będzie w **Pascalu** procedurą; Blok deklaracji zmiennych:
```delphi
var
X, Y, I, J, R: Integer;
Wszystkie są liczbami, więc niech będą typu Integer;
for x in range(9):
for X in [0 .. 8] do
Dla `x` od `0` do `8`;
____
```python
for y in range(9):
for Y in [0 .. 8] do
To samo dla `y`;
____
```python
if tab[x][y]==0: break
if Tab[X, Y] = 0 then Break;
Jeśli wartość komórki `x,y` jest równa `0`, przerywamy działanie bieżącej pętli (tej zagnieżdżonej);
____
```python
if tab[x][y]==0: break
if Tab[X, Y] = 0 then Break;
Jeśli przerwano pętlę zagnieżdżoną, przerywamy także pętlę główną;
____
```python
if tab[x][y]:
if Tab[X, Y] > 0 then
Jeśli wartość komórki `x,y` jest inna niż `0` (ujemna raczej nie może być, stąd operator `>`);
____
```python
for i in range(9):
for I in [0 .. 8] do
Dla `i` od `0` do `8`;
____
```python
print tab[i]
for J in [0 .. 8] do
Write(Tab[I, J]:2);
W **Pascalu** nie ma zdefiniowanego wyświetlania macierzy liczb, stąd dodatkowa pętla;
____
```python
print
WriteLn();
Jeśli samo `print` tylko przenosi do nowej linii to wszystko gra; Tutaj chodzi po prostu o wyświetlenie zawartości całej macierzy, więc kod w **Pascalu** jest na pewno prawidłowy;
____
```python
else:
else
:]
____
```python
for r in range(1,10):
for R in [1 .. 10] do
Dla `r` od `1` do `10` - na pewno ma być od `1` do `10`, czy od `0` do `9`?
____
```python
if test(x,y,r,tab):
if Test(X, Y, R, Tab) > 0 then
Jeśli wywołanie funkcji `test` zwórciło wartość inną niż `0`;
____
```python
tab[x][y]=r
Tab[X, Y] := R;
Wpisanie wartości zmiennej `r` do komórki `x,y`;
____
```python
pole(tab)
Pole(Tab);
Rekurencyjne wywołanie procedurki `Pole`;
____
```python
tab[x][y]=0
Tab[X, Y] := 0;
Wyzerowanie komórki `x,y`;
____
Teraz wywołanie procedury `Pole` dla przykładowej tablicy:
```delphi
var
Tab: TTab = (
(0, 0, 6, 0, 0, 0, 0, 0, 1),
(0, 7, 0, 0, 6, 0, 0, 5, 0),
(8, 0, 0, 1, 0, 3, 2, 0, 0),
(0, 0, 5, 0, 4, 0, 8, 0, 0),
(0, 4, 0, 7, 0, 2, 0, 9, 0),
(0, 0, 8, 0, 1, 0, 7, 0, 0),
(0, 0, 1, 2, 0, 5, 0, 0, 3),
(0, 6, 0, 0, 7, 0, 0, 8, 0),
(2, 0, 0, 0, 0, 0, 4, 0, 0)
);
begin
Pole(Tab);
To wszystko - wyjście dla tak przetłumaczonego kodu będzie puste, więc te dwa kody działają inaczej; Czy ktoś znający Pythona i Pascala może wskazać linijkę, w której źle przetłumaczyłem kod? Ogólnie to Pythona nie znam w ogóle, ale jego składnia jest przyjemna i sam kod zbyt prosty, żeby mieć wątpliwości;
W razie czego cały mój kod znajduje się na ideone.com - http://ideone.com/B8r1RC
Edit: Google od kilku miesięcy ciągle nękał mnie o podawanie kodu Captcha, że niby wzmożony ruch wykrył z mojej sieci, a teraz postanowił mnie zbanować; Chciałem sobie poszukać w dokumentacji co dokładnie robi funkcja range
; Tak właśnie wygląda korzystanie z usług dostawcy o nazwie ZICOM - gratulacje.