Pytania pomocnicze - INF.04

Najczęściej pętla zaczyna się od indeksu `length() - 1`, kończy na `0` i zmniejsza indeks (`i--`). Kolejne znaki są dopisywane do zmiennej wynikowej.

Pętla zaczyna od ostatniego znaku napisu i przechodzi do pierwszego. Każdy znak jest dopisywany do zmiennej wynikowej, dzięki czemu powstaje napis w odwrotnej kolejności.

Metoda przechodzi po znakach napisu od ostatniego do pierwszego i dopisuje je do zmiennej output. W efekcie zwraca napis w odwróconej kolejności.

Indeksowanie w Javie zaczyna się od `0`. Dla tekstu o długości `n` pierwszy znak ma indeks `0`, a ostatni `n - 1`.

Kod tylko tworzy odwrócony napis i go zwraca. Nie porównuje napisu wejściowego z jego odwróceniem, więc nie sprawdza, czy tekst jest palindromem.

Pętla startuje od indeksu str.length()-1, czyli od końca napisu, i zmniejsza i aż do 0. Dzięki temu znaki są pobierane od końca do początku.

Metoda `charAt(index)` zwraca znak znajdujący się pod wskazanym indeksem w ciągu znaków. Na przykład `"abc".charAt(1)` zwróci znak `'b'`.

Steruje przechodzeniem po kolejnych indeksach napisu od końca do początku. Dzięki temu znaki są pobierane w odwrotnej kolejności.

Steruje przechodzeniem po indeksach napisu od końca do początku. Dzięki temu znaki są pobierane w odwrotnej kolejności.

Metoda charAt(i) zwraca znak znajdujący się na pozycji i w napisie. W tym zadaniu służy do pobierania kolejnych znaków od końca tekstu.

Odwracanie tworzy nowy tekst w odwrotnej kolejności. Sprawdzanie palindromu polega na ustaleniu, czy tekst czytany od przodu i od tyłu jest taki sam, np. `kajak`.

Metoda charAt(i) zwraca pojedynczy znak z napisu o indeksie i. W tym zadaniu pobiera kolejne znaki od końca napisu.

Algorytm tylko tworzy odwróconą wersję napisu, ale nie porównuje jej z napisem wejściowym. Do sprawdzenia palindromu potrzebne byłoby porównanie obu ciągów.

Nie. Algorytm nie porównuje znaków ani nie ustawia ich według wartości kodów ASCII/Unicode, tylko przepisuje je od końca do początku.

Przejście po napisie odbywa się dla wszystkich jego znaków, więc podstawowo jest to O(n). W praktyce wielokrotne łączenie Stringów może być mniej wydajne, bo tworzy nowe obiekty.

Odwracanie zmienia kolejność wszystkich znaków w napisie. Wyszukiwanie polega na sprawdzeniu, czy konkretny znak występuje i ewentualnie na jakiej pozycji.

Wynikiem będzie `margorp`, ponieważ znaki zostaną odczytane od ostatniego do pierwszego.

Zmiennej output przypisano na początku pojedynczą spację, więc wynik będzie zaczynał się od spacji. Jeśli celem jest czyste odwrócenie napisu, powinno tam być pusty napis "".

Zmiennej output przypisano na początku pojedynczą spację, więc wynik będzie zaczynał się od spacji. Jeśli celem jest czyste odwrócenie napisu, powinno być użyte pusty napis "".

Metoda przyjmuje napis wejściowy i zwraca nowy napis jako wynik działania algorytmu. Nie modyfikuje bezpośrednio oryginalnego tekstu, tylko buduje nowy ciąg.

Obiekty `String` w Javie są niemodyfikowalne, więc każda konkatenacja tworzy nowy obiekt. `StringBuilder` pozwala efektywniej budować wynikowy tekst.

Odwracanie zmienia kolejność wszystkich znaków w napisie. Wyszukiwanie litery polega na sprawdzeniu, czy dany znak występuje i ewentualnie na jakiej pozycji.

Pętla pobierze kolejno znaki: 't', potem 'o', potem 'k'. Po ich dopisaniu do wyniku otrzymamy napis "tok".

