cpp-codingbat-09-Array-2.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-2 > countEvens"]},
{"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["/*\n", "Return the number of even ints in the given array. Note: the % \"mod\" operator\n", "computes the remainder, e.g. 5 % 2 is 1.\n", "\n", "countEvens([2, 1, 2, 3, 4]) \u2192 3\n", "countEvens([2, 2, 0]) \u2192 3\n", "countEvens([1, 3, 5]) \u2192 0\n", "*/\n", "\n", "int countEvens(vector<int> nums) {\n", "    return 0;\n", "}\n", "\n", "\n", "// tests:\n", "printTest( \"countEvens([2, 1, 2, 3, 4]) \u2192 3\", countEvens({2, 1, 2, 3, 4}), 3 );\n", "printTest( \"countEvens([2, 2, 0]) \u2192 3\", countEvens({2, 2, 0}), 3 );\n", "printTest( \"countEvens([1, 3, 5]) \u2192 0\", countEvens({1, 3, 5}), 0 );\n", "printTest( \"countEvens([]) \u2192 0\", countEvens({}), 0 );\n", "printTest( \"countEvens([11, 9, 0, 1]) \u2192 1\", countEvens({11, 9, 0, 1}), 1 );\n", "printTest( \"countEvens([2, 11, 9, 0]) \u2192 2\", countEvens({2, 11, 9, 0}), 2 );\n", "printTest( \"countEvens([2]) \u2192 1\", countEvens({2}), 1 );\n", "printTest( \"countEvens([2, 5, 12]) \u2192 2\", countEvens({2, 5, 12}), 2 );"]},
{"cell_type": "markdown", "metadata": {}, "source": ["# Array-2 > bigDiff"]},
{"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["/*\n", "Given an array length 1 or more of ints, return the difference between the\n", "largest and smallest values in the array. Note: the built-in Math.min(v1, v2)\n", "and Math.max(v1, v2) methods  return the smaller or larger of two values.\n", "\n", "bigDiff([10, 3, 5, 6]) \u2192 7\n", "bigDiff([7, 2, 10, 9]) \u2192 8\n", "bigDiff([2, 10, 7, 2]) \u2192 8\n", "*/\n", "\n", "int bigDiff(vector<int> nums) {\n", "    return 0;\n", "}\n", "\n", "\n", "// tests:\n", "printTest( \"bigDiff([10, 3, 5, 6]) \u2192 7\", bigDiff({10, 3, 5, 6}), 7 );\n", "printTest( \"bigDiff([7, 2, 10, 9]) \u2192 8\", bigDiff({7, 2, 10, 9}), 8 );\n", "printTest( \"bigDiff([2, 10, 7, 2]) \u2192 8\", bigDiff({2, 10, 7, 2}), 8 );\n", "printTest( \"bigDiff([2, 10]) \u2192 8\", bigDiff({2, 10}), 8 );\n", "printTest( \"bigDiff([10, 2]) \u2192 8\", bigDiff({10, 2}), 8 );\n", "printTest( \"bigDiff([10, 0]) \u2192 10\", bigDiff({10, 0}), 10 );\n", "printTest( \"bigDiff([2, 3]) \u2192 1\", bigDiff({2, 3}), 1 );\n", "printTest( \"bigDiff([2, 2]) \u2192 0\", bigDiff({2, 2}), 0 );\n", "printTest( \"bigDiff([2]) \u2192 0\", bigDiff({2}), 0 );\n", "printTest( \"bigDiff([5, 1, 6, 1, 9, 9]) \u2192 8\", bigDiff({5, 1, 6, 1, 9, 9}), 8 );\n", "printTest( \"bigDiff([7, 6, 8, 5]) \u2192 3\", bigDiff({7, 6, 8, 5}), 3 );\n", "printTest( \"bigDiff([7, 7, 6, 8, 5, 5, 6]) \u2192 3\", bigDiff({7, 7, 6, 8, 5, 5, 6}), 3 );"]},
{"cell_type": "markdown", "metadata": {}, "source": ["# Array-2 > centeredAverage"]},
{"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["/*\n", "Return the \"centered\" average of an array of ints, which we\u02bcll say is the mean\n", "average of the values, except ignoring the largest and smallest values in the\n", "array. If there are multiple copies of the smallest value, ignore just one copy,\n", "and likewise for the largest value. Use int division to produce the final\n", "average. You may assume that the array is length 3 or more.\n", "\n", "centeredAverage([1, 2, 3, 4, 100]) \u2192 3\n", "centeredAverage([1, 1, 5, 5, 10, 8, 7]) \u2192 5\n", "centeredAverage([-10, -4, -2, -4, -2, 0]) \u2192 -3\n", "*/\n", "\n", "int centeredAverage(vector<int> nums) {\n", "    return 0;\n", "}\n", "\n", "\n", "// tests:\n", "printTest( \"centeredAverage([1, 2, 3, 4, 100]) \u2192 3\", centeredAverage({1, 2, 3, 4, 100}), 3 );\n", "printTest( \"centeredAverage([1, 1, 5, 5, 10, 8, 7]) \u2192 5\", centeredAverage({1, 1, 5, 5, 10, 8, 7}), 5 );\n", "printTest( \"centeredAverage([-10, -4, -2, -4, -2, 0]) \u2192 -3\", centeredAverage({-10, -4, -2, -4, -2, 0}), -3 );\n", "printTest( \"centeredAverage([5, 3, 4, 6, 2]) \u2192 4\", centeredAverage({5, 3, 4, 6, 2}), 4 );\n", "printTest( \"centeredAverage([5, 3, 4, 0, 100]) \u2192 4\", centeredAverage({5, 3, 4, 0, 100}), 4 );\n", "printTest( \"centeredAverage([100, 0, 5, 3, 4]) \u2192 4\", centeredAverage({100, 0, 5, 3, 4}), 4 );\n", "printTest( \"centeredAverage([4, 0, 100]) \u2192 4\", centeredAverage({4, 0, 100}), 4 );\n", "printTest( \"centeredAverage([0, 2, 3, 4, 100]) \u2192 3\", centeredAverage({0, 2, 3, 4, 100}), 3 );\n", "printTest( \"centeredAverage([1, 1, 100]) \u2192 1\", centeredAverage({1, 1, 100}), 1 );\n", "printTest( \"centeredAverage([7, 7, 7]) \u2192 7\", centeredAverage({7, 7, 7}), 7 );\n", "printTest( \"centeredAverage([1, 7, 8]) \u2192 7\", centeredAverage({1, 7, 8}), 7 );\n", "printTest( \"centeredAverage([1, 1, 99, 99]) \u2192 50\", centeredAverage({1, 1, 99, 99}), 50 );\n", "printTest( \"centeredAverage([1000, 0, 1, 99]) \u2192 50\", centeredAverage({1000, 0, 1, 99}), 50 );\n", "printTest( \"centeredAverage([4, 4, 4, 4, 5]) \u2192 4\", centeredAverage({4, 4, 4, 4, 5}), 4 );\n", "printTest( \"centeredAverage([4, 4, 4, 1, 5]) \u2192 4\", centeredAverage({4, 4, 4, 1, 5}), 4 );\n", "printTest( \"centeredAverage([6, 4, 8, 12, 3]) \u2192 6\", centeredAverage({6, 4, 8, 12, 3}), 6 );"]},
{"cell_type": "markdown", "metadata": {}, "source": ["# Array-2 > sum13"]},
{"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["/*\n", "Return the sum of the numbers in the array, returning 0 for an empty array.\n", "Except the number 13 is very unlucky, so it does not count and numbers that come\n", "immediately after a 13 also do not count.\n", "\n", "sum13([1, 2, 2, 1]) \u2192 6\n", "sum13([1, 1]) \u2192 2\n", "sum13([1, 2, 2, 1, 13]) \u2192 6\n", "*/\n", "\n", "int sum13(vector<int> nums) {\n", "    return 0;\n", "}\n", "\n", "\n", "// tests:\n", "printTest( \"sum13([1, 2, 2, 1]) \u2192 6\", sum13({1, 2, 2, 1}), 6 );\n", "printTest( \"sum13([1, 1]) \u2192 2\", sum13({1, 1}), 2 );\n", "printTest( \"sum13([1, 2, 2, 1, 13]) \u2192 6\", sum13({1, 2, 2, 1, 13}), 6 );\n", "printTest( \"sum13([1, 2, 13, 2, 1, 13]) \u2192 4\", sum13({1, 2, 13, 2, 1, 13}), 4 );\n", "printTest( \"sum13([13, 1, 2, 13, 2, 1, 13]) \u2192 3\", sum13({13, 1, 2, 13, 2, 1, 13}), 3 );\n", "printTest( \"sum13([]) \u2192 0\", sum13({}), 0 );\n", "printTest( \"sum13([13]) \u2192 0\", sum13({13}), 0 );\n", "printTest( \"sum13([13, 13]) \u2192 0\", sum13({13, 13}), 0 );\n", "printTest( \"sum13([13, 0, 13]) \u2192 0\", sum13({13, 0, 13}), 0 );\n", "printTest( \"sum13([13, 1, 13]) \u2192 0\", sum13({13, 1, 13}), 0 );\n", "printTest( \"sum13([5, 7, 2]) \u2192 14\", sum13({5, 7, 2}), 14 );\n", "printTest( \"sum13([5, 13, 2]) \u2192 5\", sum13({5, 13, 2}), 5 );\n", "printTest( \"sum13([0]) \u2192 0\", sum13({0}), 0 );\n", "printTest( \"sum13([13, 0]) \u2192 0\", sum13({13, 0}), 0 );"]},
{"cell_type": "markdown", "metadata": {}, "source": ["# Array-2 > sum67"]},
{"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["/*\n", "Return the sum of the numbers in the array, except ignore sections of numbers\n", "starting with a 6 and extending to the next 7 (every 6 will be followed by at\n", "least one 7). Return 0 for no numbers.\n", "\n", "sum67([1, 2, 2]) \u2192 5\n", "sum67([1, 2, 2, 6, 99, 99, 7]) \u2192 5\n", "sum67([1, 1, 6, 7, 2]) \u2192 4\n", "*/\n", "\n", "int sum67(vector<int> nums) {\n", "    return 0;\n", "}\n", "\n", "\n", "// tests:\n", "printTest( \"sum67([1, 2, 2]) \u2192 5\", sum67({1, 2, 2}), 5 );\n", "printTest( \"sum67([1, 2, 2, 6, 99, 99, 7]) \u2192 5\", sum67({1, 2, 2, 6, 99, 99, 7}), 5 );\n", "printTest( \"sum67([1, 1, 6, 7, 2]) \u2192 4\", sum67({1, 1, 6, 7, 2}), 4 );\n", "printTest( \"sum67([1, 6, 2, 2, 7, 1, 6, 99, 99, 7]) \u2192 2\", sum67({1, 6, 2, 2, 7, 1, 6, 99, 99, 7}), 2 );\n", "printTest( \"sum67([1, 6, 2, 6, 2, 7, 1, 6, 99, 99, 7]) \u2192 2\", sum67({1, 6, 2, 6, 2, 7, 1, 6, 99, 99, 7}), 2 );\n", "printTest( \"sum67([2, 7, 6, 2, 6, 7, 2, 7]) \u2192 18\", sum67({2, 7, 6, 2, 6, 7, 2, 7}), 18 );\n", "printTest( \"sum67([2, 7, 6, 2, 6, 2, 7]) \u2192 9\", sum67({2, 7, 6, 2, 6, 2, 7}), 9 );\n", "printTest( \"sum67([1, 6, 7, 7]) \u2192 8\", sum67({1, 6, 7, 7}), 8 );\n", "printTest( \"sum67([6, 7, 1, 6, 7, 7]) \u2192 8\", sum67({6, 7, 1, 6, 7, 7}), 8 );\n", "printTest( \"sum67([6, 8, 1, 6, 7]) \u2192 0\", sum67({6, 8, 1, 6, 7}), 0 );\n", "printTest( \"sum67([]) \u2192 0\", sum67({}), 0 );\n", "printTest( \"sum67([6, 7, 11]) \u2192 11\", sum67({6, 7, 11}), 11 );\n", "printTest( \"sum67([11, 6, 7, 11]) \u2192 22\", sum67({11, 6, 7, 11}), 22 );\n", "printTest( \"sum67([2, 2, 6, 7, 7]) \u2192 11\", sum67({2, 2, 6, 7, 7}), 11 );"]},
{"cell_type": "markdown", "metadata": {}, "source": ["# Array-2 > has22"]},
{"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["/*\n", "Given an array of ints, return true if the array contains a 2 next to a 2\n", "somewhere.\n", "\n", "has22([1, 2, 2]) \u2192 true\n", "has22([1, 2, 1, 2]) \u2192 false\n", "has22([2, 1, 2]) \u2192 false\n", "*/\n", "\n", "bool has22(vector<int> nums) {\n", "    return false;\n", "}\n", "\n", "\n", "// tests:\n", "printTest( \"has22([1, 2, 2]) \u2192 true\", has22({1, 2, 2}), true );\n", "printTest( \"has22([1, 2, 1, 2]) \u2192 false\", has22({1, 2, 1, 2}), false );\n", "printTest( \"has22([2, 1, 2]) \u2192 false\", has22({2, 1, 2}), false );\n", "printTest( \"has22([2, 2, 1, 2]) \u2192 true\", has22({2, 2, 1, 2}), true );\n", "printTest( \"has22([1, 3, 2]) \u2192 false\", has22({1, 3, 2}), false );\n", "printTest( \"has22([1, 3, 2, 2]) \u2192 true\", has22({1, 3, 2, 2}), true );\n", "printTest( \"has22([2, 3, 2, 2]) \u2192 true\", has22({2, 3, 2, 2}), true );\n", "printTest( \"has22([4, 2, 4, 2, 2, 5]) \u2192 true\", has22({4, 2, 4, 2, 2, 5}), true );\n", "printTest( \"has22([1, 2]) \u2192 false\", has22({1, 2}), false );\n", "printTest( \"has22([2, 2]) \u2192 true\", has22({2, 2}), true );\n", "printTest( \"has22([2]) \u2192 false\", has22({2}), false );\n", "printTest( \"has22([]) \u2192 false\", has22({}), false );\n", "printTest( \"has22([3, 3, 2, 2]) \u2192 true\", has22({3, 3, 2, 2}), true );\n", "printTest( \"has22([5, 2, 5, 2]) \u2192 false\", has22({5, 2, 5, 2}), false );"]},
{"cell_type": "markdown", "metadata": {}, "source": ["# Array-2 > lucky13"]},
{"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["/*\n", "Given an array of ints, return true if the array contains no 1's and no 3's.\n", "\n", "lucky13([0, 2, 4]) \u2192 true\n", "lucky13([1, 2, 3]) \u2192 false\n", "lucky13([1, 2, 4]) \u2192 false\n", "*/\n", "\n", "bool lucky13(vector<int> nums) {\n", "    return false;\n", "}\n", "\n", "\n", "// tests:\n", "printTest( \"lucky13([0, 2, 4]) \u2192 true\", lucky13({0, 2, 4}), true );\n", "printTest( \"lucky13([1, 2, 3]) \u2192 false\", lucky13({1, 2, 3}), false );\n", "printTest( \"lucky13([1, 2, 4]) \u2192 false\", lucky13({1, 2, 4}), false );\n", "printTest( \"lucky13([2, 7, 2, 8]) \u2192 true\", lucky13({2, 7, 2, 8}), true );\n", "printTest( \"lucky13([2, 7, 1, 8]) \u2192 false\", lucky13({2, 7, 1, 8}), false );\n", "printTest( \"lucky13([3, 7, 2, 8]) \u2192 false\", lucky13({3, 7, 2, 8}), false );\n", "printTest( \"lucky13([2, 7, 2, 1]) \u2192 false\", lucky13({2, 7, 2, 1}), false );\n", "printTest( \"lucky13([1, 2]) \u2192 false\", lucky13({1, 2}), false );\n", "printTest( \"lucky13([2, 2]) \u2192 true\", lucky13({2, 2}), true );\n", "printTest( \"lucky13([2]) \u2192 true\", lucky13({2}), true );\n", "printTest( \"lucky13([3]) \u2192 false\", lucky13({3}), false );\n", "printTest( \"lucky13([]) \u2192 true\", lucky13({}), true );"]},
{"cell_type": "markdown", "metadata": {}, "source": ["# Array-2 > sum28"]},
{"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["/*\n", "Given an array of ints, return true if the sum of all the 2\u02bcs in the array is\n", "exactly 8.\n", "\n", "sum28([2, 3, 2, 2, 4, 2]) \u2192 true\n", "sum28([2, 3, 2, 2, 4, 2, 2]) \u2192 false\n", "sum28([1, 2, 3, 4]) \u2192 false\n", "*/\n", "\n", "bool sum28(vector<int> nums) {\n", "    return false;\n", "}\n", "\n", "\n", "// tests:\n", "printTest( \"sum28([2, 3, 2, 2, 4, 2]) \u2192 true\", sum28({2, 3, 2, 2, 4, 2}), true );\n", "printTest( \"sum28([2, 3, 2, 2, 4, 2, 2]) \u2192 false\", sum28({2, 3, 2, 2, 4, 2, 2}), false );\n", "printTest( \"sum28([1, 2, 3, 4]) \u2192 false\", sum28({1, 2, 3, 4}), false );\n", "printTest( \"sum28([2, 2, 2, 2]) \u2192 true\", sum28({2, 2, 2, 2}), true );\n", "printTest( \"sum28([1, 2, 2, 2, 2, 4]) \u2192 true\", sum28({1, 2, 2, 2, 2, 4}), true );\n", "printTest( \"sum28([]) \u2192 false\", sum28({}), false );\n", "printTest( \"sum28([2]) \u2192 false\", sum28({2}), false );\n", "printTest( \"sum28([8]) \u2192 false\", sum28({8}), false );\n", "printTest( \"sum28([2, 2, 2]) \u2192 false\", sum28({2, 2, 2}), false );\n", "printTest( \"sum28([2, 2, 2, 2, 2]) \u2192 false\", sum28({2, 2, 2, 2, 2}), false );\n", "printTest( \"sum28([1, 2, 2, 1, 2, 2]) \u2192 true\", sum28({1, 2, 2, 1, 2, 2}), true );\n", "printTest( \"sum28([5, 2, 2, 2, 4, 2]) \u2192 true\", sum28({5, 2, 2, 2, 4, 2}), true );"]},
{"cell_type": "markdown", "metadata": {}, "source": ["# Array-2 > more14"]},
{"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["/*\n", "Given an array of ints, return true if the number of 1's is greater than the\n", "number of 4's\n", "\n", "more14([1, 4, 1]) \u2192 true\n", "more14([1, 4, 1, 4]) \u2192 false\n", "more14([1, 1]) \u2192 true\n", "*/\n", "\n", "bool more14(vector<int> nums) {\n", "    return false;\n", "}\n", "\n", "\n", "// tests:\n", "printTest( \"more14([1, 4, 1]) \u2192 true\", more14({1, 4, 1}), true );\n", "printTest( \"more14([1, 4, 1, 4]) \u2192 false\", more14({1, 4, 1, 4}), false );\n", "printTest( \"more14([1, 1]) \u2192 true\", more14({1, 1}), true );\n", "printTest( \"more14([1, 6, 6]) \u2192 true\", more14({1, 6, 6}), true );\n", "printTest( \"more14([1]) \u2192 true\", more14({1}), true );\n", "printTest( \"more14([1, 4]) \u2192 false\", more14({1, 4}), false );\n", "printTest( \"more14([6, 1, 1]) \u2192 true\", more14({6, 1, 1}), true );\n", "printTest( \"more14([1, 6, 4]) \u2192 false\", more14({1, 6, 4}), false );\n", "printTest( \"more14([1, 1, 4, 4, 1]) \u2192 true\", more14({1, 1, 4, 4, 1}), true );\n", "printTest( \"more14([1, 1, 6, 4, 4, 1]) \u2192 true\", more14({1, 1, 6, 4, 4, 1}), true );\n", "printTest( \"more14([]) \u2192 false\", more14({}), false );\n", "printTest( \"more14([4, 1, 4, 6]) \u2192 false\", more14({4, 1, 4, 6}), false );\n", "printTest( \"more14([4, 1, 4, 6, 1]) \u2192 false\", more14({4, 1, 4, 6, 1}), false );\n", "printTest( \"more14([1, 4, 1, 4, 1, 6]) \u2192 true\", more14({1, 4, 1, 4, 1, 6}), true );"]},
{"cell_type": "markdown", "metadata": {}, "source": ["# Array-2 > fizzArray"]},
{"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["/*\n", "Given a number n, create and return a new int array of length n, containing the\n", "numbers 0, 1, 2, ... n-1. The given n may be 0, in which case just return a\n", "length 0 array. You do not need a separate if-statement for the length-0 case;\n", "the for-loop should naturally execute 0 times in that case, so it just works.\n", "The syntax to make a new int array is: new int[desired_length]  \u00a0 (See also:\n", "FizzBuzz Code)\n", "\n", "fizzArray(4) \u2192 [0, 1, 2, 3]\n", "fizzArray(1) \u2192 [0]\n", "fizzArray(10) \u2192 [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n", "*/\n", "\n", "std::vector<int> fizzArray(int n) {\n", "    return vector<int>{};\n", "}\n", "\n", "\n", "// tests:\n", "printTest( \"fizzArray(4) \u2192 [0, 1, 2, 3]\", fizzArray(4), {0, 1, 2, 3} );\n", "printTest( \"fizzArray(1) \u2192 [0]\", fizzArray(1), {0} );\n", "printTest( \"fizzArray(10) \u2192 [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\", fizzArray(10), {0, 1, 2, 3, 4, 5, 6, 7, 8, 9} );\n", "printTest( \"fizzArray(0) \u2192 []\", fizzArray(0), {} );\n", "printTest( \"fizzArray(2) \u2192 [0, 1]\", fizzArray(2), {0, 1} );\n", "printTest( \"fizzArray(7) \u2192 [0, 1, 2, 3, 4, 5, 6]\", fizzArray(7), {0, 1, 2, 3, 4, 5, 6} );"]},
{"cell_type": "markdown", "metadata": {}, "source": ["# Array-2 > only14"]},
{"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["/*\n", "Given an array of ints, return true if every element is a 1 or a 4.\n", "\n", "only14([1, 4, 1, 4]) \u2192 true\n", "only14([1, 4, 2, 4]) \u2192 false\n", "only14([1, 1]) \u2192 true\n", "*/\n", "\n", "bool only14(vector<int> nums) {\n", "    return false;\n", "}\n", "\n", "\n", "// tests:\n", "printTest( \"only14([1, 4, 1, 4]) \u2192 true\", only14({1, 4, 1, 4}), true );\n", "printTest( \"only14([1, 4, 2, 4]) \u2192 false\", only14({1, 4, 2, 4}), false );\n", "printTest( \"only14([1, 1]) \u2192 true\", only14({1, 1}), true );\n", "printTest( \"only14([4, 1]) \u2192 true\", only14({4, 1}), true );\n", "printTest( \"only14([2]) \u2192 false\", only14({2}), false );\n", "printTest( \"only14([]) \u2192 true\", only14({}), true );\n", "printTest( \"only14([1, 4, 1, 3]) \u2192 false\", only14({1, 4, 1, 3}), false );\n", "printTest( \"only14([3, 1, 3]) \u2192 false\", only14({3, 1, 3}), false );\n", "printTest( \"only14([1]) \u2192 true\", only14({1}), true );\n", "printTest( \"only14([4]) \u2192 true\", only14({4}), true );\n", "printTest( \"only14([3, 4]) \u2192 false\", only14({3, 4}), false );\n", "printTest( \"only14([1, 3, 4]) \u2192 false\", only14({1, 3, 4}), false );\n", "printTest( \"only14([1, 1, 1]) \u2192 true\", only14({1, 1, 1}), true );\n", "printTest( \"only14([1, 1, 1, 5]) \u2192 false\", only14({1, 1, 1, 5}), false );\n", "printTest( \"only14([4, 1, 4, 1]) \u2192 true\", only14({4, 1, 4, 1}), true );"]},
{"cell_type": "markdown", "metadata": {}, "source": ["# Array-2 > fizzArray2"]},
{"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["/*\n", "Given a number n, create and return a new string array of length n, containing\n", "the strings \"0\", \"1\" \"2\" .. through n-1. N may be 0, in which case just return a\n", "length 0 array. Note: String.valueOf(xxx) will make the String form of most\n", "types. The syntax to make a new string array is: new String[desired_length]\n", "\u00a0(See also: FizzBuzz Code)\n", "\n", "fizzArray2(4) \u2192 [\"0\", \"1\", \"2\", \"3\"]\n", "fizzArray2(10) \u2192 [\"0\", \"1\", \"2\", \"3\", \"4\", \"5\", \"6\", \"7\", \"8\", \"9\"]\n", "fizzArray2(2) \u2192 [\"0\", \"1\"]\n", "*/\n", "\n", "std::vector<string> fizzArray2(int n) {\n", "    return new vector<string>{};\n", "}\n", "\n", "\n", "// tests:\n", "printTest( \"fizzArray2(4) \u2192 [\\\"0\\\", \\\"1\\\", \\\"2\\\", \\\"3\\\"]\", fizzArray2(4), {\"0\", \"1\", \"2\", \"3\"} );\n", "printTest( \"fizzArray2(10) \u2192 [\\\"0\\\", \\\"1\\\", \\\"2\\\", \\\"3\\\", \\\"4\\\", \\\"5\\\", \\\"6\\\", \\\"7\\\", \\\"8\\\", \\\"9\\\"]\", fizzArray2(10), {\"0\", \"1\", \"2\", \"3\", \"4\", \"5\", \"6\", \"7\", \"8\", \"9\"} );\n", "printTest( \"fizzArray2(2) \u2192 [\\\"0\\\", \\\"1\\\"]\", fizzArray2(2), {\"0\", \"1\"} );\n", "printTest( \"fizzArray2(1) \u2192 [\\\"0\\\"]\", fizzArray2(1), {\"0\"} );\n", "printTest( \"fizzArray2(0) \u2192 []\", fizzArray2(0), {} );\n", "printTest( \"fizzArray2(7) \u2192 [\\\"0\\\", \\\"1\\\", \\\"2\\\", \\\"3\\\", \\\"4\\\", \\\"5\\\", \\\"6\\\"]\", fizzArray2(7), {\"0\", \"1\", \"2\", \"3\", \"4\", \"5\", \"6\"} );\n", "printTest( \"fizzArray2(9) \u2192 [\\\"0\\\", \\\"1\\\", \\\"2\\\", \\\"3\\\", \\\"4\\\", \\\"5\\\", \\\"6\\\", \\\"7\\\", \\\"8\\\"]\", fizzArray2(9), {\"0\", \"1\", \"2\", \"3\", \"4\", \"5\", \"6\", \"7\", \"8\"} );\n", "printTest( \"fizzArray2(11) \u2192 [\\\"0\\\", \\\"1\\\", \\\"2\\\", \\\"3\\\", \\\"4\\\", \\\"5\\\", \\\"6\\\", \\\"7\\\", \\\"8\\\", \\\"9\\\", \\\"10\\\"]\", fizzArray2(11), {\"0\", \"1\", \"2\", \"3\", \"4\", \"5\", \"6\", \"7\", \"8\", \"9\", \"10\"} );"]},
{"cell_type": "markdown", "metadata": {}, "source": ["# Array-2 > no14"]},
{"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["/*\n", "Given an array of ints, return true if it contains no 1's or it contains no 4's.\n", "\n", "no14([1, 2, 3]) \u2192 true\n", "no14([1, 2, 3, 4]) \u2192 false\n", "no14([2, 3, 4]) \u2192 true\n", "*/\n", "\n", "bool no14(vector<int> nums) {\n", "    return false;\n", "}\n", "\n", "\n", "// tests:\n", "printTest( \"no14([1, 2, 3]) \u2192 true\", no14({1, 2, 3}), true );\n", "printTest( \"no14([1, 2, 3, 4]) \u2192 false\", no14({1, 2, 3, 4}), false );\n", "printTest( \"no14([2, 3, 4]) \u2192 true\", no14({2, 3, 4}), true );\n", "printTest( \"no14([1, 1, 4, 4]) \u2192 false\", no14({1, 1, 4, 4}), false );\n", "printTest( \"no14([2, 2, 4, 4]) \u2192 true\", no14({2, 2, 4, 4}), true );\n", "printTest( \"no14([2, 3, 4, 1]) \u2192 false\", no14({2, 3, 4, 1}), false );\n", "printTest( \"no14([2, 1, 1]) \u2192 true\", no14({2, 1, 1}), true );\n", "printTest( \"no14([1, 4]) \u2192 false\", no14({1, 4}), false );\n", "printTest( \"no14([2]) \u2192 true\", no14({2}), true );\n", "printTest( \"no14([2, 1]) \u2192 true\", no14({2, 1}), true );\n", "printTest( \"no14([1]) \u2192 true\", no14({1}), true );\n", "printTest( \"no14([4]) \u2192 true\", no14({4}), true );\n", "printTest( \"no14([]) \u2192 true\", no14({}), true );\n", "printTest( \"no14([1, 1, 1, 1]) \u2192 true\", no14({1, 1, 1, 1}), true );\n", "printTest( \"no14([9, 4, 4, 1]) \u2192 false\", no14({9, 4, 4, 1}), false );\n", "printTest( \"no14([4, 2, 3, 1]) \u2192 false\", no14({4, 2, 3, 1}), false );\n", "printTest( \"no14([4, 2, 3, 5]) \u2192 true\", no14({4, 2, 3, 5}), true );\n", "printTest( \"no14([4, 4, 2]) \u2192 true\", no14({4, 4, 2}), true );\n", "printTest( \"no14([1, 4, 4]) \u2192 false\", no14({1, 4, 4}), false );"]},
{"cell_type": "markdown", "metadata": {}, "source": ["# Array-2 > isEverywhere"]},
{"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["/*\n", "We\u02bcll say that a value is \"everywhere\" in an array if for every pair of adjacent\n", "elements in the array, at least one of the pair is that value. Return true if\n", "the given value is everywhere in the array.\n", "\n", "isEverywhere([1, 2, 1, 3], 1) \u2192 true\n", "isEverywhere([1, 2, 1, 3], 2) \u2192 false\n", "isEverywhere([1, 2, 1, 3, 4], 1) \u2192 false\n", "*/\n", "\n", "bool isEverywhere(vector<int> nums, int val) {\n", "    return false;\n", "}\n", "\n", "\n", "// tests:\n", "printTest( \"isEverywhere([1, 2, 1, 3], 1) \u2192 true\", isEverywhere({1, 2, 1, 3}, 1), true );\n", "printTest( \"isEverywhere([1, 2, 1, 3], 2) \u2192 false\", isEverywhere({1, 2, 1, 3}, 2), false );\n", "printTest( \"isEverywhere([1, 2, 1, 3, 4], 1) \u2192 false\", isEverywhere({1, 2, 1, 3, 4}, 1), false );\n", "printTest( \"isEverywhere([2, 1, 2, 1], 1) \u2192 true\", isEverywhere({2, 1, 2, 1}, 1), true );\n", "printTest( \"isEverywhere([2, 1, 2, 1], 2) \u2192 true\", isEverywhere({2, 1, 2, 1}, 2), true );\n", "printTest( \"isEverywhere([2, 1, 2, 3, 1], 2) \u2192 false\", isEverywhere({2, 1, 2, 3, 1}, 2), false );\n", "printTest( \"isEverywhere([3, 1], 3) \u2192 true\", isEverywhere({3, 1}, 3), true );\n", "printTest( \"isEverywhere([3, 1], 2) \u2192 false\", isEverywhere({3, 1}, 2), false );\n", "printTest( \"isEverywhere([3], 1) \u2192 true\", isEverywhere({3}, 1), true );\n", "printTest( \"isEverywhere([], 1) \u2192 true\", isEverywhere({}, 1), true );\n", "printTest( \"isEverywhere([1, 2, 1, 2, 3, 2, 5], 2) \u2192 true\", isEverywhere({1, 2, 1, 2, 3, 2, 5}, 2), true );\n", "printTest( \"isEverywhere([1, 2, 1, 1, 1, 2], 2) \u2192 false\", isEverywhere({1, 2, 1, 1, 1, 2}, 2), false );\n", "printTest( \"isEverywhere([2, 1, 2, 1, 1, 2], 2) \u2192 false\", isEverywhere({2, 1, 2, 1, 1, 2}, 2), false );\n", "printTest( \"isEverywhere([2, 1, 2, 2, 2, 1, 1, 2], 2) \u2192 false\", isEverywhere({2, 1, 2, 2, 2, 1, 1, 2}, 2), false );\n", "printTest( \"isEverywhere([2, 1, 2, 2, 2, 1, 2, 1], 2) \u2192 true\", isEverywhere({2, 1, 2, 2, 2, 1, 2, 1}, 2), true );\n", "printTest( \"isEverywhere([2, 1, 2, 1, 2], 2) \u2192 true\", isEverywhere({2, 1, 2, 1, 2}, 2), true );"]},
{"cell_type": "markdown", "metadata": {}, "source": ["# Array-2 > either24"]},
{"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["/*\n", "Given an array of ints, return true if the array contains a 2 next to a 2 or a 4\n", "next to a 4, but not both.\n", "\n", "either24([1, 2, 2]) \u2192 true\n", "either24([4, 4, 1]) \u2192 true\n", "either24([4, 4, 1, 2, 2]) \u2192 false\n", "*/\n", "\n", "bool either24(vector<int> nums) {\n", "    return false;\n", "}\n", "\n", "\n", "// tests:\n", "printTest( \"either24([1, 2, 2]) \u2192 true\", either24({1, 2, 2}), true );\n", "printTest( \"either24([4, 4, 1]) \u2192 true\", either24({4, 4, 1}), true );\n", "printTest( \"either24([4, 4, 1, 2, 2]) \u2192 false\", either24({4, 4, 1, 2, 2}), false );\n", "printTest( \"either24([1, 2, 3, 4]) \u2192 false\", either24({1, 2, 3, 4}), false );\n", "printTest( \"either24([3, 5, 9]) \u2192 false\", either24({3, 5, 9}), false );\n", "printTest( \"either24([1, 2, 3, 4, 4]) \u2192 true\", either24({1, 2, 3, 4, 4}), true );\n", "printTest( \"either24([2, 2, 3, 4]) \u2192 true\", either24({2, 2, 3, 4}), true );\n", "printTest( \"either24([1, 2, 3, 2, 2, 4]) \u2192 true\", either24({1, 2, 3, 2, 2, 4}), true );\n", "printTest( \"either24([1, 2, 3, 2, 2, 4, 4]) \u2192 false\", either24({1, 2, 3, 2, 2, 4, 4}), false );\n", "printTest( \"either24([1, 2]) \u2192 false\", either24({1, 2}), false );\n", "printTest( \"either24([2, 2]) \u2192 true\", either24({2, 2}), true );\n", "printTest( \"either24([4, 4]) \u2192 true\", either24({4, 4}), true );\n", "printTest( \"either24([2]) \u2192 false\", either24({2}), false );\n", "printTest( \"either24([]) \u2192 false\", either24({}), false );"]},
{"cell_type": "markdown", "metadata": {}, "source": ["# Array-2 > matchUp"]},
{"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["/*\n", "Given arrays nums1 and nums2 of the same length, for every element in nums1,\n", "consider the corresponding element in nums2 (at the same index). Return the\n", "count of the number of times that the two elements differ by 2 or less, but are\n", "not equal.\n", "\n", "matchUp([1, 2, 3], [2, 3, 10]) \u2192 2\n", "matchUp([1, 2, 3], [2, 3, 5]) \u2192 3\n", "matchUp([1, 2, 3], [2, 3, 3]) \u2192 2\n", "*/\n", "\n", "int matchUp(vector<int> nums1, vector<int> nums2) {\n", "    return 0;\n", "}\n", "\n", "\n", "// tests:\n", "printTest( \"matchUp([1, 2, 3], [2, 3, 10]) \u2192 2\", matchUp({1, 2, 3}, {2, 3, 10}), 2 );\n", "printTest( \"matchUp([1, 2, 3], [2, 3, 5]) \u2192 3\", matchUp({1, 2, 3}, {2, 3, 5}), 3 );\n", "printTest( \"matchUp([1, 2, 3], [2, 3, 3]) \u2192 2\", matchUp({1, 2, 3}, {2, 3, 3}), 2 );\n", "printTest( \"matchUp([5, 3], [5, 5]) \u2192 1\", matchUp({5, 3}, {5, 5}), 1 );\n", "printTest( \"matchUp([5, 3], [4, 4]) \u2192 2\", matchUp({5, 3}, {4, 4}), 2 );\n", "printTest( \"matchUp([5, 3], [3, 3]) \u2192 1\", matchUp({5, 3}, {3, 3}), 1 );\n", "printTest( \"matchUp([5, 3], [2, 2]) \u2192 1\", matchUp({5, 3}, {2, 2}), 1 );\n", "printTest( \"matchUp([5, 3], [1, 1]) \u2192 1\", matchUp({5, 3}, {1, 1}), 1 );\n", "printTest( \"matchUp([5, 3], [0, 0]) \u2192 0\", matchUp({5, 3}, {0, 0}), 0 );\n", "printTest( \"matchUp([4], [4]) \u2192 0\", matchUp({4}, {4}), 0 );\n", "printTest( \"matchUp([4], [5]) \u2192 1\", matchUp({4}, {5}), 1 );"]},
{"cell_type": "markdown", "metadata": {}, "source": ["# Array-2 > has77"]},
{"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["/*\n", "Given an array of ints, return true if the array contains two 7's next to each\n", "other, or there are two 7's separated by one element, such as with {7, 1, 7}.\n", "\n", "has77([1, 7, 7]) \u2192 true\n", "has77([1, 7, 1, 7]) \u2192 true\n", "has77([1, 7, 1, 1, 7]) \u2192 false\n", "*/\n", "\n", "bool has77(vector<int> nums) {\n", "    return false;\n", "}\n", "\n", "\n", "// tests:\n", "printTest( \"has77([1, 7, 7]) \u2192 true\", has77({1, 7, 7}), true );\n", "printTest( \"has77([1, 7, 1, 7]) \u2192 true\", has77({1, 7, 1, 7}), true );\n", "printTest( \"has77([1, 7, 1, 1, 7]) \u2192 false\", has77({1, 7, 1, 1, 7}), false );\n", "printTest( \"has77([7, 7, 1, 1, 7]) \u2192 true\", has77({7, 7, 1, 1, 7}), true );\n", "printTest( \"has77([2, 7, 2, 2, 7, 2]) \u2192 false\", has77({2, 7, 2, 2, 7, 2}), false );\n", "printTest( \"has77([2, 7, 2, 2, 7, 7]) \u2192 true\", has77({2, 7, 2, 2, 7, 7}), true );\n", "printTest( \"has77([7, 2, 7, 2, 2, 7]) \u2192 true\", has77({7, 2, 7, 2, 2, 7}), true );\n", "printTest( \"has77([7, 2, 6, 2, 2, 7]) \u2192 false\", has77({7, 2, 6, 2, 2, 7}), false );\n", "printTest( \"has77([7, 7, 7]) \u2192 true\", has77({7, 7, 7}), true );\n", "printTest( \"has77([7, 1, 7]) \u2192 true\", has77({7, 1, 7}), true );\n", "printTest( \"has77([7, 1, 1]) \u2192 false\", has77({7, 1, 1}), false );\n", "printTest( \"has77([1, 2]) \u2192 false\", has77({1, 2}), false );\n", "printTest( \"has77([1, 7]) \u2192 false\", has77({1, 7}), false );\n", "printTest( \"has77([7]) \u2192 false\", has77({7}), false );"]},
{"cell_type": "markdown", "metadata": {}, "source": ["# Array-2 > has12"]},
{"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["/*\n", "Given an array of ints, return true if there is a 1 in the array with a 2\n", "somewhere later in the array.\n", "\n", "has12([1, 3, 2]) \u2192 true\n", "has12([3, 1, 2]) \u2192 true\n", "has12([3, 1, 4, 5, 2]) \u2192 true\n", "*/\n", "\n", "bool has12(vector<int> nums) {\n", "    return false;\n", "}\n", "\n", "\n", "// tests:\n", "printTest( \"has12([1, 3, 2]) \u2192 true\", has12({1, 3, 2}), true );\n", "printTest( \"has12([3, 1, 2]) \u2192 true\", has12({3, 1, 2}), true );\n", "printTest( \"has12([3, 1, 4, 5, 2]) \u2192 true\", has12({3, 1, 4, 5, 2}), true );\n", "printTest( \"has12([3, 1, 4, 5, 6]) \u2192 false\", has12({3, 1, 4, 5, 6}), false );\n", "printTest( \"has12([3, 1, 4, 1, 6, 2]) \u2192 true\", has12({3, 1, 4, 1, 6, 2}), true );\n", "printTest( \"has12([2, 1, 4, 1, 6, 2]) \u2192 true\", has12({2, 1, 4, 1, 6, 2}), true );\n", "printTest( \"has12([2, 1, 4, 1, 6]) \u2192 false\", has12({2, 1, 4, 1, 6}), false );\n", "printTest( \"has12([1]) \u2192 false\", has12({1}), false );\n", "printTest( \"has12([2, 1, 3]) \u2192 false\", has12({2, 1, 3}), false );\n", "printTest( \"has12([2, 1, 3, 2]) \u2192 true\", has12({2, 1, 3, 2}), true );\n", "printTest( \"has12([2]) \u2192 false\", has12({2}), false );\n", "printTest( \"has12([3, 2]) \u2192 false\", has12({3, 2}), false );\n", "printTest( \"has12([3, 1, 3, 2]) \u2192 true\", has12({3, 1, 3, 2}), true );\n", "printTest( \"has12([3, 5, 9]) \u2192 false\", has12({3, 5, 9}), false );\n", "printTest( \"has12([3, 5, 1]) \u2192 false\", has12({3, 5, 1}), false );\n", "printTest( \"has12([3, 2, 1]) \u2192 false\", has12({3, 2, 1}), false );\n", "printTest( \"has12([1, 2]) \u2192 true\", has12({1, 2}), true );"]},
{"cell_type": "markdown", "metadata": {}, "source": ["# Array-2 > modThree"]},
{"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["/*\n", "Given an array of ints, return true if the array contains either 3 even or 3 odd\n", "values all next to each other.\n", "\n", "modThree([2, 1, 3, 5]) \u2192 true\n", "modThree([2, 1, 2, 5]) \u2192 false\n", "modThree([2, 4, 2, 5]) \u2192 true\n", "*/\n", "\n", "bool modThree(vector<int> nums) {\n", "    return false;\n", "}\n", "\n", "\n", "// tests:\n", "printTest( \"modThree([2, 1, 3, 5]) \u2192 true\", modThree({2, 1, 3, 5}), true );\n", "printTest( \"modThree([2, 1, 2, 5]) \u2192 false\", modThree({2, 1, 2, 5}), false );\n", "printTest( \"modThree([2, 4, 2, 5]) \u2192 true\", modThree({2, 4, 2, 5}), true );\n", "printTest( \"modThree([1, 2, 1, 2, 1]) \u2192 false\", modThree({1, 2, 1, 2, 1}), false );\n", "printTest( \"modThree([9, 9, 9]) \u2192 true\", modThree({9, 9, 9}), true );\n", "printTest( \"modThree([1, 2, 1]) \u2192 false\", modThree({1, 2, 1}), false );\n", "printTest( \"modThree([1, 2]) \u2192 false\", modThree({1, 2}), false );\n", "printTest( \"modThree([1]) \u2192 false\", modThree({1}), false );\n", "printTest( \"modThree([]) \u2192 false\", modThree({}), false );\n", "printTest( \"modThree([9, 7, 2, 9]) \u2192 false\", modThree({9, 7, 2, 9}), false );\n", "printTest( \"modThree([9, 7, 2, 9, 2, 2]) \u2192 false\", modThree({9, 7, 2, 9, 2, 2}), false );\n", "printTest( \"modThree([9, 7, 2, 9, 2, 2, 6]) \u2192 true\", modThree({9, 7, 2, 9, 2, 2, 6}), true );"]},
{"cell_type": "markdown", "metadata": {}, "source": ["# Array-2 > haveThree"]},
{"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["/*\n", "Given an array of ints, return true if the value 3 appears in the array exactly\n", "3 times, and no 3\u02bcs are next to each other.\n", "\n", "haveThree([3, 1, 3, 1, 3]) \u2192 true\n", "haveThree([3, 1, 3, 3]) \u2192 false\n", "haveThree([3, 4, 3, 3, 4]) \u2192 false\n", "*/\n", "\n", "bool haveThree(vector<int> nums) {\n", "    return false;\n", "}\n", "\n", "\n", "// tests:\n", "printTest( \"haveThree([3, 1, 3, 1, 3]) \u2192 true\", haveThree({3, 1, 3, 1, 3}), true );\n", "printTest( \"haveThree([3, 1, 3, 3]) \u2192 false\", haveThree({3, 1, 3, 3}), false );\n", "printTest( \"haveThree([3, 4, 3, 3, 4]) \u2192 false\", haveThree({3, 4, 3, 3, 4}), false );\n", "printTest( \"haveThree([1, 3, 1, 3, 1, 2]) \u2192 false\", haveThree({1, 3, 1, 3, 1, 2}), false );\n", "printTest( \"haveThree([1, 3, 1, 3, 1, 3]) \u2192 true\", haveThree({1, 3, 1, 3, 1, 3}), true );\n", "printTest( \"haveThree([1, 3, 3, 1, 3]) \u2192 false\", haveThree({1, 3, 3, 1, 3}), false );\n", "printTest( \"haveThree([1, 3, 1, 3, 1, 3, 4, 3]) \u2192 false\", haveThree({1, 3, 1, 3, 1, 3, 4, 3}), false );\n", "printTest( \"haveThree([3, 4, 3, 4, 3, 4, 4]) \u2192 true\", haveThree({3, 4, 3, 4, 3, 4, 4}), true );\n", "printTest( \"haveThree([3, 3, 3]) \u2192 false\", haveThree({3, 3, 3}), false );\n", "printTest( \"haveThree([1, 3]) \u2192 false\", haveThree({1, 3}), false );\n", "printTest( \"haveThree([3]) \u2192 false\", haveThree({3}), false );\n", "printTest( \"haveThree([1]) \u2192 false\", haveThree({1}), false );"]},
{"cell_type": "markdown", "metadata": {}, "source": ["# Array-2 > twoTwo"]},
{"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["/*\n", "Given an array of ints, return true if every 2 that appears in the array is next\n", "to another 2.\n", "\n", "twoTwo([4, 2, 2, 3]) \u2192 true\n", "twoTwo([2, 2, 4]) \u2192 true\n", "twoTwo([2, 2, 4, 2]) \u2192 false\n", "*/\n", "\n", "bool twoTwo(vector<int> nums) {\n", "    return false;\n", "}\n", "\n", "\n", "// tests:\n", "printTest( \"twoTwo([4, 2, 2, 3]) \u2192 true\", twoTwo({4, 2, 2, 3}), true );\n", "printTest( \"twoTwo([2, 2, 4]) \u2192 true\", twoTwo({2, 2, 4}), true );\n", "printTest( \"twoTwo([2, 2, 4, 2]) \u2192 false\", twoTwo({2, 2, 4, 2}), false );\n", "printTest( \"twoTwo([1, 3, 4]) \u2192 true\", twoTwo({1, 3, 4}), true );\n", "printTest( \"twoTwo([1, 2, 2, 3, 4]) \u2192 true\", twoTwo({1, 2, 2, 3, 4}), true );\n", "printTest( \"twoTwo([1, 2, 3, 4]) \u2192 false\", twoTwo({1, 2, 3, 4}), false );\n", "printTest( \"twoTwo([2, 2]) \u2192 true\", twoTwo({2, 2}), true );\n", "printTest( \"twoTwo([2, 2, 7]) \u2192 true\", twoTwo({2, 2, 7}), true );\n", "printTest( \"twoTwo([2, 2, 7, 2, 1]) \u2192 false\", twoTwo({2, 2, 7, 2, 1}), false );\n", "printTest( \"twoTwo([4, 2, 2, 2]) \u2192 true\", twoTwo({4, 2, 2, 2}), true );\n", "printTest( \"twoTwo([2, 2, 2]) \u2192 true\", twoTwo({2, 2, 2}), true );\n", "printTest( \"twoTwo([1, 2]) \u2192 false\", twoTwo({1, 2}), false );\n", "printTest( \"twoTwo([2]) \u2192 false\", twoTwo({2}), false );\n", "printTest( \"twoTwo([1]) \u2192 true\", twoTwo({1}), true );\n", "printTest( \"twoTwo([]) \u2192 true\", twoTwo({}), true );\n", "printTest( \"twoTwo([5, 2, 2, 3]) \u2192 true\", twoTwo({5, 2, 2, 3}), true );\n", "printTest( \"twoTwo([2, 2, 5, 2]) \u2192 false\", twoTwo({2, 2, 5, 2}), false );"]},
{"cell_type": "markdown", "metadata": {}, "source": ["# Array-2 > sameEnds"]},
{"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["/*\n", "Return true if the group of N numbers at the start and end of the array are the\n", "same. For example, with {5, 6, 45, 99, 13, 5, 6}, the ends are the same for n=0\n", "and n=2, and false for n=1 and n=3. You may assume that n is in the range\n", "0..nums.length inclusive.\n", "\n", "sameEnds([5, 6, 45, 99, 13, 5, 6], 1) \u2192 false\n", "sameEnds([5, 6, 45, 99, 13, 5, 6], 2) \u2192 true\n", "sameEnds([5, 6, 45, 99, 13, 5, 6], 3) \u2192 false\n", "*/\n", "\n", "bool sameEnds(vector<int> nums, int len) {\n", "    return false;\n", "}\n", "\n", "\n", "// tests:\n", "printTest( \"sameEnds([5, 6, 45, 99, 13, 5, 6], 1) \u2192 false\", sameEnds({5, 6, 45, 99, 13, 5, 6}, 1), false );\n", "printTest( \"sameEnds([5, 6, 45, 99, 13, 5, 6], 2) \u2192 true\", sameEnds({5, 6, 45, 99, 13, 5, 6}, 2), true );\n", "printTest( \"sameEnds([5, 6, 45, 99, 13, 5, 6], 3) \u2192 false\", sameEnds({5, 6, 45, 99, 13, 5, 6}, 3), false );\n", "printTest( \"sameEnds([1, 2, 5, 2, 1], 1) \u2192 true\", sameEnds({1, 2, 5, 2, 1}, 1), true );\n", "printTest( \"sameEnds([1, 2, 5, 2, 1], 2) \u2192 false\", sameEnds({1, 2, 5, 2, 1}, 2), false );\n", "printTest( \"sameEnds([1, 2, 5, 2, 1], 0) \u2192 true\", sameEnds({1, 2, 5, 2, 1}, 0), true );\n", "printTest( \"sameEnds([1, 2, 5, 2, 1], 5) \u2192 true\", sameEnds({1, 2, 5, 2, 1}, 5), true );\n", "printTest( \"sameEnds([1, 1, 1], 0) \u2192 true\", sameEnds({1, 1, 1}, 0), true );\n", "printTest( \"sameEnds([1, 1, 1], 1) \u2192 true\", sameEnds({1, 1, 1}, 1), true );\n", "printTest( \"sameEnds([1, 1, 1], 2) \u2192 true\", sameEnds({1, 1, 1}, 2), true );\n", "printTest( \"sameEnds([1, 1, 1], 3) \u2192 true\", sameEnds({1, 1, 1}, 3), true );\n", "printTest( \"sameEnds([1], 1) \u2192 true\", sameEnds({1}, 1), true );\n", "printTest( \"sameEnds([], 0) \u2192 true\", sameEnds({}, 0), true );\n", "printTest( \"sameEnds([4, 2, 4, 5], 1) \u2192 false\", sameEnds({4, 2, 4, 5}, 1), false );"]},
{"cell_type": "markdown", "metadata": {}, "source": ["# Array-2 > tripleUp"]},
{"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["/*\n", "Return true if the array contains, somewhere, three increasing adjacent numbers\n", "like .... 4, 5, 6, ... or 23, 24, 25.\n", "\n", "tripleUp([1, 4, 5, 6, 2]) \u2192 true\n", "tripleUp([1, 2, 3]) \u2192 true\n", "tripleUp([1, 2, 4]) \u2192 false\n", "*/\n", "\n", "bool tripleUp(vector<int> nums) {\n", "    return false;\n", "}\n", "\n", "\n", "// tests:\n", "printTest( \"tripleUp([1, 4, 5, 6, 2]) \u2192 true\", tripleUp({1, 4, 5, 6, 2}), true );\n", "printTest( \"tripleUp([1, 2, 3]) \u2192 true\", tripleUp({1, 2, 3}), true );\n", "printTest( \"tripleUp([1, 2, 4]) \u2192 false\", tripleUp({1, 2, 4}), false );\n", "printTest( \"tripleUp([1, 2, 4, 5, 7, 6, 5, 6, 7, 6]) \u2192 true\", tripleUp({1, 2, 4, 5, 7, 6, 5, 6, 7, 6}), true );\n", "printTest( \"tripleUp([1, 2, 4, 5, 7, 6, 5, 7, 7, 6]) \u2192 false\", tripleUp({1, 2, 4, 5, 7, 6, 5, 7, 7, 6}), false );\n", "printTest( \"tripleUp([1, 2]) \u2192 false\", tripleUp({1, 2}), false );\n", "printTest( \"tripleUp([1]) \u2192 false\", tripleUp({1}), false );\n", "printTest( \"tripleUp([]) \u2192 false\", tripleUp({}), false );\n", "printTest( \"tripleUp([10, 9, 8, -100, -99, -98, 100]) \u2192 true\", tripleUp({10, 9, 8, -100, -99, -98, 100}), true );\n", "printTest( \"tripleUp([10, 9, 8, -100, -99, 99, 100]) \u2192 false\", tripleUp({10, 9, 8, -100, -99, 99, 100}), false );\n", "printTest( \"tripleUp([-100, -99, -99, 100, 101, 102]) \u2192 true\", tripleUp({-100, -99, -99, 100, 101, 102}), true );\n", "printTest( \"tripleUp([2, 3, 5, 6, 8, 9, 2, 3]) \u2192 false\", tripleUp({2, 3, 5, 6, 8, 9, 2, 3}), false );"]},
{"cell_type": "markdown", "metadata": {}, "source": ["# Array-2 > fizzArray3"]},
{"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["/*\n", "Given start and end numbers, return a new array containing the sequence of\n", "integers from start up to but not including end, so start=5 and end=10 yields\n", "{5, 6, 7, 8, 9}. The end number will be greater or equal to the start number.\n", "Note that a length-0 array is valid. (See also: FizzBuzz Code)\n", "\n", "fizzArray3(5, 10) \u2192 [5, 6, 7, 8, 9]\n", "fizzArray3(11, 18) \u2192 [11, 12, 13, 14, 15, 16, 17]\n", "fizzArray3(1, 3) \u2192 [1, 2]\n", "*/\n", "\n", "std::vector<int> fizzArray3(int start, int end) {\n", "    return vector<int>{};\n", "}\n", "\n", "\n", "// tests:\n", "printTest( \"fizzArray3(5, 10) \u2192 [5, 6, 7, 8, 9]\", fizzArray3(5, 10), {5, 6, 7, 8, 9} );\n", "printTest( \"fizzArray3(11, 18) \u2192 [11, 12, 13, 14, 15, 16, 17]\", fizzArray3(11, 18), {11, 12, 13, 14, 15, 16, 17} );\n", "printTest( \"fizzArray3(1, 3) \u2192 [1, 2]\", fizzArray3(1, 3), {1, 2} );\n", "printTest( \"fizzArray3(1, 2) \u2192 [1]\", fizzArray3(1, 2), {1} );\n", "printTest( \"fizzArray3(1, 1) \u2192 []\", fizzArray3(1, 1), {} );\n", "printTest( \"fizzArray3(1000, 1005) \u2192 [1000, 1001, 1002, 1003, 1004]\", fizzArray3(1000, 1005), {1000, 1001, 1002, 1003, 1004} );"]},
{"cell_type": "markdown", "metadata": {}, "source": ["# Array-2 > shiftLeft"]},
{"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["/*\n", "Return an array that is \"left shifted\" by one -- so {6, 2, 5, 3} returns {2, 5,\n", "3, 6}. You may modify and return the given array, or return a new array.\n", "\n", "shiftLeft([6, 2, 5, 3]) \u2192 [2, 5, 3, 6]\n", "shiftLeft([1, 2]) \u2192 [2, 1]\n", "shiftLeft([1]) \u2192 [1]\n", "*/\n", "\n", "std::vector<int> shiftLeft(vector<int> nums) {\n", "    return vector<int>{};\n", "}\n", "\n", "\n", "// tests:\n", "printTest( \"shiftLeft([6, 2, 5, 3]) \u2192 [2, 5, 3, 6]\", shiftLeft({6, 2, 5, 3}), {2, 5, 3, 6} );\n", "printTest( \"shiftLeft([1, 2]) \u2192 [2, 1]\", shiftLeft({1, 2}), {2, 1} );\n", "printTest( \"shiftLeft([1]) \u2192 [1]\", shiftLeft({1}), {1} );\n", "printTest( \"shiftLeft([]) \u2192 []\", shiftLeft({}), {} );\n", "printTest( \"shiftLeft([1, 1, 2, 2, 4]) \u2192 [1, 2, 2, 4, 1]\", shiftLeft({1, 1, 2, 2, 4}), {1, 2, 2, 4, 1} );\n", "printTest( \"shiftLeft([1, 1, 1]) \u2192 [1, 1, 1]\", shiftLeft({1, 1, 1}), {1, 1, 1} );\n", "printTest( \"shiftLeft([1, 2, 3]) \u2192 [2, 3, 1]\", shiftLeft({1, 2, 3}), {2, 3, 1} );"]},
{"cell_type": "markdown", "metadata": {}, "source": ["# Array-2 > tenRun"]},
{"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["/*\n", "For each multiple of 10 in the given array, change all the values following it\n", "to be that multiple of 10, until encountering another multiple of 10. So {2, 10,\n", "3, 4, 20, 5} yields {2, 10, 10, 10, 20, 20}.\n", "\n", "tenRun([2, 10, 3, 4, 20, 5]) \u2192 [2, 10, 10, 10, 20, 20]\n", "tenRun([10, 1, 20, 2]) \u2192 [10, 10, 20, 20]\n", "tenRun([10, 1, 9, 20]) \u2192 [10, 10, 10, 20]\n", "*/\n", "\n", "std::vector<int> tenRun(vector<int> nums) {\n", "    return vector<int>{};\n", "}\n", "\n", "\n", "// tests:\n", "printTest( \"tenRun([2, 10, 3, 4, 20, 5]) \u2192 [2, 10, 10, 10, 20, 20]\", tenRun({2, 10, 3, 4, 20, 5}), {2, 10, 10, 10, 20, 20} );\n", "printTest( \"tenRun([10, 1, 20, 2]) \u2192 [10, 10, 20, 20]\", tenRun({10, 1, 20, 2}), {10, 10, 20, 20} );\n", "printTest( \"tenRun([10, 1, 9, 20]) \u2192 [10, 10, 10, 20]\", tenRun({10, 1, 9, 20}), {10, 10, 10, 20} );\n", "printTest( \"tenRun([1, 2, 50, 1]) \u2192 [1, 2, 50, 50]\", tenRun({1, 2, 50, 1}), {1, 2, 50, 50} );\n", "printTest( \"tenRun([1, 20, 50, 1]) \u2192 [1, 20, 50, 50]\", tenRun({1, 20, 50, 1}), {1, 20, 50, 50} );\n", "printTest( \"tenRun([10, 10]) \u2192 [10, 10]\", tenRun({10, 10}), {10, 10} );\n", "printTest( \"tenRun([10, 2]) \u2192 [10, 10]\", tenRun({10, 2}), {10, 10} );\n", "printTest( \"tenRun([0, 2]) \u2192 [0, 0]\", tenRun({0, 2}), {0, 0} );\n", "printTest( \"tenRun([1, 2]) \u2192 [1, 2]\", tenRun({1, 2}), {1, 2} );\n", "printTest( \"tenRun([1]) \u2192 [1]\", tenRun({1}), {1} );\n", "printTest( \"tenRun([]) \u2192 []\", tenRun({}), {} );"]},
{"cell_type": "markdown", "metadata": {}, "source": ["# Array-2 > pre4"]},
{"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["/*\n", "Given a non-empty array of ints, return a new array containing the elements from\n", "the original array that come before the first 4 in the original array. The\n", "original array will contain at least one 4. Note that it is valid in java to\n", "create an array of length 0.\n", "\n", "pre4([1, 2, 4, 1]) \u2192 [1, 2]\n", "pre4([3, 1, 4]) \u2192 [3, 1]\n", "pre4([1, 4, 4]) \u2192 [1]\n", "*/\n", "\n", "std::vector<int> pre4(vector<int> nums) {\n", "    return vector<int>{};\n", "}\n", "\n", "\n", "// tests:\n", "printTest( \"pre4([1, 2, 4, 1]) \u2192 [1, 2]\", pre4({1, 2, 4, 1}), {1, 2} );\n", "printTest( \"pre4([3, 1, 4]) \u2192 [3, 1]\", pre4({3, 1, 4}), {3, 1} );\n", "printTest( \"pre4([1, 4, 4]) \u2192 [1]\", pre4({1, 4, 4}), {1} );\n", "printTest( \"pre4([1, 4, 4, 2]) \u2192 [1]\", pre4({1, 4, 4, 2}), {1} );\n", "printTest( \"pre4([1, 3, 4, 2, 4]) \u2192 [1, 3]\", pre4({1, 3, 4, 2, 4}), {1, 3} );\n", "printTest( \"pre4([4, 4]) \u2192 []\", pre4({4, 4}), {} );\n", "printTest( \"pre4([3, 3, 4]) \u2192 [3, 3]\", pre4({3, 3, 4}), {3, 3} );\n", "printTest( \"pre4([1, 2, 1, 4]) \u2192 [1, 2, 1]\", pre4({1, 2, 1, 4}), {1, 2, 1} );\n", "printTest( \"pre4([2, 1, 4, 2]) \u2192 [2, 1]\", pre4({2, 1, 4, 2}), {2, 1} );\n", "printTest( \"pre4([2, 1, 2, 1, 4, 2]) \u2192 [2, 1, 2, 1]\", pre4({2, 1, 2, 1, 4, 2}), {2, 1, 2, 1} );"]},
{"cell_type": "markdown", "metadata": {}, "source": ["# Array-2 > post4"]},
{"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["/*\n", "Given a non-empty array of ints, return a new array containing the elements from\n", "the original array that come after the last 4 in the original array. The\n", "original array will contain at least one 4. Note that it is valid in java to\n", "create an array of length 0.\n", "\n", "post4([2, 4, 1, 2]) \u2192 [1, 2]\n", "post4([4, 1, 4, 2]) \u2192 [2]\n", "post4([4, 4, 1, 2, 3]) \u2192 [1, 2, 3]\n", "*/\n", "\n", "std::vector<int> post4(vector<int> nums) {\n", "    return vector<int>{};\n", "}\n", "\n", "\n", "// tests:\n", "printTest( \"post4([2, 4, 1, 2]) \u2192 [1, 2]\", post4({2, 4, 1, 2}), {1, 2} );\n", "printTest( \"post4([4, 1, 4, 2]) \u2192 [2]\", post4({4, 1, 4, 2}), {2} );\n", "printTest( \"post4([4, 4, 1, 2, 3]) \u2192 [1, 2, 3]\", post4({4, 4, 1, 2, 3}), {1, 2, 3} );\n", "printTest( \"post4([4, 2]) \u2192 [2]\", post4({4, 2}), {2} );\n", "printTest( \"post4([4, 4, 3]) \u2192 [3]\", post4({4, 4, 3}), {3} );\n", "printTest( \"post4([4, 4]) \u2192 []\", post4({4, 4}), {} );\n", "printTest( \"post4([4]) \u2192 []\", post4({4}), {} );\n", "printTest( \"post4([2, 4, 1, 4, 3, 2]) \u2192 [3, 2]\", post4({2, 4, 1, 4, 3, 2}), {3, 2} );\n", "printTest( \"post4([4, 1, 4, 2, 2, 2]) \u2192 [2, 2, 2]\", post4({4, 1, 4, 2, 2, 2}), {2, 2, 2} );\n", "printTest( \"post4([3, 4, 3, 2]) \u2192 [3, 2]\", post4({3, 4, 3, 2}), {3, 2} );"]},
{"cell_type": "markdown", "metadata": {}, "source": ["# Array-2 > notAlone"]},
{"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["/*\n", "We\u02bcll say that an element in an array is \"alone\" if there are values before and\n", "after it, and those values are different from it. Return a version of the given\n", "array where every instance of the given value which is alone is replaced by\n", "whichever value to its left or right is larger.\n", "\n", "notAlone([1, 2, 3], 2) \u2192 [1, 3, 3]\n", "notAlone([1, 2, 3, 2, 5, 2], 2) \u2192 [1, 3, 3, 5, 5, 2]\n", "notAlone([3, 4], 3) \u2192 [3, 4]\n", "*/\n", "\n", "std::vector<int> notAlone(vector<int> nums, int val) {\n", "    return vector<int>{};\n", "}\n", "\n", "\n", "// tests:\n", "printTest( \"notAlone([1, 2, 3], 2) \u2192 [1, 3, 3]\", notAlone({1, 2, 3}, 2), {1, 3, 3} );\n", "printTest( \"notAlone([1, 2, 3, 2, 5, 2], 2) \u2192 [1, 3, 3, 5, 5, 2]\", notAlone({1, 2, 3, 2, 5, 2}, 2), {1, 3, 3, 5, 5, 2} );\n", "printTest( \"notAlone([3, 4], 3) \u2192 [3, 4]\", notAlone({3, 4}, 3), {3, 4} );\n", "printTest( \"notAlone([3, 3], 3) \u2192 [3, 3]\", notAlone({3, 3}, 3), {3, 3} );\n", "printTest( \"notAlone([1, 3, 1, 2], 1) \u2192 [1, 3, 3, 2]\", notAlone({1, 3, 1, 2}, 1), {1, 3, 3, 2} );\n", "printTest( \"notAlone([3], 3) \u2192 [3]\", notAlone({3}, 3), {3} );\n", "printTest( \"notAlone([], 3) \u2192 []\", notAlone({}, 3), {} );\n", "printTest( \"notAlone([7, 1, 6], 1) \u2192 [7, 7, 6]\", notAlone({7, 1, 6}, 1), {7, 7, 6} );\n", "printTest( \"notAlone([1, 1, 1], 1) \u2192 [1, 1, 1]\", notAlone({1, 1, 1}, 1), {1, 1, 1} );\n", "printTest( \"notAlone([1, 1, 1, 2], 1) \u2192 [1, 1, 1, 2]\", notAlone({1, 1, 1, 2}, 1), {1, 1, 1, 2} );"]},
{"cell_type": "markdown", "metadata": {}, "source": ["# Array-2 > zeroFront"]},
{"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["/*\n", "Return an array that contains the exact same numbers as the given array, but\n", "rearranged so that all the zeros are grouped at the start of the array. The\n", "order of the non-zero numbers does not matter. So {1, 0, 0, 1} becomes {0 ,0, 1,\n", "1}. You may modify and return the given array or make a new array.\n", "\n", "zeroFront([1, 0, 0, 1]) \u2192 [0, 0, 1, 1]\n", "zeroFront([0, 1, 1, 0, 1]) \u2192 [0, 0, 1, 1, 1]\n", "zeroFront([1, 0]) \u2192 [0, 1]\n", "*/\n", "\n", "std::vector<int> zeroFront(vector<int> nums) {\n", "    return vector<int>{};\n", "}\n", "\n", "\n", "// tests:\n", "printTest( \"zeroFront([1, 0, 0, 1]) \u2192 [0, 0, 1, 1]\", zeroFront({1, 0, 0, 1}), {0, 0, 1, 1} );\n", "printTest( \"zeroFront([0, 1, 1, 0, 1]) \u2192 [0, 0, 1, 1, 1]\", zeroFront({0, 1, 1, 0, 1}), {0, 0, 1, 1, 1} );\n", "printTest( \"zeroFront([1, 0]) \u2192 [0, 1]\", zeroFront({1, 0}), {0, 1} );\n", "printTest( \"zeroFront([0, 1]) \u2192 [0, 1]\", zeroFront({0, 1}), {0, 1} );\n", "printTest( \"zeroFront([1, 1, 1, 0]) \u2192 [0, 1, 1, 1]\", zeroFront({1, 1, 1, 0}), {0, 1, 1, 1} );\n", "printTest( \"zeroFront([2, 2, 2, 2]) \u2192 [2, 2, 2, 2]\", zeroFront({2, 2, 2, 2}), {2, 2, 2, 2} );\n", "printTest( \"zeroFront([0, 0, 1, 0]) \u2192 [0, 0, 0, 1]\", zeroFront({0, 0, 1, 0}), {0, 0, 0, 1} );\n", "printTest( \"zeroFront([-1, 0, 0, -1, 0]) \u2192 [0, 0, 0, -1, -1]\", zeroFront({-1, 0, 0, -1, 0}), {0, 0, 0, -1, -1} );\n", "printTest( \"zeroFront([0, -3, 0, -3]) \u2192 [0, 0, -3, -3]\", zeroFront({0, -3, 0, -3}), {0, 0, -3, -3} );\n", "printTest( \"zeroFront([]) \u2192 []\", zeroFront({}), {} );\n", "printTest( \"zeroFront([9, 9, 0, 9, 0, 9]) \u2192 [0, 0, 9, 9, 9, 9]\", zeroFront({9, 9, 0, 9, 0, 9}), {0, 0, 9, 9, 9, 9} );"]},
{"cell_type": "markdown", "metadata": {}, "source": ["# Array-2 > withoutTen"]},
{"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["/*\n", "Return a version of the given array where all the 10\u02bcs have been removed. The\n", "remaining elements should shift left towards the start of the array as needed,\n", "and the empty spaces a the end of the array should be 0. So {1, 10, 10, 2}\n", "yields {1, 2, 0, 0}. You may modify and return the given array or make a new\n", "array.\n", "\n", "withoutTen([1, 10, 10, 2]) \u2192 [1, 2, 0, 0]\n", "withoutTen([10, 2, 10]) \u2192 [2, 0, 0]\n", "withoutTen([1, 99, 10]) \u2192 [1, 99, 0]\n", "*/\n", "\n", "std::vector<int> withoutTen(vector<int> nums) {\n", "    return vector<int>{};\n", "}\n", "\n", "\n", "// tests:\n", "printTest( \"withoutTen([1, 10, 10, 2]) \u2192 [1, 2, 0, 0]\", withoutTen({1, 10, 10, 2}), {1, 2, 0, 0} );\n", "printTest( \"withoutTen([10, 2, 10]) \u2192 [2, 0, 0]\", withoutTen({10, 2, 10}), {2, 0, 0} );\n", "printTest( \"withoutTen([1, 99, 10]) \u2192 [1, 99, 0]\", withoutTen({1, 99, 10}), {1, 99, 0} );\n", "printTest( \"withoutTen([10, 13, 10, 14]) \u2192 [13, 14, 0, 0]\", withoutTen({10, 13, 10, 14}), {13, 14, 0, 0} );\n", "printTest( \"withoutTen([10, 13, 10, 14, 10]) \u2192 [13, 14, 0, 0, 0]\", withoutTen({10, 13, 10, 14, 10}), {13, 14, 0, 0, 0} );\n", "printTest( \"withoutTen([10, 10, 3]) \u2192 [3, 0, 0]\", withoutTen({10, 10, 3}), {3, 0, 0} );\n", "printTest( \"withoutTen([1]) \u2192 [1]\", withoutTen({1}), {1} );\n", "printTest( \"withoutTen([13, 1]) \u2192 [13, 1]\", withoutTen({13, 1}), {13, 1} );\n", "printTest( \"withoutTen([10]) \u2192 [0]\", withoutTen({10}), {0} );\n", "printTest( \"withoutTen([]) \u2192 []\", withoutTen({}), {} );"]},
{"cell_type": "markdown", "metadata": {}, "source": ["# Array-2 > zeroMax"]},
{"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["/*\n", "Return a version of the given array where each zero value in the array is\n", "replaced by the largest odd value to the right of the zero in the array. If\n", "there is no odd value to the right of the zero, leave the zero as a zero.\n", "\n", "zeroMax([0, 5, 0, 3]) \u2192 [5, 5, 3, 3]\n", "zeroMax([0, 4, 0, 3]) \u2192 [3, 4, 3, 3]\n", "zeroMax([0, 1, 0]) \u2192 [1, 1, 0]\n", "*/\n", "\n", "std::vector<int> zeroMax(vector<int> nums) {\n", "    return vector<int>{};\n", "}\n", "\n", "\n", "// tests:\n", "printTest( \"zeroMax([0, 5, 0, 3]) \u2192 [5, 5, 3, 3]\", zeroMax({0, 5, 0, 3}), {5, 5, 3, 3} );\n", "printTest( \"zeroMax([0, 4, 0, 3]) \u2192 [3, 4, 3, 3]\", zeroMax({0, 4, 0, 3}), {3, 4, 3, 3} );\n", "printTest( \"zeroMax([0, 1, 0]) \u2192 [1, 1, 0]\", zeroMax({0, 1, 0}), {1, 1, 0} );\n", "printTest( \"zeroMax([0, 1, 5]) \u2192 [5, 1, 5]\", zeroMax({0, 1, 5}), {5, 1, 5} );\n", "printTest( \"zeroMax([0, 2, 0]) \u2192 [0, 2, 0]\", zeroMax({0, 2, 0}), {0, 2, 0} );\n", "printTest( \"zeroMax([1]) \u2192 [1]\", zeroMax({1}), {1} );\n", "printTest( \"zeroMax([0]) \u2192 [0]\", zeroMax({0}), {0} );\n", "printTest( \"zeroMax([]) \u2192 []\", zeroMax({}), {} );\n", "printTest( \"zeroMax([7, 0, 4, 3, 0, 2]) \u2192 [7, 3, 4, 3, 0, 2]\", zeroMax({7, 0, 4, 3, 0, 2}), {7, 3, 4, 3, 0, 2} );\n", "printTest( \"zeroMax([7, 0, 4, 3, 0, 1]) \u2192 [7, 3, 4, 3, 1, 1]\", zeroMax({7, 0, 4, 3, 0, 1}), {7, 3, 4, 3, 1, 1} );\n", "printTest( \"zeroMax([7, 0, 4, 3, 0, 0]) \u2192 [7, 3, 4, 3, 0, 0]\", zeroMax({7, 0, 4, 3, 0, 0}), {7, 3, 4, 3, 0, 0} );\n", "printTest( \"zeroMax([7, 0, 1, 0, 0, 7]) \u2192 [7, 7, 1, 7, 7, 7]\", zeroMax({7, 0, 1, 0, 0, 7}), {7, 7, 1, 7, 7, 7} );"]},
{"cell_type": "markdown", "metadata": {}, "source": ["# Array-2 > evenOdd"]},
{"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["/*\n", "Return an array that contains the exact same numbers as the given array, but\n", "rearranged so that all the even numbers come before all the odd numbers. Other\n", "than that, the numbers can be in any order. You may modify and return the given\n", "array, or make a new array.\n", "\n", "evenOdd([1, 0, 1, 0, 0, 1, 1]) \u2192 [0, 0, 0, 1, 1, 1, 1]\n", "evenOdd([3, 3, 2]) \u2192 [2, 3, 3]\n", "evenOdd([2, 2, 2]) \u2192 [2, 2, 2]\n", "*/\n", "\n", "std::vector<int> evenOdd(vector<int> nums) {\n", "    return vector<int>{};\n", "}\n", "\n", "\n", "// tests:\n", "printTest( \"evenOdd([1, 0, 1, 0, 0, 1, 1]) \u2192 [0, 0, 0, 1, 1, 1, 1]\", evenOdd({1, 0, 1, 0, 0, 1, 1}), {0, 0, 0, 1, 1, 1, 1} );\n", "printTest( \"evenOdd([3, 3, 2]) \u2192 [2, 3, 3]\", evenOdd({3, 3, 2}), {2, 3, 3} );\n", "printTest( \"evenOdd([2, 2, 2]) \u2192 [2, 2, 2]\", evenOdd({2, 2, 2}), {2, 2, 2} );\n", "printTest( \"evenOdd([3, 2, 2]) \u2192 [2, 2, 3]\", evenOdd({3, 2, 2}), {2, 2, 3} );\n", "printTest( \"evenOdd([1, 1, 0, 1, 0]) \u2192 [0, 0, 1, 1, 1]\", evenOdd({1, 1, 0, 1, 0}), {0, 0, 1, 1, 1} );\n", "printTest( \"evenOdd([1]) \u2192 [1]\", evenOdd({1}), {1} );\n", "printTest( \"evenOdd([1, 2]) \u2192 [2, 1]\", evenOdd({1, 2}), {2, 1} );\n", "printTest( \"evenOdd([2, 1]) \u2192 [2, 1]\", evenOdd({2, 1}), {2, 1} );\n", "printTest( \"evenOdd([]) \u2192 []\", evenOdd({}), {} );"]},
{"cell_type": "markdown", "metadata": {}, "source": ["# Array-2 > fizzBuzz"]},
{"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["/*\n", "This is slightly more difficult version of the famous FizzBuzz problem which is\n", "sometimes given as a first problem for job interviews. (See also: FizzBuzz\n", "Code.) Consider the series of numbers beginning at start and running up to but\n", "not including end, so for example start=1 and end=5 gives the series 1, 2, 3, 4.\n", "Return a new String[] array containing the string form of these numbers, except\n", "for multiples of 3, use \"Fizz\" instead of the number, for multiples of 5 use\n", "\"Buzz\", and for multiples of both 3 and 5 use \"FizzBuzz\". In Java,\n", "String.valueOf(xxx) will make the String form of an int or other type. This\n", "version is a little more complicated than the usual version since you have to\n", "allocate and index into an array instead of just printing, and we vary the\n", "start/end instead of just always doing 1..100.\n", "\n", "fizzBuzz(1, 6) \u2192 [\"1\", \"2\", \"Fizz\", \"4\", \"Buzz\"]\n", "fizzBuzz(1, 8) \u2192 [\"1\", \"2\", \"Fizz\", \"4\", \"Buzz\", \"Fizz\", \"7\"]\n", "fizzBuzz(1, 11) \u2192 [\"1\", \"2\", \"Fizz\", \"4\", \"Buzz\", \"Fizz\", \"7\", \"8\", \"Fizz\",\n", "\"Buzz\"]\n", "*/\n", "\n", "std::vector<string> fizzBuzz(int start, int end) {\n", "    return new vector<string>{};\n", "}\n", "\n", "\n", "// tests:\n", "printTest( \"fizzBuzz(1, 6) \u2192 [\\\"1\\\", \\\"2\\\", \\\"Fizz\\\", \\\"4\\\", \\\"Buzz\\\"]\", fizzBuzz(1, 6), {\"1\", \"2\", \"Fizz\", \"4\", \"Buzz\"} );\n", "printTest( \"fizzBuzz(1, 8) \u2192 [\\\"1\\\", \\\"2\\\", \\\"Fizz\\\", \\\"4\\\", \\\"Buzz\\\", \\\"Fizz\\\", \\\"7\\\"]\", fizzBuzz(1, 8), {\"1\", \"2\", \"Fizz\", \"4\", \"Buzz\", \"Fizz\", \"7\"} );\n", "printTest( \"fizzBuzz(1, 11) \u2192 [\\\"1\\\", \\\"2\\\", \\\"Fizz\\\", \\\"4\\\", \\\"Buzz\\\", \\\"Fizz\\\", \\\"7\\\", \\\"8\\\", \\\"Fizz\\\", \\\"Buzz\\\"]\", fizzBuzz(1, 11), {\"1\", \"2\", \"Fizz\", \"4\", \"Buzz\", \"Fizz\", \"7\", \"8\", \"Fizz\", \"Buzz\"} );\n", "printTest( \"fizzBuzz(1, 16) \u2192 [\\\"1\\\", \\\"2\\\", \\\"Fizz\\\", \\\"4\\\", \\\"Buzz\\\", \\\"Fizz\\\", \\\"7\\\", \\\"8\\\", \\\"Fizz\\\", \\\"Buzz\\\", \\\"11\\\", \\\"Fizz\\\", \\\"13\\\", \\\"14\\\", \\\"FizzBuzz\\\"]\", fizzBuzz(1, 16), {\"1\", \"2\", \"Fizz\", \"4\", \"Buzz\", \"Fizz\", \"7\", \"8\", \"Fizz\", \"Buzz\", \"11\", \"Fizz\", \"13\", \"14\", \"FizzBuzz\"} );\n", "printTest( \"fizzBuzz(1, 4) \u2192 [\\\"1\\\", \\\"2\\\", \\\"Fizz\\\"]\", fizzBuzz(1, 4), {\"1\", \"2\", \"Fizz\"} );\n", "printTest( \"fizzBuzz(1, 2) \u2192 [\\\"1\\\"]\", fizzBuzz(1, 2), {\"1\"} );\n", "printTest( \"fizzBuzz(50, 56) \u2192 [\\\"Buzz\\\", \\\"Fizz\\\", \\\"52\\\", \\\"53\\\", \\\"Fizz\\\", \\\"Buzz\\\"]\", fizzBuzz(50, 56), {\"Buzz\", \"Fizz\", \"52\", \"53\", \"Fizz\", \"Buzz\"} );\n", "printTest( \"fizzBuzz(15, 17) \u2192 [\\\"FizzBuzz\\\", \\\"16\\\"]\", fizzBuzz(15, 17), {\"FizzBuzz\", \"16\"} );\n", "printTest( \"fizzBuzz(30, 36) \u2192 [\\\"FizzBuzz\\\", \\\"31\\\", \\\"32\\\", \\\"Fizz\\\", \\\"34\\\", \\\"Buzz\\\"]\", fizzBuzz(30, 36), {\"FizzBuzz\", \"31\", \"32\", \"Fizz\", \"34\", \"Buzz\"} );\n", "printTest( \"fizzBuzz(1000, 1006) \u2192 [\\\"Buzz\\\", \\\"1001\\\", \\\"Fizz\\\", \\\"1003\\\", \\\"1004\\\", \\\"FizzBuzz\\\"]\", fizzBuzz(1000, 1006), {\"Buzz\", \"1001\", \"Fizz\", \"1003\", \"1004\", \"FizzBuzz\"} );\n", "printTest( \"fizzBuzz(99, 102) \u2192 [\\\"Fizz\\\", \\\"Buzz\\\", \\\"101\\\"]\", fizzBuzz(99, 102), {\"Fizz\", \"Buzz\", \"101\"} );\n", "printTest( \"fizzBuzz(14, 20) \u2192 [\\\"14\\\", \\\"FizzBuzz\\\", \\\"16\\\", \\\"17\\\", \\\"Fizz\\\", \\\"19\\\"]\", fizzBuzz(14, 20), {\"14\", \"FizzBuzz\", \"16\", \"17\", \"Fizz\", \"19\"} );"]}
 ],
 "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
}