Zdecyduj, które liczby są parzyste i kliknij w odpowiednie pola Liveworksheets transforms your traditional printable worksheets into self-correcting interactive exercises that the students can do online and send to the teacher. 0%. liczby parzyste i nieparzyste w zakresie 30. Share Share by Agusiapoczta. Klasa 1 Klasa 2 Matematyka. Show More. Edit Content. Embed Jak wiemy parzystość danej liczby sprawdzamy na podstawie jej podzielności przez 2. Natomiast nasza prezentacja przeznaczona jest dla dzieci przedszkolnych, dlatego ważne jest, aby w pierwszej kolejności zauważyły cały proces poprzez układanie czerwonych żetonów po dwa, "w pary". Witam, mam do zrobienia program który ma wypełniać tablice dwuwymiarową [8][8] losowymi liczbami z przedziału 1-20, następnie wypisać największą i najmniejszą wartość. Mam problem z największą wartością, mógłby ktoś pomóc? Rozwiązanie zadania z matematyki: Wszystkie liczby parzyste z przedziału < 1,100>, które nie są podzielne przez 4 ustawiamy w ciąg (a_n). Wyznacz wzór ciągu a_n i uzasadnij, że jest on arytmetyczny. A więc tak udało mi się zrobić sumę wpisywanych liczb z klawiatury. wczytywanie kolejnych liczb w petli, np while (a!=1) {} do {} while (a!=1), w ktorej to petli dodajesz wczytana liczbe do sumy. dodanie warunku przed/po dodaniem liczby, czy suma przekroczy 100, jak przekroczy to Console.WriteLine ("Przekroczono zakres, wynik: ", wynik 3ICy. Tablice Wyobraź sobie, że musisz przechować 10 różnych wartości. Tworzysz więc 10 zmiennych. I wszystko jest w porządku do czasu, gdy dostajesz zadanie, by każdą taką zmienną zwiększyć np. o 2. Zaczynają się schody. A schody te zwiększają się gdy dochodzisz do momentu kiedy nie możesz z góry określić ile masz tych zmiennych, lub gdy tych zmiennych robi się nie 10, a na przykład 2000 razy tyle. Tutaj przychodzą z pomocą tablice, które są uporządkowanymi zbiorami zawierającymi jakieś dane. Dość klasycznym porównaniem jest szafa z bibliotecznymi kartami książek. Półka - tablica - przechowuje karty książek - u nas zmienne. Tworzenie nowej tablicy Aby stworzyć nową tablicę korzystamy z kwadratowych nawiasów: const tab = []; //pusta tablica const tab2 = [1, 2, 3, 4]; const tab3 = ["Marcin", "Ania", "Agnieszka"]; const a = "ALA"; const b = 234; const c = "PIES"; const tab = [a, b, c, "KOT", {...}]; //tablica z 5 elementami. Mogą to być oddzielne zmienne, ale też wartości wpisane bezpośrednio w tablicy Drugim sposobem tworzenia tablic - o wiele rzadziej używanym jest użycie konstruktora: const tab = new Array(10); //[blank x 10] const tab = new Array("Ala", "Bala", "Cala"); //gdy podamy więcej wartości staną się one elementami tablicy //["Ala", "Bala", "Cala"] Kolejne elementy tablicy ponumerowane za pomocą tak zwanych indeksów, które numerowane są od 0 (więcej na ten temat dowiesz się w rozdziale o obiektach). Pierwsza wartość w tablicy ma indeks 0, druga 1, trzecia 2 i tak dalej, aż do ostatniego indeksu który wynosi długość tablicy - 1 czyli Po stworzeniu tablicy aby pobrać dane elementy z tablicy wystarczy się do nich odwołać przez nazwę tablicy i indeks, który podajemy w kwadratowych nawiasach: const tab = ["Ala", "ma", "rudego", "kota"]; tab[0] ); //Ala tab[1] ); //ma tab[2] ); //rudego tab[3] ); //kota tab[ ); //ostatni element - kota W najnowszej wersji Javascript (ES2022) do odwoływania się do elementów możemy też użyć funkcji at(index). Jako index możemy tutaj podać liczbę dodatnią, ale też ujemną, dzięki czemu pobierzemy element od końca tablicy: const tab = ["Ala", "ma", "rudego", "kota"]; //Ala //ma //rudego //kota //rudego Właściwość length Każda tablica udostępnia nam właściwość length, która określa jej długość (czyli ilość jej elementów). Dzięki temu możemy poznać nie tylko długość tablicy, ale też indeks ostatniego elementu oraz w łatwy sposób przeprowadzać pętlę po wszystkich elementach naszej tablicy. //indeks: 0 1 2 const tab = ["Marcin", "Ania", "Agnieszka"]; ); //3 tab[ ] ); //Agnieszka for (let i=0; i ")); //Marcin Ania Agnieszka //zliczam liczbę liter w tablicy const cars = ["Mercedes", "Audi", "BMW"]; //15 Zamiana tekstu na tablicę Skoro powyżej zamieniliśmy tablicę na tekst, to spróbujmy zrobić to w drugą stronę. Aby to zrobić, wystarczy użyć składni spread: const txt = "kartofel"; const tab = [...txt]; //["k", "a", "r", "t", "o", "f", "e", "l"] Jeżeli chcielibyśmy tekst podzielić na podstawie znaku podziału, użyjemy do tego funkcji split() dostępnej dla tekstów: const txt = "Ala ma kota"; const tab = "); //["Ala", "ma", "kota"]; Funkcja reverse() Funkcja reverse() służy do odwracania kolejności tablicy: const tab = [1, 2, 3, 4]; //[4, 3, 2, 1] const word = "kajak"; const tab = [...word]; === //true czyli palindrom Metody indexOf(), lastIndexOf() i includes() Wyszukać element w tablicy możemy na kilka sposobów. Pierwszy z nich polega na skorzystaniu z funkcji indexOf(str) (która też jest dostępna dla stringów). Funkcja zwraca indeks na którym znalazła szukany tekst/obiekt, lub -1, jeżeli danego elementu nie znalazła: const tab = ["Marcin", "Ania", "Agnieszka", "Monika"]; //2 //-1 if ( !== -1) { występuje w tablicy pod indexem", } Kolejna metoda to lastIndexOf(), która działa bardzo podobnie, ale zwraca ostatnią pozycję szukanego tekstu: const tab = ["Agnieszka", "Marcin", "Ania", "Agnieszka", "Monika"]; //3; Kolejna funkcja to includes(), która zwraca prawdę lub fałsz w zależności czy szukana wartość znajduje się w tablicy: const tab = ["Marcin", "Ania", "Agnieszka", "Monika"]; if ( { występuje w tablicy pod indeksem", } if (! { nie występuje w tej tablicy"); } Wszystkich trzech metod możemy użyć także do wyszukiwania obiektów w tablicy, co staje się przydatne, gdy chcemy znaleźć index np. klikniętego przycisku w stronicowaniu. const ob = { name : "Jan" } const things = ["ala", "bala", "cala", ob, "data"]; //3 //bardziej realny przykład const paginationButtons = [... => { e => { const index = showSlide(index); }); }); Funkcja sort() Funkcja sort(fn*) służy do sortowania tablic. const tab = ["Marcin", "Ania", "Piotrek", "Grześ"]; tab ); //["Ania", "Grześ", "Marcin", "Piotrek"] Standardowo JavaScript segreguje tablice leksykograficznie (słownikowo). Oznacza to, że liczby traktowane są jak słowa. W większości przypadków powoduje to nieoczekiwane rezultaty: const tab = [1, 2, 21, 32, //[ 1, 2, 21, 32 ] Ale nie tylko przy liczbach funkcja ta nie zadziała. Spójrz na poniższy przykład: const tab = ["Bartek", "ania", "Celina", "agnieszka"]; //["Bartek", "Celina", "agnieszka", "ania"] Powyższy "błąd" wynika z faktu, że duże litery występują przed małymi. Aby móc posegregować naszą tablicę według własnych kryteriów (przy okazji naprawiając powyższe niedoskonałości), musimy do funkcji sort przekazać własną opcjonalną funkcję. function mySort(a, b) { ... } Javascript wykorzysta ją do porównywania kolejnych elementów w tablicy. Sama funkcja powinna zwracać odpowiednie wartości: Jeżeli funkcja zwróci wartość mniejszą od 0, to element a zostanie ustawiony przed elementem b Jeżeli funkcja zwróci wartość większą od 0, to element a zostanie ustawiony za elementem b Jeżeli funkcja zwróci wartość równą 0, to wartość oba elementy nie zostaną przestawione function compare(a, b) { if (a b) { return 1 } return 0 } Powyższe działanie obrazuje poniższy film: Przy czym puryści Javascript mogli by się przyczepić, że przecież zastosowany w Javascript algorytm sortujący jest bardziej skomplikowany. Przykładowo aby posegregować wartości liczbowe musimy utworzyć funkcję: function compareNr(a, b) { return a - b } const tab = [100, 320, 10, 25, 310, 1200, 400]; const tab3 = tab3 ); //[10, 25, 100, 310, 320, 400, 1200] const tab = [ { name: "Marcin" , height : 183 }, { name: "Ania" , height : 173 }, { name: "Agnieszka" , height : 170 }, ] //dla sort spokojnie możemy używać funkcji anonimowej b) { return - }); W powyższych przykładach sortowaliśmy po liczbach. Jeżeli podczas takiego sortowania chcielibyśmy porównać 2 teksty, odejmowanie tutaj nie zadziała prawidłowo (bo znowu wkradnie się porównywanie leksykalne). O wiele lepszym rozwiązaniem będzie użycie metody localeCompare(): const tab = ["Marcin", "ania", "Bożena"]; //ania specjalnie z małej b) { return a - b; }) //['Marcin', 'ania', 'Bożena'] b) { return b); }) //['ania', 'Bożena', 'Marcin'] Dzięki temu, że możemy przekazać własną funkcję, sortować możemy każdy rodzaj tablicy: const mails = [ "marcin@ "marcin@ "marcin@ "marcin@ ] //sortuje po domenach //z użyciem funkcji strzałkowej b) { const aDomain = @") + 1); const bDomain = @") + 1); return }) const users = [ { name : "Marcin", car : { name : "Toyota", age : 10 } }, { name : "Marcin", car : { name : "Fiat", age : 15 } }, { name : "Monika", car : { name : "BMW", age : 5 } }, ] //sortuje po wieku samochodu b) { return - }); Łączenie tablic Do połączenia (scalenia) tablic nie możemy użyć zwykłego dodawania (tak samo nie możemy odejmować tablicy od tablicy): const tab1 = ["Ala", "Basia"]; const tab2 = ["Piotr", "Marcin"]; + tab2); //Ala,BasiaPiotr,Marcin Wynikiem jest wartość typu string, co raczej nie jest prawidłowym rezultatem. Aby połączyć ze sobą kilka tablic wykorzystamy funkcje concat(), która jako parametr przyjmuje jedną lub kilka tablic: const anim1 = ["Pies", "Kot"]; const anim2 = ["Słoń", "Wieloryb"]; const anim3 = ["Chomik ninja", "Świnka morderca"]; const table = //wypisze ["Pies", "Kot", "Słoń", "Wieloryb"] const tableBig = anim3); //wypisze ["Pies", "Kot", "Słoń", "Wieloryb", "Chomik ninja", "Świnka morderca"]; W dzisiejszych czasach o wiele przyjemniejszym sposobem jest użycie spread syntax: const anim1 = ["Pies", "Kot"]; const anim2 = ["Słoń", "Wieloryb"]; const table = [...anim1, ...anim2]; Funkcja slice() Funkcja slice(od, do*) tak samo jak przy stringach, zwraca kawałek tablicy na której została wywołana. Pierwszy parametr wskazuje na indeks, od którego ma "wyciąć" elementy, a drugi wskazuje indeks do jakiego będziemy ciąć. Jeżeli nie podamy drugiej wartości, zostanie wycięty kawałek od danego indeksu do końca tablicy. const tab = ["Marcin", "Ania", "Agnieszka", "Monika", "Magda"]; const tab2 = 1); //["Marcin"] //["Marcin", "Ania", "Agnieszka", "Monika", "Magda"] const tab3 = //["Agnieszka", "Monika", "Magda"] const tab4 = 5); //["Marcin", "Ania", "Agnieszka", "Monika", "Magda"] const tab5 = //od końca //["Monika", "Magda"] const tab6 = -1); //["Agnieszka", "Monika"] Funkcja splice() Funkcja splice(index, ileUsunąć, nowyElement*...) służy zarówno do usuwania jak i wstawiania nowych elementów do tablicy. Parametr index określa miejsce w tablicy gdzie będziemy działać. Parametr ileUsunąć mówi ile elementów powinno być usuniętych z tablicy. Opcjonalne parametry nowyElement to element (lub kilka), który będzie wstawiany przed danym miejscem tablicy. const tab = ["Marcin", "Ania", "Agnieszka", "Monika"]; 1); //usuwam 1 element na indeksie 2 //["Marcin", "Ania", "Monika"] const tab = ["Marcin", "Ania", "Agnieszka", "Monika"]; 0, "A") //nic nie usuwam na indeksie 1 i wstawiam przed niego nowy element //["Marcin", "A", "Ania", "Agnieszka", "Monika"] const tab = ["pies", "kot", "chomik", "aligator", "świnka", "kanarek"]; const index = if (index !== -1) { 1); //["pies", "kot", "chomik", "świnka", "kanarek"]; } Funkcja fill() Funkcja fill() służy do wypełniania tablicy. Pierwszy jej parametr to wartość, którą zostanie wypełniona tablica. Dwa pozostałe opcjonalne parametry wskazują na indeks początku i końca wypełniania. Jeżeli nie podamy indeksu końcowego, tablica zostanie wypełniona od indeksu początkowego do swojego końca. const tab = new Array(20); //[empty x 20] //["kot", "kot", "kot", ...] const tab2 = []; = 15; //[empty x 15] 2, 5); //[empty × 2, "kot", "kot", "kot", empty × 10] const tab3 = [1, 2, 3, 4, 5]; 2); //[1, 2, "pies", "pies", "pies"] Przemieszczanie się po tablicy Jedną z najwspanialszych rzeczy, jakie dają nam tablice to możliwość wykonywania masowych operacji na wszystkich elementach w tablicy. Aby zrobić pętlę po tablicy możemy skorzystać z kilku zapisów. Jednym z nich jest użycie klasycznych pętli for/while: const tab = ["Marcin", "Ania", "Agnieszka"]; for (let i=0; i< i++) { pętli: " + i); //0, 1... //"Marcin", "Ania"... } Widzisz jak się odwołuję do danego elementu tablicy? Skoro licznik i zwiększa się od 0 do to mogę za jego pomocą pobierać kolejne elementy tablicy czyli tab[0], tab[1]... i tak do tab[ const tab = ["Marcin", "Ania", "Agnieszka"]; for (let i=0; i< i++) { const el = tab[i]; //"MARCIN", "ANIA"... } Oczywiście pętlę while też możemy zastosować, przy czym wykorzystanie jej dla iterowania po tablicy jest mało spotykane. Iterowanie po tablicach to tak częsta rzecz, że w Javascript mamy na to kilka możliwości. W dzisiejszych czasach możemy też zastosować o wiele przyjemniejszą pętlę for of, która automatycznie wyłapie nam odpowiedni element z tablicy (nie musimy odwoływać się poprzez tab[i]): const tab = ["Marcin", "Ania", "Agnieszka"]; for (const el of tab) { //el to nazwa zmiennej wymyślona przez nas //"Marcin", "Ania"... } for (const xxx of tab) { //xxx to nazwa zmiennej wymyślona przez nas //"MARCIN"... } for (let lorem of tab) { //niektórzy używają tutaj let zamiast const } Pętla ta jest na tyle wygodna, że w kolejnych rozdziałach (szczególnie DOM) dość często będę z niej korzystał. Innym sposobem wykonywania zbiorczych operacji na tablicach jest zastosowanie metod iteracyjnych takich jak forEach(). Omówimy je w kolejnym rozdziale. Tablice wielowymiarowe Skoro tablice mogą w sobie trzymać dowolne wartości, mogą także przetrzymywać obiekty, lub... kolejne tablice. Taki twór zwie się tablicami wielowymiarowymi. const tab = [ ["a1", "a2", "a3", "a4", "a5", "a6"], ["b1", "b2", "b3", "b4", "b5", "b6"], ["c1", "c2", "c3", "c4", "c5", "c6"], ] //["a1", "a2", "a3", "a4", "a5", "a6"] //6 //"a2" //"c4" Do czego takie wielowymiarowe tablice mogą się przydać? Przykładowo do przetrzymywania danych: const tab = [ ["Marcin", 183, "red", "kot"], ["Ania", 173, "blue", "pies"], ["Agnieszka", 170, "yellow", "świnka"] ] imię: ${tab[0][0]} wzrost: ${tab[0][1]} kolor: ${tab[0][2]} zwierzak: ${tab[0][3]} `); Powyższy przykład nie jest idealny. Trzymanie w taki sposób danych tego typu to proszenie się o problemy. Po pierwsze musimy pamiętać kolejność indeksów dla każdej danej. Druga sprawa to potencjalna możliwość zmiany kolejności indeksów. Problemy te rozwiązują obiekty, o których sobie jeszcze porozmawiamy. Nie oznacza to jednak, że takie wielowymiarowe tablice nie mają zastosowania. Mają - i to całkiem duże. Wystarczy chociażby spojrzeć praktycznie na dowolną grę. Większość map poziomów w takich grach zbudowana jest na bazie właśnie tablic wielowymiarowych, gdzie każdy indeks wewnętrznych tablic zawiera informację na temat użytej w danym miejscu grafiki czy wystąpienia ściany. Tutaj mała ciekawostka. Wielu artystów nie tworzy takich tablic za pomocą kodu, a raczej korzysta ze specjalnych edytorów, które służą do układania grafiki na planszy. Są to np. lub tiled, ale też wiele z popularnych narzędzi w świecie gamedevu ma swoje wbudowane edytory. Spróbujmy wyświetlić jedną z takich przykładowych tablic na ekranie konsoli debugera: const level = [ [1, 1, 0, 0, 2, 2, 0, 0, 1, 1], [1, 0, 0, 0, 2, 2, 0, 0, 0, 1], [1, 0, 1, 1, 2, 2, 1, 1, 0, 1], [1, 0, 2, 2, 2, 2, 2, 2, 0, 1], [2, 2, 2, 2, 1, 1, 2, 2, 2, 2], [2, 2, 2, 2, 1, 1, 2, 2, 2, 2], [1, 0, 2, 2, 2, 2, 2, 2, 0, 1], [1, 0, 1, 1, 2, 2, 1, 1, 0, 1], [1, 0, 0, 0, 2, 2, 0, 0, 0, 1], [1, 1, 0, 0, 2, 2, 0, 0, 1, 1] ]; let str = ""; for (const subTab of level) { //pod subTab mamy każdą kolejną podtablicę for (const el of subTab) { switch (el) { case 0 : str += "🟩"; break; case 1 : str += "🟫"; break; case 2 : str += "⬛"; break; } } str += "\n"; } W naszym przypadku w tablicy są tylko wartości 0/1/2. W praktyce musiały by się tam znaleźć indeksy każdej grafiki użytej do zrobienia danej planszy, a i przydało by się tutaj dodać kilka funkcji rysujących realną planszę. I tu się pojawia smutek autora. Chciałbym wam teraz pokazać jakiś bardziej realny przykład, ale wymagało by to sięgnięcia po bardziej zaawansowaną wiedzę, którą poznamy w późniejszych rozdziałach. Przyjdzie pora i na to. Funkcja flat() Jeżeli chcemy spłaszczyć wielowymiarową tablicę, zastosujemy funkcję flat(). Jedyny jej parametr służy do określenia ile poziomów mamy spłaszczyć: const tab = [ 1, [2,3], [4,5,[6,7]], [[[8,9], [10,11]]] ] const tab = [ 1, [2,3], [4,5,[6,7]], [[[8,9], [10,11]]] ] Jeżeli chcemy mieć pewność, że uzyskamy płaską 1 wymiarową tablicę, jako liczbę poziomów podajmy Infinity: const tab = [ 1, [2,3], [4,5,[6,7]], [[[8,9], [10,11]]] ] //[1,2,3,4,5,6,7,8,9,10,11] Funkcja map*, this*) służy do tworzenia tablic z obiektów tablico podobnych. Obiekty takie są podobne do tablic, ale równocześnie nimi nie są. Przykładem takiego obiektu są kolekcje elementów pobranych ze strony, argumenty funkcji (arguments), czy np. classList dla elementów na stronie. Będziemy się o nich uczyć w kolejnych rozdziałach. const ob = { 0 : "ala", 1 : "bela", length: 2 } //["ala", "bela"] //pobieram kolekcję buttonów ze strony const buttons = //NodeList [button, button...] const tab = //Array [button, button...] Drugi opcjonalny parametr tej funkcji może zawierać funkcję map() dla tablic: const ob = { 0 : "ala", 1 : "bela", length: 2 } const tab = function(el) { return }); //["ALA", "BELA"] Trzeci - równie opcjonalny parametr wskazuje na this. Działa on podobnie do stosowanego w przypadku metod dla tablic. W praktyce w większości przypadków używany jest tylko pierwszy parametr czyli obiekt, który poddajemy konwersji (tak jak w pierwszym przykładzie). W dzisiejszych czasach w wielu przypadkach zamiast powyższej metody możemy skorzystać ze spread syntax: const buttons = //NodeList [button, button...] const buttonsTabA = [...buttons]; //array const buttonsTabB = //array Różnica między spread syntax a jest taka, że tą drugą możemy zastosować dla obiektów tablico podobnych, które nie mają zaimplementowanej własnej funkcji iterującej: const ob = { 0: "a", 1: "b", length: 2 }; //["a", "b"] //ob[ is not a function Spokojnie. Nie musisz się teraz skupiać na bardzo dokładnym poznaniu każdego aspektu działania tej metody. Wszystko przyjdzie z czasem. String - teksty Funkcje Pętle są wykorzystywane w programowaniu w celu automatyzacji powtarzalnych zadań. Najbardziej podstawowymi typami pętli zastosowanych w JavaScript są instrukcje while i do…while. Instrukcje while i do…while są oparte na wyrażeniach warunkowych, zatem są wykonywane, gdy wynikiem zdefiniowanego wyrażenia warunkowego jest prawda. Instrukcje for działają w ten sam sposób i mają wbudowane dodatkowe funkcje, takie jak licznik pętli, umożliwiający wcześniejsze zdefiniowanie liczby iteracji pętli. W tym artykule poznamy instrukcję for, for…of i for…in, które są istotnymi elementami języka programowania JavaScript. Spis treści1 Pętla Instrukcja Wyrażenie Wyrażenia Modyfikacja Długość tablicy2 Pętla for…in3 Pętla for…of Pętla for Instrukcja for jest typem pętli, która wykorzystuje maksymalnie do trzech opcjonalnych wyrażeń w celu zaimplementowania powtarzających się czynności, zdefiniowanych w bloku kodu. Spójrzmy na przykład, ilustrujący co to oznacza. for (inicjalizacja; instrukcja warunkowa; wyrażenie końcowe) { // kod } W powyższej składni w instrukcji for umieszczono trzy wyrażenia: initialization (inicjujące), condition (warunkowe) oraz final expression (końcowe), zwane także inkrementacją. Użyjemy podstawowego przykładu, aby zademonstrować, za co odpowiada każda z tych instrukcji. // pętla for z 5 iteracjami for (let i = 0; i 3) { break; } } 0 1 2 3 Ostrzeżenie: Instrukcja break musi zostać dołączona, jeśli instrukcja warunkowa zostanie pominięta. W przeciwnym wypadku pętla będzie działać nieprzerwanie jako pętla nieskończona i prawdopodobnie doprowadzi do zawieszenia przeglądarki. Ostatecznie, wyrażenie końcowe może zostać usunięte, poprzez umieszczenie go na końcu pętli. Nadal należy uwzględnić obydwa średniki, w przeciwnym razie pętla nie będzie działać. // deklaracja zmiennej poza pętlą let i = 0; // pomijanie wszystkich warunków for (; ;) { if (i > 3) { break; } i++; } 0 1 2 3 Jak widać z powyższych przykładów, zdefiniowanie wszystkich trzech instrukcji zapewnia najbardziej zwięzły i czytelny kod. Warto jednak na przyszłość wiedzieć, że możliwe jest pominięcie omówionych instrukcji. Modyfikacja tablicy Możemy użyć pętli do modyfikowania tablicy. W następnym przykładzie utworzymy pustą tablicę i zapełnimy ją wartościami zmiennej licznika pętli. // inicjalizujemy pustą tablicę let arrayExample = []; // inicjalizacja pętli for z trzykrotnym powtórzeniem for (let i = 0; i < 3; i++) { // aktualizujemy dane w tablicy zmienną } [ 0 ] [ 0, 1 ] [ 0, 1, 2 ] Definiujemy pętlę, która działa, dopóki instrukcja warunkowa i Długość tablicy Czasami możemy chcieć, aby pętla działała kilkukrotnie, nie będąc pewnym, jaka będzie liczba iteracji. Zamiast definiować liczbę stałą, jak to zrobiliśmy w poprzednich przykładach, możemy skorzystać z właściwości length (długość) tablicy, aby pętla działała tyle razy, ile jest w niej elementów. // deklaracja tablicy z 3 obiektami let zupa = [ "rosol", "pomidorowa", "zurek" ]; // inicjalizacja pętli for dla uruchomienia tyle razy - jaka jest długość tablicy for (let i = 0; i < i++) { // wyświetlamy każdy obiekt z tablicy w konsoli } Otrzymamy następujące dane wyjściowe. rosol pomidorowa zurek W tym przykładzie zwiększamy wartość zmiennej iteracyjnej przez każdy indeks tablicy za pomocą komendy zupa[i] (np. pętla będzie zwiększać wartość zmiennej iteracyjnej przez zupa[0], zupa[1] itd.). To powoduje, że indeks aktualizuje się dynamicznie wraz z każdą iteracją. Pętla for…in Instrukcja for…in dokonuje iteracji na podstawie właściwości obiektu. Aby to zademonstrować, stworzymy prosty obiekt zubr z kilkoma zmiennymi name:value. const zubr = { typ: "strunowce", rodzina: "wolowate", masa: Infinity } Korzystając z pętli for…in, możemy łatwo uzyskać dostęp do każdej z nazw właściwości. // Print property names of object for (attribute in zubr) { } typ rodzina masa Możemy również uzyskać dostęp do wartości przypisanej każdej właściwości, używając nazwy właściwości jako wartości indeksowej obiektu. // Print property values of object for (attribute in zubr) { } strunowce wolowate Infinity Łącząc je, możemy uzyskać dostęp do wszystkich nazw i wartości obiektu. // Print names and values of object properties for (attribute in zubr) { + `: ${zubr[attribute]}`); } TYP: strunowce RODZINA: wolowate MASA: Infinity Użyliśmy metody toUpperCase(), aby zmodyfikować nazwę właściwości, a następnie jej wartość. for…in jest niezwykle użytecznym sposobem na iterację w oparciu o właściwości obiektu. Pętla for…of Instrukcja for…in jest przydatna do iteracji w oparciu o właściwości obiektu, ale do iteracji w oparciu o obiekty iterowalne, takie jak tablice i łańcuchy znaków, możemy użyć instrukcji for …of. Instrukcja for…of jest nowszym rozwiązaniem w ramach ECMAScript 6. ECMAScript (lub ES) to specyfikacja języka skryptowego stworzona w celu standaryzacji JavaScript. W tym przykładzie pętli for…of utworzymy tablicę i wyświetlimy każdy element tablicy w konsoli. // Initialize array of zubr species let zubry = [ "zubr nizinny", "zubr kaukaski", "zubr karpacki" ]; // Print out each type of zubr for (let zubr of zubry) { } Z instrukcji for…of otrzymamy następujące dane wyjściowe. zubr nizinny zubr kaukaski zubr karpacki Możliwe jest również wyświetlenie indeksu związanego z elementami indeksowymi przy użyciu metody entries(). ... // Loop through both index and element for (let [index, zubr] of { zubr); } 0 'zubr nizinny' 1 'zubr kaukaski' 2 'zubr karpacki' Łańcuch znaków może być iterowany w taki sam sposób jak tablica. // Assign string to a variable let zubrString = "zubry"; // Iterate through each index in the string for (let zubr of zubrString) { } z u b r y W tym przypadku zapętliliśmy każdy znak w łańcuchu, wyświetlając je w sekwencji. Ta lekcja dostępna jest także w formie filmu. Pętle w programowaniu są wykorzystywane niemal w każdym programie. Jest to jedna z podstawowych konstrukcji wykorzystywana we wszystkich językach programowania. Pozwalają one wykonywać określoną czynność wielokrotnie na przykład, gdy musimy wyświetlić 10 razy prawie to samo. Poznamy tutaj pętle, które pozwalają powtarzać jakąś czynność niewiadomą ilość razy oraz takie, które z góry zakładają pewną liczbę wykonań. Pętla while Pętlę while najczęściej wykorzystuje się w miejscach, gdzie zakładana ilość powtórzeń jest bliżej nieokreślona, ale znamy warunek jaki musi być spełniony. Jej schematyczną postać przedstawiono poniżej: while(warunek){ instrukcje do wykonania } Gdy warunek jest spełniony instrukcja we wnętrzu pętli jest wykonywana. Jeżeli natomiast warunek jest fałszywy może się ona nie wykonać, ani razu. Zazwyczaj stosuje się jakąś zmienną liczbową, a następnie dzięki inkrementacji, lub dekrementacji zmienia do momentu, aż warunek stanie się fałszywy. Podobnie jak przy instrukcji warunkowej if można pominąć nawiasy klamrowe w wypadku, gdy w ciele pętli znajduje się tylko jedna metoda, lub dowolna instrukcja. Dobrze jest sobie zapamiętać ją jako: "dopóki warunek jest spełniony to wykonuj instrukcje". Zobaczmy jej działanie na praktycznym przykładzie: public class Odczyt{ public static void main(String[] args){ int licznik = 0; while(licznik<10){ jest petla"); licznik++; } pętli"); } } Zadeklarowaliśmy zmienną licznik i przypisaliśmy jej 0. Sprawdzamy warunek, czy jest ona mniejsza od 10 - faktycznie jest więc wykonujemy instrukcje w jej wnętrzu. Wyświetlamy tekst "To jest pętla" i zwiększamy licznik o 1. Następnie znowu sprawdzany jest warunek, czy 1<10, ponownie tak, więc powtarzamy poprzednie czynności. Gdy licznik osiąga wartość 10 warunek jest fałszywy, ponieważ 10 nie jest mniejsze od 10. Pętla jest przerywana i wyświetlany jest tekst "Koniec pętli". Pętla do while Różni się ona od pętli while przede wszystkim tym, że to co znajduje się w jej wnętrzu wykona się przynajmniej raz, ponieważ warunek jest sprawdzany dopiero w drugiej kolejności. Schematyczna budowa przedstawia się o tak: do{ instrukcje do wykonania } while(warunek); Zwróć uwagę na kończący wyrażenie średnik, który przy pętli while nie występuje. instrukcje do wykonania są egzekwowane przynajmniej raz, a dopiero później sprawdzamy warunek, gdy jest on prawdziwy, instrukcje są powtarzane. Tą pętlę można zapamiętać następująco "wykonuj instrukcje dopóki warunek jest prawdziwy" - widzimy tutaj tylko zamianę słów, ale mają one kluczowe znaczenie. Wcześniejszy przykład z użyciem pętli do...while wyglądałby tak: public class Odczyt{ public static void main(String[] args){ int licznik = 0; do{ jest petla"); licznik++; } while(licznik<10); pętli"); } } Przebieg działania jest prawie taki sam, tylko, że gdyby przykładowo licznik był zainicjowany liczbą 20, to mimo wszystko wyświetliłby się raz napis "To jest pętla". W naszym przypadku napis wyświetla się 10 razy. Pętla for Pętlę for od dwóch poprzednich odróżnia przede wszystkim rodzaj zastosowań. W jej przypadku zazwyczaj wiemy dokładnie ile razy ma się jakaś czynność powtórzyć. Jej schemat to: for(wyrażenie początkowe ; warunek ; modyfikator_licznika){ instrukcje do wykonania } Wyrażenie początkowe służy do zainicjowania jakiegoś licznika, którym zazwyczaj jest w tym samym miejscu zadeklarowana zmienna typu całkowitego - najczęściej oznacza się je przy pomocy liter od "i" wzwyż, jest to przydatne przy zagnieżdżonych pętlach, gdzie przy długich nazwach ciężko by się było połapać. Warunek sprawdza, czy ma się wykonać instrukcja z wnętrza pętli, natomiast modyfikator zmienia licznik - zazwyczaj jest to instrukcja inkrementacji. Wcześniejszy przykład z wykorzystaniem pętli for wyglądałby więc tak: public class Odczyt{ public static void main(String[] args){ for(int i=0; i<10; i++){ jest pętla"); } pętli"); } } Jak widać nie musieliśmy tutaj deklarować zmiennej globalnej, a zapis jest bardziej zwięzły. Działanie jest dokładnie takie samo jak w przypadku pętli while. Pętla foreach Istnieje również pętla foreach która pozwala na iterację po wszystkich elementach tablicy lub kolekcji. Opis tej pętli znajdziesz pod w artylkule o pętli foreach. $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$Napisać program, który pobiera od użytkownika ciąg liczb całkowitych. Pobieranie danych kończone jest podaniem wartości 0 (nie wliczana do danych). W następnej kolejności program powinien wyświetlić sumę największej oraz najmniejszej z podanych liczb, średnią arytmetyczną wprowadzonych liczb, a także ile z wprowadzonych liczb było jest większych od średniej. #include #include #include #include #include using namespace std; int main() { int tab[1000], n=1; int i=0, suma=0, najwieksza , najmniejsza,srednia, zlicz = 0; while ( n!=0) { cout>n; tab[i]= n; i++; zlicz++; } najmniejsza = tab[0]; najwieksza = tab[0]; for (int i = 0; inajwieksza) najwieksza=tab[i]; else if (tab[i]>n; suma = suma + n; zlicz= zlicz+1; } while (suma 2) i wypisuje na standardowym wyjściu największą liczbę k taką, że k dzieli n i k >n; tab = new int[n]; if (n> n; tab = new int[n]; if (n > n; if (n==0) cout najwieksza) { najwieksza = tab[i]; cout #include #include #include #include using namespace std; int main() { int tab[5][5]; srand (time(NULL)); for (int i=0;i<5;i++) {cout<

liczby parzyste od 0 do 100 javascript