Asertywność pozwala jasno przedstawić swoje potrzeby i granice, nie atakując drugiej strony. Dzięki temu negocjator nie jest ani uległy, ani agresywny.

Cierpliwość pomaga zachować spokój, analizować argumenty i nie podejmować pochopnych decyzji. Jest szczególnie ważna, gdy rozmowy są trudne lub trwają długo.

Cierpliwość pomaga spokojnie wysłuchać argumentów, nie podejmować pochopnych decyzji i dążyć do porozumienia krok po kroku. To szczególnie ważne w trudnych lub długich rozmowach.

Intuicja to umiejętność wyczuwania nastroju, intencji i reakcji drugiej strony. Pomaga dobrać odpowiedni sposób komunikacji i moment na przedstawienie argumentów.

Intuicja to umiejętność szybkiego wyczuwania intencji, nastroju i możliwych reakcji rozmówcy. Nie zastępuje wiedzy, ale pomaga lepiej ocenić sytuację i dobrać sposób działania.

Negocjator powinien unikać porywczości, buty, nadmiernej nieśmiałości i pesymizmu. Takie cechy utrudniają osiągnięcie porozumienia i mogą zaostrzać konflikt.

Przeszkadzają m.in. porywczość, buta, nieśmiałość i skrajny pesymizm. Takie postawy utrudniają komunikację, osłabiają zaufanie i mogą prowadzić do konfliktu zamiast porozumienia.

Przygotowanie pozwala znać swoje cele, argumenty, możliwe ustępstwa i granice. Dzięki temu negocjator podejmuje decyzje na podstawie faktów, a nie emocji.

Słowa przekazują argumenty i warunki, a mowa ciała pokazuje nastawienie, pewność siebie i otwartość. Spójność obu form komunikacji zwiększa wiarygodność negocjatora.

Powinien zachować spokój, wysłuchać drugiej strony i skupić się na rozwiązaniu problemu. Ważne jest oddzielenie emocji od faktów.

Nie, celem negocjacji jest osiągnięcie możliwie korzystnego i trwałego porozumienia. Zbyt agresywne podejście może zniszczyć relacje i utrudnić dalszą współpracę.

Hermetyzacja polega na ukrywaniu danych i szczegółów implementacji klasy przed kodem zewnętrznym. Dostęp do nich odbywa się przez określone metody klasy.

Pola `private` nie mogą być bezpośrednio modyfikowane spoza klasy. Dzięki temu klasa może kontrolować poprawność zmian danych.

Modyfikatory dostępu określają, które pola i metody są widoczne z zewnątrz klasy. Dzięki nim można ukryć elementy wewnętrzne, np. oznaczając je jako private.

Hermetyzacja dotyczy ukrywania danych i kontroli dostępu do elementów klasy. Dziedziczenie pozwala tworzyć nowe klasy na podstawie już istniejących.

Prywatne pola chronią dane przed niekontrolowaną zmianą z zewnątrz. Dostęp do nich odbywa się wtedy przez metody, które mogą sprawdzać poprawność danych.

Hermetyzacja chroni wnętrze obiektu, a polimorfizm pozwala używać obiektów różnych klas przez wspólny interfejs. Są to różne zasady programowania obiektowego.

Gettery służą do odczytu wartości pól, a settery do ich kontrolowanej zmiany. Pozwalają zachować hermetyzację, zamiast udostępniać pola bezpośrednio.

Funkcja zaprzyjaźniona, oznaczona słowem `friend`, może mieć dostęp do prywatnych i chronionych elementów klasy. Jest wyjątkiem od standardowego ograniczenia dostępu.

Wyjątki służą do obsługi błędów i sytuacji wyjątkowych w programie. Nie są zasadą programowania obiektowego związaną z ukrywaniem elementów klasy.

Ukrywanie implementacji zmniejsza ryzyko błędów i ułatwia późniejsze zmiany w kodzie. Użytkownik klasy korzysta z jej publicznego interfejsu, nie znając szczegółów działania.

`protected` oznacza, że metoda lub pole jest dostępne wewnątrz klasy, w której zostało zdefiniowane, oraz w klasach po niej dziedziczących. Nie jest dostępne jak element publiczny z dowolnego miejsca programu.

