contest seminar 2.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### https://official.contest.yandex.ru/contest/20310/enter/"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# max"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "2\n",
      "10\n"
     ]
    }
   ],
   "source": [
    "a = int(input().strip())\n",
    "b = int(input().strip())\n",
    "res = (((a // b) * a) + ((b // a) * b)) // ((a // b) + (b // a))\n",
    "print(res)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# comparison"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "10\n",
      "0\n"
     ]
    }
   ],
   "source": [
    "a = int(input().strip())\n",
    "b = int(input().strip())\n",
    "if a > b:\n",
    "    res = 1\n",
    "elif a < b:\n",
    "    res = 2\n",
    "else:\n",
    "    res = 0\n",
    "print(res)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# sign"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-1\n",
      "-1\n"
     ]
    }
   ],
   "source": [
    "n = int(input().strip())\n",
    "if n > 0:\n",
    "    res = 1\n",
    "elif n < 0:\n",
    "    res = -1\n",
    "else:\n",
    "    res = 0\n",
    "print(res)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# max"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "9\n",
      "2\n",
      "19\n",
      "19\n"
     ]
    }
   ],
   "source": [
    "a = int(input())\n",
    "b = int(input())\n",
    "c = int(input())\n",
    "res = a\n",
    "if b > res:\n",
    "    res = b\n",
    "if c > res:\n",
    "    res = c\n",
    "print(res)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# coordinates"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "YES\n"
     ]
    }
   ],
   "source": [
    "import math\n",
    "\n",
    "a = int(input())\n",
    "b = int(input())\n",
    "c = int(input())\n",
    "d = int(input())\n",
    "\n",
    "if math.copysign(1, a) == math.copysign(1, c) and math.copysign(1, b) == math.copysign(1, d):\n",
    "    print('YES')\n",
    "else:\n",
    "    print('NO')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# flats"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "11\n",
      "15\n",
      "YES\n"
     ]
    }
   ],
   "source": [
    "a = int(input())\n",
    "b = int(input())\n",
    "firsts = a - 1\n",
    "our = b - a + 1\n",
    "# print(firsts)\n",
    "# print(our)\n",
    "if firsts%our == 0:\n",
    "    print('YES')\n",
    "else:\n",
    "    print('NO')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# leap"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n",
      "YES\n"
     ]
    }
   ],
   "source": [
    "a = int(input())\n",
    "\n",
    "if a % 400 == 0 or (a % 4 == 0 and not(a % 100 == 0)):\n",
    "    print('YES')\n",
    "else:\n",
    "    print('NO')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# king"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n",
      "4\n",
      "5\n",
      "5\n",
      "NO\n"
     ]
    }
   ],
   "source": [
    "a = int(input())\n",
    "b = int(input())\n",
    "c = int(input())\n",
    "d = int(input())\n",
    "\n",
    "if 0 < (a - c)**2 + (b - d)**2 <= 2:\n",
    "    print('YES')\n",
    "else:\n",
    "    print('NO')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(4 - 5)**2 + (4 - 5)**2 "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# ice"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "64\n",
      "YES\n"
     ]
    }
   ],
   "source": [
    "a = int(input())\n",
    "def ice_ice(a):\n",
    "    if a % 5 == 0 or a % 3 == 0:\n",
    "        return ('YES')\n",
    "    else:\n",
    "        rem_3 = a//3\n",
    "        for i in range(rem_3):\n",
    "            if (a-i*3)% 5 == 0:\n",
    "                return('YES')\n",
    "\n",
    "    return('NO')\n",
    "\n",
    "\n",
    "print(ice_ice(a))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# even odd"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      " 1\n",
      " 2\n",
      " 3\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "YES\n"
     ]
    }
   ],
   "source": [
    "a = int(input())\n",
    "b = int(input())\n",
    "c = int(input())\n",
    "\n",
    "nums = [a, b, c]\n",
    "odds = list()\n",
    "evens = list()\n",
    "def odd_even(nlist):\n",
    "    for i in nlist:\n",
    "        evens.append(i % 2 == 0)\n",
    "        odds.append(not(i % 2 == 0))\n",
    "    if any(odds) and any(evens):\n",
    "        return('YES')\n",
    "    else:\n",
    "        return('NO')\n",
    "        \n",
    "\n",
    "print(odd_even(nums))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# K chocolate"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      " 2\n",
      " 10\n",
      " 7\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "NO\n"
     ]
    }
   ],
   "source": [
    "n = int(input())\n",
    "m = int(input())\n",
    "k = int(input())\n",
    "\n",
    "possible_1 = set(i * m for i in range(n + 1))\n",
    "possible_2 = set(i * n for i in range(m + 1))\n",
    "all_vars = possible_1.union(possible_2)\n",
    "if k in all_vars:\n",
    "    print('YES')\n",
    "else:\n",
    "    print('NO')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "R "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# J цвет клеток"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      " 1\n",
      " 1\n",
      " 2\n",
      " 3\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "NO\n"
     ]
    }
   ],
   "source": [
    "a = int(input())\n",
    "b = int(input())\n",
    "c = int(input())\n",
    "d = int(input())\n",
    "\n",
    "if ((a + b) % 2 == 0) == ((c + d) % 2 == 0):\n",
    "    print('YES')\n",
    "else:\n",
    "    print('NO')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# M. Упорядочить три числа"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      " 3\n",
      " 2\n",
      " 1\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 2 3\n"
     ]
    }
   ],
   "source": [
    "a = int(input())\n",
    "b = int(input())\n",
    "c = int(input())\n",
    "if a > b:\n",
    "    (a, b) = (b, a)\n",
    "if b > c:\n",
    "    (b, c) = (c, b)\n",
    "if a > b:\n",
    "    (a, b) = (b, a)\n",
    "if b > c:\n",
    "    (b, c) = (c, b)\n",
    "print(a, b, c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# L шашаки"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      " 2\n",
      " 2\n",
      " 1\n",
      " 1\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "NO\n"
     ]
    }
   ],
   "source": [
    "from_col = int(input())\n",
    "from_row = int(input())\n",
    "to_col = int(input())\n",
    "to_row = int(input())\n",
    "if ((from_col + from_row) % 2 == 0) == ((to_col + to_row) % 2 == 0):\n",
    "    if (to_row >= to_col - from_col + from_row) and (to_row >= -to_col + from_col + from_row):\n",
    "        print('YES')\n",
    "    else:\n",
    "        print('NO') \n",
    "else:\n",
    "    print('NO')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# N. совпадения"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      " 1\n",
      " 2\n",
      " 3\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n"
     ]
    }
   ],
   "source": [
    "a = int(input())\n",
    "b = int(input())\n",
    "c = int(input())\n",
    "res = 0\n",
    "if a == b:\n",
    "    res += 1\n",
    "if b == c:\n",
    "    res += 1\n",
    "if a == c:\n",
    "    res += 1\n",
    "if res == 1:\n",
    "    res += 1\n",
    "print(res)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# O треугульник"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      " 1\n",
      " 2\n",
      " 3\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "impossible\n"
     ]
    }
   ],
   "source": [
    "a = int(input())\n",
    "b = int(input())\n",
    "c = int(input())\n",
    "sides = sorted([a, b, c])\n",
    "ss = []\n",
    "for i in sides: \n",
    "        ss.append(i * i)  \n",
    "if max(sides) >= ((a + b + c) / 2):\n",
    "    print('impossible')\n",
    "elif ss[2] > ss[1] + ss[0]:\n",
    "    print('obtuse')\n",
    "elif ss[2] < ss[1] + ss[0]:\n",
    "    print('acute')\n",
    "else:\n",
    "    print('rectangular')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# P узник"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      " 2\n",
      " 2\n",
      " 1\n",
      " 1\n",
      " 2\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "YES\n"
     ]
    }
   ],
   "source": [
    "a = int(input())\n",
    "b = int(input())\n",
    "c = int(input())\n",
    "d = int(input())\n",
    "e = int(input())\n",
    "brick = sorted([a, b, c])\n",
    "hole = sorted([d, e])\n",
    "\n",
    "if brick[0] > hole[0] or brick[1] > hole[1]:\n",
    "    print('NO')\n",
    "else:\n",
    "    print('YES')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Q boxes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      " 3\n",
      " 2\n",
      " 1\n",
      " 2\n",
      " 2\n",
      " 3\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The first box is smaller than the second one\n"
     ]
    }
   ],
   "source": [
    "a = int(input())\n",
    "b = int(input())\n",
    "c = int(input())\n",
    "d = int(input())\n",
    "e = int(input())\n",
    "f = int(input())\n",
    "first = sorted([a, b, c])\n",
    "second = sorted([d, e, f])\n",
    "def box_compare(first, second):\n",
    "    if first == second:\n",
    "        return('Boxes are equal')\n",
    "    one_bigger = []\n",
    "    two_bigger = []\n",
    "    for i in range(3):\n",
    "        one_bigger.append(first[i] >= second[i])\n",
    "        two_bigger.append(first[i] <= second[i])\n",
    "    if all(one_bigger):\n",
    "        return('The first box is larger than the second one')\n",
    "    elif all(two_bigger):\n",
    "        return('The first box is smaller than the second one')\n",
    "    else:\n",
    "        return('Boxes are incomparable')\n",
    "\n",
    "\n",
    "print(box_compare(first, second))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# R laptop stacking"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      " 7\n",
      " 7\n",
      " 7\n",
      " 3\n",
      " 3\n",
      " 3\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "8\n"
     ]
    }
   ],
   "source": [
    "import itertools\n",
    "from operator import floordiv \n",
    "a = int(input())\n",
    "b = int(input())\n",
    "c = int(input())\n",
    "d = int(input())\n",
    "e = int(input())\n",
    "f = int(input())\n",
    "bag = sorted([a, b, c])\n",
    "item = sorted([d, e, f])\n",
    "def laptops(bag, item):\n",
    "    max_count = 0\n",
    "    orintations = list(itertools.permutations(item))\n",
    "    for pos_i in orintations:\n",
    "        tup_div = tuple(map(floordiv, bag, pos_i)) \n",
    "        pos_i_count = tup_div[0] * tup_div[1] * tup_div[2]\n",
    "        if pos_i_count > max_count:\n",
    "            max_count = pos_i_count\n",
    "    return(max_count)\n",
    "print(laptops(bag, item))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# S cows"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      " 33\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "33 korovy\n"
     ]
    }
   ],
   "source": [
    "a = int(input())\n",
    "variants = ['korov', 'korova', 'korovy']\n",
    "def cows(i, values = variants):\n",
    "    if i % 10 == 1 and i != 11:\n",
    "        return(values[1])\n",
    "    if i % 10 in [2, 3, 4] and i not in [12, 13, 14]:\n",
    "        return(values[2]) \n",
    "    return(values[0])\n",
    "print(a, cows(a, variants))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "15 % 10 in [2, 3, 4]\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# U hard equation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      " 1\n",
      " 1\n",
      " 2\n",
      " 2\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "NO\n"
     ]
    }
   ],
   "source": [
    "a = int(input())\n",
    "b = int(input())\n",
    "c = int(input())\n",
    "d = int(input())\n",
    "\n",
    "\n",
    "def eqsolve():\n",
    "    if a !=0 and (b * c - a * d != 0):\n",
    "        res = -b / a\n",
    "        if res.is_integer():\n",
    "            res = int(res)\n",
    "        return(res)\n",
    "    if a == 0 and b == 0:\n",
    "        return('INF')\n",
    "    else:\n",
    "        return('NO')\n",
    "print(eqsolve())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# v котлеты"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      " 100\n",
      " 1\n",
      " 2\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n"
     ]
    }
   ],
   "source": [
    "k = int(input().strip())\n",
    "m = int(input().strip())\n",
    "n = int(input().strip())\n",
    "\n",
    "times = 0\n",
    "cotlet_sides_per_pan = k\n",
    "sides = n * 2\n",
    "\n",
    "if n <= k:\n",
    "    times = 2\n",
    "elif sides % cotlet_sides_per_pan == 0:\n",
    "    times = sides // cotlet_sides_per_pan\n",
    "else:\n",
    "    times = sides // cotlet_sides_per_pan + 1\n",
    "res = times * m\n",
    "print(res)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# w matches"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      " 1\n",
      " 5\n",
      " 0\n",
      " 1\n",
      " 4\n",
      " 8\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n"
     ]
    }
   ],
   "source": [
    "a = int(input())\n",
    "b = int(input())\n",
    "c = int(input())\n",
    "d = int(input())\n",
    "e = int(input())\n",
    "f = int(input())\n",
    "m1 = set(range(a, b ))\n",
    "m2 = set(range(c, d ))\n",
    "m3 = set(range(e, f ))\n",
    "matches = [m1, m2, m3]\n",
    "#print(m1)\n",
    "#print(m2)\n",
    "#print(m3)\n",
    "\n",
    "def solves(all_matches, position):\n",
    "    m_without_pos = all_matches[:position] + all_matches[(position + 1):]\n",
    "    m23 = m_without_pos[0] | m_without_pos[1]\n",
    "    big_23 = set(range(min(min(m_without_pos[0]), min(m_without_pos[1])), max(max(m_without_pos[0]), max(m_without_pos[1])) + 1))\n",
    "    return(len(big_23.difference(m23))<=len(all_matches[position]))\n",
    "\n",
    "m_all = m1 | m2 | m3\n",
    "m_max = set(range(min(a, b, c, d, e, f), max(a, b, c, d, e, f) ))\n",
    "def match_solve():\n",
    "    if m_all == m_max:\n",
    "        solved = 1\n",
    "        return(0)\n",
    "    for i in range(3):\n",
    "        if solves(matches, i):\n",
    "            return(i + 1)\n",
    "    return(-1)\n",
    "print(match_solve())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# x container"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Длина, ширина и высота первого ящика — l1, w1 и h1, соответствующие размеры второго ящика – l2, w2 и h2. Контейнер имеет длину, ширину и высоту lc, wc и h"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      " 3\n",
      " 2\n",
      " 2\n",
      " 3\n",
      " 1\n",
      " 2\n",
      " 5\n",
      " 2\n",
      " 3\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "NO\n"
     ]
    }
   ],
   "source": [
    "l1 = int(input())\n",
    "w1 = int(input())\n",
    "h1 = int(input())\n",
    "l2 = int(input())\n",
    "w2 = int(input())\n",
    "h2 = int(input())\n",
    "lc = int(input())\n",
    "wc = int(input())\n",
    "hc = int(input())\n",
    "\n",
    "import itertools\n",
    "b1 = [l1, w1, h1]\n",
    "b2 = [l2, w2, h2]\n",
    "cont = [lc, wc, hc]\n",
    "\n",
    "b1_rot = [False, True]\n",
    "b2_rot  = [False, True]\n",
    "b2_pos = ['r', 'down']\n",
    "stack = [False, True]\n",
    "cont_rot = [False, True]\n",
    "c = list(itertools.product(b1_rot, b2_rot, b2_pos, stack, cont_rot))\n",
    "# print(c)\n",
    "len(c)\n",
    "\n",
    "def solves_one(ch_vect, box1, box2, container):\n",
    "    bounding = [0, 0, 0]\n",
    "    if ch_vect[0]:\n",
    "        box1[0], box1[1] = box1[1], box1[0]\n",
    "    if ch_vect[1]:\n",
    "        box2[0], box2[1] = box2[1], box2[0]\n",
    "    if ch_vect[3]:\n",
    "        # stack vert:\n",
    "        bounding = [max(box1[0], box2[0]), max(box1[1], box2[1]), box1[2] + box2[2]]\n",
    "    else:\n",
    "        if ch_vect[2] == 'r':\n",
    "            # stack right\n",
    "            bounding = [box1[0] + box2[0], max(box1[1], box2[1]), max(box1[2], box2[2])]\n",
    "        else:\n",
    "            # stack down\n",
    "            bounding = [max(box1[0], box2[0]), box1[1] + box2[1], max(box1[2], box2[2])]\n",
    "    if ch_vect[4]:\n",
    "        container[0], container[1] = container[1], container[0]\n",
    "    if container[0] >= bounding[0] and container[1] >= bounding[1] and container[2] >= bounding[2]:\n",
    "        # print(container, 'container fits:')\n",
    "        # print(bounding, 'bounding')\n",
    "        # print(box1, 'box1 position')\n",
    "        # print(box2, 'box2 position')\n",
    "        return True\n",
    "    else:\n",
    "        return False\n",
    "\n",
    "def fin_solve():\n",
    "    for variant in c:\n",
    "        # print(variant)\n",
    "        if solves_one(variant, b1, b2, cont):\n",
    "            return('YES')\n",
    "            break\n",
    "    return('NO')\n",
    "\n",
    "print(fin_solve())"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}