Make your own quiz Manage my Quizzes Plans / Features Guides and Help Contact Privacy & Security

Ib111

Za XXX doplníme list[str], za YYY doplníme str

Za XXX doplníme list[str], za YYY doplníme char | None

Za XXX doplníme list[list[int]], za YYY doplníme int

Za XXX doplníme list[list[int]], za YYY doplníme int | None

Za XXX doplníme list[str], za YYY doplníme str | None

Za XXX doplníme list[list[str]], za YYY doplníme str

X < 2 or c >= sqrt(x)

X >= 3 ** c

X % 2 == 0 or x >= 3 ** c

X >= 2 ** c

X >= 121 or x <= 7 ** c

X >= 121 or x < 7 ** c

502

Výpočet výrazu foo(2) nikdy neskončí.

501

498

500

499

Data1 = sorted(data2)

Return data < [17]

Data = data + [42]

Result = [data1, data2]

Equal = (data1 == data2)

Data.insert(- len(data) // 2, - len(data) // 2)

Není predikát, protože modifikuje seznamy v proměnných nums1 a nums2

Není predikát, protože pro stejný vstup může vrátit různé výstupy.

Není predikát, protože nikdy nevrátí hodnotu False.

Není predikát, protože modifikuje parametr nums.

Je predikát.

Není predikát, protože jako vstup bere datový typ množina a práce s množinami nikdy není čistá.

Lst.push(7)

Lst = lst + [7]

Num.set(num.get() + 1)

Num += 1

Lst.append(7)

Num.increase(1)

Je čistá.

Není čistá, protože pracuje s řetězci.

Není čistá, protože má jiný vedlejší efekt.

Není čistá, protože modifikuje parametr data, a to tak, že mění jak klíče, tak hodnoty ve slovníku.

Není čistá, protože modifikuje parametr data, a to tak, že mění klíče ve slovníku, zatímco hodnoty nechává původní.

Není čistá, protože modifikuje parametr data, a to tak, že mění hodnoty ve slovníku, zatímco klíče nechává původní.

B == {1: {2}, 3: {4, 7}}

A == {1: {2}, 3: {7}}

A == {1: {2}, 3: set()}

A == {1: {2}, 3: {4, 7}}

B == {1: {2}, 3: {7}}

B == {1: {2}, 3: set()}

Žádná z ostatních možností není správná.

Ceil(num / 2.0 * -2.0)

Round(num / 2.0 * -2.0)

Trunc(num / 2.0 * -2.0)

Num / 2.0 * -2.0

Floor(num / 2.0 * -2.0)

S.get(42) is not None

42 in s

(num // 7) % 10

(num // 10) % 10

(num // 10) % 7

(num // 7) % 7

Právě tvrzení C

Právě tvrzení B a C

Právě tvrzení B

Právě tvrzení A

Právě tvrzení A a B

Právě tvrzení A a C

X == -1

S.update(new_s)

X *= -1

D.pop("X")

X * -1

Return f(a, b, c)

A > 0

A % 11 == 1 and a < 10 * 121

A < 121

A % 11 == 1

A % 11 + a // 11 % 11 < 21

A > 0 and a % 11 == 1

A == [[1, 3]]

B == [[1, 3], [2]]

A == [[1], []]

B == [[1], [2]]

B == [[1, 3]]

A == [[1]]

(not a and b) or (not b and c) or (not c and a)

True

B or c

B and (not a or not c)

A or b or not c

B or (a and c)

Y == b - a

A <= 0 or b >= 0 or y < 0

Y >= 0

Y >= b - a

Y == 0 or y == b - a

Y <= 0

Vyhodnocení výrazu nikdy neskončí.

Skončí s nějakou jinou chybou.

Skončí s chybou at least one argument of / must be a float na řádku A.

Skončí bez chyby.

Skončí s chybou ZeroDivisionError na řádku A.

Skončí s chybou ZeroDivisionError na řádku B.

Skončí s chybou ZeroDivisionError na řádku C.

Není čistá, protože pro různé vstupy vrací různé výstupy.

Je čistá.

Není možné rozhodnout, protože záleží na tom, co bude v parametru data.

Není čistá, protože pro stejné vstupy vrací různé výstupy.

Není čistá, protože modifikuje seznam data.

Není čistá, protože má nějaký jiný vedlejší efekt.

[1, 2]

[7, 2]

[0, 2]

[6, 9]

[1, 9]

[7, 9]

Tuple[int] | tuple[str] | tuple[float]

Tuple[int | str | float]

Tuple[int, str, int]

Tuple[int, str, float]

Tuple(int, str, float)

Tuple[int, str, float] | None

Operátor násobení v Pythonu zapisujeme pomocí znaku +.

Datová strukura ntice (tuple) smí obsahovat položky různých typů.

Abstraktní datová struktura zásobník funguje na principu LOFI (low fidelity), tedy při výběru prvku dostaneme vždy ten s nejnižší hodnotou.

Každou koncově rekurzivní funkci je možné ekvivalentně napsat bez rekurze.

Operátor dělení v Pythonu zapisujeme pomocí znaku %.

V algoritmu Insert Sort opakovaně procházíme celý seznam a prohazujeme špatně uspořádané dvojice sousedních prvků.

[2, 2]

[1, 2]

[9, 9]

[9, 2]

[1, 9]

[2, 9]

7 if x > 10 else 11

Data.pop(0)

Return a + b == 7

Sorted(row)

S == [1, 2, 3]

Num *= -1

Data.pop(3)

Has_answer = (42 in data)

New = data + [21]

Data.reverse()

Value = (data[0] + data[-1] + data[len(data) // 2]) // 3

Data.insert(-1, -1)

MyClass.do_something()

Do_something(my_obj)

My_obj = do_something()

My_obj.do_something()

My_obj.do_something

Nic takového není možné provést.

Y == a + b

A > b and b > 0

B > 0

X > 0

A + b > 0

A > 0

Round(num / 10.0)

Num / 10.0

Floor(num / 10.0)

Ceil(num / 10.0)

Trunc(num / 10.0)

Žádná z ostatních možností není správná.

Není čistá, protože používá metodu append.

Není čistá, protože se uvnitř vytváří nový seznam.

Není čistá, protože modifikuje parametr num.

Je čistá.

Není čistá, protože modifikuje parametr data.

Není čistá, protože modifikuje oba své parametry.

None | str

List[int]

None | int

Int

Int | None | str

Str

Data = data + [0]

Is_less = data1 < data2

Data.reverse()

Data = data.copy()

Data.append(data1)

Data[len(data) // 2] = data1

Promenna a bude na konci programu: (1 odpoved)

[7, 9]

[1, 9]

[1, 2]

[0, 2]

[7, 2]

[6, 9]

[1, 1]

[[1], [1]]

[[1, 2], [1]]

[1, 2, 1]

[1, 2, 1, 2]

[[1, 2], [1, 2]]

Není čistá, protože modifikuje parametr data.

Není čistá, protože má jiný vedlejší efekt.

Není čistá, protože pro stejné vstupy vrací různé výstupy.

Není čistá, protože používá funkci sum, která nemusí být čistá.

Je čistá.

Není čistá, protože uvnitř používá metodu copy.

Data[-1]

Return num == 0

F(a, b, c)

Nums.add(num)

Assert num == 0

Num == 0

Dict[int, int, None]

Set[int, int, None]

Set[int] | None

Set[int | None]

Set[int] | set[None]

Set[int | None] | None

Tri správne odpovede

A == 0 or x <= a

X <= min(a, b)

X < a or x < b

A >= b or x <= a

A % x == 0

X >= 0

A or b or (c and a)

A or b or c

A or not b or not c

A or (not b and c)

A or b or not c

(a or b) and (a or c)

Power = one ** 2 + two ** 2

Power = one ^ 2 + two ^ 2

Lst.remove(last[-1])

Power = (one + two) ^ 2

Lst.pop()

Power = (one + two) ** 2

Operátor celočíselného dělení zapisujeme v Pythonu jako /.

Položky v datové struktuře slovník (dict) se skládají ze dvou částí: klíče a hodnoty; přitom klíče musí být unikátní, zatímco hodnoty nikoliv.

Eukleidův algoritmus pro výpočet největšího společného dělitele je založen na principu půlení intervalu.

Abstraktní datová struktura fronta funguje na principu LIFO (last input, first output), tedy prvky vkládáme do atributu last a odebíráme z atributu first.

Každou rekurzivní funkci je možné ekvivalentně napsat bez rekurze.

V algoritmu Select Sort opakovaně procházíme celý seznam a prohazujeme špatně uspořádané dvojice sousedních prvků.

Ceil(num / 10)

Round(num / 10 + 0.5)

Floor(num / 10 + 0.9)

(num + 9) // 10

(num + 5) // 10

(num + 1) // 10

[4, 2, 1, 3, 5]

[5, 3, 1]

[5, 3, 1, 2, 4]

[4, 2]

[1, 2, 3, 4, 5]

[5, 4, 3, 2, 1]

Str | int

None | int

Int

Str

None | str

None | str | int

Není predikát, protože modifikuje parametr name.

Je predikát.

Není predikát, protože pro stejný vstup může vrátit různé hodnoty.

Není predikát, protože používá řetězce.

Není predikát, protože nikdy nevrátí hodnotu True.

Není predikát, protože má nějaký jiný vedlejší efekt.

A == b

A > 0 and b > 0

A + b > 0

A > 0

B > 0

A > max(-b, 0)

Není predikát, protože modifikuje parametr name.

Není možné rozhodnout, protože záleží na obsahu souboru names.txt.

Není prefikát, protože pro stejný vstup může vrátit různé hodnoty.

Není predikát, protože nemá vstupní parametr typu bool.

Není predikát, protože používá řetězce.

Je predikát.

Algoritmus binárního vyhledávaní je zalložen na principu půlení intervalu.

Aritmetické výrazy s operátory + a * se vyhodnocují líně, tj. Nejprve se vyhodnotí levý operand a teprve pokud je to nutné, vyhodnotí se I ten pravý.

Abstraktní datová struktura zásobník funguje na principu LIFO (last in, first out), teda pri vybrání prvku ze zásobníku dostaneme ten naposledy vložený.

Klíče v datové strukture slovník jsou vždy sestupne usporádany.

Klíče v datové strukture slovník jsou vždy vzestupne usporádany.

V algoritmu Insert Sort opakovane hledáme maximum dosud nezpracované části seznamu a prohadzujeme je s prvkom na spávné pozici.

[7, 2]

[7, 9]

[6, 9]

[1, 9]

[1, 2]

[0, 2]

[[3], [1], [3]]

[[1], [1], [3]]

[[1, 2], [1, 2], [3]]

[[1, 2], [1], [3]]

[[], [], []]

[[3], [3], [3]]

Num + 7.2

Ceil(num + 7.2)

Trunc(num + 7.2)

Round(num + 7.2)

Floor(num + 7.2)

Žádná z ostatních možností není správná.

False

A and not b and not c

(not a or not c) and not b

Not a or not b or not c

Not a and not b and not c

(not a and not b) or (not b and not c) or (not c and not a)

[1, 2, 1, 3, 1, 2, 4]

[3, 2]

[1, 2, 3, 4]

[1, 2, 1, 2, 3, 1, 2, 3, 4]

[1, 2, 3, 1, 2, 4]

[1, 2, 1, 3, 1, 4]

S.insert("A")

Dct.set("X", 17)

Dct.insert("X", 17)

S.append("A")

S.add("A")

Dct["X"] = 17

A >= b or x + y <= a

X + y < a or x + y < b

X + y <= min(a, b)

A % (x + y) == 0

A == 0 or x + y <= a

X + y >= 0

None | int | str

Int

None | str

Str

None | int

List[int]

Tuple[bool] | tuple[int] | tuple[str]

Tuple[bool, int, str]

Tuple[bool, int, char]

Tuple[bool, int | None, str | None]

List[bool | int | str]

Tuple[bool | int | str]

A * 5 == b

A < b

A + 444 == b

A == b

A % 4 == b % 4

Data[0] = [3]

Data[0].append(3)

Assert len(data) > 0

Students[uco] =""

Students.get(uco)

Return students[uco]

Není čistá, protože pro stejné vstupy vrací ruzne výstupy.

Není čistá, protože má jiný vedlejší efekt.

Není čistá, protože modifikuje parametr data.

Není čistá, protože uvnitr používa metodu copy.

Není čistá, protože používa funkci sum, ktorá nemusí byt čistá.

Je čistá.

Data = data1 + data2

Return data1 == data2

Data.insert(-3, 3)

Ints = [1 if x > 0 else 0 for x in data]

Data.pop(len(data) - 2)

Data.insert(3, 3)

Mystery(3, [])

[1, 2, 1, 3]

[1, 2, 3]

[3, 2, 1]

[]

[1, 2, 1, 3, 1]

[1, [2]]

2 správne odpovede

A = [2, 1]

A = [2, 1, 0]

A = [1, 2, 0]

B = [1, 2, 0]

B = [1, 2]

B = [2, 1, 0]

(a or b) and (b or c)

(not a or b) and c

Not a and b and not c

B or (not a or c)

True

B and not a or c

V konštantnom čase sa vyhodnotí: (2 správne odpovede).

Answer = True in data and 1 + 1 == 3

Data.pop(3)

First = sorted(data)[0]

Data[3] = data[-3]

Length = len(data)

Mystery(11)

[2, 5, 3, 11]

[2, 5, 11]

[]

[2, 5, 8, 3, 11, 14]

[5, 3, 2, 1]

[2]

2 správne odpovede

A = [[7, 2], [3, 4]]

A = [[1, 2], [5, 6]]

A = [[7, 2], [5, 6]]

B = [[7, 2], [5, 6]]

B = [[1, 2], [5, 6]]

B = [[1, 2], [3, 4]]

Je predikát.

Není predikát, protože modifikuje parametr a.

Není predikát, protože modifikuje parametr b.

Není predikát, protože pro ruzne vstupy muze vratit ruzne vystupy

Není predikát, protože nemusí vracať bool.

Není predikát, protože používa rekurziu.

Je čistá.

Není čistá, protože muze mat vedlejši efekty.

Není čistá, protože modifikuje parametr db.

Není čistá, protože modifikuje parametr uco.

Není čistá, protože pracuje s retazcemi.

Není čistá, protoze vracia inu hodnotu ako None.

1 odpoved

List[int]

Int

List[list[int]]

List[str | int]

List[list[tuple[int, int]]]

List[tuple[int, int]]

Mystery(4, [])

[4, 3, 2, 1, 1, 2, 3, 4]

[4, 3, 2, 1, 0, 1, 2, 3, 4]

[4, 3, 2, 1, -1, -2, -3, -4]

[4, 3, 2, 1, 0, -1, -2, -3, -4]

[-4, -3, -2, -1, 1, 2, 3, 4]

[1, 2, 3, 4]

2 správne odpovede

A = [1, 2, 3]

A = [1]

A = [1, 2]

B = [1]

B = [1, 2, 3]

B = [1, 2]

V konštantnom čase se vyhodnotí: (2 správne odpovede).

Data.pop(3)

New_data = data + [21]

Has_answer == (42 in data)

Data.reverse()

Value = (data[0] + data[-1] + data[len(data) // 2] // 3

Data.insert(-1, -1)

Je čistá.

Není čistá, protože mení klíče slovníku uloženého v parametru data.

Není čistá, protože mení hodnoty slovníku uloženého v parametru data.

Není čistá, protože má nejaký jiný vedlejší efekt.

Není čistá, protože pre ruzne vstupy muze vratit ruzne vystupy.

Není čistá, protože nevrací bool.

Je čistá.

Není čistá, protože má nejaký jiný vedlejší efekt.

Není čistá, protože pre ruzne vstupy muze vratit ruzne vystupy.

Není čistá, protože vrací dva ruzne typy.

Není čistá protoze pouziva funkcii sorted

Mystery(5, [])

[5, 3, 1, 2, 4]

[1, 2, 3, 4, 5]

[5, 3, 1, 4, 2]

[1, 3, 5, 2, 4]

[5, 3, 1, -1, 0, 2, 4]

[5, 4, 3, 2, 1]

2 správne odpovede

A = [2, 9]

B = [2, 9]

A = [1, 2]

B = [9, 2]

A = [9, 2]

B = [1, 9]

V konštantnom čase sa vyhodnotí: (2 odpovede).

Answer = False and (true in data)

Data.pop(0)

New.data = data + [True]

Data.sort()

Data.insert(0, -1)

Data.append(17)

Je čistá.

Není čistá, protože má iné vedlejší efekty.

Není čistá, protože pracuje s retezcemi.

Není čistá, protože modifikuje parametr xs.

Není čistá, protože nevrací bool.

Není čistá, protože pre rovnake vstupy muze vracat ruzne vystupy

Je čistá.

Není čistá, protože má iné vedlejší efekty.

Není čistá, protože pracuje s retezcemi.

Není čistá, protože modifikuje parametr s.

Není čistá, protože pre rovnake vstupy muze vracat ruzne vystupy.

Není čistá, protože nevrací bool.

Foo(1700, 283)

1983

1984

1990

Výpočet se nikdy neskončí.

1700

1985

Mystery(4, [])

[1, 2, 3, 1, 4, 1, 2]

[1, 2, 1, 3, 1, 4]

[1, 2, 1, 3, 1, 4, 1, 2]

[1, 2, 3, 4, 1, 2]

[]

[1, 2, -1, 3, 1, 4, -1, 2]

2 správne odpovede

A = [("C", 4), ("B", 1)]

B = [("A", 2), ("A", 3)]

A = [("A", 2), ("A", 3)]

B = [("C", 4), ("B", 1)]

A = [("A", 2), ("C", 4)]

B = [("A", 2), ("B", 1)]

Je predikát.

Není predikát, protože modifikuje parametr data.

Není predikát, protože modifikuje parametr limit.

Není predikát, protože vrací typ bool.

Není predikát, protože pre rovnake vstupy muze vracat ruzne vystupy.

Není predikát, protože modifikuje oba parametry.

Není predikát, protože modifikuje parametr nums.

Je predikát.

Není predikát, protože pre rovnake vstupy muze vracat ruzne vystupy.

Není predikát, protože vrací typ bool.

Není predikát, protože používa funkcii sorted.

Není predikát, protože používa funkcii sort().

Ktoré z nasledujíich nejsou výrazy. (2 odpovede)

Show(a, b, c)

Game.move(LEFT, 2)

Assert a + b > 0

Import math

True

None

najdete vstupní podmínku

Len(data) >= 0

Data[0] != 0

0 not in data

Len(data) > 0 and data[0] != 0 and 0 in data

Len(data) > 0 or data[0] != 0 and 0 in data

Data[0] == 0

{"name":"Ib111", "url":"https://www.quiz-maker.com/QPREVIEW","txt":"","img":"https://www.quiz-maker.com/3012/CDN/97-4759204/81.png?sz=1200"}

More Quizzes

CMO as a Service: Match Test

Comprehensive Reviewer Part 1

924660

Renovation Style

420

Questions for wedding/Reception

840

Do u know me well?

1059

Ποιο γλυκό του Χάλογουιν είσαι;

520

Science true or false

20100

Չարենցն ու ԵՍ

1050

NV03_KY NANG QUAN LY + KS NOI BO

924673

BENDS AND HITCHES

13621

Make your own Quiz

Unlock and Upgrade

Remove all limits from your Quizzes

Ib111

More Quizzes