Metoda oznaczona jako protected jest dostępna wewnątrz tej klasy oraz w klasach, które po niej dziedziczą. Nie można jej zwykle wywołać bezpośrednio z kodu zewnętrznego na zwykłej instancji.

`public` pozwala korzystać z elementu z każdego miejsca programu, np. przez instancję klasy. `protected` ogranicza dostęp do samej klasy i klas pochodnych.

public udostępnia metodę wszystkim fragmentom programu, a protected ogranicza dostęp do klasy bazowej i klas pochodnych. protected lepiej wspiera hermetyzację.

`private` pozwala na dostęp tylko wewnątrz tej samej klasy. `protected` dodatkowo umożliwia dostęp w klasach dziedziczących.

Bo protected nie daje dostępu z dowolnego miejsca w programie. Taka metoda nie jest przeznaczona do publicznego użycia przez kod zewnętrzny.

Zwykle nie. Jeśli metoda jest `protected`, nie można jej wywołać tak jak metody publicznej, np. `obiekt.Metoda()`, spoza klasy lub klasy dziedziczącej.

Pozwala udostępnić pewne mechanizmy klasom dziedziczącym bez wystawiania ich na zewnątrz. To częsty sposób budowania rozszerzalnych klas bazowych.

`protected` jest szczególnie używany przy dziedziczeniu, ponieważ pozwala klasom pochodnym korzystać z wybranych elementów klasy bazowej bez udostępniania ich całemu programowi.

Pozwalają kontrolować, które elementy klasy są widoczne na zewnątrz, a które pozostają ukryte. Dzięki temu ogranicza się niepożądany dostęp do wnętrza obiektu.

Służą do kontrolowania dostępu do elementów klasy. Pomagają realizować enkapsulację, czyli ukrywanie szczegółów implementacji i udostępnianie tylko potrzebnych operacji.

Najczęściej spotyka się public, private i protected, czasem także internal lub protected internal zależnie od języka. Każdy z nich określa inny poziom widoczności metody.

IDE to zintegrowane środowisko programistyczne, które łączy edytor kodu, narzędzia uruchamiania, debugowania i zarządzania projektem. Ułatwia tworzenie aplikacji.

IDE to zintegrowane środowisko programistyczne, które łączy edytor kodu, kompilację, uruchamianie i debugowanie. Ułatwia tworzenie, testowanie i rozwijanie aplikacji.

Te środowiska IDE najczęściej kojarzą się z językiem Java. Szczególnie Eclipse i NetBeans są klasycznymi środowiskami używanymi do nauki i pracy z Javą.

Te środowiska powstały głównie z myślą o programowaniu w Javie i mają bardzo dobre wsparcie dla tego języka. Umożliwiają wygodne tworzenie projektów Java, zarządzanie bibliotekami i debugowanie.

Visual Studio jest środowiskiem silnie kojarzonym z C#, C++ oraz platformą .NET. W pytaniu podano IntelliJ IDEA, Eclipse i NetBeans, które typowo wskazują na Javę.

Nie, mogą obsługiwać także inne języki, często przez wtyczki lub dodatkowe moduły. Jednak ich podstawowe i najbardziej charakterystyczne zastosowanie dotyczy Javy.

JVM, czyli Java Virtual Machine, uruchamia bytecode wygenerowany z kodu Javy. Dzięki temu programy Java mogą działać na różnych systemach operacyjnych.

Najważniejsze to podpowiadanie składni, automatyczne uzupełnianie kodu, wykrywanie błędów, debuger i refaktoryzacja. Dzięki nim programista szybciej pisze poprawny kod.

Przydatne są podpowiedzi składni, automatyczne importy, wykrywanie błędów, uruchamianie programu i debugger. IDE pomaga też zarządzać klasami, pakietami i bibliotekami.

Edytor tekstu służy głównie do pisania kodu, a IDE oferuje dodatkowo narzędzia do kompilacji, uruchamiania, testowania i analizy programu. IDE jest więc bardziej kompleksowym środowiskiem pracy.

Nie, wiele IDE można rozszerzać i używać do różnych języków. Jednak ich podstawowe i najbardziej typowe zastosowanie w kontekście egzaminacyjnym to programowanie w Javie.

