Serwis Edukacyjny w I-LO w Tarnowie Materiały dla uczniów liceum |
Wyjście Spis treści Wstecz Dalej Autor artykułu: mgr Jerzy Wałaszek |
©2024 mgr Jerzy Wałaszek |
Przed pierwszym użyciem każda tablica musi być zadeklarowana tak jak wszystkie zmienne używane w programie – tablica jest zmienną złożoną. Poniżej podajemy sposoby deklaracji tablicy w wybranych przez nas językach programowania:
Deklarację tablicy w języku Pascal umieszczamy w sekcji deklaracji zmiennych var. Składnia deklaracji tablicy jest następująca:
nazwa_tablicy : array [indeks_początkowy..indeks_końcowy] of typ_elementów;
Słowa array oraz of są słowami kluczowymi, które muszą się pojawić w deklaracji tablicy. Poniżej podajemy kilka przykładów:
var … a : array [1..3] of integer; // tablica zawierająca 3 elementy, które mogą przechowywać elementy całkowite x : array [0..9] of double; // tablica przechowująca 10 liczb typu double c : array [2..7] of char; // tablica przechowująca 6 wartości znakowych …
W powyższym przykładzie zadeklarowano trzy tablice a, x oraz c. Posiadają one elementy o następujących indeksach:
Tablica a : a[1] a[2] a[3] - 3 elementy typu integer Tablica x : x[0] x[1] x[2] x[3] x[4] x[5] x[6] x[7] x[8] x[9] - 10 elementów typu double Tablica c : c[2] c[3] c[4] c[5] c[6] c[7] - 6 elementów typu char
Deklarację tablicy umieszczamy w języku
typ_danych nazwa_tablicy[liczba_elementów];
Poniżej podajemy kilka przykładów deklaracji tablic w
… int a[3]; // tablica zawierająca 3 elementy typu int double x[10]; // tablica przechowująca 10 liczb typu double char c[6]; // tablica przechowująca 6 wartości znakowych …
W języku
W powyższym przykładzie zadeklarowano trzy tablice a, x oraz c. Posiadają one elementy o następujących indeksach:
Tablica a : a[0] a[1] a[2] - 3 elementy typu integer Tablica x : x[0] x[1] x[2] x[3] x[4] x[5] x[6] x[7] x[8] x[9] - 10 elementów typu double Tablica c : c[0] c[1] c[2] c[3] c[4] c[5] - 6 elementów typu char
Zwróć uwagę, iż tablica nie posiada elementu o indeksie równym ilości elementów. Zatem jeśli zadeklarujemy np. tablicę:
double Tlk[168];
to jej ostatnim elementem jest Tlk[167], a nie
Tlk[168].
Odwołanie się w programie do Tlk[168] jest błędem, którego kompilator
zwykle nie zgłosi, zakładając, iż programista wie co robi. Niestety, język
Deklaracji tablicy w języku Free Basic dokonujemy w obrębie instrukcji Dim wraz z innymi zmiennymi. Składnia jest następująca:
Dim nazwa_tablicy(indeks_końcowy) As typ_elementów Dim nazwa_tablicy(indeks_początkowy To indeks_końcowy) As typ_elementów Dim As typ_elementów nazwa_tablicy(indeks_końcowy) Dim As typ_elementów nazwa_tablicy(indeks_początkowy To indeks_końcowy)
Dwie końcowe składnie pozwalają szybko deklarować jednym poleceniem Dim zmienne tego samego typu, na przykład:
Dim As Integer a,b,x(20),h(3 To 10)
Poniżej podajemy kilka przykładów deklaracji tablic:
… Dim a(1 To 3) As Integer ' tablica zawierająca 3 elementy, które mogą przechowywać elementy całkowite Dim As Double x(9) ' tablica przechowująca 10 liczb typu double Dim c(2 To 7) As Ubyte ' tablica przechowująca 6 wartości 8 bitowych bez znaku …
W powyższym przykładzie zadeklarowano trzy tablice a, x oraz c. Posiadają one elementy o następujących indeksach:
Tablica a : a(1) a(2) a(3) - 3 elementy typu Integer Tablica x : x(0) x(1) x(2) x(3) x(4) x(5) x(6) x(7) x(8) x(9) - 10 elementów typu Double Tablica c : c(2) c(3) c(4) c(5) c(6) c(7) - 6 elementów typu Ubyte
W języku Python odpowiednikiem tablicy jest lista. Typ elementów tablicy/listy określany jest podczas przypisania. Pustą tablicę/listę tworzymy następująco:
a = [] # pusta lista
Elementem tablicy może być liczba, tekst lub inny obiekt. Każdy element może przechowywać daną dowolnego typu. Zatem w języku Python tablica nie musi przechowywać elementów o tym samym typie. Uruchom poniższy program:
Python
(dodatek)# Tablica/lista # Data: 20.02.2024 # (C)2024 mgr Jerzy Wałaszek # -------------------------- # Lista o 3 elementach różnego typu # --------------------------------- a = [25, 3.1415, "Karol"] for i in range(len(a)): print("a[%1d] = " % i, end="") print(a[i]) print() |
Wynik: |
a[0] = 25 a[1] = 3.1415 a[2] = Karol |
Dostęp do elementów tablicy/listy może być wykonany na różne sposoby, w tym także poprzez indeksy. Numeracja indeksów rozpoczyna się od 0.
Więcej na temat tablic/list języka Python znajdziesz dalej w tym rozdziale.
Często zdarza się, iż chcemy utworzyć tablicę z zadaną z góry zawartością (np. tablica zawierająca początkowe liczby pierwsze). Postępujemy wtedy w sposób następujący:
W bloku deklaracji zmiennych var wpisujemy:
nazwa_tablicy : array [indeks_początkowy..indeks_końcowy] of typ_elementów = (lista_wartości_dla_kolejnych_elementów);
Poniższy przykład tworzy tablicę 10 liczb całkowitych i wypełnia ją kolejnymi liczbami Fibonacciego.
var … fib : array [0..9] of integer = (0,1,1,2,3,5,8,13,21,33); …
Składnia tworzenia tablicy z zawartością jest w języku
typ_elementów nazwa_tablicy = {lista_wartości_dla_kolejnych_elementów};
Zwróć uwagę, iż nie musimy podawać liczby elementów. Kompilator utworzy w tablicy tyle elementów, ile podamy dla nich wartości na liście inicjalizacyjnej. Poniższy przykład tworzy tablicę 10 liczb całkowitych i wypełnia ją kolejnymi liczbami Fibonacciego.
… int fib[] = {0,1,1,2,3,5,8,13,21,33}; …
W języku Basic tablicę tworzymy i inicjujemy w obrębie polecenia Dim:
Dim nazwa_tablicy(indeks_końcowy) As typ_elementów => {lista_wartości_dla_kolejnych_elementów} Dim nazwa_tablicy(indeks_początkowy To indeks_końcowy) As typ_elementów => {lista_wartości_dla_kolejnych_elementów}
W pierwszym przypadku tablica zawiera elementy o indeksach przebiegających od 0 do wartości podanej jako indeks_końcowy. W przypadku drugim programista może swobodnie określać zakres indeksów tablicy. Liczba wartości na liście inicjalizacyjnej musi się zgadzać z deklaracją indeksów. Poniższy przykład tworzy tablicę 10 liczb całkowitych i wypełnia ją kolejnymi liczbami Fibonacciego.
… Dim fib(9) as integer => {0,1,1,2,3,5,8,13,21,33} …
W języku Python tablicę/listę możemy utworzyć poprzez przypisanie. Poniższy przykład tworzy tablicę/listę z kolejnymi liczbami Fibonacciego:
… fib = [0,1,1,2,3,5,8,13,21,33] …
Indeksy elementów rozpoczynają się od wartości 0. W tym przykładzie pierwszym elementem jest fib[0], a ostatnim jest fib[9].
Typ elementów tablicy/listy nie musi być jednolity. Poniższy przykład tworzy tablicę/listę z elementami różnego typu:
Python
(dodatek)# Tablica/lista # Data: 20.02.2024 # (C)2024 mgr Jerzy Wałaszek # -------------------------- # Lista o 10 elementach a = [0,1,2,3.17,4,5.22,6,"Ciąg rosnący",8,9.786] for i in range(len(a)): print("a[%1d] = " % i, end="") print(a[i]) |
Wynik: |
a[0] = 0 a[1] = 1 a[2] = 2 a[3] = 3.17 a[4] = 4 a[5] = 5.22 a[6] = 6 a[7] = Ciąg rosnący a[8] = 8 a[9] = 9.786 |
Zdarza się, iż w trakcie pisania programu nie wiemy, ile dokładnie elementów będzie zawierała używana w tym programie tablica. W takim przypadku problem tworzenia tablicy możemy rozwiązać na dwa sposoby:
Aby utworzyć tablicę dynamiczną w języku Pascal najpierw deklarujemy jej typ:
type nazwa_typu_tablicy = array of nazwa_typu_elementów;
Zwróć uwagę, iż w definicji typu za słowem array nie podajemy zakresu indeksów. Ma to sens, ponieważ ilość elementów będzie określana dynamicznie w czasie wykonywania programu. Teraz kompilator potrzebuje jedynie informacji o typie elementów, które będzie przechowywała tablica. Pozwoli mu to później zarezerwować odpowiedni obszar pamięci oraz obliczać adresy indeksowanych elementów. Poniższy przykład tworzy typ dynamicznej tablicy, która będzie przechowywała elementy typu double:
type Tdouble = array of integer;
Po zdefiniowaniu typu dla tablicy dynamicznej możemy go użyć do tworzenia zmiennych w bloku var.
var nazwa_zmiennej : nazwa_typu_tablicy;
Poniższy przykład wykorzystuje typ Tdouble do utworzenia trzech zmiennych a, b, c.
var a, b, c : Tdouble;
Każda ze zmiennych a, b, c jest w rzeczywistości wskaźnikiem, czyli zmienną przechowującą adres właściwych danych. Na początku wszystkie trzy wskaźniki zawierają adres NIL, który w Pascalu nie wskazuje żadnego obiektu. Jeśli chcemy używać tablicy dynamicznej, to na początku programu musimy zarezerwować w pamięci odpowiedni obszar na elementy tablicy i adres początku tego obszaru umieścić we wskaźniku. Dokonujemy tego za pomocą procedury:
SetLength(nazwa_zmiennej, liczba_komórek_tablicy);
Po tej operacji mamy dostęp do poszczególnych elementów tablicy za pomocą
indeksów. W tablicach dynamicznych indeksy kolejnych elementów rozpoczynają się
od 0, a kończą na liczbie komórek
… SetLength(a,10); // elementy od a[0] do a[9] SetLength(b,100); // elementy od b[0] do b[99] SetLength(c,1000); // elementy od c[0] do c[999] …
Jeśli tablica dynamiczne została utworzona w procedurze lub funkcji, to jest automatycznie usuwana z pamięci po zakończeniu działania procedury lub funkcji. Tablicę dynamiczną można usunąć z pamięci ustawiając jej długość na 0. Poniższy przykład usuwa tablicę c:
… SetLength(c,0); …
Należy pamiętać, iż usunięty został obszar pamięci zajmowany przez elementy tablicy c, a nie sama zmienna c, która jest tylko wskaźnikiem.
Ponieważ zmienne tablic dynamicznych są wskaźnikami, to poniższa operacja nie powoduje przepisania elementów tablicy b[ ] do tablicy a[ ], jak można by przypuszczać:
a := b;
W rzeczywistości
W celu utworzenia w języku
typ_elementów * nazwa_tablicy_dynamicznej;
Zmienna wskaźnikowa (ang. pointer
variable) nie przechowuje danych tylko adres obszaru pamięci komputera, w którym te dane się znajdują. Deklarację zmiennej wskaźnikowej zawsze poprzedzamy
znakiem gwiazdki. W poniższym przykładzie tworzymy trzy wskaźniki
… double *a,*b,*c; …
Pamięć rezerwujemy operatorem new i adres zarezerwowanego obszaru umieszczamy w zmiennej wskaźnikowej:
nazwa_tablicy_dynamicznej = new typ_elementów [liczba_elementów];
Poniższy przykład tworzy trzy tablice dynamiczne, w których będzie można przechowywać odpowiednio 10, 100 i 1000 elementów typu double:
… a = new double[10]; // elementy od a[0] do a[9] b = new double[100]; // elementy od b[0] do b[99] c = new double[1000]; // elementy od c[0] do c[999] …
Po tej operacji do elementów tablic a,
b i c
odwołujemy się w zwykły sposób za pomocą indeksów. Istnieje również alternatywna
metoda, wykorzystująca fakt, iż zmienne
Tablica | Wskaźnik |
a[2] = 10.54; cout << a[2] << endl; |
*(a+2) = 10.54; cout << *(a+2) << endl; |
W rzeczywistości zapis a[i] kompilator i tak
przekształca sobie na zapis
Tablice dynamiczne nie są automatycznie usuwane z pamięci, jeśli utworzono je w funkcji. Dlatego po zakończeniu korzystania z tablicy program powinien zwolnić zajmowaną przez tablicę pamięć. Dokonujemy tego poleceniem delete w sposób następujący:
delete [] nazwa_tablicy_dynamicznej;
W poniższym przykładzie zwalniamy pamięć zarezerwowaną wcześniej na elementy
… delete [] b; // usuwamy obszar wskazywany przez b delete [] c; // usuwamy obszar wskazywany przez c …
Należy również wspomnieć, iż Code::Blocks dopuszcza konstrukcję:
typ_elementów nazwa_tablicy[zmienna];
co pozwala na tworzenie statycznych tablic o liczbie elementów podanej w
zmiennej. Na przykład poniższa konstrukcja programowa tworzy statyczną
… int n; cin >> n; double a[n]; …
Jednakże nie jest to zbyt standardowe rozwiązanie i może nie być przenośne na
inne kompilatory
W języku Basic dynamiczna tablica powstaje, gdy w poleceniu Dim użyjemy zmiennej do określenia rozmiaru tablicy. Poniższy przykład tworzy tablicę liczb typu double o rozmiarze odczytanym z klawiatury:
Dim n As Integer Input n: Dim a(n) As Double
W tym samym celu możemy również wykorzystać polecenie Redim. Poniższy przykład tworzy trzy tablice dynamiczne zawierające odpowiednio 10, 100 i 1000 elementów typu double:
Redim As Double a(9),b(99),c(999)
Gdy tablica dynamiczna przestanie być potrzebna, można ją usunąć z pamięci poleceniem:
Erase nazwa_tablicy_dynamicznej
Inny sposób tworzenia tablic dynamicznych wiąże się z wykorzystaniem wskaźników. Wskaźnik jest zmienną, która zawiera adres innej zmiennej. Procedura tworzenia tablicy dynamicznej za pomocą wskaźnika jest następująca:
1. Tworzymy wskaźnik do danych, które ma przechowywać tablica:
Dim A As typ_danych Ptr
2. Przydzielamy blok pamięci na n danych:
A = New typ_danych[n]
3. Tablica gotowa, dostęp do elementów uzyskujemy za pomocą indeksów w nawiasach kwadratowych:
A[15] = …
4. Gdy tablica przestanie być potrzebna, należy zwolnić zajmowaną przez nią pamięć:
Delete [] A
W języku Python tablica/lista jest automatycznie zmienną dynamiczną, której rozmiar może być w każdej chwili zmieniany. W tym celu wykorzystujemy funkcje operujące na listach. Oto kilka z nich (resztę znajdziesz w dokumentacji języka Python oraz w dalszej części artykułu):
Dołącza do końca listy nowy element o podanej wartości (wartość może być dowolnym wyrażeniem o dowolnym typie). W efekcie liczba elementów rośnie o 1.
Python
(dodatek)# Tablica/lista # Data: 20.02.2024 # (C)2024 mgr Jerzy Wałaszek # -------------------------- # Lista o 3 elementach a = ["Ala", "ma", "kocura"] # Wypisujemy zawartość listy print(a) # Na koniec listy dodajemy element a.append(53.96) # Wypisujemy zawartość listy print(a) |
Wynik: |
['Ala', 'ma', 'kocura'] ['Ala', 'ma', 'kocura', 53.96] |
Usuwa z listy wszystkie elementy. W efekcie lista staje się pusta.
Python
(dodatek)# Tablica/lista # Data: 20.02.2024 # (C)2024 mgr Jerzy Wałaszek # -------------------------- # Lista o 3 elementach a = ["Ala", "ma", "kocura"] # Wypisujemy zawartość listy print(a) # Usuwamy wszystkie elementy a.clear() # Wypisujemy zawartość listy print(a) |
Wynik: |
['Ala', 'ma', 'kocura'] [] |
Zwraca kopię listy. Funkcja jest potrzebna, ponieważ proste przypisanie:
list2 = list1
Nie tworzy osobnej kopii listy list1 w zmiennej list2, lecz umieszcza w niej referencję, czyli odwołanie do list1. Jeśli zmienimy list1, to automatycznie zmieni się tak samo list2, ponieważ obie zmienne wskazują na tę samą listę w pamięci komputera. Uruchom poniższy program:
Python
(dodatek)# Tablica/lista # Data: 20.02.2024 # (C)2024 mgr Jerzy Wałaszek # -------------------------- a = ["Ala", "ma", "kocura"] b = a # b jest odwołaniem do a print(b) # Wyświetla a! a.append(1999) # Zmieniamy a print(b) # Wyświetla wciąż a!!! |
Wynik: |
['Ala', 'ma', 'kocura'] ['Ala', 'ma', 'kocura', 1999] |
A teraz to samo z kopią:
Python
(dodatek)# Tablica/lista # Data: 20.02.2024 # (C)2024 mgr Jerzy Wałaszek # -------------------------- a = ["Ala", "ma", "kocura"] b = a.copy() # b jest kopią a a.append(1999) # Zmieniamy a print(b) # Wyświetla kopię a!!! print(a) # Wyświetla zmienione a |
Wynik: |
['Ala', 'ma', 'kocura'] ['Ala', 'ma', 'kocura', 1999] |
Tutaj funkcja copy( ) zwróciła kopię listy a, i zmienna b wskazuje tę kopię. Zmiana listy a nie wpłynie na b, ponieważ obie zmienne wskazują na osobne listy.
Zwraca liczbę elementów listy.
Python
(dodatek)# Tablica/lista # Data: 20.02.2024 # (C)2024 mgr Jerzy Wałaszek # -------------------------- a = ["Ala", "ma", "kocura"] print(a) print(len(a)) a.append(1234) print(a) print(len(a)) |
Wynik: |
['Ala', 'ma', 'kocura'] 3 ['Ala', 'ma', 'kocura', 1234] 4 |
Uwaga: problem nie dotyczy języka Python, gdzie tablice/listy posiadają dynamiczny rozmiar.
Gdy operujemy na dynamicznych strukturach danych, to często okazuje się, że taką strukturę należy zwiększyć lub zmniejszyć w czasie działania programu. Np. utworzyliśmy na początku algorytmu dynamiczną tablicę 100 elementową, lecz dalej okazało się, że w tablicy tej należy dodatkowo umieścić jeszcze 50 kolejnych elementów. Co możemy zrobić? Odpowiedź jest prosta – dynamicznie zmienić rozmiar naszej struktury. Zasada jest następująca:
Oprócz wskazania do tablicy
tworzymy dodatkową zmienną, która przechowuje jej maksymalny rozmiar. Oznaczmy
tę zmienną przez nn. Każdą tablicę tworzymy z pewnym zapasem komórek, oznaczmy
go
Gdy dodajemy element do tablicy, to najpierw zwiększamy
Zwróć uwagę, że cała tablica zmieniła swoje położenie w pamięci. Jeśli zatem posiadałeś jakieś zmienne, które przechowywały adresy jej elementów (wskaźniki), to teraz przestaną one być aktualne, ponieważ wskazują stary obszar, który już do tej tablicy nie należy (chociaż przez pewien czas może zachowywać swoją zawartość aż system zapisze go innymi danymi). Należy to wziąć pod uwagę, gdy planujesz wykorzystywanie dynamicznych tablic o dynamicznym rozmiarze.
Pascal… inc (n); if n >= Length(A) then SetLength(A,Length(A)+z); … |
… if(++n >= nn) { typ_danych * T = new typ_danych[nn+z]; for(int i = 0; i < nn; i++) T[i] = A[i]; delete [] A; A = T; nn += z; } … |
BasicDim As typ_danych Ptr T Dim As Integer i … n += 1 If n >= nn Then T = New typ_danych[nn+z] For i = 0 To nn-1 T[i] = A[i] Next Delete [] A A = T nn += z End If … |
Przy usuwaniu elementów z tablicy postępujemy podobnie. Gdy usuniemy element,
to rozmiar
Pascal… dec (n); if n <= Length(A)-z-z then SetLength(A,Length(A)-z); … |
… if(--n <= nn-z-z) { typ_danych * T = new typ_danych[nn-z]; for(int i = 0; i < n; i++) T[i] = A[i]; delete [] A; A = T; nn -= z; } … |
BasicDim As typ_danych Ptr T Dim As Integer i … n -= 1 If n <= nn-z-z Then T = New typ_danych[nn-z] For i = 0 To n-1 T[i] = A[i] Next Delete [] A A = T nn -= z End If … |
Dane dla programu zwykle muszą być odczytywane ze zewnętrznego źródła – konsoli lub pliku. W takim przypadku nie wiemy z góry (tzn. w trakcie pisania programu) ile ich będzie. Narzucającym się rozwiązaniem jest zastosowanie tablic dynamicznych. Ze źródła danych odczytujemy rozmiar tablicy, tworzymy tablicę dynamiczną o odpowiednim rozmiarze, a następnie wczytujemy do jej komórek poszczególne dane.
Poniżej podajemy sposoby odczytu zawartości tablicy z konsoli. Sposób ten jest bardzo ogólny. Wykorzystanie standardowego wejścia jako źródła danych daje nam kilka możliwości wprowadzania danych:
Przekierowanie standardowego wejścia z konsoli na plik na dysku. W tym przypadku program będzie pobierał dane z pliku, a nie z klawiatury. Aby to uzyskać uruchamiamy program w oknie konsoli następująco:
nazwa_programu < nazwa_pliku_wejściowego
Na przykład nasz program nazywa się szukaj.exe, a plik nosi nazwę dane.txt. Odpowiednie polecenie odczytu danych z pliku przez nasz program wygląda następująco:
szukaj < dane.txt
To rozwiązanie umożliwia również zapis danych wynikowych nie na ekran konsoli, lecz do pliku na dysku. W tym celu wystarczy wydać polecenie:
nazwa_programu > nazwa_pliku_wynikowego
Wejście i wyjście można przekierować w jednym poleceniu. Np. nasz program szukaj może odczytać dane wejściowe z pliku dane.txt, a wyniki swojej pracy umieścić w pliku wyniki.txt. W tym celu wydajemy takie oto polecenie:
szukaj < dane.txt > wyniki.txt
Jeśli często korzystasz z takich opcji uruchamiania programu, to
zamiast wpisywać polecenie z klawiatury, można stworzyć sobie prosty
plik wsadowy (ang. batch file), w
którym umieszczamy niezbędne polecenia. Plikowi można nadać prostą
nazwę,
@echo off cls echo DANE WEJSCIOWE: echo. type dane.txt echo. prg < dane.txt > wyniki.txt echo WYNIKI: echo. type wyniki.txt echo.
Uwaga: Zanim uruchomisz program, przeczytaj wstęp do tego artykułu, w którym wyjaśniamy funkcje tych programów oraz sposób korzystania z nich. |
Program z pierwszego wiersza odczytuje liczbę n określającą ilość danych. Z następnych n wierszy odczytywane są dane i umieszczane w tablicy dynamicznej. Odczytane dane zostają następnie wyświetlone jedna obok drugiej. Wypróbuj z tym programem podane powyżej trzy opcje dostarczania danych i wyprowadzania wyników. |
Pascal// Odczyt danych // Data: 25.04.2008 // (C)2020 mgr Jerzy Wałaszek //--------------------------- program prg; type Tinteger = array of integer; var T : Tinteger; n, i : integer; begin readln(n); SetLength(T, n); for i := 0 to n-1 do readln(T[i]); writeln; for i := 0 to n-1 do write(T[i],' '); writeln; writeln; SetLength(T,0); end. |
// Odczyt danych // Data: 25.04.2008 // (C)2020 mgr Jerzy Wałaszek //--------------------------- #include <iostream> using namespace std; int main() { int * T, n, i; cin >> n; T = new int[n]; for(i = 0; i < n; i++) cin >> T[i]; cout << endl; for(i = 0; i < n; i++) cout << T[i] << " "; cout << endl << endl; delete [] T; return 0; } |
Basic' Odczyt danych ' Data: 25.04.2008 ' (C)2020 mgr Jerzy Wałaszek '--------------------------- Dim T As Integer Ptr Dim As Integer n, i Open Cons For Input As #1 Input #1,n T = New Integer[n] For i = 0 To n-1 Input #1,T[i] Next Close #1 Print For i = 0 To n-1 Print T[i]; Next Print Print Delete [] T End |
Python
(dodatek)# Odczyt danych # Data: 20.02.2024 # (C)2024 mgr Jerzy Wałaszek # -------------------------- n = int(input()) t = [] for i in range(n): t.append(int(input())) print() print(t) t.clear() |
Wynik: |
6 12 34 28 65 121 83 12 34 28 65 121 83 |
Czasami algorytm musi wstępnie wypełnić tablicę określoną zawartością. Operację taką przeprowadza się w pętli iteracyjnej, której zmienna licznikowa przebiega przez wszystkie kolejne indeksy elementów. Następnie wykorzystuje się zmienną licznikową jako indeks elementu tablicy, w którym umieszczamy określoną zawartość.
W poniższych przykładach zakładamy, iż w programie zadeklarowano tablicę T o 100 elementach typu integer. Indeksy elementów tablicy T są w zakresie od 0 do 99.
Pascal… for i := 0 to 99 do T[i] := x; … |
… for(i = 0; i < 100; i++) T[i] = x; … |
Basic… For i = 0 To 99 T(i) = x Next … |
Python
(dodatek)… for i in range(100): t[i] = x … |
Python
(dodatek)t.clear() for i in range(100): t.append(x) … |
Python
(dodatek)… for i in t: i = x … |
Pascal… for i := 0 to 99 do T[i] := (i+1) shl 1; … |
… for(i = 0; i < 100; i++) T[i] = (i+1) << 1; … |
Basic… For i = 0 To 99 T(i) = (i+1) shl 1 Next … |
Python
(dodatek)… for i in range(100): T[i] = (i+1) << 1 … |
Python
(dodatek)… T.clear() for i in range(100): T.append((i+1) << 1) … |
Pascal… for i := 0 to 99 do T[i] := 1+(i shl 1) |
… for(i = 0; i < 100; i++) T[i] = 1+(i << 1); … |
Basic… For i = 0 To 99 T(i) = 1+(i shl 1) Next … |
Python
(dodatek)… for i in range(100): T[i] = 1+(i << 1) … |
Python
(dodatek)… T.clear() for i in range(100): T.append(1+(i << 1)) … |
Pascalrandomize; … for i := 0 to 99 do T[i] := a+random(b-a+1); … |
#include <cstdlib> #include <ctime> … srand(time(NULL)); … for(i = 0; i < 100; i++) T[i] = a+rand()%(b-a+1); … |
BasicRandomize … For i = 0 To 99 T(i) = a+Cint(Rnd*(b-a+1)) Next … |
Python
(dodatek)import random … for i in range(100): T[i] = random.randrange(a,b+1) … |
Zespół Przedmiotowy Chemii-Fizyki-Informatyki w I Liceum Ogólnokształcącym im. Kazimierza Brodzińskiego w Tarnowie ul. Piłsudskiego 4 ©2024 mgr Jerzy Wałaszek |
Materiały tylko do użytku dydaktycznego. Ich kopiowanie i powielanie jest dozwolone
pod warunkiem podania źródła oraz niepobierania za to pieniędzy.
Pytania proszę przesyłać na adres email:
Serwis wykorzystuje pliki cookies. Jeśli nie chcesz ich otrzymywać, zablokuj je w swojej przeglądarce.
Informacje dodatkowe.