cpp-codingbat-04-Array-1.ipynb


{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
	"#include <iostream>\n",
	"#include <iomanip>\n",
	"#include <vector>\n",
	"\n",
	"using namespace std;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
	"namespace testns { template<class A> void printTest( string str, A run, A expected )\n",
	"{\n",
	"    if( run == expected )\n",
	"        cout << boolalpha << \"\\033[1;32m\"\n",
	"            << \"Expected: \" << setw(60) << left << str << \" Run: \" << setw(20) << left << run << \"\\t\\tOK\"\n",
	"            << \"\\033[0m\" << endl;\n",
	"    else\n",
	"        cerr << boolalpha << \"\\033[1;31m\"\n",
	"            << \"Expected: \" << setw(60) << left << str << \" Run: \" << setw(20) << left << run << \"\\t\\tX\"\n",
	"            << \"\\033[0m\" << endl;\n",
	"} } using namespace testns;\n",
	"void printTest( string str, string run, const char* expected ){ printTest( str, \"\\\"\"+run+\"\\\"\", \"\\\"\"+string( expected )+\"\\\"\" ); }\n",
	"template<class A> void printTest( string str, vector<A> run, vector<A> expected )\n",
	"{\n",
	"    string runStr = \"[\"; for( A a : run ) runStr += to_string( a ) + \", \";\n",
	"    if( runStr.length() > 1 ) runStr = runStr.substr(0, runStr.length()-2); runStr += \"]\";\n",
	"    string expStr = \"[\"; for( A a : expected ) expStr += to_string( a ) + \", \";\n",
	"    if( expStr.length() > 1 ) expStr = expStr.substr(0, expStr.length()-2); expStr += \"]\";\n",
	"    printTest( str, runStr, expStr );\n",
	"}"
   ]
  },
{"cell_type": "markdown", "metadata": {}, "source": ["# Array-1 > firstLast6"]},
{"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["/*\n", "Given an array of ints, return true if 6 appears as either the first or last\n", "element in the array. The array will be length 1 or more.\n", "\n", "firstLast6([1, 2, 6]) \u2192 true\n", "firstLast6([6, 1, 2, 3]) \u2192 true\n", "firstLast6([13, 6, 1, 2, 3]) \u2192 false\n", "*/\n", "\n", "bool firstLast6(vector<int> nums) {\n", "    return false;\n", "}\n", "\n", "\n", "// tests:\n", "printTest( \"firstLast6([1, 2, 6]) \u2192 true\", firstLast6({1, 2, 6}), true );\n", "printTest( \"firstLast6([6, 1, 2, 3]) \u2192 true\", firstLast6({6, 1, 2, 3}), true );\n", "printTest( \"firstLast6([13, 6, 1, 2, 3]) \u2192 false\", firstLast6({13, 6, 1, 2, 3}), false );\n", "printTest( \"firstLast6([13, 6, 1, 2, 6]) \u2192 true\", firstLast6({13, 6, 1, 2, 6}), true );\n", "printTest( \"firstLast6([3, 2, 1]) \u2192 false\", firstLast6({3, 2, 1}), false );\n", "printTest( \"firstLast6([3, 6, 1]) \u2192 false\", firstLast6({3, 6, 1}), false );\n", "printTest( \"firstLast6([3, 6]) \u2192 true\", firstLast6({3, 6}), true );\n", "printTest( \"firstLast6([6]) \u2192 true\", firstLast6({6}), true );\n", "printTest( \"firstLast6([3]) \u2192 false\", firstLast6({3}), false );\n", "printTest( \"firstLast6([5, 6]) \u2192 true\", firstLast6({5, 6}), true );\n", "printTest( \"firstLast6([5, 5]) \u2192 false\", firstLast6({5, 5}), false );\n", "printTest( \"firstLast6([1, 2, 3, 4, 6]) \u2192 true\", firstLast6({1, 2, 3, 4, 6}), true );\n", "printTest( \"firstLast6([1, 2, 3, 4]) \u2192 false\", firstLast6({1, 2, 3, 4}), false );"]},
{"cell_type": "markdown", "metadata": {}, "source": ["# Array-1 > sameFirstLast"]},
{"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["/*\n", "Given an array of ints, return true if the array is length 1 or more, and the\n", "first element and the last element are equal.\n", "\n", "sameFirstLast([1, 2, 3]) \u2192 false\n", "sameFirstLast([1, 2, 3, 1]) \u2192 true\n", "sameFirstLast([1, 2, 1]) \u2192 true\n", "*/\n", "\n", "bool sameFirstLast(vector<int> nums) {\n", "    return false;\n", "}\n", "\n", "\n", "// tests:\n", "printTest( \"sameFirstLast([1, 2, 3]) \u2192 false\", sameFirstLast({1, 2, 3}), false );\n", "printTest( \"sameFirstLast([1, 2, 3, 1]) \u2192 true\", sameFirstLast({1, 2, 3, 1}), true );\n", "printTest( \"sameFirstLast([1, 2, 1]) \u2192 true\", sameFirstLast({1, 2, 1}), true );\n", "printTest( \"sameFirstLast([7]) \u2192 true\", sameFirstLast({7}), true );\n", "printTest( \"sameFirstLast([]) \u2192 false\", sameFirstLast({}), false );\n", "printTest( \"sameFirstLast([1, 2, 3, 4, 5, 1]) \u2192 true\", sameFirstLast({1, 2, 3, 4, 5, 1}), true );\n", "printTest( \"sameFirstLast([1, 2, 3, 4, 5, 13]) \u2192 false\", sameFirstLast({1, 2, 3, 4, 5, 13}), false );\n", "printTest( \"sameFirstLast([13, 2, 3, 4, 5, 13]) \u2192 true\", sameFirstLast({13, 2, 3, 4, 5, 13}), true );\n", "printTest( \"sameFirstLast([7, 7]) \u2192 true\", sameFirstLast({7, 7}), true );"]},
{"cell_type": "markdown", "metadata": {}, "source": ["# Array-1 > makePi"]},
{"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["/*\n", "Return an int array length 3 containing the first 3 digits of pi, {3, 1, 4}.\n", "\n", "makePi() \u2192 [3, 1, 4]\n", "*/\n", "\n", "std::vector<int> makePi() {\n", "    return vector<int>{};\n", "}\n", "\n", "\n", "// tests:\n", "printTest( \"makePi() \u2192 [3, 1, 4]\", makePi(), {3, 1, 4} );"]},
{"cell_type": "markdown", "metadata": {}, "source": ["# Array-1 > commonEnd"]},
{"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["/*\n", "Given 2 arrays of ints, a and b, return true if they have the same first element\n", "or they have the same last element. Both arrays will be length 1 or more.\n", "\n", "commonEnd([1, 2, 3], [7, 3]) \u2192 true\n", "commonEnd([1, 2, 3], [7, 3, 2]) \u2192 false\n", "commonEnd([1, 2, 3], [1, 3]) \u2192 true\n", "*/\n", "\n", "bool commonEnd(vector<int> a, vector<int> b) {\n", "    return false;\n", "}\n", "\n", "\n", "// tests:\n", "printTest( \"commonEnd([1, 2, 3], [7, 3]) \u2192 true\", commonEnd({1, 2, 3}, {7, 3}), true );\n", "printTest( \"commonEnd([1, 2, 3], [7, 3, 2]) \u2192 false\", commonEnd({1, 2, 3}, {7, 3, 2}), false );\n", "printTest( \"commonEnd([1, 2, 3], [1, 3]) \u2192 true\", commonEnd({1, 2, 3}, {1, 3}), true );\n", "printTest( \"commonEnd([1, 2, 3], [1]) \u2192 true\", commonEnd({1, 2, 3}, {1}), true );\n", "printTest( \"commonEnd([1, 2, 3], [2]) \u2192 false\", commonEnd({1, 2, 3}, {2}), false );"]},
{"cell_type": "markdown", "metadata": {}, "source": ["# Array-1 > sum3"]},
{"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["/*\n", "Given an array of ints length 3, return the sum of all the elements.\n", "\n", "sum3([1, 2, 3]) \u2192 6\n", "sum3([5, 11, 2]) \u2192 18\n", "sum3([7, 0, 0]) \u2192 7\n", "*/\n", "\n", "int sum3(vector<int> nums) {\n", "    return 0;\n", "}\n", "\n", "\n", "// tests:\n", "printTest( \"sum3([1, 2, 3]) \u2192 6\", sum3({1, 2, 3}), 6 );\n", "printTest( \"sum3([5, 11, 2]) \u2192 18\", sum3({5, 11, 2}), 18 );\n", "printTest( \"sum3([7, 0, 0]) \u2192 7\", sum3({7, 0, 0}), 7 );\n", "printTest( \"sum3([1, 2, 1]) \u2192 4\", sum3({1, 2, 1}), 4 );\n", "printTest( \"sum3([1, 1, 1]) \u2192 3\", sum3({1, 1, 1}), 3 );\n", "printTest( \"sum3([2, 7, 2]) \u2192 11\", sum3({2, 7, 2}), 11 );"]},
{"cell_type": "markdown", "metadata": {}, "source": ["# Array-1 > rotateLeft3"]},
{"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["/*\n", "Given an array of ints length 3, return an array with the elements \"rotated\n", "left\" so {1, 2, 3} yields {2, 3, 1}.\n", "\n", "rotateLeft3([1, 2, 3]) \u2192 [2, 3, 1]\n", "rotateLeft3([5, 11, 9]) \u2192 [11, 9, 5]\n", "rotateLeft3([7, 0, 0]) \u2192 [0, 0, 7]\n", "*/\n", "\n", "std::vector<int> rotateLeft3(vector<int> nums) {\n", "    return vector<int>{};\n", "}\n", "\n", "\n", "// tests:\n", "printTest( \"rotateLeft3([1, 2, 3]) \u2192 [2, 3, 1]\", rotateLeft3({1, 2, 3}), {2, 3, 1} );\n", "printTest( \"rotateLeft3([5, 11, 9]) \u2192 [11, 9, 5]\", rotateLeft3({5, 11, 9}), {11, 9, 5} );\n", "printTest( \"rotateLeft3([7, 0, 0]) \u2192 [0, 0, 7]\", rotateLeft3({7, 0, 0}), {0, 0, 7} );\n", "printTest( \"rotateLeft3([1, 2, 1]) \u2192 [2, 1, 1]\", rotateLeft3({1, 2, 1}), {2, 1, 1} );\n", "printTest( \"rotateLeft3([0, 0, 1]) \u2192 [0, 1, 0]\", rotateLeft3({0, 0, 1}), {0, 1, 0} );"]},
{"cell_type": "markdown", "metadata": {}, "source": ["# Array-1 > reverse3"]},
{"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["/*\n", "Given an array of ints length 3, return a new array with the elements in reverse\n", "order, so {1, 2, 3} becomes {3, 2, 1}.\n", "\n", "reverse3([1, 2, 3]) \u2192 [3, 2, 1]\n", "reverse3([5, 11, 9]) \u2192 [9, 11, 5]\n", "reverse3([7, 0, 0]) \u2192 [0, 0, 7]\n", "*/\n", "\n", "std::vector<int> reverse3(vector<int> nums) {\n", "    return vector<int>{};\n", "}\n", "\n", "\n", "// tests:\n", "printTest( \"reverse3([1, 2, 3]) \u2192 [3, 2, 1]\", reverse3({1, 2, 3}), {3, 2, 1} );\n", "printTest( \"reverse3([5, 11, 9]) \u2192 [9, 11, 5]\", reverse3({5, 11, 9}), {9, 11, 5} );\n", "printTest( \"reverse3([7, 0, 0]) \u2192 [0, 0, 7]\", reverse3({7, 0, 0}), {0, 0, 7} );\n", "printTest( \"reverse3([2, 1, 2]) \u2192 [2, 1, 2]\", reverse3({2, 1, 2}), {2, 1, 2} );\n", "printTest( \"reverse3([1, 2, 1]) \u2192 [1, 2, 1]\", reverse3({1, 2, 1}), {1, 2, 1} );\n", "printTest( \"reverse3([2, 11, 3]) \u2192 [3, 11, 2]\", reverse3({2, 11, 3}), {3, 11, 2} );\n", "printTest( \"reverse3([0, 6, 5]) \u2192 [5, 6, 0]\", reverse3({0, 6, 5}), {5, 6, 0} );\n", "printTest( \"reverse3([7, 2, 3]) \u2192 [3, 2, 7]\", reverse3({7, 2, 3}), {3, 2, 7} );"]},
{"cell_type": "markdown", "metadata": {}, "source": ["# Array-1 > maxEnd3"]},
{"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["/*\n", "Given an array of ints length 3, figure out which is larger, the first or last\n", "element in the array, and set all the other elements to be that value. Return\n", "the changed array.\n", "\n", "maxEnd3([1, 2, 3]) \u2192 [3, 3, 3]\n", "maxEnd3([11, 5, 9]) \u2192 [11, 11, 11]\n", "maxEnd3([2, 11, 3]) \u2192 [3, 3, 3]\n", "*/\n", "\n", "std::vector<int> maxEnd3(vector<int> nums) {\n", "    return vector<int>{};\n", "}\n", "\n", "\n", "// tests:\n", "printTest( \"maxEnd3([1, 2, 3]) \u2192 [3, 3, 3]\", maxEnd3({1, 2, 3}), {3, 3, 3} );\n", "printTest( \"maxEnd3([11, 5, 9]) \u2192 [11, 11, 11]\", maxEnd3({11, 5, 9}), {11, 11, 11} );\n", "printTest( \"maxEnd3([2, 11, 3]) \u2192 [3, 3, 3]\", maxEnd3({2, 11, 3}), {3, 3, 3} );\n", "printTest( \"maxEnd3([11, 3, 3]) \u2192 [11, 11, 11]\", maxEnd3({11, 3, 3}), {11, 11, 11} );\n", "printTest( \"maxEnd3([3, 11, 11]) \u2192 [11, 11, 11]\", maxEnd3({3, 11, 11}), {11, 11, 11} );\n", "printTest( \"maxEnd3([2, 2, 2]) \u2192 [2, 2, 2]\", maxEnd3({2, 2, 2}), {2, 2, 2} );\n", "printTest( \"maxEnd3([2, 11, 2]) \u2192 [2, 2, 2]\", maxEnd3({2, 11, 2}), {2, 2, 2} );\n", "printTest( \"maxEnd3([0, 0, 1]) \u2192 [1, 1, 1]\", maxEnd3({0, 0, 1}), {1, 1, 1} );"]},
{"cell_type": "markdown", "metadata": {}, "source": ["# Array-1 > sum2"]},
{"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["/*\n", "Given an array of ints, return the sum of the first 2 elements in the array. If\n", "the array length is less than 2, just sum up the elements that exist, returning\n", "0 if the array is length 0.\n", "\n", "sum2([1, 2, 3]) \u2192 3\n", "sum2([1, 1]) \u2192 2\n", "sum2([1, 1, 1, 1]) \u2192 2\n", "*/\n", "\n", "int sum2(vector<int> nums) {\n", "    return 0;\n", "}\n", "\n", "\n", "// tests:\n", "printTest( \"sum2([1, 2, 3]) \u2192 3\", sum2({1, 2, 3}), 3 );\n", "printTest( \"sum2([1, 1]) \u2192 2\", sum2({1, 1}), 2 );\n", "printTest( \"sum2([1, 1, 1, 1]) \u2192 2\", sum2({1, 1, 1, 1}), 2 );\n", "printTest( \"sum2([1, 2]) \u2192 3\", sum2({1, 2}), 3 );\n", "printTest( \"sum2([1]) \u2192 1\", sum2({1}), 1 );\n", "printTest( \"sum2([]) \u2192 0\", sum2({}), 0 );\n", "printTest( \"sum2([4, 5, 6]) \u2192 9\", sum2({4, 5, 6}), 9 );\n", "printTest( \"sum2([4]) \u2192 4\", sum2({4}), 4 );"]},
{"cell_type": "markdown", "metadata": {}, "source": ["# Array-1 > middleWay"]},
{"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["/*\n", "Given 2 int arrays, a and b, each length 3, return a new array length 2\n", "containing their middle elements.\n", "\n", "middleWay([1, 2, 3], [4, 5, 6]) \u2192 [2, 5]\n", "middleWay([7, 7, 7], [3, 8, 0]) \u2192 [7, 8]\n", "middleWay([5, 2, 9], [1, 4, 5]) \u2192 [2, 4]\n", "*/\n", "\n", "std::vector<int> middleWay(vector<int> a, vector<int> b) {\n", "    return vector<int>{};\n", "}\n", "\n", "\n", "// tests:\n", "printTest( \"middleWay([1, 2, 3], [4, 5, 6]) \u2192 [2, 5]\", middleWay({1, 2, 3}, {4, 5, 6}), {2, 5} );\n", "printTest( \"middleWay([7, 7, 7], [3, 8, 0]) \u2192 [7, 8]\", middleWay({7, 7, 7}, {3, 8, 0}), {7, 8} );\n", "printTest( \"middleWay([5, 2, 9], [1, 4, 5]) \u2192 [2, 4]\", middleWay({5, 2, 9}, {1, 4, 5}), {2, 4} );\n", "printTest( \"middleWay([1, 9, 7], [4, 8, 8]) \u2192 [9, 8]\", middleWay({1, 9, 7}, {4, 8, 8}), {9, 8} );\n", "printTest( \"middleWay([1, 2, 3], [3, 1, 4]) \u2192 [2, 1]\", middleWay({1, 2, 3}, {3, 1, 4}), {2, 1} );\n", "printTest( \"middleWay([1, 2, 3], [4, 1, 1]) \u2192 [2, 1]\", middleWay({1, 2, 3}, {4, 1, 1}), {2, 1} );"]},
{"cell_type": "markdown", "metadata": {}, "source": ["# Array-1 > makeEnds"]},
{"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["/*\n", "Given an array of ints, return a new array length 2 containing the first and\n", "last elements from the original array. The original array will be length 1 or\n", "more.\n", "\n", "makeEnds([1, 2, 3]) \u2192 [1, 3]\n", "makeEnds([1, 2, 3, 4]) \u2192 [1, 4]\n", "makeEnds([7, 4, 6, 2]) \u2192 [7, 2]\n", "*/\n", "\n", "std::vector<int> makeEnds(vector<int> nums) {\n", "    return vector<int>{};\n", "}\n", "\n", "\n", "// tests:\n", "printTest( \"makeEnds([1, 2, 3]) \u2192 [1, 3]\", makeEnds({1, 2, 3}), {1, 3} );\n", "printTest( \"makeEnds([1, 2, 3, 4]) \u2192 [1, 4]\", makeEnds({1, 2, 3, 4}), {1, 4} );\n", "printTest( \"makeEnds([7, 4, 6, 2]) \u2192 [7, 2]\", makeEnds({7, 4, 6, 2}), {7, 2} );\n", "printTest( \"makeEnds([1, 2, 2, 2, 2, 2, 2, 3]) \u2192 [1, 3]\", makeEnds({1, 2, 2, 2, 2, 2, 2, 3}), {1, 3} );\n", "printTest( \"makeEnds([7, 4]) \u2192 [7, 4]\", makeEnds({7, 4}), {7, 4} );\n", "printTest( \"makeEnds([7]) \u2192 [7, 7]\", makeEnds({7}), {7, 7} );\n", "printTest( \"makeEnds([5, 2, 9]) \u2192 [5, 9]\", makeEnds({5, 2, 9}), {5, 9} );\n", "printTest( \"makeEnds([2, 3, 4, 1]) \u2192 [2, 1]\", makeEnds({2, 3, 4, 1}), {2, 1} );"]},
{"cell_type": "markdown", "metadata": {}, "source": ["# Array-1 > has23"]},
{"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["/*\n", "Given an int array length 2, return true if it contains a 2 or a 3.\n", "\n", "has23([2, 5]) \u2192 true\n", "has23([4, 3]) \u2192 true\n", "has23([4, 5]) \u2192 false\n", "*/\n", "\n", "bool has23(vector<int> nums) {\n", "    return false;\n", "}\n", "\n", "\n", "// tests:\n", "printTest( \"has23([2, 5]) \u2192 true\", has23({2, 5}), true );\n", "printTest( \"has23([4, 3]) \u2192 true\", has23({4, 3}), true );\n", "printTest( \"has23([4, 5]) \u2192 false\", has23({4, 5}), false );\n", "printTest( \"has23([2, 2]) \u2192 true\", has23({2, 2}), true );\n", "printTest( \"has23([3, 2]) \u2192 true\", has23({3, 2}), true );\n", "printTest( \"has23([3, 3]) \u2192 true\", has23({3, 3}), true );\n", "printTest( \"has23([7, 7]) \u2192 false\", has23({7, 7}), false );\n", "printTest( \"has23([3, 9]) \u2192 true\", has23({3, 9}), true );\n", "printTest( \"has23([9, 5]) \u2192 false\", has23({9, 5}), false );"]},
{"cell_type": "markdown", "metadata": {}, "source": ["# Array-1 > no23"]},
{"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["/*\n", "Given an int array length 2, return true if it does not contain a 2 or 3.\n", "\n", "no23([4, 5]) \u2192 true\n", "no23([4, 2]) \u2192 false\n", "no23([3, 5]) \u2192 false\n", "*/\n", "\n", "bool no23(vector<int> nums) {\n", "    return false;\n", "}\n", "\n", "\n", "// tests:\n", "printTest( \"no23([4, 5]) \u2192 true\", no23({4, 5}), true );\n", "printTest( \"no23([4, 2]) \u2192 false\", no23({4, 2}), false );\n", "printTest( \"no23([3, 5]) \u2192 false\", no23({3, 5}), false );\n", "printTest( \"no23([1, 9]) \u2192 true\", no23({1, 9}), true );\n", "printTest( \"no23([2, 9]) \u2192 false\", no23({2, 9}), false );\n", "printTest( \"no23([1, 3]) \u2192 false\", no23({1, 3}), false );\n", "printTest( \"no23([1, 1]) \u2192 true\", no23({1, 1}), true );\n", "printTest( \"no23([2, 2]) \u2192 false\", no23({2, 2}), false );\n", "printTest( \"no23([3, 3]) \u2192 false\", no23({3, 3}), false );\n", "printTest( \"no23([7, 8]) \u2192 true\", no23({7, 8}), true );\n", "printTest( \"no23([8, 7]) \u2192 true\", no23({8, 7}), true );"]},
{"cell_type": "markdown", "metadata": {}, "source": ["# Array-1 > makeLast"]},
{"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["/*\n", "Given an int array, return a new array with double the length where its last\n", "element is the same as the original array, and all the other elements are 0. The\n", "original array will be length 1 or more. Note: by default, a new int array\n", "contains all 0\u02bcs.\n", "\n", "makeLast([4, 5, 6]) \u2192 [0, 0, 0, 0, 0, 6]\n", "makeLast([1, 2]) \u2192 [0, 0, 0, 2]\n", "makeLast([3]) \u2192 [0, 3]\n", "*/\n", "\n", "std::vector<int> makeLast(vector<int> nums) {\n", "    return vector<int>{};\n", "}\n", "\n", "\n", "// tests:\n", "printTest( \"makeLast([4, 5, 6]) \u2192 [0, 0, 0, 0, 0, 6]\", makeLast({4, 5, 6}), {0, 0, 0, 0, 0, 6} );\n", "printTest( \"makeLast([1, 2]) \u2192 [0, 0, 0, 2]\", makeLast({1, 2}), {0, 0, 0, 2} );\n", "printTest( \"makeLast([3]) \u2192 [0, 3]\", makeLast({3}), {0, 3} );\n", "printTest( \"makeLast([0]) \u2192 [0, 0]\", makeLast({0}), {0, 0} );\n", "printTest( \"makeLast([7, 7, 7]) \u2192 [0, 0, 0, 0, 0, 7]\", makeLast({7, 7, 7}), {0, 0, 0, 0, 0, 7} );\n", "printTest( \"makeLast([3, 1, 4]) \u2192 [0, 0, 0, 0, 0, 4]\", makeLast({3, 1, 4}), {0, 0, 0, 0, 0, 4} );\n", "printTest( \"makeLast([1, 2, 3, 4]) \u2192 [0, 0, 0, 0, 0, 0, 0, 4]\", makeLast({1, 2, 3, 4}), {0, 0, 0, 0, 0, 0, 0, 4} );\n", "printTest( \"makeLast([1, 2, 3, 0]) \u2192 [0, 0, 0, 0, 0, 0, 0, 0]\", makeLast({1, 2, 3, 0}), {0, 0, 0, 0, 0, 0, 0, 0} );\n", "printTest( \"makeLast([2, 4]) \u2192 [0, 0, 0, 4]\", makeLast({2, 4}), {0, 0, 0, 4} );"]},
{"cell_type": "markdown", "metadata": {}, "source": ["# Array-1 > double23"]},
{"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["/*\n", "Given an int array, return true if the array contains 2 twice, or 3 twice. The\n", "array will be length 0, 1, or 2.\n", "\n", "double23([2, 2]) \u2192 true\n", "double23([3, 3]) \u2192 true\n", "double23([2, 3]) \u2192 false\n", "*/\n", "\n", "bool double23(vector<int> nums) {\n", "    return false;\n", "}\n", "\n", "\n", "// tests:\n", "printTest( \"double23([2, 2]) \u2192 true\", double23({2, 2}), true );\n", "printTest( \"double23([3, 3]) \u2192 true\", double23({3, 3}), true );\n", "printTest( \"double23([2, 3]) \u2192 false\", double23({2, 3}), false );\n", "printTest( \"double23([3, 2]) \u2192 false\", double23({3, 2}), false );\n", "printTest( \"double23([4, 5]) \u2192 false\", double23({4, 5}), false );\n", "printTest( \"double23([2]) \u2192 false\", double23({2}), false );\n", "printTest( \"double23([3]) \u2192 false\", double23({3}), false );\n", "printTest( \"double23([]) \u2192 false\", double23({}), false );\n", "printTest( \"double23([3, 4]) \u2192 false\", double23({3, 4}), false );"]},
{"cell_type": "markdown", "metadata": {}, "source": ["# Array-1 > fix23"]},
{"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["/*\n", "Given an int array length 3, if there is a 2 in the array immediately followed\n", "by a 3, set the 3 element to 0. Return the changed array.\n", "\n", "fix23([1, 2, 3]) \u2192 [1, 2, 0]\n", "fix23([2, 3, 5]) \u2192 [2, 0, 5]\n", "fix23([1, 2, 1]) \u2192 [1, 2, 1]\n", "*/\n", "\n", "std::vector<int> fix23(vector<int> nums) {\n", "    return vector<int>{};\n", "}\n", "\n", "\n", "// tests:\n", "printTest( \"fix23([1, 2, 3]) \u2192 [1, 2, 0]\", fix23({1, 2, 3}), {1, 2, 0} );\n", "printTest( \"fix23([2, 3, 5]) \u2192 [2, 0, 5]\", fix23({2, 3, 5}), {2, 0, 5} );\n", "printTest( \"fix23([1, 2, 1]) \u2192 [1, 2, 1]\", fix23({1, 2, 1}), {1, 2, 1} );\n", "printTest( \"fix23([3, 2, 1]) \u2192 [3, 2, 1]\", fix23({3, 2, 1}), {3, 2, 1} );\n", "printTest( \"fix23([2, 2, 3]) \u2192 [2, 2, 0]\", fix23({2, 2, 3}), {2, 2, 0} );\n", "printTest( \"fix23([2, 3, 3]) \u2192 [2, 0, 3]\", fix23({2, 3, 3}), {2, 0, 3} );"]},
{"cell_type": "markdown", "metadata": {}, "source": ["# Array-1 > start1"]},
{"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["/*\n", "Start with 2 int arrays, a and b, of any length. Return how many of the arrays\n", "have 1 as their first element.\n", "\n", "start1([1, 2, 3], [1, 3]) \u2192 2\n", "start1([7, 2, 3], [1]) \u2192 1\n", "start1([1, 2], []) \u2192 1\n", "*/\n", "\n", "int start1(vector<int> a, vector<int> b) {\n", "    return 0;\n", "}\n", "\n", "\n", "// tests:\n", "printTest( \"start1([1, 2, 3], [1, 3]) \u2192 2\", start1({1, 2, 3}, {1, 3}), 2 );\n", "printTest( \"start1([7, 2, 3], [1]) \u2192 1\", start1({7, 2, 3}, {1}), 1 );\n", "printTest( \"start1([1, 2], []) \u2192 1\", start1({1, 2}, {}), 1 );\n", "printTest( \"start1([], [1, 2]) \u2192 1\", start1({}, {1, 2}), 1 );\n", "printTest( \"start1([7], []) \u2192 0\", start1({7}, {}), 0 );\n", "printTest( \"start1([7], [1]) \u2192 1\", start1({7}, {1}), 1 );\n", "printTest( \"start1([1], [1]) \u2192 2\", start1({1}, {1}), 2 );\n", "printTest( \"start1([7], [8]) \u2192 0\", start1({7}, {8}), 0 );\n", "printTest( \"start1([], []) \u2192 0\", start1({}, {}), 0 );\n", "printTest( \"start1([1, 3], [1]) \u2192 2\", start1({1, 3}, {1}), 2 );"]},
{"cell_type": "markdown", "metadata": {}, "source": ["# Array-1 > biggerTwo"]},
{"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["/*\n", "Start with 2 int arrays, a and b, each length 2. Consider the sum of the values\n", "in each array. Return the array which has the largest sum. In event of a tie,\n", "return a.\n", "\n", "biggerTwo([1, 2], [3, 4]) \u2192 [3, 4]\n", "biggerTwo([3, 4], [1, 2]) \u2192 [3, 4]\n", "biggerTwo([1, 1], [1, 2]) \u2192 [1, 2]\n", "*/\n", "\n", "std::vector<int> biggerTwo(vector<int> a, vector<int> b) {\n", "    return vector<int>{};\n", "}\n", "\n", "\n", "// tests:\n", "printTest( \"biggerTwo([1, 2], [3, 4]) \u2192 [3, 4]\", biggerTwo({1, 2}, {3, 4}), {3, 4} );\n", "printTest( \"biggerTwo([3, 4], [1, 2]) \u2192 [3, 4]\", biggerTwo({3, 4}, {1, 2}), {3, 4} );\n", "printTest( \"biggerTwo([1, 1], [1, 2]) \u2192 [1, 2]\", biggerTwo({1, 1}, {1, 2}), {1, 2} );\n", "printTest( \"biggerTwo([2, 1], [1, 1]) \u2192 [2, 1]\", biggerTwo({2, 1}, {1, 1}), {2, 1} );\n", "printTest( \"biggerTwo([2, 2], [1, 3]) \u2192 [2, 2]\", biggerTwo({2, 2}, {1, 3}), {2, 2} );\n", "printTest( \"biggerTwo([1, 3], [2, 2]) \u2192 [1, 3]\", biggerTwo({1, 3}, {2, 2}), {1, 3} );\n", "printTest( \"biggerTwo([6, 7], [3, 1]) \u2192 [6, 7]\", biggerTwo({6, 7}, {3, 1}), {6, 7} );"]},
{"cell_type": "markdown", "metadata": {}, "source": ["# Array-1 > makeMiddle"]},
{"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["/*\n", "Given an array of ints of even length, return a new array length 2 containing\n", "the middle two elements from the original array. The original array will be\n", "length 2 or more.\n", "\n", "makeMiddle([1, 2, 3, 4]) \u2192 [2, 3]\n", "makeMiddle([7, 1, 2, 3, 4, 9]) \u2192 [2, 3]\n", "makeMiddle([1, 2]) \u2192 [1, 2]\n", "*/\n", "\n", "std::vector<int> makeMiddle(vector<int> nums) {\n", "    return vector<int>{};\n", "}\n", "\n", "\n", "// tests:\n", "printTest( \"makeMiddle([1, 2, 3, 4]) \u2192 [2, 3]\", makeMiddle({1, 2, 3, 4}), {2, 3} );\n", "printTest( \"makeMiddle([7, 1, 2, 3, 4, 9]) \u2192 [2, 3]\", makeMiddle({7, 1, 2, 3, 4, 9}), {2, 3} );\n", "printTest( \"makeMiddle([1, 2]) \u2192 [1, 2]\", makeMiddle({1, 2}), {1, 2} );\n", "printTest( \"makeMiddle([5, 2, 4, 7]) \u2192 [2, 4]\", makeMiddle({5, 2, 4, 7}), {2, 4} );\n", "printTest( \"makeMiddle([9, 0, 4, 3, 9, 1]) \u2192 [4, 3]\", makeMiddle({9, 0, 4, 3, 9, 1}), {4, 3} );"]},
{"cell_type": "markdown", "metadata": {}, "source": ["# Array-1 > plusTwo"]},
{"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["/*\n", "Given 2 int arrays, each length 2, return a new array length 4 containing all\n", "their elements.\n", "\n", "plusTwo([1, 2], [3, 4]) \u2192 [1, 2, 3, 4]\n", "plusTwo([4, 4], [2, 2]) \u2192 [4, 4, 2, 2]\n", "plusTwo([9, 2], [3, 4]) \u2192 [9, 2, 3, 4]\n", "*/\n", "\n", "std::vector<int> plusTwo(vector<int> a, vector<int> b) {\n", "    return vector<int>{};\n", "}\n", "\n", "\n", "// tests:\n", "printTest( \"plusTwo([1, 2], [3, 4]) \u2192 [1, 2, 3, 4]\", plusTwo({1, 2}, {3, 4}), {1, 2, 3, 4} );\n", "printTest( \"plusTwo([4, 4], [2, 2]) \u2192 [4, 4, 2, 2]\", plusTwo({4, 4}, {2, 2}), {4, 4, 2, 2} );\n", "printTest( \"plusTwo([9, 2], [3, 4]) \u2192 [9, 2, 3, 4]\", plusTwo({9, 2}, {3, 4}), {9, 2, 3, 4} );"]},
{"cell_type": "markdown", "metadata": {}, "source": ["# Array-1 > swapEnds"]},
{"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["/*\n", "Given an array of ints, swap the first and last elements in the array. Return\n", "the modified array. The array length will be at least 1.\n", "\n", "swapEnds([1, 2, 3, 4]) \u2192 [4, 2, 3, 1]\n", "swapEnds([1, 2, 3]) \u2192 [3, 2, 1]\n", "swapEnds([8, 6, 7, 9, 5]) \u2192 [5, 6, 7, 9, 8]\n", "*/\n", "\n", "std::vector<int> swapEnds(vector<int> nums) {\n", "    return vector<int>{};\n", "}\n", "\n", "\n", "// tests:\n", "printTest( \"swapEnds([1, 2, 3, 4]) \u2192 [4, 2, 3, 1]\", swapEnds({1, 2, 3, 4}), {4, 2, 3, 1} );\n", "printTest( \"swapEnds([1, 2, 3]) \u2192 [3, 2, 1]\", swapEnds({1, 2, 3}), {3, 2, 1} );\n", "printTest( \"swapEnds([8, 6, 7, 9, 5]) \u2192 [5, 6, 7, 9, 8]\", swapEnds({8, 6, 7, 9, 5}), {5, 6, 7, 9, 8} );\n", "printTest( \"swapEnds([3, 1, 4, 1, 5, 9]) \u2192 [9, 1, 4, 1, 5, 3]\", swapEnds({3, 1, 4, 1, 5, 9}), {9, 1, 4, 1, 5, 3} );\n", "printTest( \"swapEnds([1, 2]) \u2192 [2, 1]\", swapEnds({1, 2}), {2, 1} );\n", "printTest( \"swapEnds([1]) \u2192 [1]\", swapEnds({1}), {1} );"]},
{"cell_type": "markdown", "metadata": {}, "source": ["# Array-1 > midThree"]},
{"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["/*\n", "Given an array of ints of odd length, return a new array length 3 containing the\n", "elements from the middle of the array. The array length will be at least 3.\n", "\n", "midThree([1, 2, 3, 4, 5]) \u2192 [2, 3, 4]\n", "midThree([8, 6, 7, 5, 3, 0, 9]) \u2192 [7, 5, 3]\n", "midThree([1, 2, 3]) \u2192 [1, 2, 3]\n", "*/\n", "\n", "std::vector<int> midThree(vector<int> nums) {\n", "    return vector<int>{};\n", "}\n", "\n", "\n", "// tests:\n", "printTest( \"midThree([1, 2, 3, 4, 5]) \u2192 [2, 3, 4]\", midThree({1, 2, 3, 4, 5}), {2, 3, 4} );\n", "printTest( \"midThree([8, 6, 7, 5, 3, 0, 9]) \u2192 [7, 5, 3]\", midThree({8, 6, 7, 5, 3, 0, 9}), {7, 5, 3} );\n", "printTest( \"midThree([1, 2, 3]) \u2192 [1, 2, 3]\", midThree({1, 2, 3}), {1, 2, 3} );"]},
{"cell_type": "markdown", "metadata": {}, "source": ["# Array-1 > maxTriple"]},
{"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["/*\n", "Given an array of ints of odd length, look at the first, last, and middle values\n", "in the array and return the largest. The array length will be a least 1.\n", "\n", "maxTriple([1, 2, 3]) \u2192 3\n", "maxTriple([1, 5, 3]) \u2192 5\n", "maxTriple([5, 2, 3]) \u2192 5\n", "*/\n", "\n", "int maxTriple(vector<int> nums) {\n", "    return 0;\n", "}\n", "\n", "\n", "// tests:\n", "printTest( \"maxTriple([1, 2, 3]) \u2192 3\", maxTriple({1, 2, 3}), 3 );\n", "printTest( \"maxTriple([1, 5, 3]) \u2192 5\", maxTriple({1, 5, 3}), 5 );\n", "printTest( \"maxTriple([5, 2, 3]) \u2192 5\", maxTriple({5, 2, 3}), 5 );\n", "printTest( \"maxTriple([1, 2, 3, 1, 1]) \u2192 3\", maxTriple({1, 2, 3, 1, 1}), 3 );\n", "printTest( \"maxTriple([1, 7, 3, 1, 5]) \u2192 5\", maxTriple({1, 7, 3, 1, 5}), 5 );\n", "printTest( \"maxTriple([5, 1, 3, 7, 1]) \u2192 5\", maxTriple({5, 1, 3, 7, 1}), 5 );\n", "printTest( \"maxTriple([5, 1, 7, 3, 7, 8, 1]) \u2192 5\", maxTriple({5, 1, 7, 3, 7, 8, 1}), 5 );\n", "printTest( \"maxTriple([5, 1, 7, 9, 7, 8, 1]) \u2192 9\", maxTriple({5, 1, 7, 9, 7, 8, 1}), 9 );\n", "printTest( \"maxTriple([5, 1, 7, 3, 7, 8, 9]) \u2192 9\", maxTriple({5, 1, 7, 3, 7, 8, 9}), 9 );\n", "printTest( \"maxTriple([2, 2, 5, 1, 1]) \u2192 5\", maxTriple({2, 2, 5, 1, 1}), 5 );"]},
{"cell_type": "markdown", "metadata": {}, "source": ["# Array-1 > frontPiece"]},
{"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["/*\n", "Given an int array of any length, return a new array of its first 2 elements. If\n", "the array is smaller than length 2, use whatever elements are present.\n", "\n", "frontPiece([1, 2, 3]) \u2192 [1, 2]\n", "frontPiece([1, 2]) \u2192 [1, 2]\n", "frontPiece([1]) \u2192 [1]\n", "*/\n", "\n", "std::vector<int> frontPiece(vector<int> nums) {\n", "    return vector<int>{};\n", "}\n", "\n", "\n", "// tests:\n", "printTest( \"frontPiece([1, 2, 3]) \u2192 [1, 2]\", frontPiece({1, 2, 3}), {1, 2} );\n", "printTest( \"frontPiece([1, 2]) \u2192 [1, 2]\", frontPiece({1, 2}), {1, 2} );\n", "printTest( \"frontPiece([1]) \u2192 [1]\", frontPiece({1}), {1} );\n", "printTest( \"frontPiece([]) \u2192 []\", frontPiece({}), {} );\n", "printTest( \"frontPiece([6, 5, 0]) \u2192 [6, 5]\", frontPiece({6, 5, 0}), {6, 5} );\n", "printTest( \"frontPiece([6, 5]) \u2192 [6, 5]\", frontPiece({6, 5}), {6, 5} );\n", "printTest( \"frontPiece([3, 1, 4, 1, 5]) \u2192 [3, 1]\", frontPiece({3, 1, 4, 1, 5}), {3, 1} );\n", "printTest( \"frontPiece([6]) \u2192 [6]\", frontPiece({6}), {6} );"]},
{"cell_type": "markdown", "metadata": {}, "source": ["# Array-1 > unlucky1"]},
{"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["/*\n", "We\u02bcll say that a 1 immediately followed by a 3 in an array is an \"unlucky\" 1.\n", "Return true if the given array contains an unlucky 1 in the first 2 or last 2\n", "positions in the array.\n", "\n", "unlucky1([1, 3, 4, 5]) \u2192 true\n", "unlucky1([2, 1, 3, 4, 5]) \u2192 true\n", "unlucky1([1, 1, 1]) \u2192 false\n", "*/\n", "\n", "bool unlucky1(vector<int> nums) {\n", "    return false;\n", "}\n", "\n", "\n", "// tests:\n", "printTest( \"unlucky1([1, 3, 4, 5]) \u2192 true\", unlucky1({1, 3, 4, 5}), true );\n", "printTest( \"unlucky1([2, 1, 3, 4, 5]) \u2192 true\", unlucky1({2, 1, 3, 4, 5}), true );\n", "printTest( \"unlucky1([1, 1, 1]) \u2192 false\", unlucky1({1, 1, 1}), false );\n", "printTest( \"unlucky1([1, 3, 1]) \u2192 true\", unlucky1({1, 3, 1}), true );\n", "printTest( \"unlucky1([1, 1, 3]) \u2192 true\", unlucky1({1, 1, 3}), true );\n", "printTest( \"unlucky1([1, 2, 3]) \u2192 false\", unlucky1({1, 2, 3}), false );\n", "printTest( \"unlucky1([3, 3, 3]) \u2192 false\", unlucky1({3, 3, 3}), false );\n", "printTest( \"unlucky1([1, 3]) \u2192 true\", unlucky1({1, 3}), true );\n", "printTest( \"unlucky1([1, 4]) \u2192 false\", unlucky1({1, 4}), false );\n", "printTest( \"unlucky1([1]) \u2192 false\", unlucky1({1}), false );\n", "printTest( \"unlucky1([]) \u2192 false\", unlucky1({}), false );\n", "printTest( \"unlucky1([1, 1, 1, 3, 1]) \u2192 false\", unlucky1({1, 1, 1, 3, 1}), false );\n", "printTest( \"unlucky1([1, 1, 3, 1, 1]) \u2192 true\", unlucky1({1, 1, 3, 1, 1}), true );\n", "printTest( \"unlucky1([1, 1, 1, 1, 3]) \u2192 true\", unlucky1({1, 1, 1, 1, 3}), true );\n", "printTest( \"unlucky1([1, 4, 1, 5]) \u2192 false\", unlucky1({1, 4, 1, 5}), false );\n", "printTest( \"unlucky1([1, 1, 2, 3]) \u2192 false\", unlucky1({1, 1, 2, 3}), false );\n", "printTest( \"unlucky1([2, 3, 2, 1]) \u2192 false\", unlucky1({2, 3, 2, 1}), false );\n", "printTest( \"unlucky1([2, 3, 1, 3]) \u2192 true\", unlucky1({2, 3, 1, 3}), true );\n", "printTest( \"unlucky1([1, 2, 3, 4, 1, 3]) \u2192 true\", unlucky1({1, 2, 3, 4, 1, 3}), true );"]},
{"cell_type": "markdown", "metadata": {}, "source": ["# Array-1 > make2"]},
{"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["/*\n", "Given 2 int arrays, a and b, return a new array length 2 containing, as much as\n", "will fit, the elements from a followed by the elements from b. The arrays may be\n", "any length, including 0, but there will be 2 or more elements available between\n", "the 2 arrays.\n", "\n", "make2([4, 5], [1, 2, 3]) \u2192 [4, 5]\n", "make2([4], [1, 2, 3]) \u2192 [4, 1]\n", "make2([], [1, 2]) \u2192 [1, 2]\n", "*/\n", "\n", "std::vector<int> make2(vector<int> a, vector<int> b) {\n", "    return vector<int>{};\n", "}\n", "\n", "\n", "// tests:\n", "printTest( \"make2([4, 5], [1, 2, 3]) \u2192 [4, 5]\", make2({4, 5}, {1, 2, 3}), {4, 5} );\n", "printTest( \"make2([4], [1, 2, 3]) \u2192 [4, 1]\", make2({4}, {1, 2, 3}), {4, 1} );\n", "printTest( \"make2([], [1, 2]) \u2192 [1, 2]\", make2({}, {1, 2}), {1, 2} );\n", "printTest( \"make2([1, 2], []) \u2192 [1, 2]\", make2({1, 2}, {}), {1, 2} );\n", "printTest( \"make2([3], [1, 2, 3]) \u2192 [3, 1]\", make2({3}, {1, 2, 3}), {3, 1} );\n", "printTest( \"make2([3], [1]) \u2192 [3, 1]\", make2({3}, {1}), {3, 1} );\n", "printTest( \"make2([3, 1, 4], []) \u2192 [3, 1]\", make2({3, 1, 4}, {}), {3, 1} );\n", "printTest( \"make2([1], [1]) \u2192 [1, 1]\", make2({1}, {1}), {1, 1} );\n", "printTest( \"make2([1, 2, 3], [7, 8]) \u2192 [1, 2]\", make2({1, 2, 3}, {7, 8}), {1, 2} );\n", "printTest( \"make2([7, 8], [1, 2, 3]) \u2192 [7, 8]\", make2({7, 8}, {1, 2, 3}), {7, 8} );\n", "printTest( \"make2([7], [1, 2, 3]) \u2192 [7, 1]\", make2({7}, {1, 2, 3}), {7, 1} );\n", "printTest( \"make2([5, 4], [2, 3, 7]) \u2192 [5, 4]\", make2({5, 4}, {2, 3, 7}), {5, 4} );"]},
{"cell_type": "markdown", "metadata": {}, "source": ["# Array-1 > front11"]},
{"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["/*\n", "Given 2 int arrays, a and b, of any length, return a new array with the first\n", "element of each array. If either array is length 0, ignore that array.\n", "\n", "front11([1, 2, 3], [7, 9, 8]) \u2192 [1, 7]\n", "front11([1], [2]) \u2192 [1, 2]\n", "front11([1, 7], []) \u2192 [1]\n", "*/\n", "\n", "std::vector<int> front11(vector<int> a, vector<int> b) {\n", "    return vector<int>{};\n", "}\n", "\n", "\n", "// tests:\n", "printTest( \"front11([1, 2, 3], [7, 9, 8]) \u2192 [1, 7]\", front11({1, 2, 3}, {7, 9, 8}), {1, 7} );\n", "printTest( \"front11([1], [2]) \u2192 [1, 2]\", front11({1}, {2}), {1, 2} );\n", "printTest( \"front11([1, 7], []) \u2192 [1]\", front11({1, 7}, {}), {1} );\n", "printTest( \"front11([], [2, 8]) \u2192 [2]\", front11({}, {2, 8}), {2} );\n", "printTest( \"front11([], []) \u2192 []\", front11({}, {}), {} );\n", "printTest( \"front11([3], [1, 4, 1, 9]) \u2192 [3, 1]\", front11({3}, {1, 4, 1, 9}), {3, 1} );\n", "printTest( \"front11([1, 4, 1, 9], []) \u2192 [1]\", front11({1, 4, 1, 9}, {}), {1} );"]}
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "C++17",
   "language": "C++17",
   "name": "xcpp17"
  },
  "language_info": {
   "codemirror_mode": "text/x-c++src",
   "file_extension": ".cpp",
   "mimetype": "text/x-c++src",
   "name": "c++",
   "version": "17"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}