LEVEL: Стандартные структуры данных

{
  name: @vaspahomov test
  description: Описание: Задачи на разные алгоритмы и разные сложности
  levels:
  [
    {
      next_levels:
      [
      ]
      description: Стандартные структуры данных
      number: 0
      generators:
      [
        {
          possible_answers:
          [
            Θ(log(list.Count()))
            Θ(√{{list.Count()}})
            Θ(1)
            Θ({{list.Count()}})
            Θ({{list.Count()}}²)
          ]
          text:
            '''
            var n = {{any_of [1, 5, 24, 42, 100]}};
            var list = new List<int> {...};
            list.RemoveAt(n);
            '''
          question: Оцени временную сложность данного алгоритма: 
          hints: 
          [
              При удалении некоторые элементы будут сдвигаться
              Почитай [документацию](docs.microsoft.com/en-us/dotnet/api/system.collections.generic.list-1.removeat)
          ]
          answer: Θ({{list.Count()}})
          streak: 1
        }

        {
          possible_answers:
          [
            Θ(log(list.Count()))
            Θ(√{{list.Count()}})
            Θ(1)
            Θ({{list.Count()}})
            Θ({{list.Count()}}²)
          ]
          text:
            '''
            var n = {{const1}};
            var list = new List<int> {...};
            list.Remove(n);
            '''
          question: Оцени временную сложность данного алгоритма: 
          hints: 
          [
              Какая сложность поиска элемента в list?
              Почитай [документацию](https://docs.microsoft.com/en-us/dotnet/api/system.collections.generic.list-1.remove)
          ]
          answer: Θ({{list.Count()}})
          streak: 1
        }

        {
          possible_answers:
          [
            Θ(log(list.Count()))
            Θ(√{{list.Count()}})
            Θ(1)
            Θ({{list.Count()}})
            Θ({{list.Count()}}²)
          ]
          text:
            '''
            var n = {{const1}};
            var list = new List<int> {...};
            list.RemoveLast();
            '''
          question: Оцени временную сложность данного алгоритма: 
          hints: 
          [
              Подумай, сколько элементов придется перечислить, чтоб найти последний
              Почитай [документацию](https://docs.microsoft.com/en-us/dotnet/api/system.collections.generic.linkedlist-1.removelast)
          ]
          answer: Θ(1)
          streak: 1
        }

        {
          possible_answers:
          [
            Θ(log(list.Count()))
            Θ(√{{list.Count()}})
            Θ(1)
            Θ({{list.Count()}})
            Θ({{list.Count()}}²)
          ]
          text:
            '''
            var list = new List<int>();
            list.Add({{const1}});
            Console.WriteLine(list[0]);
            '''
          question: Оцени временную сложность данного алгоритма: 
          hints: 
          [
              Почитай [документацию](https://docs.microsoft.com/en-us/dotnet/api/system.collections.generic.list-1.system-collections-ilist-add)
          ]
          answer: Θ(1)
          streak: 1
        }

        {
          possible_answers:
          [
            Θ(log(list.Count()))
            Θ(√{{list.Count()}})
            Θ(1)
            Θ({{list.Count()}})
            Θ({{list.Count()}}²)
          ]
          text:
            '''
            var list = new LinkedList<int>();
            list.Add({{const1}});
            Console.WriteLine(list[0]);
            '''
          question: Оцени временную сложность данного алгоритма: 
          hints: 
          [
              Подумай над тем, как представляется LinkedList в памяти
          ]
          answer: Θ({{list.Count()}})
          streak: 1
        }

        {
          possible_answers:
          [
            Θ(log(set.Count()))
            Θ(√{{set.Count()}})
            Θ(1)
            Θ({{set.Count()}})
            Θ({{set.Count()}}²)
          ]
          text:
            '''
            var set = new HashSet<int>();
            set.Add({{const1}});
            set.Contains({{const1}});
            '''
          question: Оцени временную сложность данного алгоритма: 
          hints: 
          [
              Почитай [документацию](https://docs.microsoft.com/en-us/dotnet/api/system.collections.generic.hashset-1.contains)
          ]
          answer: Θ(1)
          streak: 1
        }

        {
          possible_answers:
          [
            Θ(log(set.Count()))
            Θ(√{{set.Count()}})
            Θ(1)
            Θ({{set.Count()}})
            Θ({{set.Count()}}²)
          ]
          text:
            '''
            var set = new SortedSet<int>();
            set.Add({{const1}});
            '''
          question: Оцени временную сложность данного алгоритма: 
          hints: 
          [
              В виде какой структуры данных хранится SortedSet?
              Почитай [документацию](https://docs.microsoft.com/en-us/dotnet/api/system.collections.generic.sortedset-1.add)
          ]
          answer: Θ(log(set.Count()))
          streak: 1
        }

        {
          possible_answers:
          [
            Θ(log(set.Count()))
            Θ(√{{set.Count()}})
            Θ(1)
            Θ({{set.Count()}})
            Θ({{set.Count()}}²)
          ]
          text:
            '''
            var set = new SortedSet<int>();
            set.Add({{const1}});
            set.Contains({{const1}});
            '''
          question: Оцени временную сложность данного алгоритма: 
          hints: 
          [
              В виде какой структуры данных хранится SortedSet?
              Что нужно сделать чтоб найти элемент в дереве?
              Почитай [документацию](https://docs.microsoft.com/en-us/dotnet/api/system.collections.generic.sortedset-1.contains)
          ]
          answer: Θ(log(set.Count()))
          streak: 1
        }

        {
          possible_answers:
          [
            Θ(log(queue.Count()))
            Θ(√{{queue.Count()}})
            Θ(1)
            Θ({{queue.Count()}})
            Θ({{queue.Count()}}²)
          ]
          text:
            '''
            var queue = new Queue<int>();
            queue.Enqueue({{const1}});
            '''
          question: Оцени временную сложность данного алгоритма: 
          hints: 
          [
              Почитай [документацию](https://docs.microsoft.com/en-us/dotnet/api/system.collections.generic.queue-1.enqueue)
          ]
          answer: Θ(1)
          streak: 1
        }

        {
          possible_answers:
          [
            Θ(log(queue.Count()))
            Θ(√{{queue.Count()}})
            Θ(1)
            Θ({{queue.Count()}})
            Θ({{queue.Count()}}²)
          ]
          text:
            '''
            var queue = new Queue<int> { ... };
            queue.Dequeue({{const1}});
            '''
          question: Оцени временную сложность данного алгоритма: 
          hints: 
          [
              Почитай [документацию](https://docs.microsoft.com/en-us/dotnet/api/system.collections.generic.queue-1.dequeue)
          ]
          answer: Θ(1)
          streak: 1
        }

        {
          possible_answers:
          [
            Θ(log(queue.Count()))
            Θ(√{{queue.Count()}})
            Θ(1)
            Θ({{queue.Count()}})
            Θ({{queue.Count()}}²)
          ]
          text:
            '''
            var queue = new Queue<int> { ... };
            queue.Contains({{const1}});
            '''
          question: Оцени временную сложность данного алгоритма: 
          hints: 
          [
           
          ]
          answer: Θ({{queue.Count()}})
          streak: 1
        }

        {
          possible_answers:
          [
            Θ(log(stack.Count()))
            Θ(√{{stack.Count()}})
            Θ(1)
            Θ({{stack.Count()}})
            Θ({{stack.Count()}}²)
          ]
          text:
            '''
            var stack = new Stack<int>();
            stack.Push({{const1}});
            '''
          question: Оцени временную сложность данного алгоритма: 
          hints: 
          [
            Почитай [документацию](https://docs.microsoft.com/en-us/dotnet/api/system.collections.generic.stack-1.push)
          ]
          answer: Θ(1)
          streak: 1
        }

        {
          possible_answers:
          [
            Θ(log(stack.Count()))
            Θ(√{{stack.Count()}})
            Θ(1)
            Θ({{stack.Count()}})
            Θ({{stack.Count()}}²)
          ]
          text:
            '''
            var stack = new Stack<int> { ... };
            stack.Pop({{const1}});
            '''
          question: Оцени временную сложность данного алгоритма: 
          hints: 
          [
            Почитай [документацию](https://docs.microsoft.com/en-us/dotnet/api/system.collections.generic.stack-1.pop)
          ]
          answer: Θ(1)
          streak: 1
        }

        {
          possible_answers:
          [
            Θ(log(list.Count()))
            Θ(√{{list.Count()}})
            Θ(1)
            Θ({{list.Count()}})
            Θ({{list.Count()}}²)
          ]
          text:
            '''
            var list = new ImmutableList<int>();
            list.Add({{const1}});
            Console.WriteLine(list[0]);
            '''
          question: Оцени временную сложность данного алгоритма: 
          hints: 
          [
              ImmutableList представляется в виде дерева :)
              Почитай [документацию](https://docs.microsoft.com/en-us/dotnet/api/system.collections.immutable.immutablelist-1) по ImmutableList
          ]
          answer: Θ(log(list.Count()))
          streak: 1
        }
      ]
    }
  ]
}