cpp-codingbat-07-String-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": ["# String-2 > doubleChar"]},
{"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["/*\n", "Given a string, return a string where for every char in the original, there are\n", "two chars.\n", "\n", "doubleChar(\"The\") \u2192 \"TThhee\"\n", "doubleChar(\"AAbb\") \u2192 \"AAAAbbbb\"\n", "doubleChar(\"Hi-There\") \u2192 \"HHii--TThheerree\"\n", "*/\n", "\n", "string doubleChar(string str) {\n", "    return \"\";\n", "}\n", "\n", "\n", "// tests:\n", "printTest( \"doubleChar(\\\"The\\\") \u2192 \\\"TThhee\\\"\", doubleChar(\"The\"), \"TThhee\" );\n", "printTest( \"doubleChar(\\\"AAbb\\\") \u2192 \\\"AAAAbbbb\\\"\", doubleChar(\"AAbb\"), \"AAAAbbbb\" );\n", "printTest( \"doubleChar(\\\"Hi-There\\\") \u2192 \\\"HHii--TThheerree\\\"\", doubleChar(\"Hi-There\"), \"HHii--TThheerree\" );\n", "printTest( \"doubleChar(\\\"Word!\\\") \u2192 \\\"WWoorrdd!!\\\"\", doubleChar(\"Word!\"), \"WWoorrdd!!\" );\n", "printTest( \"doubleChar(\\\"!!\\\") \u2192 \\\"!!!!\\\"\", doubleChar(\"!!\"), \"!!!!\" );\n", "printTest( \"doubleChar(\\\"\\\") \u2192 \\\"\\\"\", doubleChar(\"\"), \"\" );\n", "printTest( \"doubleChar(\\\"a\\\") \u2192 \\\"aa\\\"\", doubleChar(\"a\"), \"aa\" );\n", "printTest( \"doubleChar(\\\".\\\") \u2192 \\\"..\\\"\", doubleChar(\".\"), \"..\" );\n", "printTest( \"doubleChar(\\\"aa\\\") \u2192 \\\"aaaa\\\"\", doubleChar(\"aa\"), \"aaaa\" );"]},
{"cell_type": "markdown", "metadata": {}, "source": ["# String-2 > countHi"]},
{"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["/*\n", "Return the number of times that the string \"hi\" appears anywhere in the given\n", "string.\n", "\n", "countHi(\"abc hi ho\") \u2192 1\n", "countHi(\"ABChi hi\") \u2192 2\n", "countHi(\"hihi\") \u2192 2\n", "*/\n", "\n", "int countHi(string str) {\n", "    return 0;\n", "}\n", "\n", "\n", "// tests:\n", "printTest( \"countHi(\\\"abc hi ho\\\") \u2192 1\", countHi(\"abc hi ho\"), 1 );\n", "printTest( \"countHi(\\\"ABChi hi\\\") \u2192 2\", countHi(\"ABChi hi\"), 2 );\n", "printTest( \"countHi(\\\"hihi\\\") \u2192 2\", countHi(\"hihi\"), 2 );\n", "printTest( \"countHi(\\\"hiHIhi\\\") \u2192 2\", countHi(\"hiHIhi\"), 2 );\n", "printTest( \"countHi(\\\"\\\") \u2192 0\", countHi(\"\"), 0 );\n", "printTest( \"countHi(\\\"h\\\") \u2192 0\", countHi(\"h\"), 0 );\n", "printTest( \"countHi(\\\"hi\\\") \u2192 1\", countHi(\"hi\"), 1 );\n", "printTest( \"countHi(\\\"Hi is no HI on ahI\\\") \u2192 0\", countHi(\"Hi is no HI on ahI\"), 0 );\n", "printTest( \"countHi(\\\"hiho not HOHIhi\\\") \u2192 2\", countHi(\"hiho not HOHIhi\"), 2 );"]},
{"cell_type": "markdown", "metadata": {}, "source": ["# String-2 > catDog"]},
{"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["/*\n", "Return true if the string \"cat\" and \"dog\" appear the same number of times in the\n", "given string.\n", "\n", "catDog(\"catdog\") \u2192 true\n", "catDog(\"catcat\") \u2192 false\n", "catDog(\"1cat1cadodog\") \u2192 true\n", "*/\n", "\n", "bool catDog(string str) {\n", "    return false;\n", "}\n", "\n", "\n", "// tests:\n", "printTest( \"catDog(\\\"catdog\\\") \u2192 true\", catDog(\"catdog\"), true );\n", "printTest( \"catDog(\\\"catcat\\\") \u2192 false\", catDog(\"catcat\"), false );\n", "printTest( \"catDog(\\\"1cat1cadodog\\\") \u2192 true\", catDog(\"1cat1cadodog\"), true );\n", "printTest( \"catDog(\\\"catxxdogxxxdog\\\") \u2192 false\", catDog(\"catxxdogxxxdog\"), false );\n", "printTest( \"catDog(\\\"catxdogxdogxcat\\\") \u2192 true\", catDog(\"catxdogxdogxcat\"), true );\n", "printTest( \"catDog(\\\"catxdogxdogxca\\\") \u2192 false\", catDog(\"catxdogxdogxca\"), false );\n", "printTest( \"catDog(\\\"dogdogcat\\\") \u2192 false\", catDog(\"dogdogcat\"), false );\n", "printTest( \"catDog(\\\"dogogcat\\\") \u2192 true\", catDog(\"dogogcat\"), true );\n", "printTest( \"catDog(\\\"dog\\\") \u2192 false\", catDog(\"dog\"), false );\n", "printTest( \"catDog(\\\"cat\\\") \u2192 false\", catDog(\"cat\"), false );\n", "printTest( \"catDog(\\\"ca\\\") \u2192 true\", catDog(\"ca\"), true );\n", "printTest( \"catDog(\\\"c\\\") \u2192 true\", catDog(\"c\"), true );\n", "printTest( \"catDog(\\\"\\\") \u2192 true\", catDog(\"\"), true );"]},
{"cell_type": "markdown", "metadata": {}, "source": ["# String-2 > countCode"]},
{"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["/*\n", "Return the number of times that the string \"code\" appears anywhere in the given\n", "string, except we\u02bcll accept any letter for the \u02bcd\u02bc, so \"cope\" and \"cooe\" count.\n", "\n", "countCode(\"aaacodebbb\") \u2192 1\n", "countCode(\"codexxcode\") \u2192 2\n", "countCode(\"cozexxcope\") \u2192 2\n", "*/\n", "\n", "int countCode(string str) {\n", "    return 0;\n", "}\n", "\n", "\n", "// tests:\n", "printTest( \"countCode(\\\"aaacodebbb\\\") \u2192 1\", countCode(\"aaacodebbb\"), 1 );\n", "printTest( \"countCode(\\\"codexxcode\\\") \u2192 2\", countCode(\"codexxcode\"), 2 );\n", "printTest( \"countCode(\\\"cozexxcope\\\") \u2192 2\", countCode(\"cozexxcope\"), 2 );\n", "printTest( \"countCode(\\\"cozfxxcope\\\") \u2192 1\", countCode(\"cozfxxcope\"), 1 );\n", "printTest( \"countCode(\\\"xxcozeyycop\\\") \u2192 1\", countCode(\"xxcozeyycop\"), 1 );\n", "printTest( \"countCode(\\\"cozcop\\\") \u2192 0\", countCode(\"cozcop\"), 0 );\n", "printTest( \"countCode(\\\"abcxyz\\\") \u2192 0\", countCode(\"abcxyz\"), 0 );\n", "printTest( \"countCode(\\\"code\\\") \u2192 1\", countCode(\"code\"), 1 );\n", "printTest( \"countCode(\\\"ode\\\") \u2192 0\", countCode(\"ode\"), 0 );\n", "printTest( \"countCode(\\\"c\\\") \u2192 0\", countCode(\"c\"), 0 );\n", "printTest( \"countCode(\\\"\\\") \u2192 0\", countCode(\"\"), 0 );\n", "printTest( \"countCode(\\\"AAcodeBBcoleCCccoreDD\\\") \u2192 3\", countCode(\"AAcodeBBcoleCCccoreDD\"), 3 );\n", "printTest( \"countCode(\\\"AAcodeBBcoleCCccorfDD\\\") \u2192 2\", countCode(\"AAcodeBBcoleCCccorfDD\"), 2 );\n", "printTest( \"countCode(\\\"coAcodeBcoleccoreDD\\\") \u2192 3\", countCode(\"coAcodeBcoleccoreDD\"), 3 );"]},
{"cell_type": "markdown", "metadata": {}, "source": ["# String-2 > endOther"]},
{"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["/*\n", "Given two strings, return true if either of the strings appears at the very end\n", "of the other string, ignoring upper/lower case differences (in other words, the\n", "computation should not be \"case sensitive\"). Note:  str.toLowerCase() returns\n", "the lowercase version of a string.\n", "\n", "endOther(\"Hiabc\", \"abc\") \u2192 true\n", "endOther(\"AbC\", \"HiaBc\") \u2192 true\n", "endOther(\"abc\", \"abXabc\") \u2192 true\n", "*/\n", "\n", "bool endOther(string a, string b) {\n", "    return false;\n", "}\n", "\n", "\n", "// tests:\n", "printTest( \"endOther(\\\"Hiabc\\\", \\\"abc\\\") \u2192 true\", endOther(\"Hiabc\", \"abc\"), true );\n", "printTest( \"endOther(\\\"AbC\\\", \\\"HiaBc\\\") \u2192 true\", endOther(\"AbC\", \"HiaBc\"), true );\n", "printTest( \"endOther(\\\"abc\\\", \\\"abXabc\\\") \u2192 true\", endOther(\"abc\", \"abXabc\"), true );\n", "printTest( \"endOther(\\\"Hiabc\\\", \\\"abcd\\\") \u2192 false\", endOther(\"Hiabc\", \"abcd\"), false );\n", "printTest( \"endOther(\\\"Hiabc\\\", \\\"bc\\\") \u2192 true\", endOther(\"Hiabc\", \"bc\"), true );\n", "printTest( \"endOther(\\\"Hiabcx\\\", \\\"bc\\\") \u2192 false\", endOther(\"Hiabcx\", \"bc\"), false );\n", "printTest( \"endOther(\\\"abc\\\", \\\"abc\\\") \u2192 true\", endOther(\"abc\", \"abc\"), true );\n", "printTest( \"endOther(\\\"xyz\\\", \\\"12xyz\\\") \u2192 true\", endOther(\"xyz\", \"12xyz\"), true );\n", "printTest( \"endOther(\\\"yz\\\", \\\"12xz\\\") \u2192 false\", endOther(\"yz\", \"12xz\"), false );\n", "printTest( \"endOther(\\\"Z\\\", \\\"12xz\\\") \u2192 true\", endOther(\"Z\", \"12xz\"), true );\n", "printTest( \"endOther(\\\"12\\\", \\\"12\\\") \u2192 true\", endOther(\"12\", \"12\"), true );\n", "printTest( \"endOther(\\\"abcXYZ\\\", \\\"abcDEF\\\") \u2192 false\", endOther(\"abcXYZ\", \"abcDEF\"), false );\n", "printTest( \"endOther(\\\"ab\\\", \\\"ab12\\\") \u2192 false\", endOther(\"ab\", \"ab12\"), false );\n", "printTest( \"endOther(\\\"ab\\\", \\\"12ab\\\") \u2192 true\", endOther(\"ab\", \"12ab\"), true );"]},
{"cell_type": "markdown", "metadata": {}, "source": ["# String-2 > xyzThere"]},
{"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["/*\n", "Return true if the given string contains an appearance of \"xyz\" where the xyz is\n", "not directly preceeded by a period (.). So \"xxyz\" counts but \"x.xyz\" does not.\n", "\n", "xyzThere(\"abcxyz\") \u2192 true\n", "xyzThere(\"abc.xyz\") \u2192 false\n", "xyzThere(\"xyz.abc\") \u2192 true\n", "*/\n", "\n", "bool xyzThere(string str) {\n", "    return false;\n", "}\n", "\n", "\n", "// tests:\n", "printTest( \"xyzThere(\\\"abcxyz\\\") \u2192 true\", xyzThere(\"abcxyz\"), true );\n", "printTest( \"xyzThere(\\\"abc.xyz\\\") \u2192 false\", xyzThere(\"abc.xyz\"), false );\n", "printTest( \"xyzThere(\\\"xyz.abc\\\") \u2192 true\", xyzThere(\"xyz.abc\"), true );\n", "printTest( \"xyzThere(\\\"abcxy\\\") \u2192 false\", xyzThere(\"abcxy\"), false );\n", "printTest( \"xyzThere(\\\"xyz\\\") \u2192 true\", xyzThere(\"xyz\"), true );\n", "printTest( \"xyzThere(\\\"xy\\\") \u2192 false\", xyzThere(\"xy\"), false );\n", "printTest( \"xyzThere(\\\"x\\\") \u2192 false\", xyzThere(\"x\"), false );\n", "printTest( \"xyzThere(\\\"\\\") \u2192 false\", xyzThere(\"\"), false );\n", "printTest( \"xyzThere(\\\"abc.xyzxyz\\\") \u2192 true\", xyzThere(\"abc.xyzxyz\"), true );\n", "printTest( \"xyzThere(\\\"abc.xxyz\\\") \u2192 true\", xyzThere(\"abc.xxyz\"), true );\n", "printTest( \"xyzThere(\\\".xyz\\\") \u2192 false\", xyzThere(\".xyz\"), false );\n", "printTest( \"xyzThere(\\\"12.xyz\\\") \u2192 false\", xyzThere(\"12.xyz\"), false );\n", "printTest( \"xyzThere(\\\"12xyz\\\") \u2192 true\", xyzThere(\"12xyz\"), true );\n", "printTest( \"xyzThere(\\\"1.xyz.xyz2.xyz\\\") \u2192 false\", xyzThere(\"1.xyz.xyz2.xyz\"), false );"]},
{"cell_type": "markdown", "metadata": {}, "source": ["# String-2 > bobThere"]},
{"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["/*\n", "Return true if the given string contains a \"bob\" string, but where the middle\n", "'o' char can be any char.\n", "\n", "bobThere(\"abcbob\") \u2192 true\n", "bobThere(\"b9b\") \u2192 true\n", "bobThere(\"bac\") \u2192 false\n", "*/\n", "\n", "bool bobThere(string str) {\n", "    return false;\n", "}\n", "\n", "\n", "// tests:\n", "printTest( \"bobThere(\\\"abcbob\\\") \u2192 true\", bobThere(\"abcbob\"), true );\n", "printTest( \"bobThere(\\\"b9b\\\") \u2192 true\", bobThere(\"b9b\"), true );\n", "printTest( \"bobThere(\\\"bac\\\") \u2192 false\", bobThere(\"bac\"), false );\n", "printTest( \"bobThere(\\\"bbb\\\") \u2192 true\", bobThere(\"bbb\"), true );\n", "printTest( \"bobThere(\\\"abcdefb\\\") \u2192 false\", bobThere(\"abcdefb\"), false );\n", "printTest( \"bobThere(\\\"123abcbcdbabxyz\\\") \u2192 true\", bobThere(\"123abcbcdbabxyz\"), true );\n", "printTest( \"bobThere(\\\"b12\\\") \u2192 false\", bobThere(\"b12\"), false );\n", "printTest( \"bobThere(\\\"b1b\\\") \u2192 true\", bobThere(\"b1b\"), true );\n", "printTest( \"bobThere(\\\"b12b1b\\\") \u2192 true\", bobThere(\"b12b1b\"), true );\n", "printTest( \"bobThere(\\\"bbc\\\") \u2192 false\", bobThere(\"bbc\"), false );\n", "printTest( \"bobThere(\\\"bbb\\\") \u2192 true\", bobThere(\"bbb\"), true );\n", "printTest( \"bobThere(\\\"bb\\\") \u2192 false\", bobThere(\"bb\"), false );\n", "printTest( \"bobThere(\\\"b\\\") \u2192 false\", bobThere(\"b\"), false );"]},
{"cell_type": "markdown", "metadata": {}, "source": ["# String-2 > xyBalance"]},
{"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["/*\n", "We\u02bcll say that a String is xy-balanced if for all the \u02bcx\u02bc chars in the string,\n", "there exists a \u02bcy\u02bc char somewhere later in the string. So \"xxy\" is balanced, but\n", "\"xyx\" is not. One \u02bcy\u02bc can balance multiple \u02bcx\u02bcs. Return true if the given string\n", "is xy-balanced.\n", "\n", "xyBalance(\"aaxbby\") \u2192 true\n", "xyBalance(\"aaxbb\") \u2192 false\n", "xyBalance(\"yaaxbb\") \u2192 false\n", "*/\n", "\n", "bool xyBalance(string str) {\n", "    return false;\n", "}\n", "\n", "\n", "// tests:\n", "printTest( \"xyBalance(\\\"aaxbby\\\") \u2192 true\", xyBalance(\"aaxbby\"), true );\n", "printTest( \"xyBalance(\\\"aaxbb\\\") \u2192 false\", xyBalance(\"aaxbb\"), false );\n", "printTest( \"xyBalance(\\\"yaaxbb\\\") \u2192 false\", xyBalance(\"yaaxbb\"), false );\n", "printTest( \"xyBalance(\\\"yaaxbby\\\") \u2192 true\", xyBalance(\"yaaxbby\"), true );\n", "printTest( \"xyBalance(\\\"xaxxbby\\\") \u2192 true\", xyBalance(\"xaxxbby\"), true );\n", "printTest( \"xyBalance(\\\"xaxxbbyx\\\") \u2192 false\", xyBalance(\"xaxxbbyx\"), false );\n", "printTest( \"xyBalance(\\\"xxbxy\\\") \u2192 true\", xyBalance(\"xxbxy\"), true );\n", "printTest( \"xyBalance(\\\"xxbx\\\") \u2192 false\", xyBalance(\"xxbx\"), false );\n", "printTest( \"xyBalance(\\\"bbb\\\") \u2192 true\", xyBalance(\"bbb\"), true );\n", "printTest( \"xyBalance(\\\"bxbb\\\") \u2192 false\", xyBalance(\"bxbb\"), false );\n", "printTest( \"xyBalance(\\\"bxyb\\\") \u2192 true\", xyBalance(\"bxyb\"), true );\n", "printTest( \"xyBalance(\\\"xy\\\") \u2192 true\", xyBalance(\"xy\"), true );\n", "printTest( \"xyBalance(\\\"y\\\") \u2192 true\", xyBalance(\"y\"), true );\n", "printTest( \"xyBalance(\\\"x\\\") \u2192 false\", xyBalance(\"x\"), false );\n", "printTest( \"xyBalance(\\\"\\\") \u2192 true\", xyBalance(\"\"), true );\n", "printTest( \"xyBalance(\\\"yxyxyxyx\\\") \u2192 false\", xyBalance(\"yxyxyxyx\"), false );\n", "printTest( \"xyBalance(\\\"yxyxyxyxy\\\") \u2192 true\", xyBalance(\"yxyxyxyxy\"), true );\n", "printTest( \"xyBalance(\\\"12xabxxydxyxyzz\\\") \u2192 true\", xyBalance(\"12xabxxydxyxyzz\"), true );"]},
{"cell_type": "markdown", "metadata": {}, "source": ["# String-2 > mixString"]},
{"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["/*\n", "Given two strings, a and b, create a bigger string made of the first char of a,\n", "the first char of b, the second char of a, the second char of b, and so on. Any\n", "leftover chars go at the end of the result.\n", "\n", "mixString(\"abc\", \"xyz\") \u2192 \"axbycz\"\n", "mixString(\"Hi\", \"There\") \u2192 \"HTihere\"\n", "mixString(\"xxxx\", \"There\") \u2192 \"xTxhxexre\"\n", "*/\n", "\n", "string mixString(string a, string b) {\n", "    return \"\";\n", "}\n", "\n", "\n", "// tests:\n", "printTest( \"mixString(\\\"abc\\\", \\\"xyz\\\") \u2192 \\\"axbycz\\\"\", mixString(\"abc\", \"xyz\"), \"axbycz\" );\n", "printTest( \"mixString(\\\"Hi\\\", \\\"There\\\") \u2192 \\\"HTihere\\\"\", mixString(\"Hi\", \"There\"), \"HTihere\" );\n", "printTest( \"mixString(\\\"xxxx\\\", \\\"There\\\") \u2192 \\\"xTxhxexre\\\"\", mixString(\"xxxx\", \"There\"), \"xTxhxexre\" );\n", "printTest( \"mixString(\\\"xxx\\\", \\\"X\\\") \u2192 \\\"xXxx\\\"\", mixString(\"xxx\", \"X\"), \"xXxx\" );\n", "printTest( \"mixString(\\\"2/\\\", \\\"27 around\\\") \u2192 \\\"22/7 around\\\"\", mixString(\"2/\", \"27 around\"), \"22/7 around\" );\n", "printTest( \"mixString(\\\"\\\", \\\"Hello\\\") \u2192 \\\"Hello\\\"\", mixString(\"\", \"Hello\"), \"Hello\" );\n", "printTest( \"mixString(\\\"Abc\\\", \\\"\\\") \u2192 \\\"Abc\\\"\", mixString(\"Abc\", \"\"), \"Abc\" );\n", "printTest( \"mixString(\\\"\\\", \\\"\\\") \u2192 \\\"\\\"\", mixString(\"\", \"\"), \"\" );\n", "printTest( \"mixString(\\\"a\\\", \\\"b\\\") \u2192 \\\"ab\\\"\", mixString(\"a\", \"b\"), \"ab\" );\n", "printTest( \"mixString(\\\"ax\\\", \\\"b\\\") \u2192 \\\"abx\\\"\", mixString(\"ax\", \"b\"), \"abx\" );\n", "printTest( \"mixString(\\\"a\\\", \\\"bx\\\") \u2192 \\\"abx\\\"\", mixString(\"a\", \"bx\"), \"abx\" );\n", "printTest( \"mixString(\\\"So\\\", \\\"Long\\\") \u2192 \\\"SLoong\\\"\", mixString(\"So\", \"Long\"), \"SLoong\" );\n", "printTest( \"mixString(\\\"Long\\\", \\\"So\\\") \u2192 \\\"LSoong\\\"\", mixString(\"Long\", \"So\"), \"LSoong\" );"]},
{"cell_type": "markdown", "metadata": {}, "source": ["# String-2 > repeatEnd"]},
{"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["/*\n", "Given a string and an int n, return a string made of n repetitions of the last n\n", "characters of the string. You may assume that n is between 0 and the length of\n", "the string, inclusive.\n", "\n", "repeatEnd(\"Hello\", 3) \u2192 \"llollollo\"\n", "repeatEnd(\"Hello\", 2) \u2192 \"lolo\"\n", "repeatEnd(\"Hello\", 1) \u2192 \"o\"\n", "*/\n", "\n", "string repeatEnd(string str, int n) {\n", "    return \"\";\n", "}\n", "\n", "\n", "// tests:\n", "printTest( \"repeatEnd(\\\"Hello\\\", 3) \u2192 \\\"llollollo\\\"\", repeatEnd(\"Hello\", 3), \"llollollo\" );\n", "printTest( \"repeatEnd(\\\"Hello\\\", 2) \u2192 \\\"lolo\\\"\", repeatEnd(\"Hello\", 2), \"lolo\" );\n", "printTest( \"repeatEnd(\\\"Hello\\\", 1) \u2192 \\\"o\\\"\", repeatEnd(\"Hello\", 1), \"o\" );\n", "printTest( \"repeatEnd(\\\"Hello\\\", 0) \u2192 \\\"\\\"\", repeatEnd(\"Hello\", 0), \"\" );\n", "printTest( \"repeatEnd(\\\"abc\\\", 3) \u2192 \\\"abcabcabc\\\"\", repeatEnd(\"abc\", 3), \"abcabcabc\" );\n", "printTest( \"repeatEnd(\\\"1234\\\", 2) \u2192 \\\"3434\\\"\", repeatEnd(\"1234\", 2), \"3434\" );\n", "printTest( \"repeatEnd(\\\"1234\\\", 3) \u2192 \\\"234234234\\\"\", repeatEnd(\"1234\", 3), \"234234234\" );\n", "printTest( \"repeatEnd(\\\"\\\", 0) \u2192 \\\"\\\"\", repeatEnd(\"\", 0), \"\" );"]},
{"cell_type": "markdown", "metadata": {}, "source": ["# String-2 > repeatFront"]},
{"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["/*\n", "Given a string and an int n, return a string made of the first n characters of\n", "the string, followed by the first n-1 characters of the string, and so on. You\n", "may assume that n is between 0 and the length of the string, inclusive (i.e. n\n", ">= 0 and n <= str.length()).\n", "\n", "repeatFront(\"Chocolate\", 4) \u2192 \"ChocChoChC\"\n", "repeatFront(\"Chocolate\", 3) \u2192 \"ChoChC\"\n", "repeatFront(\"Ice Cream\", 2) \u2192 \"IcI\"\n", "*/\n", "\n", "string repeatFront(string str, int n) {\n", "    return \"\";\n", "}\n", "\n", "\n", "// tests:\n", "printTest( \"repeatFront(\\\"Chocolate\\\", 4) \u2192 \\\"ChocChoChC\\\"\", repeatFront(\"Chocolate\", 4), \"ChocChoChC\" );\n", "printTest( \"repeatFront(\\\"Chocolate\\\", 3) \u2192 \\\"ChoChC\\\"\", repeatFront(\"Chocolate\", 3), \"ChoChC\" );\n", "printTest( \"repeatFront(\\\"Ice Cream\\\", 2) \u2192 \\\"IcI\\\"\", repeatFront(\"Ice Cream\", 2), \"IcI\" );\n", "printTest( \"repeatFront(\\\"Ice Cream\\\", 1) \u2192 \\\"I\\\"\", repeatFront(\"Ice Cream\", 1), \"I\" );\n", "printTest( \"repeatFront(\\\"Ice Cream\\\", 0) \u2192 \\\"\\\"\", repeatFront(\"Ice Cream\", 0), \"\" );\n", "printTest( \"repeatFront(\\\"xyz\\\", 3) \u2192 \\\"xyzxyx\\\"\", repeatFront(\"xyz\", 3), \"xyzxyx\" );\n", "printTest( \"repeatFront(\\\"\\\", 0) \u2192 \\\"\\\"\", repeatFront(\"\", 0), \"\" );\n", "printTest( \"repeatFront(\\\"Java\\\", 4) \u2192 \\\"JavaJavJaJ\\\"\", repeatFront(\"Java\", 4), \"JavaJavJaJ\" );\n", "printTest( \"repeatFront(\\\"Java\\\", 1) \u2192 \\\"J\\\"\", repeatFront(\"Java\", 1), \"J\" );"]},
{"cell_type": "markdown", "metadata": {}, "source": ["# String-2 > repeatSeparator"]},
{"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["/*\n", "Given two strings, word and a separator sep, return a big string made of count\n", "occurrences of the word, separated by the separator string.\n", "\n", "repeatSeparator(\"Word\", \"X\", 3) \u2192 \"WordXWordXWord\"\n", "repeatSeparator(\"This\", \"And\", 2) \u2192 \"ThisAndThis\"\n", "repeatSeparator(\"This\", \"And\", 1) \u2192 \"This\"\n", "*/\n", "\n", "string repeatSeparator(string word, string sep, int count) {\n", "    return \"\";\n", "}\n", "\n", "\n", "// tests:\n", "printTest( \"repeatSeparator(\\\"Word\\\", \\\"X\\\", 3) \u2192 \\\"WordXWordXWord\\\"\", repeatSeparator(\"Word\", \"X\", 3), \"WordXWordXWord\" );\n", "printTest( \"repeatSeparator(\\\"This\\\", \\\"And\\\", 2) \u2192 \\\"ThisAndThis\\\"\", repeatSeparator(\"This\", \"And\", 2), \"ThisAndThis\" );\n", "printTest( \"repeatSeparator(\\\"This\\\", \\\"And\\\", 1) \u2192 \\\"This\\\"\", repeatSeparator(\"This\", \"And\", 1), \"This\" );\n", "printTest( \"repeatSeparator(\\\"Hi\\\", \\\"-n-\\\", 2) \u2192 \\\"Hi-n-Hi\\\"\", repeatSeparator(\"Hi\", \"-n-\", 2), \"Hi-n-Hi\" );\n", "printTest( \"repeatSeparator(\\\"AAA\\\", \\\"\\\", 1) \u2192 \\\"AAA\\\"\", repeatSeparator(\"AAA\", \"\", 1), \"AAA\" );\n", "printTest( \"repeatSeparator(\\\"AAA\\\", \\\"\\\", 0) \u2192 \\\"\\\"\", repeatSeparator(\"AAA\", \"\", 0), \"\" );\n", "printTest( \"repeatSeparator(\\\"A\\\", \\\"B\\\", 5) \u2192 \\\"ABABABABA\\\"\", repeatSeparator(\"A\", \"B\", 5), \"ABABABABA\" );\n", "printTest( \"repeatSeparator(\\\"abc\\\", \\\"XX\\\", 3) \u2192 \\\"abcXXabcXXabc\\\"\", repeatSeparator(\"abc\", \"XX\", 3), \"abcXXabcXXabc\" );\n", "printTest( \"repeatSeparator(\\\"abc\\\", \\\"XX\\\", 2) \u2192 \\\"abcXXabc\\\"\", repeatSeparator(\"abc\", \"XX\", 2), \"abcXXabc\" );\n", "printTest( \"repeatSeparator(\\\"abc\\\", \\\"XX\\\", 1) \u2192 \\\"abc\\\"\", repeatSeparator(\"abc\", \"XX\", 1), \"abc\" );\n", "printTest( \"repeatSeparator(\\\"XYZ\\\", \\\"a\\\", 2) \u2192 \\\"XYZaXYZ\\\"\", repeatSeparator(\"XYZ\", \"a\", 2), \"XYZaXYZ\" );"]},
{"cell_type": "markdown", "metadata": {}, "source": ["# String-2 > prefixAgain"]},
{"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["/*\n", "Given a string, consider the prefix string made of the first N chars of the\n", "string. Does that prefix string appear somewhere else in the string? Assume that\n", "the string is not empty and that N is in the range 1..str.length().\n", "\n", "prefixAgain(\"abXYabc\", 1) \u2192 true\n", "prefixAgain(\"abXYabc\", 2) \u2192 true\n", "prefixAgain(\"abXYabc\", 3) \u2192 false\n", "*/\n", "\n", "bool prefixAgain(string str, int n) {\n", "    return false;\n", "}\n", "\n", "\n", "// tests:\n", "printTest( \"prefixAgain(\\\"abXYabc\\\", 1) \u2192 true\", prefixAgain(\"abXYabc\", 1), true );\n", "printTest( \"prefixAgain(\\\"abXYabc\\\", 2) \u2192 true\", prefixAgain(\"abXYabc\", 2), true );\n", "printTest( \"prefixAgain(\\\"abXYabc\\\", 3) \u2192 false\", prefixAgain(\"abXYabc\", 3), false );\n", "printTest( \"prefixAgain(\\\"xyzxyxyxy\\\", 2) \u2192 true\", prefixAgain(\"xyzxyxyxy\", 2), true );\n", "printTest( \"prefixAgain(\\\"xyzxyxyxy\\\", 3) \u2192 false\", prefixAgain(\"xyzxyxyxy\", 3), false );\n", "printTest( \"prefixAgain(\\\"Hi12345Hi6789Hi10\\\", 1) \u2192 true\", prefixAgain(\"Hi12345Hi6789Hi10\", 1), true );\n", "printTest( \"prefixAgain(\\\"Hi12345Hi6789Hi10\\\", 2) \u2192 true\", prefixAgain(\"Hi12345Hi6789Hi10\", 2), true );\n", "printTest( \"prefixAgain(\\\"Hi12345Hi6789Hi10\\\", 3) \u2192 true\", prefixAgain(\"Hi12345Hi6789Hi10\", 3), true );\n", "printTest( \"prefixAgain(\\\"Hi12345Hi6789Hi10\\\", 4) \u2192 false\", prefixAgain(\"Hi12345Hi6789Hi10\", 4), false );\n", "printTest( \"prefixAgain(\\\"a\\\", 1) \u2192 false\", prefixAgain(\"a\", 1), false );\n", "printTest( \"prefixAgain(\\\"aa\\\", 1) \u2192 true\", prefixAgain(\"aa\", 1), true );\n", "printTest( \"prefixAgain(\\\"ab\\\", 1) \u2192 false\", prefixAgain(\"ab\", 1), false );"]},
{"cell_type": "markdown", "metadata": {}, "source": ["# String-2 > xyzMiddle"]},
{"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["/*\n", "Given a string, does \"xyz\" appear in the middle of the string? To define middle,\n", "we\u02bcll say that the number of chars to the left and right of the \"xyz\" must\n", "differ by at most one. This problem is harder than it looks.\n", "\n", "xyzMiddle(\"AAxyzBB\") \u2192 true\n", "xyzMiddle(\"AxyzBB\") \u2192 true\n", "xyzMiddle(\"AxyzBBB\") \u2192 false\n", "*/\n", "\n", "bool xyzMiddle(string str) {\n", "    return false;\n", "}\n", "\n", "\n", "// tests:\n", "printTest( \"xyzMiddle(\\\"AAxyzBB\\\") \u2192 true\", xyzMiddle(\"AAxyzBB\"), true );\n", "printTest( \"xyzMiddle(\\\"AxyzBB\\\") \u2192 true\", xyzMiddle(\"AxyzBB\"), true );\n", "printTest( \"xyzMiddle(\\\"AxyzBBB\\\") \u2192 false\", xyzMiddle(\"AxyzBBB\"), false );\n", "printTest( \"xyzMiddle(\\\"AxyzBBBB\\\") \u2192 false\", xyzMiddle(\"AxyzBBBB\"), false );\n", "printTest( \"xyzMiddle(\\\"AAAxyzB\\\") \u2192 false\", xyzMiddle(\"AAAxyzB\"), false );\n", "printTest( \"xyzMiddle(\\\"AAAxyzBB\\\") \u2192 true\", xyzMiddle(\"AAAxyzBB\"), true );\n", "printTest( \"xyzMiddle(\\\"AAAAxyzBB\\\") \u2192 false\", xyzMiddle(\"AAAAxyzBB\"), false );\n", "printTest( \"xyzMiddle(\\\"AAAAAxyzBBB\\\") \u2192 false\", xyzMiddle(\"AAAAAxyzBBB\"), false );\n", "printTest( \"xyzMiddle(\\\"1x345xyz12x4\\\") \u2192 true\", xyzMiddle(\"1x345xyz12x4\"), true );\n", "printTest( \"xyzMiddle(\\\"xyzAxyzBBB\\\") \u2192 true\", xyzMiddle(\"xyzAxyzBBB\"), true );\n", "printTest( \"xyzMiddle(\\\"xyzAxyzBxyz\\\") \u2192 true\", xyzMiddle(\"xyzAxyzBxyz\"), true );\n", "printTest( \"xyzMiddle(\\\"xyzxyzAxyzBxyzxyz\\\") \u2192 true\", xyzMiddle(\"xyzxyzAxyzBxyzxyz\"), true );\n", "printTest( \"xyzMiddle(\\\"xyzxyzxyzBxyzxyz\\\") \u2192 true\", xyzMiddle(\"xyzxyzxyzBxyzxyz\"), true );\n", "printTest( \"xyzMiddle(\\\"xyzxyzAxyzxyzxyz\\\") \u2192 true\", xyzMiddle(\"xyzxyzAxyzxyzxyz\"), true );\n", "printTest( \"xyzMiddle(\\\"xyzxyzAxyzxyzxy\\\") \u2192 false\", xyzMiddle(\"xyzxyzAxyzxyzxy\"), false );\n", "printTest( \"xyzMiddle(\\\"AxyzxyzBB\\\") \u2192 false\", xyzMiddle(\"AxyzxyzBB\"), false );\n", "printTest( \"xyzMiddle(\\\"\\\") \u2192 false\", xyzMiddle(\"\"), false );\n", "printTest( \"xyzMiddle(\\\"x\\\") \u2192 false\", xyzMiddle(\"x\"), false );\n", "printTest( \"xyzMiddle(\\\"xy\\\") \u2192 false\", xyzMiddle(\"xy\"), false );\n", "printTest( \"xyzMiddle(\\\"xyz\\\") \u2192 true\", xyzMiddle(\"xyz\"), true );\n", "printTest( \"xyzMiddle(\\\"xyzz\\\") \u2192 true\", xyzMiddle(\"xyzz\"), true );"]},
{"cell_type": "markdown", "metadata": {}, "source": ["# String-2 > getSandwich"]},
{"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["/*\n", "A sandwich is two pieces of bread with something in between. Return the string\n", "that is between the first and last appearance of \"bread\" in the given string, or\n", "return the empty string \"\" if there are not two pieces of bread.\n", "\n", "getSandwich(\"breadjambread\") \u2192 \"jam\"\n", "getSandwich(\"xxbreadjambreadyy\") \u2192 \"jam\"\n", "getSandwich(\"xxbreadyy\") \u2192 \"\"\n", "*/\n", "\n", "string getSandwich(string str) {\n", "    return \"\";\n", "}\n", "\n", "\n", "// tests:\n", "printTest( \"getSandwich(\\\"breadjambread\\\") \u2192 \\\"jam\\\"\", getSandwich(\"breadjambread\"), \"jam\" );\n", "printTest( \"getSandwich(\\\"xxbreadjambreadyy\\\") \u2192 \\\"jam\\\"\", getSandwich(\"xxbreadjambreadyy\"), \"jam\" );\n", "printTest( \"getSandwich(\\\"xxbreadyy\\\") \u2192 \\\"\\\"\", getSandwich(\"xxbreadyy\"), \"\" );\n", "printTest( \"getSandwich(\\\"xxbreadbreadjambreadyy\\\") \u2192 \\\"breadjam\\\"\", getSandwich(\"xxbreadbreadjambreadyy\"), \"breadjam\" );\n", "printTest( \"getSandwich(\\\"breadAbread\\\") \u2192 \\\"A\\\"\", getSandwich(\"breadAbread\"), \"A\" );\n", "printTest( \"getSandwich(\\\"breadbread\\\") \u2192 \\\"\\\"\", getSandwich(\"breadbread\"), \"\" );\n", "printTest( \"getSandwich(\\\"abcbreaz\\\") \u2192 \\\"\\\"\", getSandwich(\"abcbreaz\"), \"\" );\n", "printTest( \"getSandwich(\\\"xyz\\\") \u2192 \\\"\\\"\", getSandwich(\"xyz\"), \"\" );\n", "printTest( \"getSandwich(\\\"\\\") \u2192 \\\"\\\"\", getSandwich(\"\"), \"\" );\n", "printTest( \"getSandwich(\\\"breadbreaxbread\\\") \u2192 \\\"breax\\\"\", getSandwich(\"breadbreaxbread\"), \"breax\" );\n", "printTest( \"getSandwich(\\\"breaxbreadybread\\\") \u2192 \\\"y\\\"\", getSandwich(\"breaxbreadybread\"), \"y\" );\n", "printTest( \"getSandwich(\\\"breadbreadbreadbread\\\") \u2192 \\\"breadbread\\\"\", getSandwich(\"breadbreadbreadbread\"), \"breadbread\" );"]},
{"cell_type": "markdown", "metadata": {}, "source": ["# String-2 > sameStarChar"]},
{"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["/*\n", "Returns true if for every '*' (star) in the string, if there are chars both\n", "immediately before and after the star, they are the same.\n", "\n", "sameStarChar(\"xy*yzz\") \u2192 true\n", "sameStarChar(\"xy*zzz\") \u2192 false\n", "sameStarChar(\"*xa*az\") \u2192 true\n", "*/\n", "\n", "bool sameStarChar(string str) {\n", "    return false;\n", "}\n", "\n", "\n", "// tests:\n", "printTest( \"sameStarChar(\\\"xy*yzz\\\") \u2192 true\", sameStarChar(\"xy*yzz\"), true );\n", "printTest( \"sameStarChar(\\\"xy*zzz\\\") \u2192 false\", sameStarChar(\"xy*zzz\"), false );\n", "printTest( \"sameStarChar(\\\"*xa*az\\\") \u2192 true\", sameStarChar(\"*xa*az\"), true );\n", "printTest( \"sameStarChar(\\\"*xa*bz\\\") \u2192 false\", sameStarChar(\"*xa*bz\"), false );\n", "printTest( \"sameStarChar(\\\"*xa*a*\\\") \u2192 true\", sameStarChar(\"*xa*a*\"), true );\n", "printTest( \"sameStarChar(\\\"\\\") \u2192 true\", sameStarChar(\"\"), true );\n", "printTest( \"sameStarChar(\\\"*xa*a*a\\\") \u2192 true\", sameStarChar(\"*xa*a*a\"), true );\n", "printTest( \"sameStarChar(\\\"*xa*a*b\\\") \u2192 false\", sameStarChar(\"*xa*a*b\"), false );\n", "printTest( \"sameStarChar(\\\"*12*2*2\\\") \u2192 true\", sameStarChar(\"*12*2*2\"), true );\n", "printTest( \"sameStarChar(\\\"12*2*3*\\\") \u2192 false\", sameStarChar(\"12*2*3*\"), false );\n", "printTest( \"sameStarChar(\\\"abcDEF\\\") \u2192 true\", sameStarChar(\"abcDEF\"), true );\n", "printTest( \"sameStarChar(\\\"XY*YYYY*Z*\\\") \u2192 false\", sameStarChar(\"XY*YYYY*Z*\"), false );\n", "printTest( \"sameStarChar(\\\"XY*YYYY*Y*\\\") \u2192 true\", sameStarChar(\"XY*YYYY*Y*\"), true );\n", "printTest( \"sameStarChar(\\\"12*2*3*\\\") \u2192 false\", sameStarChar(\"12*2*3*\"), false );\n", "printTest( \"sameStarChar(\\\"*\\\") \u2192 true\", sameStarChar(\"*\"), true );\n", "printTest( \"sameStarChar(\\\"**\\\") \u2192 true\", sameStarChar(\"**\"), true );"]},
{"cell_type": "markdown", "metadata": {}, "source": ["# String-2 > oneTwo"]},
{"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["/*\n", "Given a string, compute a new string by moving the first char to come after the\n", "next two chars, so \"abc\" yields \"bca\". Repeat this process for each subsequent\n", "group of 3 chars, so \"abcdef\" yields \"bcaefd\". Ignore any group of fewer than 3\n", "chars at the end.\n", "\n", "oneTwo(\"abc\") \u2192 \"bca\"\n", "oneTwo(\"tca\") \u2192 \"cat\"\n", "oneTwo(\"tcagdo\") \u2192 \"catdog\"\n", "*/\n", "\n", "string oneTwo(string str) {\n", "    return \"\";\n", "}\n", "\n", "\n", "// tests:\n", "printTest( \"oneTwo(\\\"abc\\\") \u2192 \\\"bca\\\"\", oneTwo(\"abc\"), \"bca\" );\n", "printTest( \"oneTwo(\\\"tca\\\") \u2192 \\\"cat\\\"\", oneTwo(\"tca\"), \"cat\" );\n", "printTest( \"oneTwo(\\\"tcagdo\\\") \u2192 \\\"catdog\\\"\", oneTwo(\"tcagdo\"), \"catdog\" );\n", "printTest( \"oneTwo(\\\"chocolate\\\") \u2192 \\\"hocolctea\\\"\", oneTwo(\"chocolate\"), \"hocolctea\" );\n", "printTest( \"oneTwo(\\\"1234567890\\\") \u2192 \\\"231564897\\\"\", oneTwo(\"1234567890\"), \"231564897\" );\n", "printTest( \"oneTwo(\\\"xabxabxabxabxabxabxab\\\") \u2192 \\\"abxabxabxabxabxabxabx\\\"\", oneTwo(\"xabxabxabxabxabxabxab\"), \"abxabxabxabxabxabxabx\" );\n", "printTest( \"oneTwo(\\\"abcdefx\\\") \u2192 \\\"bcaefd\\\"\", oneTwo(\"abcdefx\"), \"bcaefd\" );\n", "printTest( \"oneTwo(\\\"abcdefxy\\\") \u2192 \\\"bcaefd\\\"\", oneTwo(\"abcdefxy\"), \"bcaefd\" );\n", "printTest( \"oneTwo(\\\"abcdefxyz\\\") \u2192 \\\"bcaefdyzx\\\"\", oneTwo(\"abcdefxyz\"), \"bcaefdyzx\" );\n", "printTest( \"oneTwo(\\\"\\\") \u2192 \\\"\\\"\", oneTwo(\"\"), \"\" );\n", "printTest( \"oneTwo(\\\"x\\\") \u2192 \\\"\\\"\", oneTwo(\"x\"), \"\" );\n", "printTest( \"oneTwo(\\\"xy\\\") \u2192 \\\"\\\"\", oneTwo(\"xy\"), \"\" );\n", "printTest( \"oneTwo(\\\"xyz\\\") \u2192 \\\"yzx\\\"\", oneTwo(\"xyz\"), \"yzx\" );\n", "printTest( \"oneTwo(\\\"abcdefghijklkmnopqrstuvwxyz1234567890\\\") \u2192 \\\"bcaefdhigkljmnkpqostrvwuyzx231564897\\\"\", oneTwo(\"abcdefghijklkmnopqrstuvwxyz1234567890\"), \"bcaefdhigkljmnkpqostrvwuyzx231564897\" );\n", "printTest( \"oneTwo(\\\"abcdefghijklkmnopqrstuvwxyz123456789\\\") \u2192 \\\"bcaefdhigkljmnkpqostrvwuyzx231564897\\\"\", oneTwo(\"abcdefghijklkmnopqrstuvwxyz123456789\"), \"bcaefdhigkljmnkpqostrvwuyzx231564897\" );\n", "printTest( \"oneTwo(\\\"abcdefghijklkmnopqrstuvwxyz12345678\\\") \u2192 \\\"bcaefdhigkljmnkpqostrvwuyzx231564\\\"\", oneTwo(\"abcdefghijklkmnopqrstuvwxyz12345678\"), \"bcaefdhigkljmnkpqostrvwuyzx231564\" );"]},
{"cell_type": "markdown", "metadata": {}, "source": ["# String-2 > zipZap"]},
{"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["/*\n", "Look for patterns like \"zip\" and \"zap\" in the string -- length-3, starting with\n", "'z' and ending with 'p'. Return a string where for all such words, the middle\n", "letter is gone, so \"zipXzap\" yields \"zpXzp\".\n", "\n", "zipZap(\"zipXzap\") \u2192 \"zpXzp\"\n", "zipZap(\"zopzop\") \u2192 \"zpzp\"\n", "zipZap(\"zzzopzop\") \u2192 \"zzzpzp\"\n", "*/\n", "\n", "string zipZap(string str) {\n", "    return \"\";\n", "}\n", "\n", "\n", "// tests:\n", "printTest( \"zipZap(\\\"zipXzap\\\") \u2192 \\\"zpXzp\\\"\", zipZap(\"zipXzap\"), \"zpXzp\" );\n", "printTest( \"zipZap(\\\"zopzop\\\") \u2192 \\\"zpzp\\\"\", zipZap(\"zopzop\"), \"zpzp\" );\n", "printTest( \"zipZap(\\\"zzzopzop\\\") \u2192 \\\"zzzpzp\\\"\", zipZap(\"zzzopzop\"), \"zzzpzp\" );\n", "printTest( \"zipZap(\\\"zibzap\\\") \u2192 \\\"zibzp\\\"\", zipZap(\"zibzap\"), \"zibzp\" );\n", "printTest( \"zipZap(\\\"zip\\\") \u2192 \\\"zp\\\"\", zipZap(\"zip\"), \"zp\" );\n", "printTest( \"zipZap(\\\"zi\\\") \u2192 \\\"zi\\\"\", zipZap(\"zi\"), \"zi\" );\n", "printTest( \"zipZap(\\\"z\\\") \u2192 \\\"z\\\"\", zipZap(\"z\"), \"z\" );\n", "printTest( \"zipZap(\\\"\\\") \u2192 \\\"\\\"\", zipZap(\"\"), \"\" );\n", "printTest( \"zipZap(\\\"zzp\\\") \u2192 \\\"zp\\\"\", zipZap(\"zzp\"), \"zp\" );\n", "printTest( \"zipZap(\\\"abcppp\\\") \u2192 \\\"abcppp\\\"\", zipZap(\"abcppp\"), \"abcppp\" );\n", "printTest( \"zipZap(\\\"azbcppp\\\") \u2192 \\\"azbcppp\\\"\", zipZap(\"azbcppp\"), \"azbcppp\" );\n", "printTest( \"zipZap(\\\"azbcpzpp\\\") \u2192 \\\"azbcpzp\\\"\", zipZap(\"azbcpzpp\"), \"azbcpzp\" );"]},
{"cell_type": "markdown", "metadata": {}, "source": ["# String-2 > starOut"]},
{"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["/*\n", "Return a version of the given string, where for every star (*) in the string the\n", "star and the chars immediately to its left and right are gone. So \"ab*cd\" yields\n", "\"ad\" and \"ab**cd\" also yields \"ad\".\n", "\n", "starOut(\"ab*cd\") \u2192 \"ad\"\n", "starOut(\"ab**cd\") \u2192 \"ad\"\n", "starOut(\"sm*eilly\") \u2192 \"silly\"\n", "*/\n", "\n", "string starOut(string str) {\n", "    return \"\";\n", "}\n", "\n", "\n", "// tests:\n", "printTest( \"starOut(\\\"ab*cd\\\") \u2192 \\\"ad\\\"\", starOut(\"ab*cd\"), \"ad\" );\n", "printTest( \"starOut(\\\"ab**cd\\\") \u2192 \\\"ad\\\"\", starOut(\"ab**cd\"), \"ad\" );\n", "printTest( \"starOut(\\\"sm*eilly\\\") \u2192 \\\"silly\\\"\", starOut(\"sm*eilly\"), \"silly\" );\n", "printTest( \"starOut(\\\"sm*eil*ly\\\") \u2192 \\\"siy\\\"\", starOut(\"sm*eil*ly\"), \"siy\" );\n", "printTest( \"starOut(\\\"sm**eil*ly\\\") \u2192 \\\"siy\\\"\", starOut(\"sm**eil*ly\"), \"siy\" );\n", "printTest( \"starOut(\\\"sm***eil*ly\\\") \u2192 \\\"siy\\\"\", starOut(\"sm***eil*ly\"), \"siy\" );\n", "printTest( \"starOut(\\\"stringy*\\\") \u2192 \\\"string\\\"\", starOut(\"stringy*\"), \"string\" );\n", "printTest( \"starOut(\\\"*stringy\\\") \u2192 \\\"tringy\\\"\", starOut(\"*stringy\"), \"tringy\" );\n", "printTest( \"starOut(\\\"*str*in*gy\\\") \u2192 \\\"ty\\\"\", starOut(\"*str*in*gy\"), \"ty\" );\n", "printTest( \"starOut(\\\"abc\\\") \u2192 \\\"abc\\\"\", starOut(\"abc\"), \"abc\" );\n", "printTest( \"starOut(\\\"a*bc\\\") \u2192 \\\"c\\\"\", starOut(\"a*bc\"), \"c\" );\n", "printTest( \"starOut(\\\"ab\\\") \u2192 \\\"ab\\\"\", starOut(\"ab\"), \"ab\" );\n", "printTest( \"starOut(\\\"a*b\\\") \u2192 \\\"\\\"\", starOut(\"a*b\"), \"\" );\n", "printTest( \"starOut(\\\"a\\\") \u2192 \\\"a\\\"\", starOut(\"a\"), \"a\" );\n", "printTest( \"starOut(\\\"a*\\\") \u2192 \\\"\\\"\", starOut(\"a*\"), \"\" );\n", "printTest( \"starOut(\\\"*a\\\") \u2192 \\\"\\\"\", starOut(\"*a\"), \"\" );\n", "printTest( \"starOut(\\\"*\\\") \u2192 \\\"\\\"\", starOut(\"*\"), \"\" );\n", "printTest( \"starOut(\\\"\\\") \u2192 \\\"\\\"\", starOut(\"\"), \"\" );"]},
{"cell_type": "markdown", "metadata": {}, "source": ["# String-2 > plusOut"]},
{"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["/*\n", "Given a string and a non-empty word string, return a version of the original\n", "String where all chars have been replaced by pluses (\"+\"), except for\n", "appearances of the word string which are preserved unchanged.\n", "\n", "plusOut(\"12xy34\", \"xy\") \u2192 \"++xy++\"\n", "plusOut(\"12xy34\", \"1\") \u2192 \"1+++++\"\n", "plusOut(\"12xy34xyabcxy\", \"xy\") \u2192 \"++xy++xy+++xy\"\n", "*/\n", "\n", "string plusOut(string str, string word) {\n", "    return \"\";\n", "}\n", "\n", "\n", "// tests:\n", "printTest( \"plusOut(\\\"12xy34\\\", \\\"xy\\\") \u2192 \\\"++xy++\\\"\", plusOut(\"12xy34\", \"xy\"), \"++xy++\" );\n", "printTest( \"plusOut(\\\"12xy34\\\", \\\"1\\\") \u2192 \\\"1+++++\\\"\", plusOut(\"12xy34\", \"1\"), \"1+++++\" );\n", "printTest( \"plusOut(\\\"12xy34xyabcxy\\\", \\\"xy\\\") \u2192 \\\"++xy++xy+++xy\\\"\", plusOut(\"12xy34xyabcxy\", \"xy\"), \"++xy++xy+++xy\" );\n", "printTest( \"plusOut(\\\"abXYabcXYZ\\\", \\\"ab\\\") \u2192 \\\"ab++ab++++\\\"\", plusOut(\"abXYabcXYZ\", \"ab\"), \"ab++ab++++\" );\n", "printTest( \"plusOut(\\\"abXYabcXYZ\\\", \\\"abc\\\") \u2192 \\\"++++abc+++\\\"\", plusOut(\"abXYabcXYZ\", \"abc\"), \"++++abc+++\" );\n", "printTest( \"plusOut(\\\"abXYabcXYZ\\\", \\\"XY\\\") \u2192 \\\"++XY+++XY+\\\"\", plusOut(\"abXYabcXYZ\", \"XY\"), \"++XY+++XY+\" );\n", "printTest( \"plusOut(\\\"abXYxyzXYZ\\\", \\\"XYZ\\\") \u2192 \\\"+++++++XYZ\\\"\", plusOut(\"abXYxyzXYZ\", \"XYZ\"), \"+++++++XYZ\" );\n", "printTest( \"plusOut(\\\"--++ab\\\", \\\"++\\\") \u2192 \\\"++++++\\\"\", plusOut(\"--++ab\", \"++\"), \"++++++\" );\n", "printTest( \"plusOut(\\\"aaxxxxbb\\\", \\\"xx\\\") \u2192 \\\"++xxxx++\\\"\", plusOut(\"aaxxxxbb\", \"xx\"), \"++xxxx++\" );\n", "printTest( \"plusOut(\\\"123123\\\", \\\"3\\\") \u2192 \\\"++3++3\\\"\", plusOut(\"123123\", \"3\"), \"++3++3\" );"]},
{"cell_type": "markdown", "metadata": {}, "source": ["# String-2 > wordEnds"]},
{"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["/*\n", "Given a string and a non-empty word string, return a string made of each char\n", "just before and just after every appearance of the word in the string. Ignore\n", "cases where there is no char before or after the word, and a char may be\n", "included twice if it is between two words.\n", "\n", "wordEnds(\"abcXY123XYijk\", \"XY\") \u2192 \"c13i\"\n", "wordEnds(\"XY123XY\", \"XY\") \u2192 \"13\"\n", "wordEnds(\"XY1XY\", \"XY\") \u2192 \"11\"\n", "*/\n", "\n", "string wordEnds(string str, string word) {\n", "    return \"\";\n", "}\n", "\n", "\n", "// tests:\n", "printTest( \"wordEnds(\\\"abcXY123XYijk\\\", \\\"XY\\\") \u2192 \\\"c13i\\\"\", wordEnds(\"abcXY123XYijk\", \"XY\"), \"c13i\" );\n", "printTest( \"wordEnds(\\\"XY123XY\\\", \\\"XY\\\") \u2192 \\\"13\\\"\", wordEnds(\"XY123XY\", \"XY\"), \"13\" );\n", "printTest( \"wordEnds(\\\"XY1XY\\\", \\\"XY\\\") \u2192 \\\"11\\\"\", wordEnds(\"XY1XY\", \"XY\"), \"11\" );\n", "printTest( \"wordEnds(\\\"XYXY\\\", \\\"XY\\\") \u2192 \\\"XY\\\"\", wordEnds(\"XYXY\", \"XY\"), \"XY\" );\n", "printTest( \"wordEnds(\\\"XY\\\", \\\"XY\\\") \u2192 \\\"\\\"\", wordEnds(\"XY\", \"XY\"), \"\" );\n", "printTest( \"wordEnds(\\\"Hi\\\", \\\"XY\\\") \u2192 \\\"\\\"\", wordEnds(\"Hi\", \"XY\"), \"\" );\n", "printTest( \"wordEnds(\\\"\\\", \\\"XY\\\") \u2192 \\\"\\\"\", wordEnds(\"\", \"XY\"), \"\" );\n", "printTest( \"wordEnds(\\\"abc1xyz1i1j\\\", \\\"1\\\") \u2192 \\\"cxziij\\\"\", wordEnds(\"abc1xyz1i1j\", \"1\"), \"cxziij\" );\n", "printTest( \"wordEnds(\\\"abc1xyz1\\\", \\\"1\\\") \u2192 \\\"cxz\\\"\", wordEnds(\"abc1xyz1\", \"1\"), \"cxz\" );\n", "printTest( \"wordEnds(\\\"abc1xyz11\\\", \\\"1\\\") \u2192 \\\"cxz11\\\"\", wordEnds(\"abc1xyz11\", \"1\"), \"cxz11\" );\n", "printTest( \"wordEnds(\\\"abc1xyz1abc\\\", \\\"abc\\\") \u2192 \\\"11\\\"\", wordEnds(\"abc1xyz1abc\", \"abc\"), \"11\" );\n", "printTest( \"wordEnds(\\\"abc1xyz1abc\\\", \\\"b\\\") \u2192 \\\"acac\\\"\", wordEnds(\"abc1xyz1abc\", \"b\"), \"acac\" );\n", "printTest( \"wordEnds(\\\"abc1abc1abc\\\", \\\"abc\\\") \u2192 \\\"1111\\\"\", wordEnds(\"abc1abc1abc\", \"abc\"), \"1111\" );"]}
 ],
 "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
}