Wskazówką są nazwy środowisk takich jak IntelliJ IDEA, Eclipse i NetBeans, które najczęściej występują w kontekście Javy. Jeśli pytanie dotyczy ich podstawowego przeznaczenia, poprawną odpowiedzią zwykle jest Java.

Należy podzielić sześć znaków po znaku # na trzy pary: pierwsza para to R, druga to G, trzecia to B. Na przykład #AA41FF oznacza R=AA, G=41, B=FF.

Zapis składa się z trzech par cyfr szesnastkowych: RR oznacza czerwony, GG zielony, a BB niebieski. Każda para opisuje natężenie danej składowej w zakresie od 00 do FF.

Pierwszą cyfrę mnoży się przez 16, a następnie dodaje wartość drugiej cyfry. Przykład: 41 hex to 4 × 16 + 1 = 65.

A w systemie szesnastkowym ma wartość 10, więc AA to 10×16 + 10 = 170. Dlatego składowa czerwieni wynosi 170.

Litery oznaczają wartości od 10 do 15: A=10, B=11, C=12, D=13, E=14, F=15.

Cyfra 4 stoi na pozycji szesnastek, a 1 na pozycji jedności, więc 4×16 + 1 = 65. To wartość składowej zielonej.

Jedna składowa RGB jest zwykle zapisywana na 8 bitach. 8 bitów pozwala zapisać 256 wartości, czyli od 0 do 255.

F to 15 w systemie szesnastkowym, więc FF to 15×16 + 15 = 255. Jest to maksymalna wartość jednej składowej RGB w 8-bitowym zapisie.

Po przeliczeniu składowych otrzymujemy AA=170, 41=65 i FF=255. Zapis CSS to rgb(170, 65, 255).

AA to 170, 41 to 65, a FF to 255. Zatem kolor ma składowe RGB równe 170, 65, 255.

Największa dwucyfrowa liczba szesnastkowa to FF. Po przeliczeniu daje 15 × 16 + 15 = 255.

Najczęstsze błędy to mylenie liter A-F z cyframi dziesiętnymi, zła kolejność składowych oraz pomijanie wartości pozycyjnej 16. Często też błędnie uznaje się, że 41 to 41 dziesiętnie, zamiast 65.

Podstawowa składnia to `CREATE PROCEDURE nazwa_procedury AS BEGIN ... END`. Najpierw podaje się polecenie `CREATE PROCEDURE`, a następnie nazwę procedury.

Należy użyć składni `CREATE PROCEDURE nazwa_procedury`. W podanym pytaniu poprawny początek to `CREATE PROCEDURE dodajUsera`.

Procedura składowa przechowuje zestaw instrukcji SQL, które można wielokrotnie uruchamiać. Ułatwia organizację logiki bazy danych i automatyzuje operacje.

Ponieważ w MS SQL procedurę składową tworzy się poleceniem `CREATE PROCEDURE`, po którym następuje nazwa procedury. W tym przypadku nazwą jest `dodajUsera`.

SQL Server wymaga ścisłej składni poleceń. Zapis `CREATE dodajUsera PROCEDURE` lub użycie `ADD` jest niepoprawne składniowo.

Podstawowy zapis to `CREATE PROCEDURE nazwa AS BEGIN ... END`. Najważniejsze jest zachowanie poprawnej kolejności słów kluczowych.

W T-SQL obowiązuje kolejność słów kluczowych `CREATE PROCEDURE`, a dopiero potem nazwa procedury. Polecenie `ADD` nie służy do tworzenia procedur składowych.

Nie. W MS SQL do tworzenia procedury używa się `CREATE PROCEDURE`, a nie `ADD PROCEDURE`.

Procedura składowa przechowuje zestaw instrukcji SQL wykonywanych pod jedną nazwą. Ułatwia automatyzację operacji, porządkuje logikę i może zwiększać bezpieczeństwo dostępu do danych.

W SQL Server po słowie `CREATE` musi wystąpić typ obiektu, czyli `PROCEDURE`, a dopiero potem jego nazwa. Zła kolejność powoduje błąd składni.

Procedurę uruchamia się poleceniem `EXEC` albo `EXECUTE`, np. `EXEC dodajUsera;`.

