Выпуск#25: ITренировка — актуальные вопросы и задачи от ведущих компаний

    Сегодня мы подготовили последний выпуск ITренировки в текущем формате.
    КДПВ
    Мы подобрали для Вас задачи с собеседований в Cisco. Там задают вопросы не только про маршрутизацию и железо (в подборке есть такие вопросы), но и логические задачи. Наиболее интересные из них — ждут Вас под катом.

    Нужно отметить также, что этот выпуск будет последним в данном формате, но будет продолжен в измененном виде. Мы решили поменять формат и площадку для последующих выпусков ITренировки — продолжение будет в Типичном программисте.

    Вопросы


    1. Magnet, Magnetic and Nonmagnetic
      How can you differentiate among a magnet, magnetic material and nonmagnetic material?

      Перевод
      Как отличить магнит, магнитный материал и немагнит? (прим. Вопрос по железу в неожиданном ракурсе. Требует некоторых знаний физики)
    2. Viral infection
      The world is facing a serious viral infection. The government of various countries have issued every citizen two bottles. You as well have been given the same. Now one pill from each bottle is to be taken every day for a month to become immune to the virus. The problem is that if you take just one, or if you take two from the same bottle, you will die a painful death.

      While using it, you hurriedly open the bottles and pour the tablets in your hand. Three tablets come down in your hand and you realize they look exactly the same and have same characteristics. You can’t throw away the pill as they are limited and you can’t put them back or you may put it wrong and may die someday. How would you solve this problem?

      Перевод
      Мир столкнулся со страшной вирусной инфекцией. Правительства всех стран выдают каждому гражданину две бутылочки с лекарством. Вам выдали такой же комплект. Нужно принимать по одной таблетке из каждой бутылки ежедневно в течении месяца, чтобы приобрести иммунитет к вирусу. Если же принять только одну таблетку или две из одной бутылки — наступит мучительная смерть.

      Принимая очередную порцию таблеток, Вы открываете обе бутыли и поспешно высыпаете таблетки в ладонь. Поздно, но Вы понимаете, что высыпалось три таблетки, а также то, что они выглядят абсолютно одинаково. Таблетку выбросить нельзя, поскольку их количество ограничено, и Вы не можете положить их обратно, иначе, в случае ошибки, Вы когда-нибудь умрете. Как бы Вы решили эту проблему?

      (прим. Похожая задача уже была в ранних выпусках.)

    Задачи


    1. Sort elements by frequency
      Print the elements of an array in the decreasing frequency. If 2 numbers have same frequency then print the one which came first.

      Examples:

      Input: arr[] = {2, 5, 2, 8, 5, 6, 8, 8}
      Output: arr[] = {8, 8, 8, 2, 2, 5, 5, 6}

      Input: arr[] = {2, 5, 2, 6, -1, 9999999, 5, 8, 8, 8}
      Output: arr[] = {8, 8, 8, 2, 2, 5, 5, 6, -1, 9999999}

      Перевод
      Выведите элементы массива в порядке убывания по частоте вхождения. Если два числа имеют одинаковую частоту — выводить первым то, что встречается первым.

      Примеры:

      Вход: arr[] = {2, 5, 2, 8, 5, 6, 8, 8}
      Выход: arr[] = {8, 8, 8, 2, 2, 5, 5, 6}

      Вход: arr[] = {2, 5, 2, 6, -1, 9999999, 5, 8, 8, 8}
      Выход: arr[] = {8, 8, 8, 2, 2, 5, 5, 6, -1, 9999999}
    2. Check BST
      A binary search tree (BST) is a node based binary tree data structure which has the following properties.

      • The left subtree of a node contains only nodes with keys less than the node’s key.
      • The right subtree of a node contains only nodes with keys greater than the node’s key.
      • Both the left and right subtrees must also be binary search trees.

      From the above properties it naturally follows that:
      • Each node (item in the tree) has a distinct key.

                           4
                        /     \
                      2        5
                    /    \
                  1       3
      

      Your task is to create a program to check if a binary tree is BST or not.

      Перевод
      Дано двоичное дерево поиска, которое имеет следующие свойства:
      * Левое поддерево для каждого узла содержит числа меньше значения данного узла.
      * Правое поддерево для каждого узла содержит числа больше значения данного узла.
      * И левое и правое поддеревья являются двоичными деревьями поиска.

      Из описанного следует, что каждый узел в дереве содержит уникальный ключ.

                           4
                        /     \
                      2        5
                    /    \
                  1       3
      

      Ваша задача — написать программу для проверки, является ли дерево двоичным деревом поиска или нет.
    3. Liter, water and 2 smocking «coprime» vessels
      There are two vessels of capacities ‘a’ and ‘b’ respectively. We have infinite water supply. Give an efficient algorithm to make exactly 1 litre of water in one of the vessels. You can throw all the water from any vessel any point of time. Assume that ‘a’ and ‘b’ are Coprimes.

      Перевод
      Даны 2 сосуда емкостью 'a' и 'b' и бесконечный источник воды. Предложите эффективный алгоритм для отмера ровно 1 литра воды с помощью этих сосудов. Вы можете вылить всю воду из любого сосуда в любой момент времени. Примем также, что 'a' и 'b' взаимно простые числа.

    Ответы будут даны в течение следующей недели — успейте решить. Удачи!

    Решения


    1. Вопрос 1
      andyudol предложил решение.

    2. Вопрос 2
      В комментариях предложили верное решение — тут, а тут — еще и несколько вариантов.

    3. Задача 1
      Исходный вариант решения:
      #include<bits/stdc++.h>
      using namespace std;
       
      // Used for sorting
      struct ele
      {
          int count, index, val;
      };
       
      // Used for sorting by value
      bool mycomp(struct ele a, struct ele b) {
          return (a.val < b.val);
      }
       
      // Used for sorting by frequency. And if frequency is same,
      // then by appearance
      bool mycomp2(struct ele a, struct ele b) {
          if (a.count != b.count) return (a.count < b.count);
          else return a.index > b.index;
      }
       
      void sortByFrequency(int arr[], int n)
      {
          struct ele element[n];
          for (int i = 0; i < n; i++)
          {
              element[i].index = i;    /* Fill Indexes */
              element[i].count = 0;    /* Initialize counts as 0 */
              element[i].val = arr[i]; /* Fill values in structure
                                           elements */
          }
       
          /* Sort the structure elements according to value,
             we used stable sort so relative order is maintained. */
          stable_sort(element, element+n, mycomp);
       
          /* initialize count of first element as 1 */
          element[0].count = 1;
       
          /* Count occurrences of remaining elements */
          for (int i = 1; i < n; i++)
          {
              if (element[i].val == element[i-1].val)
              {
                  element[i].count += element[i-1].count+1;
       
                  /* Set count of previous element as -1 , we are
                     doing this because we'll again sort on the
                     basis of counts (if counts are equal than on
                     the basis of index)*/
                  element[i-1].count = -1;
       
                  /* Retain the first index (Remember first index
                     is always present in the first duplicate we
                     used stable sort. */
                  element[i].index = element[i-1].index;
              }
       
              /* Else If previous element is not equal to current
                so set the count to 1 */
              else element[i].count = 1;
          }
       
          /* Now we have counts and first index for each element so now
             sort on the basis of count and in case of tie use index
             to sort.*/
          stable_sort(element, element+n, mycomp2);
          for (int i = n-1, index=0; i >= 0; i--)
              if (element[i].count != -1)
                 for (int j=0; j<element[i].count; j++)
                      arr[index++] = element[i].val;
      }
       
      // Driver program
      int main()
      {
          int arr[] = {2, 5, 2, 6, -1, 9999999, 5, 8, 8, 8};
          int n = sizeof(arr)/sizeof(arr[0]);
       
          sortByFrequency(arr, n);
       
          for (int i=0; i<n; i++)
             cout << arr[i] << " ";
          return 0;
      }


    4. Задача 2
      Решение на Java:
      /Java implementation to check if given Binary tree
      //is a BST or not
       
      /* Class containing left and right child of current
       node and key value*/
      class Node
      {
          int data;
          Node left, right;
       
          public Node(int item)
          {
              data = item;
              left = right = null;
          }
      }
       
      public class BinaryTree
      {
          //Root of the Binary Tree
          Node root;
       
          /* can give min and max value according to your code or
          can write a function to find min and max value of tree. */
       
          /* returns true if given search tree is binary
           search tree (efficient version) */
          boolean isBST()  {
              return isBSTUtil(root, Integer.MIN_VALUE,
                                     Integer.MAX_VALUE);
          }
       
          /* Returns true if the given tree is a BST and its
            values are >= min and <= max. */
          boolean isBSTUtil(Node node, int min, int max)
          {
              /* an empty tree is BST */
              if (node == null)
                  return true;
       
              /* false if this node violates the min/max constraints */
              if (node.data < min || node.data > max)
                  return false;
       
              /* otherwise check the subtrees recursively
              tightening the min/max constraints */
              // Allow only distinct values
              return (isBSTUtil(node.left, min, node.data-1) &&
                      isBSTUtil(node.right, node.data+1, max));
          }
       
          /* Driver program to test above functions */
          public static void main(String args[])
          {
              BinaryTree tree = new BinaryTree();
              tree.root = new Node(4);
              tree.root.left = new Node(2);
              tree.root.right = new Node(5);
              tree.root.left.left = new Node(1);
              tree.root.left.right = new Node(3);
       
              if (tree.isBST())
                  System.out.println("IS BST");
              else
                  System.out.println("Not a BST");
          }
      }
      


    5. Задача 3
      Вариант решения:
      
      #include <iostream>
      using namespace std;
       
      // A utility function to get GCD of two numbers
      int gcd(int a, int b) { return b? gcd(b, a % b) : a; }
       
      // Class to represent a Vessel
      class Vessel
      {
          // A vessel has capacity, and current amount of water in it
          int capacity, current;
      public:
          // Constructor: initializes capacity as given, and current as 0
          Vessel(int capacity) { this->capacity = capacity; current = 0; }
       
          // The main function to fill one litre in this vessel. Capacity of V2
          // must be greater than this vessel and two capacities must be co-prime
          void makeOneLitre(Vessel &V2);
       
          // Fills vessel with given amount and returns the amount of water 
          // transferred to it. If the vessel becomes full, then the vessel 
          // is made empty.
          int transfer(int amount);
      };
       
      // The main function to fill one litre in this vessel. Capacity 
      // of V2 must be greater than this vessel and two capacities 
      // must be coprime
      void Vessel:: makeOneLitre(Vessel &V2)
      {
          // solution exists iff a and b are co-prime
          if (gcd(capacity, V2.capacity) != 1)
              return;
       
          while (current != 1)
          {
              // fill A (smaller vessel)
              if (current == 0)
                  current = capacity;
       
              cout << "Vessel 1: " << current << "   Vessel 2: "
                   << V2.current << endl;
       
              // Transfer water from V1 to V2 and reduce current of V1 by
              //  the amount equal to transferred water
              current = current - V2.transfer(current);
          }
       
          // Finally, there will be 1 litre in vessel 1
          cout << "Vessel 1: " << current << "   Vessel 2: "
               << V2.current << endl;
      }
       
      // Fills vessel with given amount and returns the amount of water 
      // transferred to it. If the vessel becomes full, then the vessel 
      // is made empty
      int Vessel::transfer(int amount)
      {
          // If the vessel can accommodate the given amount
          if (current + amount < capacity)
          {
              current += amount;
              return amount;
          }
       
          // If the vessel cannot accommodate the given amount, then
          // store the amount of water transferred
          int transferred = capacity - current;
       
          // Since the vessel becomes full, make the vessel
          // empty so that it can be filled again
          current = 0;
       
          return transferred;
      }
       
      // Driver program to test above function
      int main()
      {
          int a = 3, b = 7;  // a must be smaller than b
       
          // Create two vessels of capacities a and b
          Vessel V1(a), V2(b);
       
          // Get 1 litre in first vessel
          V1.makeOneLitre(V2);
       
          return 0;
      }
      


    Spice IT Recruitment
    82.39
    ИТ специализированное кадровое агентство
    Share post
    AdBlock has stolen the banner, but banners are not teeth — they will be back

    More
    Ads

    Comments 28

      +3
      Задача про вирусную инфекцию:
      1. Отложим пока три таблетки и пересчитаем сколько осталось в бутылках. В одной из бутылок будет на одну таблетку больше. Заберем эту лишную таблетку и положим к трем высыпавшимся. Таким образом в куче высыпавшихся таблеток будет по две таблетки из каждой бутылки.
      2. Разломим каждую таблетку пополам. «Левые» половины сложим в одну кучу. «Правые» в другую.
      Таким образом, в каждой куче будет по две половинки таблетки из каждой бутылки. Или по одной целой таблетке из каждой бутылки.
      3. Сегодня съедим левую кучку, завтра съедим правую.
        0
        Думаю, суть задачи в том, что открывать бутылки повторно нельзя и пересчитывать таблетки тоже (типа их там гугол штук и если вы прям ща не выпьете, то каюк). Поэтому скорее интересует ход мыслей, я тоже склоняют к разламыванию таблеток.
          0
          «Нужно принимать по одной таблетке из каждой бутылки ежедневно в течении месяца, чтобы приобрести иммунитет к вирусу.»
          «Таблетку выбросить нельзя, поскольку их количество ограничено.»

          Их там не более 31.
            0
            Зато возникает другой вопрос: А одинаковое ли количество этих таблеток в каждой бутылке изначально?
          +1
          Немного дополню по этой задаче (Эпидемия):

          У меня варианты следующие:
          1. Пойти к соседу-фармацевту, у него по-любому излишки остались.)
          2. Ничего не говорится о вкусе: просто попробывать на язык, а не придумывать хитроумные комбинации.
          3. Ничего не говорится о весе: просто взвешать.
          4. Ничего не говорится о молекулярном составе, а он точно разный(это же не плацебо): посмотреть в микроскоп(если он есть конечно)

          Ну а если действительно решать эту задачу, то предлагаю следующие шаги:

          1. Отложим эти 3 таблетки в 3-ю баночку(подпишем «тут лежит 3 таблетки»)
          2. Ну и кушаем до победного!!! То есть как врач прописал по одной из каждой баночки(лишь бы опять такого случая не произошло)
          3. В итоге в одной из баночек осталось одна таблетка.
          4. Вытаскиваем эту таблетку и 3 таблетки из 3-ей банки.
          5. Режем пополам, и кушаем 2 дня: одну половину таблеток в один день, другую — в другой.

          Преимущество данного метода в том, что таблетки считать не надо.
            0
            Еще один вариант:
            Положить все таблетки в одну кучу, растолочь, размешать до однообразной массы и разделить на оставшееся количество дней.
              0
              Правда, здесь нужно учитывать химическую активность данного соединения.
                0
                Да, кстати, если правительство выдает 2 бутылочки отдельно, значит они химически реагируют. Значит можно проверить на химреакцию — соединить 2 таблетки и посмотреть не изменило ли место соприкосновения окраску. Если изменилась — то таблетки разных типов.
                  0

                  Современные таблетки ещё и упаковывают в растворимые оболочки, чтобы они попали в нужный отдел пищеварительного тракта. (Например, чтобы не прореагировали с желудочным соком).


                  Поэтому даже не растолочь, а разрезать пополам — может быть фатально.

                    0
                    Да, лучше надрезать. А про растолочь — это другой ответ(химическая реакция не учитывалась, хотя тоже может пойти как ответ если срок годности для потребления данного соединения превышает месяц)
                      0
                      Для оболочки можно свои капсулы использовать если что.
                0
                Clear
              +1
              Вопр. 1. Случай, когда перевод требует некоторого знания физики. Потому что «намагниченный материал» = «магнит». На самом деле имеются в виду магнит, магнитный материал (ферромагнетик) и немагнитный материал.
              Кроме того, условие нечётко сформулировано: можно ли применять дополнительные средства, например, железные опилки или нагрев? Предположим, что нельзя.
              Тогда проблема в различении магнита и магнитного материала. Воспользуемся тем, что сила притяжения магнитного материала к полюсу магнита больше, чем между полюсами (если бы кусок магнитного материала был точкой, = 0).
                0
                Замечание принято, спасибо.
                0
                1.
                int[] SortByFrequency(int[] arr) 
                {
                 return arr
                    .Select(i => new Tuple<int, int>(i, arr.Count(v => v == i)))
                    .OrderByDescending(t => t.Item2)
                    .ThenBy(t => t.Item1)
                    .Select(t => t.Item1)
                    .ToArray();
                }
                

                  0
                  > If 2 numbers have same frequency then print the one which came first.
                  .ThenBy(t => t.Item1) — отсортирует по возрастанию
                    0
                    Ох, не заметил. Тогда так должно работать как надо
                    int[] SortByFrequency(int[] arr) 
                    {
                     return arr
                        .GroupBy(i=>i)
                        .OrderByDescending(g=>g.Count())
                        .SelectMany(l=>l.ToArray())
                        .ToArray();
                    }
                    
                  0

                  Вопрос 1
                  Для различения нужен магнит (хотя бы электрический)


                  • магнит во внешнем поле будет ориентироваться, возникнет и сила, и крутящий момент
                  • магнитный материал будет притягиваться (диамагнетик) или отталкиваться (парамагнетик)
                  • немагнитному материалу пофиг

                  Если "вопрос по железу" имеется в виду русский сленг (железо — hardware), то магнит можно добыть из любого моторчика.

                    –1

                    Вопрос 2.


                    Умри, но сдохни!

                    Выбор между умереть медленно и мучительно от болезни и быстро и мучительно от отравления.
                    Захлопни пасть и жри две таблетки! А завтра возьми ещё одну таблетку из бутылки и сожри с оставшейся.


                    А вообще, возьми эти три таблетки и отложи на конец месяца. А сейчас прими новую порцию, уже заведомо правильную. Если в конце месяца останется запас таблеток в бутылках, то и чёрт с ними. Если же там впритык, то в предпоследний день будет одна таблетка в бутылке, и три таблетки в заначке. Захлопни пасть и жри! С вероятностью 2/3 тебе повезёт.

                      0

                      Задача 1


                      Гистограммы, не?
                      from collections import Counter
                      counts = Counter(arr)
                      result = sorted(arr, reverse=True, key=lambda a: counts[a])  # sorted устойчиво
                        0

                        Задача 2


                        (пишу спойлер! потому что задача немного некорректна — и некорректно переведена)


                        В этом дереве ключи уникальны и упорядочены при поперечном обходе.
                        Пишем процедуру поперечного обхода и проверяем.


                        Единственная проблема, — если отношение порядка нетранзитивно на данном наборе ключей, то нас постигнет печаль.
                        Во-первых, "из описанного следует, что каждый узел в дереве уникален" — нет, не следует.
                        (Кстати, в переводе вместо обобщённых "ключей" появляются "числа" — а для чисел есть дополнительные гарантии).


                        Рассмотрим дерево, вырожденное в правый список: X -> Y -> Z.
                        При поперечном обходе мы, допустим, выяснили, что X<Y, Y<Z. А нам нужно, чтобы ещё и X<Z ("все ключи правого поддерева меньше ключа корня").
                        Но если отношение транзитивности не выполняется, то вполне может быть X<>Z какое угодно.


                        Таким образом, честная процедура — это сравнивать все дочерние узлы со всеми родительскими.
                        В худшем случае алгоритм квадратичный (забег по дереву, вырожденному в список).

                          0

                          Два дымящихся сосуда — это детская задачка из Перельмана, если вообще не из Магницкого.


                          Просто берём и повторяем одну процедуру
                          1) налить доверху сосуд А
                          2) слить из А в Б (доверху или сколько получилось)
                          3) если в А ещё что-то осталось, вылить всё из Б и повторить с шага 2;
                          4) если в А ничего не осталось, повторить с шага 1


                          Рано или поздно в одном из сосудов будет НОД(А, Б).

                            0
                            Вопрос в эффективности.
                              0

                              Этот алгоритм единственный и поэтому наиболее (и наименее тоже) эффективный.
                              Всё, что мы можем варьировать — это что принять за сосуд А, а что за сосуд Б.


                              Ну и какой критерий эффективности, количество вылитой впустую воды, количество перелитой воды (совершённая работа), количество операций?


                              Если жалко думать и не жалко моделировать — можно смоделировать обе ветки алгоритма и сравнить. Сложность моделирования — O(А*Б / НОД(А, Б)^2)

                                0
                                Я думаю — количество операций.
                                  0

                                  Рассмотрим плоскость с осями "заполнение сосуда А" и "заполнение сосуда Б".
                                  Понятно, что область допустимых значений — это всего лишь прямоугольник (0,0)-(А, Б).
                                  Но мы размножим его, замостив копиями всю плоскость. Получится такая сетка.


                                  Операция "заполнить сосуд" — это сместиться по оси А (или Б) на один шаг сетки вперёд.
                                  Операция "слить" — сместиться по другой оси назад.
                                  Операция "перелить" — сместиться по диагонали до пересечения с ближайшей линией сетки (горизонтальной или вертикальной, как повезёт).
                                  После такого пересечения последует операция "заполнить" или "слить", которая заставляет текущую точку перепрыгнуть на то же самое место на противоположной стороне прямоугольника, — а поскольку прямоугольники у нас по всей плоскости, то мы просто делаем себе зарубку "была операция" и остаёмся на том же месте.


                                  Проведём диагональную линию из точки (0,0). И посмотрим, как скоро она приведёт нас в точку (t,t) = (kA+1,mB) или (kA,mB+1). При этом мы выполним k операций долива, m операций слива и k+m операций перелива.
                                  (На этом пока мысль иссякла, — как точнее сформулировать и объяснить, как из этого определить, который путь быстрее — доливать в А или сливать в А).

                            0
                            2 сосуда(простой вариант)

                            code
                            vessel.h
                            #ifndef VESSEL_H
                            #define VESSEL_H
                            
                            class Vessel {
                            	int current,capacity;
                            public:
                            	Vessel(int capacity);
                            
                            	void fill();
                            	int fill(Vessel *vessel); 
                            	void pour();
                            	int pour(Vessel *vessel);
                            	int getCurrent();
                            	bool isFull();
                            };
                            
                            #endif
                            


                            vessel.cpp
                            #include "vessel.h"
                            
                            Vessel::Vessel(int capacity){
                            	this->capacity = capacity;
                            	this->current = 0;
                            }
                            
                            void Vessel::fill() {
                            	current = capacity;
                            }
                            
                            int Vessel::fill(Vessel* fromVessel) {
                            	int liquid = fromVessel->getCurrent();
                            	int volume = capacity - current;
                            	int result;
                            
                            	if (volume < liquid) {
                            		current += volume;
                            		result = volume;
                            	} else {
                            		current += liquid;
                            		result = liquid;
                            	}
                            
                            	return result;
                            }
                            
                            void Vessel::pour() {
                            	current = 0;
                            }
                            
                            int Vessel::pour(Vessel *toVessel){
                            	int poured = toVessel->fill(this);
                            	this->current -= poured;
                            	return poured;
                            }
                            
                            int Vessel::getCurrent() {
                            	return this->current;
                            }
                            
                            bool Vessel::isFull() {
                            	return current == capacity;
                            }
                            


                            main.cpp
                            #include <iostream>
                            #include "vessel.h"
                            
                            void printVessels(Vessel* a, Vessel* b) {
                            	using namespace std;
                            	cout << "A: " << a->getCurrent() << " ";
                            	cout << "B: " << b->getCurrent() << endl;
                            }
                            
                            int main() {
                            	using namespace std;
                            
                            	Vessel *a = new Vessel(7);
                            	Vessel *b = new Vessel(10);
                            	printVessels(a, b);
                            
                            	while(a->getCurrent() != 1) {
                            		if (b->isFull()) {
                            			b->pour();
                            			cout << "B pour  : ";
                            			printVessels(a, b);
                            		}
                            
                            		if(a->getCurrent() == 0) {
                            			a->fill(); 
                            			cout << "A fill  : ";
                            			printVessels(a, b);
                            		}
                            
                            		a->pour(b);
                            		cout << "A pour B: ";
                            		printVessels(a, b);
                            
                            
                            	}
                            
                            	return 0;
                            }
                            
                            



                            output

                            A: 0 B: 0
                            A fill : A: 7 B: 0
                            A pour B: A: 0 B: 7
                            A fill : A: 7 B: 7
                            A pour B: A: 4 B: 10
                            B pour : A: 4 B: 0
                            A pour B: A: 0 B: 4
                            A fill : A: 7 B: 4
                            A pour B: A: 1 B: 10
                              0
                              Немного поправил, заменил

                              C++ code
                              int Vessel::fill(Vessel* fromVessel) {
                              	int liquid = fromVessel->getCurrent();
                              	int volume = capacity - current;
                              	int result;
                              
                              	if (volume < liquid) {
                              		current += volume;
                              		result = volume;
                              	} else {
                              		current += liquid;
                              		result = liquid;
                              	}
                              
                              	return result;
                              }
                              


                              на

                              int Vessel::fill(Vessel* fromVessel) {
                              	int liquid = fromVessel->getCurrent();
                              	int volume = capacity - current;
                              	int result;
                              
                              	if (volume < liquid) {
                              		result = volume;
                              	} else {
                              		result = liquid;
                              	}
                              
                              	current += result;
                              
                              	return result;
                              }
                              



                              github.com/tigertv/algorithms/tree/master/habr/413571/vessels

                            Only users with full accounts can post comments. Log in, please.