Przykładowo: `CREATE PROCEDURE dodajUsera AS BEGIN SELECT 'OK' END`. Taka procedura po uruchomieniu wykona zapisane w niej instrukcje.

Procedurę uruchamia się zwykle poleceniem `EXEC` lub `EXECUTE`, np. `EXEC dodajUsera`. Jeśli ma parametry, podaje się je po nazwie procedury.

Przykładowo: `CREATE PROCEDURE dodajUsera AS BEGIN SELECT 'OK' END`. W praktyce procedura zwykle zawiera parametry i instrukcje `INSERT`, `UPDATE` lub `SELECT`.

Parametry pozwalają przekazywać do procedury dane, np. login, hasło lub adres e-mail użytkownika. Dzięki temu jedna procedura może działać dla różnych wartości.

Tworzenie odbywa się przez `CREATE PROCEDURE`, czyli zapisanie definicji w bazie. Uruchamianie wykonuje się zwykle poleceniem `EXEC nazwa_procedury`.

`CREATE PROCEDURE` tworzy nową procedurę, a `ALTER PROCEDURE` modyfikuje już istniejącą. Użycie niewłaściwego polecenia może zakończyć się błędem.

Zwykłe zapytanie wykonuje się bezpośrednio, natomiast procedura jest zapisana w bazie i może być wielokrotnie wywoływana po nazwie. Procedura może zawierać wiele instrukcji SQL.

Najczęstsze błędy to zła kolejność słów kluczowych, użycie nieistniejącego polecenia `ADD`, brak nazwy procedury albo pominięcie części z instrukcjami wewnątrz procedury.

Bloki `BEGIN` i `END` grupują instrukcje należące do procedury. Dzięki temu kod jest czytelniejszy i łatwiejszy do rozbudowy.

Najczęściej używa się polecenia `EXEC` lub `EXECUTE`, np. `EXEC dodajUsera`. Jeśli procedura ma parametry, podaje się je przy wywołaniu.

LIFO oznacza Last In, First Out, czyli ostatni dodany element jest usuwany jako pierwszy. To podstawowa cecha stosu.

Wskazuje na to zestaw operacji push, pop, peek i isEmpty. Charakterystyczne jest też usuwanie ostatnio dodanego elementu, czyli zasada LIFO.

`pop()` usuwa element ze szczytu stosu, a `peek()` tylko go odczytuje. Po `peek()` zawartość stosu się nie zmienia.

LIFO oznacza Last In, First Out. Element dodany jako ostatni zostanie usunięty jako pierwszy.

Metody `push`, `pop`, `peek` i `isEmpty` są typowym zestawem operacji stosu. Szczególnie ważne jest to, że `pop()` usuwa ostatnio dodany element.

peek() tylko odczytuje element ze szczytu stosu bez usuwania go. pop() zwraca ten element i jednocześnie usuwa go ze struktury.

Stos działa według zasady LIFO, czyli usuwa najpierw ostatnio dodany element. Kolejka działa według FIFO, czyli usuwa najpierw element dodany jako pierwszy.

Kolejka działa zwykle według zasady FIFO, czyli pierwszy wszedł, pierwszy wyszedł. W pytaniu usuwany jest ostatnio dodany element, więc to nie kolejka.

Stos stosuje się m.in. do obsługi wywołań funkcji, cofania operacji, odwracania danych oraz sprawdzania poprawności nawiasów w wyrażeniach.

Nie. Tablica to sposób przechowywania danych, a stos to abstrakcyjna struktura danych z określonymi operacjami i zasadą działania.

Stos jest używany m.in. do obsługi wywołań funkcji, cofania operacji, sprawdzania nawiasów i przechodzenia rekurencyjnego przez dane.

isEmpty() sprawdza, czy stos zawiera jakiekolwiek elementy. Jest ważna przed wykonaniem pop() lub peek(), aby uniknąć błędu odczytu z pustej struktury.

Oznacza listę, której elementami są wartości typu `int`, czyli liczby całkowite. Do takiej listy nie można dodać np. tekstu ani liczby rzeczywistej bez konwersji.

Oznacza listę generyczną, której elementy mają typ `int`. Taka kolekcja przechowuje liczby całkowite.

`List<int>` przechowuje liczby całkowite, np. `1`, `25`, `-4`. `List<double>` przechowuje liczby rzeczywiste, np. `3.14` lub `2.5`.

Ponieważ typ elementów został określony jako `int`. C# kontroluje zgodność typów już na etapie kompilacji.

Metoda `Add()` dodaje nowy element na koniec listy. Dodawany element musi być zgodny z typem określonym w `List<T>`.

Lista będzie wtedy przechowywać wartości typu `double`, czyli liczby rzeczywiste. Typ w nawiasach ostrych określa rodzaj danych w kolekcji.

`T` oznacza parametr typu w kolekcji generycznej. W konkretnym użyciu zastępuje się go typem, np. `int`, `string` albo `double`.

Służą do podania typu generycznego. To właśnie tam określa się, jakiego typu elementy będą przechowywane w liście.

Tablica ma zwykle stały rozmiar po utworzeniu, a `List<T>` może dynamicznie zwiększać liczbę elementów. Lista udostępnia też wygodne metody, np. `Add()`, `Remove()` i `Contains()`.

Zapewniają bezpieczeństwo typów, czytelniejszy kod i mniej błędów. Nie wymagają też ręcznego rzutowania elementów.

Pierwszy element odczytuje się przez indeks `0`, np. `liczby[0]`. Indeksowanie w C# zaczyna się od zera.

Obie przechowują liczby całkowite, ale `List<int>` ma dynamiczny rozmiar i wygodne metody, np. `Add` czy `Remove`. Tablica ma zwykle stały rozmiar po utworzeniu.

Losuje liczbę całkowitą z zakresu od 0 do dlPuli - 1. Górna granica podana jako drugi argument nie jest wliczana.

Hasło może zawierać małe litery, wielkie litery oraz cyfry, ponieważ tylko takie znaki znajdują się w zmiennej `pulaZnakow`. Nie ma tam symboli specjalnych.

Pętla `for` wykonuje się dla wartości `i` od 0 do 7, czyli łącznie 8 razy. W każdym obiegu do wyniku dopisywany jest jeden znak.

Dokładnie 8 znaków, bo pętla `for` wykonuje się dla `i` od 0 do 7, czyli łącznie 8 razy.

Nie. Te znaki są dostępne w puli, więc mogą się pojawić, ale losowanie nie gwarantuje wystąpienia każdego rodzaju znaku.

W łańcuchu `pulaZnakow` nie ma znaków takich jak `!`, `@`, `#` czy `%`. Program losuje wyłącznie spośród znaków zapisanych w tej zmiennej.

Pula znaków zawiera tylko litery i cyfry. Nie ma w niej symboli, więc kod nie może ich wylosować.

Program nie tworzy hasła o zmiennej długości, tylko zawsze dokładnie 8-znakowe. Sformułowanie „co najmniej” sugeruje możliwość dłuższego hasła, której tu nie ma.

Zmienna `dlPuli` ma wartość `pulaZnakow.Length - 1`, a metoda `Next` nie wlicza górnej granicy. W efekcie ostatni znak puli nigdy nie zostanie wylosowany.

Losuje indeks znaku z określonego zakresu, przy czym górna granica nie jest wliczana. To oznacza, że nie każdy znak z puli musi być faktycznie osiągalny, jeśli zakres ustawiono błędnie.

Należy użyć `random.Next(0, pulaZnakow.Length)`. Wtedy możliwe indeksy obejmują zakres od 0 do `Length - 1`.

Ustawiono `dlPuli = pulaZnakow.Length - 1`, a potem użyto tej wartości jako wyłącznej górnej granicy w `Next()`. W efekcie ostatni znak z puli nigdy nie zostanie wylosowany.

„Zawiera” oznacza pewność wystąpienia cyfry w wyniku. „Może zawierać” oznacza jedynie, że cyfra jest dostępna w puli znaków i może zostać wylosowana.

Należy użyć `pulaZnakow.Length` jako górnej granicy w `Random.Next()`, bez odejmowania 1. Wtedy losowanie obejmie wszystkie znaki zapisane w napisie.