     },
     "outputs": [],
     "source": [
      "def compress_string(string):\n",
      "    if string is None or len(string) == 0:\n",
      "        return string\n",
      "\n",
      "    # Calculate the size of the compressed string\n",
      "    size = 0\n",
      "    last_char = string[0]\n",
      "    for char in string:\n",
      "        if char != last_char:\n",
      "            size += 2\n",
      "            last_char = char\n",
      "    size += 2\n",
      "\n",
      "    # If the compressed string size is greater than\n",
      "    # or equal to string size, return original string\n",
      "    if size >= len(string):\n",
      "        return string\n",
      "\n",
      "    # Create compressed_string\n",
      "    compressed_string = list()\n",
      "    count = 0\n",
      "    last_char = string[0]\n",
      "    for char in string:\n",
      "        if char == last_char:\n",
      "            count += 1\n",
      "        else:\n",
      "            compressed_string.append(last_char)\n",
      "            compressed_string.append(str(count))\n",
      "            count = 1\n",
      "            last_char = char\n",
      "    compressed_string.append(last_char)\n",
      "    compressed_string.append(str(count))\n",
      "\n",
      "    # Convert the characters in the list to a string\n",
      "    return \"\".join(compressed_string)"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
 
</s> remove     "            * Append last_char to compressed_string\n",
    "            * append count to compressed_string\n",
    "            * count = 1\n",
    "            * last_char = char\n",
 </s> add     "            * If the count is more than 2\n",
    "                * Append last_char to compressed_string\n",
    "                * append count to compressed_string\n",
    "                * count = 1\n",
    "                * last_char = char\n",
    "            * If count is 1\n",
    "                * Append last_char to compressed_string\n",
    "                * count = 1\n",
    "                * last_char = char\n",
    "            * If count is 2\n",
    "                * Append last_char to compressed_string\n",
    "                * Append last_char to compressed_string once more\n",
    "                * count = 1\n",
    "                * last_char = char\n", </s> remove     "        assert_equal(func('AAABCCDDDD'), 'A3B1C2D4')\n",
 </s> add     "        assert_equal(func('AAABCCDDDD'), 'A3BCCD4')\n", </s> remove     "## Problem: Compress a string such that 'AAABCCDDDD' becomes 'A3B1C2D4'.  Only compress the string if it saves space.\n",
 </s> add     "## Problem: Compress a string such that 'AAABCCDDDD' becomes 'A3BCCD4'.  Only compress the string if it saves space.\n", </s> remove     "* 'AAABCCDDDD' -> 'A3B1C2D4'"
 </s> add     "* 'AAABCCDDDD' -> 'A3BCCD4'" </s> remove         assert_equal(func('AAABCCDDDD'), 'A3B1C2D4')
 </s> add         assert_equal(func('AAABCCDDDD'), 'A3BCCD4')
    "\tif string is None or len(string) == 0:\n",
    "\t\treturn string\n",
    "\n",
    "\t# Calculate the size of the compressed string\n",
    "\tsize = 0\n",
    "\tlast_char = string[0]\n",
    "\tfor char in string:\n",
    "\t\tif char != last_char:\n",
    "\t\t\tsize += 2\n",
    "\t\t\tlast_char = char\n",
    "\tsize += 2\n",
    "\n",
    "\t# If the compressed string size is greater than\n",
    "\t# or equal to string size, return original string\n",
    "\tif size >= len(string):\n",
    "\t\treturn string\n",
    "\n",
    "\t# Create compressed_string\n",
    "\t# New objective:\n",
    "\t\t# Single characters are to be left as is\n",
    "\t\t# Double characters are to be left as are\n",
    "\tcompressed_string = list()\n",
    "\tcount = 0\n",
    "\tlast_char = string[0]\n",
    "\tfor char in string:\n",
    "\t\tif char == last_char:\n",
    "\t\t\tcount += 1\n",
    "\t\telse:\n",
    "\t\t\t# Do the old compression tricks only if count exceeds two\n",
    "\t\t\tif count > 2:\n",
    "\t\t\t\tcompressed_string.append(last_char)\n",
    "\t\t\t\tcompressed_string.append(str(count))\n",
    "\t\t\t\tcount = 1\n",
    "\t\t\t\tlast_char = char\n",
    "\t\t\t# If count is either 1 or 2 (or 0?)\n",
    "\t\t\t# FIXME: CAN COUNT BE 0?\n",
    "\t\t\telse:\n",
    "\t\t\t\t# If count is 1, leave the char as is\n",
    "\t\t\t\tif count == 1:\n",
    "\t\t\t\t\tcompressed_string.append(last_char)\n",
    "\t\t\t\t\tcount = 1\n",
    "\t\t\t\t\tlast_char = char\n",
    "\t\t\t\t# If count is 2, append the character twice\n",
    "\t\t\t\telse:\n",
    "\t\t\t\t\tcompressed_string.append(last_char)\n",
    "\t\t\t\t\tcompressed_string.append(last_char)\n",
    "\t\t\t\t\tcount = 1\n",
    "\t\t\t\t\tlast_char = char\n",
    "\tcompressed_string.append(last_char)\n",
    "\tcompressed_string.append(str(count))\n",
    "\n",
    "\t# Convert the characters in the list to a string\n",
    "\treturn \"\".join(compressed_string)"
     },
     "outputs": [],
     "source": [
      "def compress_string(string):\n",
    "\tif string is None or len(string) == 0:\n",
    "\t\treturn string\n",
    "\n",
    "\t# Calculate the size of the compressed string\n",
    "\tsize = 0\n",
    "\tlast_char = string[0]\n",
    "\tfor char in string:\n",
    "\t\tif char != last_char:\n",
    "\t\t\tsize += 2\n",
    "\t\t\tlast_char = char\n",
    "\tsize += 2\n",
    "\n",
    "\t# If the compressed string size is greater than\n",
    "\t# or equal to string size, return original string\n",
    "\tif size >= len(string):\n",
    "\t\treturn string\n",
    "\n",
    "\t# Create compressed_string\n",
    "\t# New objective:\n",
    "\t\t# Single characters are to be left as is\n",
    "\t\t# Double characters are to be left as are\n",
    "\tcompressed_string = list()\n",
    "\tcount = 0\n",
    "\tlast_char = string[0]\n",
    "\tfor char in string:\n",
    "\t\tif char == last_char:\n",
    "\t\t\tcount += 1\n",
    "\t\telse:\n",
    "\t\t\t# Do the old compression tricks only if count exceeds two\n",
    "\t\t\tif count > 2:\n",
    "\t\t\t\tcompressed_string.append(last_char)\n",
    "\t\t\t\tcompressed_string.append(str(count))\n",
    "\t\t\t\tcount = 1\n",
    "\t\t\t\tlast_char = char\n",
    "\t\t\t# If count is either 1 or 2 (or 0?)\n",
    "\t\t\t# FIXME: CAN COUNT BE 0?\n",
    "\t\t\telse:\n",
    "\t\t\t\t# If count is 1, leave the char as is\n",
    "\t\t\t\tif count == 1:\n",
    "\t\t\t\t\tcompressed_string.append(last_char)\n",
    "\t\t\t\t\tcount = 1\n",
    "\t\t\t\t\tlast_char = char\n",
    "\t\t\t\t# If count is 2, append the character twice\n",
    "\t\t\t\telse:\n",
    "\t\t\t\t\tcompressed_string.append(last_char)\n",
    "\t\t\t\t\tcompressed_string.append(last_char)\n",
    "\t\t\t\t\tcount = 1\n",
    "\t\t\t\t\tlast_char = char\n",
    "\tcompressed_string.append(last_char)\n",
    "\tcompressed_string.append(str(count))\n",
    "\n",
    "\t# Convert the characters in the list to a string\n",
    "\treturn \"\".join(compressed_string)"
    "\tif string is None or len(string) == 0:\n",
    "\t\treturn string\n",
    "\n",
    "\t# Calculate the size of the compressed string\n",
    "\tsize = 0\n",
    "\tlast_char = string[0]\n",
    "\tfor char in string:\n",
    "\t\tif char != last_char:\n",
    "\t\t\tsize += 2\n",
    "\t\t\tlast_char = char\n",
    "\tsize += 2\n",
    "\n",
    "\t# If the compressed string size is greater than\n",
    "\t# or equal to string size, return original string\n",
    "\tif size >= len(string):\n",
    "\t\treturn string\n",
    "\n",
    "\t# Create compressed_string\n",
    "\t# New objective:\n",
    "\t\t# Single characters are to be left as is\n",
    "\t\t# Double characters are to be left as are\n",
    "\tcompressed_string = list()\n",
    "\tcount = 0\n",
    "\tlast_char = string[0]\n",
    "\tfor char in string:\n",
    "\t\tif char == last_char:\n",
    "\t\t\tcount += 1\n",
    "\t\telse:\n",
    "\t\t\t# Do the old compression tricks only if count exceeds two\n",
    "\t\t\tif count > 2:\n",
    "\t\t\t\tcompressed_string.append(last_char)\n",
    "\t\t\t\tcompressed_string.append(str(count))\n",
    "\t\t\t\tcount = 1\n",
    "\t\t\t\tlast_char = char\n",
    "\t\t\t# If count is either 1 or 2 (or 0?)\n",
    "\t\t\t# FIXME: CAN COUNT BE 0?\n",
    "\t\t\telse:\n",
    "\t\t\t\t# If count is 1, leave the char as is\n",
    "\t\t\t\tif count == 1:\n",
    "\t\t\t\t\tcompressed_string.append(last_char)\n",
    "\t\t\t\t\tcount = 1\n",
    "\t\t\t\t\tlast_char = char\n",
    "\t\t\t\t# If count is 2, append the character twice\n",
    "\t\t\t\telse:\n",
    "\t\t\t\t\tcompressed_string.append(last_char)\n",
    "\t\t\t\t\tcompressed_string.append(last_char)\n",
    "\t\t\t\t\tcount = 1\n",
    "\t\t\t\t\tlast_char = char\n",
    "\tcompressed_string.append(last_char)\n",
    "\tcompressed_string.append(str(count))\n",
    "\n",
    "\t# Convert the characters in the list to a string\n",
    "\treturn \"\".join(compressed_string)"
    "\tif string is None or len(string) == 0:\n",
    "\t\treturn string\n",
    "\n",
    "\t# Calculate the size of the compressed string\n",
    "\tsize = 0\n",
    "\tlast_char = string[0]\n",
    "\tfor char in string:\n",
    "\t\tif char != last_char:\n",
    "\t\t\tsize += 2\n",
    "\t\t\tlast_char = char\n",
    "\tsize += 2\n",
    "\n",
    "\t# If the compressed string size is greater than\n",
    "\t# or equal to string size, return original string\n",
    "\tif size >= len(string):\n",
    "\t\treturn string\n",
    "\n",
    "\t# Create compressed_string\n",
    "\t# New objective:\n",
    "\t\t# Single characters are to be left as is\n",
    "\t\t# Double characters are to be left as are\n",
    "\tcompressed_string = list()\n",
    "\tcount = 0\n",
    "\tlast_char = string[0]\n",
    "\tfor char in string:\n",
    "\t\tif char == last_char:\n",
    "\t\t\tcount += 1\n",
    "\t\telse:\n",
    "\t\t\t# Do the old compression tricks only if count exceeds two\n",
    "\t\t\tif count > 2:\n",
    "\t\t\t\tcompressed_string.append(last_char)\n",
    "\t\t\t\tcompressed_string.append(str(count))\n",
    "\t\t\t\tcount = 1\n",
    "\t\t\t\tlast_char = char\n",
    "\t\t\t# If count is either 1 or 2 (or 0?)\n",
    "\t\t\t# FIXME: CAN COUNT BE 0?\n",
    "\t\t\telse:\n",
    "\t\t\t\t# If count is 1, leave the char as is\n",
    "\t\t\t\tif count == 1:\n",
    "\t\t\t\t\tcompressed_string.append(last_char)\n",
    "\t\t\t\t\tcount = 1\n",
    "\t\t\t\t\tlast_char = char\n",
    "\t\t\t\t# If count is 2, append the character twice\n",
    "\t\t\t\telse:\n",
    "\t\t\t\t\tcompressed_string.append(last_char)\n",
    "\t\t\t\t\tcompressed_string.append(last_char)\n",
    "\t\t\t\t\tcount = 1\n",
    "\t\t\t\t\tlast_char = char\n",
    "\tcompressed_string.append(last_char)\n",
    "\tcompressed_string.append(str(count))\n",
    "\n",
    "\t# Convert the characters in the list to a string\n",
    "\treturn \"\".join(compressed_string)"
    "\tif string is None or len(string) == 0:\n",
    "\t\treturn string\n",
    "\n",
    "\t# Calculate the size of the compressed string\n",
    "\tsize = 0\n",
    "\tlast_char = string[0]\n",
    "\tfor char in string:\n",
    "\t\tif char != last_char:\n",
    "\t\t\tsize += 2\n",
    "\t\t\tlast_char = char\n",
    "\tsize += 2\n",
    "\n",
    "\t# If the compressed string size is greater than\n",
    "\t# or equal to string size, return original string\n",
    "\tif size >= len(string):\n",
    "\t\treturn string\n",
    "\n",
    "\t# Create compressed_string\n",
    "\t# New objective:\n",
    "\t\t# Single characters are to be left as is\n",
    "\t\t# Double characters are to be left as are\n",
    "\tcompressed_string = list()\n",
    "\tcount = 0\n",
    "\tlast_char = string[0]\n",
    "\tfor char in string:\n",
    "\t\tif char == last_char:\n",
    "\t\t\tcount += 1\n",
    "\t\telse:\n",
    "\t\t\t# Do the old compression tricks only if count exceeds two\n",
    "\t\t\tif count > 2:\n",
    "\t\t\t\tcompressed_string.append(last_char)\n",
    "\t\t\t\tcompressed_string.append(str(count))\n",
    "\t\t\t\tcount = 1\n",
    "\t\t\t\tlast_char = char\n",
    "\t\t\t# If count is either 1 or 2 (or 0?)\n",
    "\t\t\t# FIXME: CAN COUNT BE 0?\n",
    "\t\t\telse:\n",
    "\t\t\t\t# If count is 1, leave the char as is\n",
    "\t\t\t\tif count == 1:\n",
    "\t\t\t\t\tcompressed_string.append(last_char)\n",
    "\t\t\t\t\tcount = 1\n",
    "\t\t\t\t\tlast_char = char\n",
    "\t\t\t\t# If count is 2, append the character twice\n",
    "\t\t\t\telse:\n",
    "\t\t\t\t\tcompressed_string.append(last_char)\n",
    "\t\t\t\t\tcompressed_string.append(last_char)\n",
    "\t\t\t\t\tcount = 1\n",
    "\t\t\t\t\tlast_char = char\n",
    "\tcompressed_string.append(last_char)\n",
    "\tcompressed_string.append(str(count))\n",
    "\n",
    "\t# Convert the characters in the list to a string\n",
    "\treturn \"\".join(compressed_string)"
    "\tif string is None or len(string) == 0:\n",
    "\t\treturn string\n",
    "\n",
    "\t# Calculate the size of the compressed string\n",
    "\tsize = 0\n",
    "\tlast_char = string[0]\n",
    "\tfor char in string:\n",
    "\t\tif char != last_char:\n",
    "\t\t\tsize += 2\n",
    "\t\t\tlast_char = char\n",
    "\tsize += 2\n",
    "\n",
    "\t# If the compressed string size is greater than\n",
    "\t# or equal to string size, return original string\n",
    "\tif size >= len(string):\n",
    "\t\treturn string\n",
    "\n",
    "\t# Create compressed_string\n",
    "\t# New objective:\n",
    "\t\t# Single characters are to be left as is\n",
    "\t\t# Double characters are to be left as are\n",
    "\tcompressed_string = list()\n",
    "\tcount = 0\n",
    "\tlast_char = string[0]\n",
    "\tfor char in string:\n",
    "\t\tif char == last_char:\n",
    "\t\t\tcount += 1\n",
    "\t\telse:\n",
    "\t\t\t# Do the old compression tricks only if count exceeds two\n",
    "\t\t\tif count > 2:\n",
    "\t\t\t\tcompressed_string.append(last_char)\n",
    "\t\t\t\tcompressed_string.append(str(count))\n",
    "\t\t\t\tcount = 1\n",
    "\t\t\t\tlast_char = char\n",
    "\t\t\t# If count is either 1 or 2 (or 0?)\n",
    "\t\t\t# FIXME: CAN COUNT BE 0?\n",
    "\t\t\telse:\n",
    "\t\t\t\t# If count is 1, leave the char as is\n",
    "\t\t\t\tif count == 1:\n",
    "\t\t\t\t\tcompressed_string.append(last_char)\n",
    "\t\t\t\t\tcount = 1\n",
    "\t\t\t\t\tlast_char = char\n",
    "\t\t\t\t# If count is 2, append the character twice\n",
    "\t\t\t\telse:\n",
    "\t\t\t\t\tcompressed_string.append(last_char)\n",
    "\t\t\t\t\tcompressed_string.append(last_char)\n",
    "\t\t\t\t\tcount = 1\n",
    "\t\t\t\t\tlast_char = char\n",
    "\tcompressed_string.append(last_char)\n",
    "\tcompressed_string.append(str(count))\n",
    "\n",
    "\t# Convert the characters in the list to a string\n",
    "\treturn \"\".join(compressed_string)"
    "\tif string is None or len(string) == 0:\n",
    "\t\treturn string\n",
    "\n",
    "\t# Calculate the size of the compressed string\n",
    "\tsize = 0\n",
    "\tlast_char = string[0]\n",
    "\tfor char in string:\n",
    "\t\tif char != last_char:\n",
    "\t\t\tsize += 2\n",
    "\t\t\tlast_char = char\n",
    "\tsize += 2\n",
    "\n",
    "\t# If the compressed string size is greater than\n",
    "\t# or equal to string size, return original string\n",
    "\tif size >= len(string):\n",
    "\t\treturn string\n",
    "\n",
    "\t# Create compressed_string\n",
    "\t# New objective:\n",
    "\t\t# Single characters are to be left as is\n",
    "\t\t# Double characters are to be left as are\n",
    "\tcompressed_string = list()\n",
    "\tcount = 0\n",
    "\tlast_char = string[0]\n",
    "\tfor char in string:\n",
    "\t\tif char == last_char:\n",
    "\t\t\tcount += 1\n",
    "\t\telse:\n",
    "\t\t\t# Do the old compression tricks only if count exceeds two\n",
    "\t\t\tif count > 2:\n",
    "\t\t\t\tcompressed_string.append(last_char)\n",
    "\t\t\t\tcompressed_string.append(str(count))\n",
    "\t\t\t\tcount = 1\n",
    "\t\t\t\tlast_char = char\n",
    "\t\t\t# If count is either 1 or 2 (or 0?)\n",
    "\t\t\t# FIXME: CAN COUNT BE 0?\n",
    "\t\t\telse:\n",
    "\t\t\t\t# If count is 1, leave the char as is\n",
    "\t\t\t\tif count == 1:\n",
    "\t\t\t\t\tcompressed_string.append(last_char)\n",
    "\t\t\t\t\tcount = 1\n",
    "\t\t\t\t\tlast_char = char\n",
    "\t\t\t\t# If count is 2, append the character twice\n",
    "\t\t\t\telse:\n",
    "\t\t\t\t\tcompressed_string.append(last_char)\n",
    "\t\t\t\t\tcompressed_string.append(last_char)\n",
    "\t\t\t\t\tcount = 1\n",
    "\t\t\t\t\tlast_char = char\n",
    "\tcompressed_string.append(last_char)\n",
    "\tcompressed_string.append(str(count))\n",
    "\n",
    "\t# Convert the characters in the list to a string\n",
    "\treturn \"\".join(compressed_string)"
    "\tif string is None or len(string) == 0:\n",
    "\t\treturn string\n",
    "\n",
    "\t# Calculate the size of the compressed string\n",
    "\tsize = 0\n",
    "\tlast_char = string[0]\n",
    "\tfor char in string:\n",
    "\t\tif char != last_char:\n",
    "\t\t\tsize += 2\n",
    "\t\t\tlast_char = char\n",
    "\tsize += 2\n",
    "\n",
    "\t# If the compressed string size is greater than\n",
    "\t# or equal to string size, return original string\n",
    "\tif size >= len(string):\n",
    "\t\treturn string\n",
    "\n",
    "\t# Create compressed_string\n",
    "\t# New objective:\n",
    "\t\t# Single characters are to be left as is\n",
    "\t\t# Double characters are to be left as are\n",
    "\tcompressed_string = list()\n",
    "\tcount = 0\n",
    "\tlast_char = string[0]\n",
    "\tfor char in string:\n",
    "\t\tif char == last_char:\n",
    "\t\t\tcount += 1\n",
    "\t\telse:\n",
    "\t\t\t# Do the old compression tricks only if count exceeds two\n",
    "\t\t\tif count > 2:\n",
    "\t\t\t\tcompressed_string.append(last_char)\n",
    "\t\t\t\tcompressed_string.append(str(count))\n",
    "\t\t\t\tcount = 1\n",
    "\t\t\t\tlast_char = char\n",
    "\t\t\t# If count is either 1 or 2 (or 0?)\n",
    "\t\t\t# FIXME: CAN COUNT BE 0?\n",
    "\t\t\telse:\n",
    "\t\t\t\t# If count is 1, leave the char as is\n",
    "\t\t\t\tif count == 1:\n",
    "\t\t\t\t\tcompressed_string.append(last_char)\n",
    "\t\t\t\t\tcount = 1\n",
    "\t\t\t\t\tlast_char = char\n",
    "\t\t\t\t# If count is 2, append the character twice\n",
    "\t\t\t\telse:\n",
    "\t\t\t\t\tcompressed_string.append(last_char)\n",
    "\t\t\t\t\tcompressed_string.append(last_char)\n",
    "\t\t\t\t\tcount = 1\n",
    "\t\t\t\t\tlast_char = char\n",
    "\tcompressed_string.append(last_char)\n",
    "\tcompressed_string.append(str(count))\n",
    "\n",
    "\t# Convert the characters in the list to a string\n",
    "\treturn \"\".join(compressed_string)"
    "\tif string is None or len(string) == 0:\n",
    "\t\treturn string\n",
    "\n",
    "\t# Calculate the size of the compressed string\n",
    "\tsize = 0\n",
    "\tlast_char = string[0]\n",
    "\tfor char in string:\n",
    "\t\tif char != last_char:\n",
    "\t\t\tsize += 2\n",
    "\t\t\tlast_char = char\n",
    "\tsize += 2\n",
    "\n",
    "\t# If the compressed string size is greater than\n",
    "\t# or equal to string size, return original string\n",
    "\tif size >= len(string):\n",
    "\t\treturn string\n",
    "\n",
    "\t# Create compressed_string\n",
    "\t# New objective:\n",
    "\t\t# Single characters are to be left as is\n",
    "\t\t# Double characters are to be left as are\n",
    "\tcompressed_string = list()\n",
    "\tcount = 0\n",
    "\tlast_char = string[0]\n",
    "\tfor char in string:\n",
    "\t\tif char == last_char:\n",
    "\t\t\tcount += 1\n",
    "\t\telse:\n",
    "\t\t\t# Do the old compression tricks only if count exceeds two\n",
    "\t\t\tif count > 2:\n",
    "\t\t\t\tcompressed_string.append(last_char)\n",
    "\t\t\t\tcompressed_string.append(str(count))\n",
    "\t\t\t\tcount = 1\n",
    "\t\t\t\tlast_char = char\n",
    "\t\t\t# If count is either 1 or 2 (or 0?)\n",
    "\t\t\t# FIXME: CAN COUNT BE 0?\n",
    "\t\t\telse:\n",
    "\t\t\t\t# If count is 1, leave the char as is\n",
    "\t\t\t\tif count == 1:\n",
    "\t\t\t\t\tcompressed_string.append(last_char)\n",
    "\t\t\t\t\tcount = 1\n",
    "\t\t\t\t\tlast_char = char\n",
    "\t\t\t\t# If count is 2, append the character twice\n",
    "\t\t\t\telse:\n",
    "\t\t\t\t\tcompressed_string.append(last_char)\n",
    "\t\t\t\t\tcompressed_string.append(last_char)\n",
    "\t\t\t\t\tcount = 1\n",
    "\t\t\t\t\tlast_char = char\n",
    "\tcompressed_string.append(last_char)\n",
    "\tcompressed_string.append(str(count))\n",
    "\n",
    "\t# Convert the characters in the list to a string\n",
    "\treturn \"\".join(compressed_string)"
    "\tif string is None or len(string) == 0:\n",
    "\t\treturn string\n",
    "\n",
    "\t# Calculate the size of the compressed string\n",
    "\tsize = 0\n",
    "\tlast_char = string[0]\n",
    "\tfor char in string:\n",
    "\t\tif char != last_char:\n",
    "\t\t\tsize += 2\n",
    "\t\t\tlast_char = char\n",
    "\tsize += 2\n",
    "\n",
    "\t# If the compressed string size is greater than\n",
    "\t# or equal to string size, return original string\n",
    "\tif size >= len(string):\n",
    "\t\treturn string\n",
    "\n",
    "\t# Create compressed_string\n",
    "\t# New objective:\n",
    "\t\t# Single characters are to be left as is\n",
    "\t\t# Double characters are to be left as are\n",
    "\tcompressed_string = list()\n",
    "\tcount = 0\n",
    "\tlast_char = string[0]\n",
    "\tfor char in string:\n",
    "\t\tif char == last_char:\n",
    "\t\t\tcount += 1\n",
    "\t\telse:\n",
    "\t\t\t# Do the old compression tricks only if count exceeds two\n",
    "\t\t\tif count > 2:\n",
    "\t\t\t\tcompressed_string.append(last_char)\n",
    "\t\t\t\tcompressed_string.append(str(count))\n",
    "\t\t\t\tcount = 1\n",
    "\t\t\t\tlast_char = char\n",
    "\t\t\t# If count is either 1 or 2 (or 0?)\n",
    "\t\t\t# FIXME: CAN COUNT BE 0?\n",
    "\t\t\telse:\n",
    "\t\t\t\t# If count is 1, leave the char as is\n",
    "\t\t\t\tif count == 1:\n",
    "\t\t\t\t\tcompressed_string.append(last_char)\n",
    "\t\t\t\t\tcount = 1\n",
    "\t\t\t\t\tlast_char = char\n",
    "\t\t\t\t# If count is 2, append the character twice\n",
    "\t\t\t\telse:\n",
    "\t\t\t\t\tcompressed_string.append(last_char)\n",
    "\t\t\t\t\tcompressed_string.append(last_char)\n",
    "\t\t\t\t\tcount = 1\n",
    "\t\t\t\t\tlast_char = char\n",
    "\tcompressed_string.append(last_char)\n",
    "\tcompressed_string.append(str(count))\n",
    "\n",
    "\t# Convert the characters in the list to a string\n",
    "\treturn \"\".join(compressed_string)"
    "\tif string is None or len(string) == 0:\n",
    "\t\treturn string\n",
    "\n",
    "\t# Calculate the size of the compressed string\n",
    "\tsize = 0\n",
    "\tlast_char = string[0]\n",
    "\tfor char in string:\n",
    "\t\tif char != last_char:\n",
    "\t\t\tsize += 2\n",
    "\t\t\tlast_char = char\n",
    "\tsize += 2\n",
    "\n",
    "\t# If the compressed string size is greater than\n",
    "\t# or equal to string size, return original string\n",
    "\tif size >= len(string):\n",
    "\t\treturn string\n",
    "\n",
    "\t# Create compressed_string\n",
    "\t# New objective:\n",
    "\t\t# Single characters are to be left as is\n",
    "\t\t# Double characters are to be left as are\n",
    "\tcompressed_string = list()\n",
    "\tcount = 0\n",
    "\tlast_char = string[0]\n",
    "\tfor char in string:\n",
    "\t\tif char == last_char:\n",
    "\t\t\tcount += 1\n",
    "\t\telse:\n",
    "\t\t\t# Do the old compression tricks only if count exceeds two\n",
    "\t\t\tif count > 2:\n",
    "\t\t\t\tcompressed_string.append(last_char)\n",
    "\t\t\t\tcompressed_string.append(str(count))\n",
    "\t\t\t\tcount = 1\n",
    "\t\t\t\tlast_char = char\n",
    "\t\t\t# If count is either 1 or 2 (or 0?)\n",
    "\t\t\t# FIXME: CAN COUNT BE 0?\n",
    "\t\t\telse:\n",
    "\t\t\t\t# If count is 1, leave the char as is\n",
    "\t\t\t\tif count == 1:\n",
    "\t\t\t\t\tcompressed_string.append(last_char)\n",
    "\t\t\t\t\tcount = 1\n",
    "\t\t\t\t\tlast_char = char\n",
    "\t\t\t\t# If count is 2, append the character twice\n",
    "\t\t\t\telse:\n",
    "\t\t\t\t\tcompressed_string.append(last_char)\n",
    "\t\t\t\t\tcompressed_string.append(last_char)\n",
    "\t\t\t\t\tcount = 1\n",
    "\t\t\t\t\tlast_char = char\n",
    "\tcompressed_string.append(last_char)\n",
    "\tcompressed_string.append(str(count))\n",
    "\n",
    "\t# Convert the characters in the list to a string\n",
    "\treturn \"\".join(compressed_string)"
    "\tif string is None or len(string) == 0:\n",
    "\t\treturn string\n",
    "\n",
    "\t# Calculate the size of the compressed string\n",
    "\tsize = 0\n",
    "\tlast_char = string[0]\n",
    "\tfor char in string:\n",
    "\t\tif char != last_char:\n",
    "\t\t\tsize += 2\n",
    "\t\t\tlast_char = char\n",
    "\tsize += 2\n",
    "\n",
    "\t# If the compressed string size is greater than\n",
    "\t# or equal to string size, return original string\n",
    "\tif size >= len(string):\n",
    "\t\treturn string\n",
    "\n",
    "\t# Create compressed_string\n",
    "\t# New objective:\n",
    "\t\t# Single characters are to be left as is\n",
    "\t\t# Double characters are to be left as are\n",
    "\tcompressed_string = list()\n",
    "\tcount = 0\n",
    "\tlast_char = string[0]\n",
    "\tfor char in string:\n",
    "\t\tif char == last_char:\n",
    "\t\t\tcount += 1\n",
    "\t\telse:\n",
    "\t\t\t# Do the old compression tricks only if count exceeds two\n",
    "\t\t\tif count > 2:\n",
    "\t\t\t\tcompressed_string.append(last_char)\n",
    "\t\t\t\tcompressed_string.append(str(count))\n",
    "\t\t\t\tcount = 1\n",
    "\t\t\t\tlast_char = char\n",
    "\t\t\t# If count is either 1 or 2 (or 0?)\n",
    "\t\t\t# FIXME: CAN COUNT BE 0?\n",
    "\t\t\telse:\n",
    "\t\t\t\t# If count is 1, leave the char as is\n",
    "\t\t\t\tif count == 1:\n",
    "\t\t\t\t\tcompressed_string.append(last_char)\n",
    "\t\t\t\t\tcount = 1\n",
    "\t\t\t\t\tlast_char = char\n",
    "\t\t\t\t# If count is 2, append the character twice\n",
    "\t\t\t\telse:\n",
    "\t\t\t\t\tcompressed_string.append(last_char)\n",
    "\t\t\t\t\tcompressed_string.append(last_char)\n",
    "\t\t\t\t\tcount = 1\n",
    "\t\t\t\t\tlast_char = char\n",
    "\tcompressed_string.append(last_char)\n",
    "\tcompressed_string.append(str(count))\n",
    "\n",
    "\t# Convert the characters in the list to a string\n",
    "\treturn \"\".join(compressed_string)"
    "\tif string is None or len(string) == 0:\n",
    "\t\treturn string\n",
    "\n",
    "\t# Calculate the size of the compressed string\n",
    "\tsize = 0\n",
    "\tlast_char = string[0]\n",
    "\tfor char in string:\n",
    "\t\tif char != last_char:\n",
    "\t\t\tsize += 2\n",
    "\t\t\tlast_char = char\n",
    "\tsize += 2\n",
    "\n",
    "\t# If the compressed string size is greater than\n",
    "\t# or equal to string size, return original string\n",
    "\tif size >= len(string):\n",
    "\t\treturn string\n",
    "\n",
    "\t# Create compressed_string\n",
    "\t# New objective:\n",
    "\t\t# Single characters are to be left as is\n",
    "\t\t# Double characters are to be left as are\n",
    "\tcompressed_string = list()\n",
    "\tcount = 0\n",
    "\tlast_char = string[0]\n",
    "\tfor char in string:\n",
    "\t\tif char == last_char:\n",
    "\t\t\tcount += 1\n",
    "\t\telse:\n",
    "\t\t\t# Do the old compression tricks only if count exceeds two\n",
    "\t\t\tif count > 2:\n",
    "\t\t\t\tcompressed_string.append(last_char)\n",
    "\t\t\t\tcompressed_string.append(str(count))\n",
    "\t\t\t\tcount = 1\n",
    "\t\t\t\tlast_char = char\n",
    "\t\t\t# If count is either 1 or 2 (or 0?)\n",
    "\t\t\t# FIXME: CAN COUNT BE 0?\n",
    "\t\t\telse:\n",
    "\t\t\t\t# If count is 1, leave the char as is\n",
    "\t\t\t\tif count == 1:\n",
    "\t\t\t\t\tcompressed_string.append(last_char)\n",
    "\t\t\t\t\tcount = 1\n",
    "\t\t\t\t\tlast_char = char\n",
    "\t\t\t\t# If count is 2, append the character twice\n",
    "\t\t\t\telse:\n",
    "\t\t\t\t\tcompressed_string.append(last_char)\n",
    "\t\t\t\t\tcompressed_string.append(last_char)\n",
    "\t\t\t\t\tcount = 1\n",
    "\t\t\t\t\tlast_char = char\n",
    "\tcompressed_string.append(last_char)\n",
    "\tcompressed_string.append(str(count))\n",
    "\n",
    "\t# Convert the characters in the list to a string\n",
    "\treturn \"\".join(compressed_string)"
    "\tif string is None or len(string) == 0:\n",
    "\t\treturn string\n",
    "\n",
    "\t# Calculate the size of the compressed string\n",
    "\tsize = 0\n",
    "\tlast_char = string[0]\n",
    "\tfor char in string:\n",
    "\t\tif char != last_char:\n",
    "\t\t\tsize += 2\n",
    "\t\t\tlast_char = char\n",
    "\tsize += 2\n",
    "\n",
    "\t# If the compressed string size is greater than\n",
    "\t# or equal to string size, return original string\n",
    "\tif size >= len(string):\n",
    "\t\treturn string\n",
    "\n",
    "\t# Create compressed_string\n",
    "\t# New objective:\n",
    "\t\t# Single characters are to be left as is\n",
    "\t\t# Double characters are to be left as are\n",
    "\tcompressed_string = list()\n",
    "\tcount = 0\n",
    "\tlast_char = string[0]\n",
    "\tfor char in string:\n",
    "\t\tif char == last_char:\n",
    "\t\t\tcount += 1\n",
    "\t\telse:\n",
    "\t\t\t# Do the old compression tricks only if count exceeds two\n",
    "\t\t\tif count > 2:\n",
    "\t\t\t\tcompressed_string.append(last_char)\n",
    "\t\t\t\tcompressed_string.append(str(count))\n",
    "\t\t\t\tcount = 1\n",
    "\t\t\t\tlast_char = char\n",
    "\t\t\t# If count is either 1 or 2 (or 0?)\n",
    "\t\t\t# FIXME: CAN COUNT BE 0?\n",
    "\t\t\telse:\n",
    "\t\t\t\t# If count is 1, leave the char as is\n",
    "\t\t\t\tif count == 1:\n",
    "\t\t\t\t\tcompressed_string.append(last_char)\n",
    "\t\t\t\t\tcount = 1\n",
    "\t\t\t\t\tlast_char = char\n",
    "\t\t\t\t# If count is 2, append the character twice\n",
    "\t\t\t\telse:\n",
    "\t\t\t\t\tcompressed_string.append(last_char)\n",
    "\t\t\t\t\tcompressed_string.append(last_char)\n",
    "\t\t\t\t\tcount = 1\n",
    "\t\t\t\t\tlast_char = char\n",
    "\tcompressed_string.append(last_char)\n",
    "\tcompressed_string.append(str(count))\n",
    "\n",
    "\t# Convert the characters in the list to a string\n",
    "\treturn \"\".join(compressed_string)"
    "\tif string is None or len(string) == 0:\n",
    "\t\treturn string\n",
    "\n",
    "\t# Calculate the size of the compressed string\n",
    "\tsize = 0\n",
    "\tlast_char = string[0]\n",
    "\tfor char in string:\n",
    "\t\tif char != last_char:\n",
    "\t\t\tsize += 2\n",
    "\t\t\tlast_char = char\n",
    "\tsize += 2\n",
    "\n",
    "\t# If the compressed string size is greater than\n",
    "\t# or equal to string size, return original string\n",
    "\tif size >= len(string):\n",
    "\t\treturn string\n",
    "\n",
    "\t# Create compressed_string\n",
    "\t# New objective:\n",
    "\t\t# Single characters are to be left as is\n",
    "\t\t# Double characters are to be left as are\n",
    "\tcompressed_string = list()\n",
    "\tcount = 0\n",
    "\tlast_char = string[0]\n",
    "\tfor char in string:\n",
    "\t\tif char == last_char:\n",
    "\t\t\tcount += 1\n",
    "\t\telse:\n",
    "\t\t\t# Do the old compression tricks only if count exceeds two\n",
    "\t\t\tif count > 2:\n",
    "\t\t\t\tcompressed_string.append(last_char)\n",
    "\t\t\t\tcompressed_string.append(str(count))\n",
    "\t\t\t\tcount = 1\n",
    "\t\t\t\tlast_char = char\n",
    "\t\t\t# If count is either 1 or 2 (or 0?)\n",
    "\t\t\t# FIXME: CAN COUNT BE 0?\n",
    "\t\t\telse:\n",
    "\t\t\t\t# If count is 1, leave the char as is\n",
    "\t\t\t\tif count == 1:\n",
    "\t\t\t\t\tcompressed_string.append(last_char)\n",
    "\t\t\t\t\tcount = 1\n",
    "\t\t\t\t\tlast_char = char\n",
    "\t\t\t\t# If count is 2, append the character twice\n",
    "\t\t\t\telse:\n",
    "\t\t\t\t\tcompressed_string.append(last_char)\n",
    "\t\t\t\t\tcompressed_string.append(last_char)\n",
    "\t\t\t\t\tcount = 1\n",
    "\t\t\t\t\tlast_char = char\n",
    "\tcompressed_string.append(last_char)\n",
    "\tcompressed_string.append(str(count))\n",
    "\n",
    "\t# Convert the characters in the list to a string\n",
    "\treturn \"\".join(compressed_string)"
    "\tif string is None or len(string) == 0:\n",
    "\t\treturn string\n",
    "\n",
    "\t# Calculate the size of the compressed string\n",
    "\tsize = 0\n",
    "\tlast_char = string[0]\n",
    "\tfor char in string:\n",
    "\t\tif char != last_char:\n",
    "\t\t\tsize += 2\n",
    "\t\t\tlast_char = char\n",
    "\tsize += 2\n",
    "\n",
    "\t# If the compressed string size is greater than\n",
    "\t# or equal to string size, return original string\n",
    "\tif size >= len(string):\n",
    "\t\treturn string\n",
    "\n",
    "\t# Create compressed_string\n",
    "\t# New objective:\n",
    "\t\t# Single characters are to be left as is\n",
    "\t\t# Double characters are to be left as are\n",
    "\tcompressed_string = list()\n",
    "\tcount = 0\n",
    "\tlast_char = string[0]\n",
    "\tfor char in string:\n",
    "\t\tif char == last_char:\n",
    "\t\t\tcount += 1\n",
    "\t\telse:\n",
    "\t\t\t# Do the old compression tricks only if count exceeds two\n",
    "\t\t\tif count > 2:\n",
    "\t\t\t\tcompressed_string.append(last_char)\n",
    "\t\t\t\tcompressed_string.append(str(count))\n",
    "\t\t\t\tcount = 1\n",
    "\t\t\t\tlast_char = char\n",
    "\t\t\t# If count is either 1 or 2 (or 0?)\n",
    "\t\t\t# FIXME: CAN COUNT BE 0?\n",
    "\t\t\telse:\n",
    "\t\t\t\t# If count is 1, leave the char as is\n",
    "\t\t\t\tif count == 1:\n",
    "\t\t\t\t\tcompressed_string.append(last_char)\n",
    "\t\t\t\t\tcount = 1\n",
    "\t\t\t\t\tlast_char = char\n",
    "\t\t\t\t# If count is 2, append the character twice\n",
    "\t\t\t\telse:\n",
    "\t\t\t\t\tcompressed_string.append(last_char)\n",
    "\t\t\t\t\tcompressed_string.append(last_char)\n",
    "\t\t\t\t\tcount = 1\n",
    "\t\t\t\t\tlast_char = char\n",
    "\tcompressed_string.append(last_char)\n",
    "\tcompressed_string.append(str(count))\n",
    "\n",
    "\t# Convert the characters in the list to a string\n",
    "\treturn \"\".join(compressed_string)"
    "\tif string is None or len(string) == 0:\n",
    "\t\treturn string\n",
    "\n",
    "\t# Calculate the size of the compressed string\n",
    "\tsize = 0\n",
    "\tlast_char = string[0]\n",
    "\tfor char in string:\n",
    "\t\tif char != last_char:\n",
    "\t\t\tsize += 2\n",
    "\t\t\tlast_char = char\n",
    "\tsize += 2\n",
    "\n",
    "\t# If the compressed string size is greater than\n",
    "\t# or equal to string size, return original string\n",
    "\tif size >= len(string):\n",
    "\t\treturn string\n",
    "\n",
    "\t# Create compressed_string\n",
    "\t# New objective:\n",
    "\t\t# Single characters are to be left as is\n",
    "\t\t# Double characters are to be left as are\n",
    "\tcompressed_string = list()\n",
    "\tcount = 0\n",
    "\tlast_char = string[0]\n",
    "\tfor char in string:\n",
    "\t\tif char == last_char:\n",
    "\t\t\tcount += 1\n",
    "\t\telse:\n",
    "\t\t\t# Do the old compression tricks only if count exceeds two\n",
    "\t\t\tif count > 2:\n",
    "\t\t\t\tcompressed_string.append(last_char)\n",
    "\t\t\t\tcompressed_string.append(str(count))\n",
    "\t\t\t\tcount = 1\n",
    "\t\t\t\tlast_char = char\n",
    "\t\t\t# If count is either 1 or 2 (or 0?)\n",
    "\t\t\t# FIXME: CAN COUNT BE 0?\n",
    "\t\t\telse:\n",
    "\t\t\t\t# If count is 1, leave the char as is\n",
    "\t\t\t\tif count == 1:\n",
    "\t\t\t\t\tcompressed_string.append(last_char)\n",
    "\t\t\t\t\tcount = 1\n",
    "\t\t\t\t\tlast_char = char\n",
    "\t\t\t\t# If count is 2, append the character twice\n",
    "\t\t\t\telse:\n",
    "\t\t\t\t\tcompressed_string.append(last_char)\n",
    "\t\t\t\t\tcompressed_string.append(last_char)\n",
    "\t\t\t\t\tcount = 1\n",
    "\t\t\t\t\tlast_char = char\n",
    "\tcompressed_string.append(last_char)\n",
    "\tcompressed_string.append(str(count))\n",
    "\n",
    "\t# Convert the characters in the list to a string\n",
    "\treturn \"\".join(compressed_string)"
    "\tif string is None or len(string) == 0:\n",
    "\t\treturn string\n",
    "\n",
    "\t# Calculate the size of the compressed string\n",
    "\tsize = 0\n",
    "\tlast_char = string[0]\n",
    "\tfor char in string:\n",
    "\t\tif char != last_char:\n",
    "\t\t\tsize += 2\n",
    "\t\t\tlast_char = char\n",
    "\tsize += 2\n",
    "\n",
    "\t# If the compressed string size is greater than\n",
    "\t# or equal to string size, return original string\n",
    "\tif size >= len(string):\n",
    "\t\treturn string\n",
    "\n",
    "\t# Create compressed_string\n",
    "\t# New objective:\n",
    "\t\t# Single characters are to be left as is\n",
    "\t\t# Double characters are to be left as are\n",
    "\tcompressed_string = list()\n",
    "\tcount = 0\n",
    "\tlast_char = string[0]\n",
    "\tfor char in string:\n",
    "\t\tif char == last_char:\n",
    "\t\t\tcount += 1\n",
    "\t\telse:\n",
    "\t\t\t# Do the old compression tricks only if count exceeds two\n",
    "\t\t\tif count > 2:\n",
    "\t\t\t\tcompressed_string.append(last_char)\n",
    "\t\t\t\tcompressed_string.append(str(count))\n",
    "\t\t\t\tcount = 1\n",
    "\t\t\t\tlast_char = char\n",
    "\t\t\t# If count is either 1 or 2 (or 0?)\n",
    "\t\t\t# FIXME: CAN COUNT BE 0?\n",
    "\t\t\telse:\n",
    "\t\t\t\t# If count is 1, leave the char as is\n",
    "\t\t\t\tif count == 1:\n",
    "\t\t\t\t\tcompressed_string.append(last_char)\n",
    "\t\t\t\t\tcount = 1\n",
    "\t\t\t\t\tlast_char = char\n",
    "\t\t\t\t# If count is 2, append the character twice\n",
    "\t\t\t\telse:\n",
    "\t\t\t\t\tcompressed_string.append(last_char)\n",
    "\t\t\t\t\tcompressed_string.append(last_char)\n",
    "\t\t\t\t\tcount = 1\n",
    "\t\t\t\t\tlast_char = char\n",
    "\tcompressed_string.append(last_char)\n",
    "\tcompressed_string.append(str(count))\n",
    "\n",
    "\t# Convert the characters in the list to a string\n",
    "\treturn \"\".join(compressed_string)"
    "\tif string is None or len(string) == 0:\n",
    "\t\treturn string\n",
    "\n",
    "\t# Calculate the size of the compressed string\n",
    "\tsize = 0\n",
    "\tlast_char = string[0]\n",
    "\tfor char in string:\n",
    "\t\tif char != last_char:\n",
    "\t\t\tsize += 2\n",
    "\t\t\tlast_char = char\n",
    "\tsize += 2\n",
    "\n",
    "\t# If the compressed string size is greater than\n",
    "\t# or equal to string size, return original string\n",
    "\tif size >= len(string):\n",
    "\t\treturn string\n",
    "\n",
    "\t# Create compressed_string\n",
    "\t# New objective:\n",
    "\t\t# Single characters are to be left as is\n",
    "\t\t# Double characters are to be left as are\n",
    "\tcompressed_string = list()\n",
    "\tcount = 0\n",
    "\tlast_char = string[0]\n",
    "\tfor char in string:\n",
    "\t\tif char == last_char:\n",
    "\t\t\tcount += 1\n",
    "\t\telse:\n",
    "\t\t\t# Do the old compression tricks only if count exceeds two\n",
    "\t\t\tif count > 2:\n",
    "\t\t\t\tcompressed_string.append(last_char)\n",
    "\t\t\t\tcompressed_string.append(str(count))\n",
    "\t\t\t\tcount = 1\n",
    "\t\t\t\tlast_char = char\n",
    "\t\t\t# If count is either 1 or 2 (or 0?)\n",
    "\t\t\t# FIXME: CAN COUNT BE 0?\n",
    "\t\t\telse:\n",
    "\t\t\t\t# If count is 1, leave the char as is\n",
    "\t\t\t\tif count == 1:\n",
    "\t\t\t\t\tcompressed_string.append(last_char)\n",
    "\t\t\t\t\tcount = 1\n",
    "\t\t\t\t\tlast_char = char\n",
    "\t\t\t\t# If count is 2, append the character twice\n",
    "\t\t\t\telse:\n",
    "\t\t\t\t\tcompressed_string.append(last_char)\n",
    "\t\t\t\t\tcompressed_string.append(last_char)\n",
    "\t\t\t\t\tcount = 1\n",
    "\t\t\t\t\tlast_char = char\n",
    "\tcompressed_string.append(last_char)\n",
    "\tcompressed_string.append(str(count))\n",
    "\n",
    "\t# Convert the characters in the list to a string\n",
    "\treturn \"\".join(compressed_string)"
    "\tif string is None or len(string) == 0:\n",
    "\t\treturn string\n",
    "\n",
    "\t# Calculate the size of the compressed string\n",
    "\tsize = 0\n",
    "\tlast_char = string[0]\n",
    "\tfor char in string:\n",
    "\t\tif char != last_char:\n",
    "\t\t\tsize += 2\n",
    "\t\t\tlast_char = char\n",
    "\tsize += 2\n",
    "\n",
    "\t# If the compressed string size is greater than\n",
    "\t# or equal to string size, return original string\n",
    "\tif size >= len(string):\n",
    "\t\treturn string\n",
    "\n",
    "\t# Create compressed_string\n",
    "\t# New objective:\n",
    "\t\t# Single characters are to be left as is\n",
    "\t\t# Double characters are to be left as are\n",
    "\tcompressed_string = list()\n",
    "\tcount = 0\n",
    "\tlast_char = string[0]\n",
    "\tfor char in string:\n",
    "\t\tif char == last_char:\n",
    "\t\t\tcount += 1\n",
    "\t\telse:\n",
    "\t\t\t# Do the old compression tricks only if count exceeds two\n",
    "\t\t\tif count > 2:\n",
    "\t\t\t\tcompressed_string.append(last_char)\n",
    "\t\t\t\tcompressed_string.append(str(count))\n",
    "\t\t\t\tcount = 1\n",
    "\t\t\t\tlast_char = char\n",
    "\t\t\t# If count is either 1 or 2 (or 0?)\n",
    "\t\t\t# FIXME: CAN COUNT BE 0?\n",
    "\t\t\telse:\n",
    "\t\t\t\t# If count is 1, leave the char as is\n",
    "\t\t\t\tif count == 1:\n",
    "\t\t\t\t\tcompressed_string.append(last_char)\n",
    "\t\t\t\t\tcount = 1\n",
    "\t\t\t\t\tlast_char = char\n",
    "\t\t\t\t# If count is 2, append the character twice\n",
    "\t\t\t\telse:\n",
    "\t\t\t\t\tcompressed_string.append(last_char)\n",
    "\t\t\t\t\tcompressed_string.append(last_char)\n",
    "\t\t\t\t\tcount = 1\n",
    "\t\t\t\t\tlast_char = char\n",
    "\tcompressed_string.append(last_char)\n",
    "\tcompressed_string.append(str(count))\n",
    "\n",
    "\t# Convert the characters in the list to a string\n",
    "\treturn \"\".join(compressed_string)"
    "\tif string is None or len(string) == 0:\n",
    "\t\treturn string\n",
    "\n",
    "\t# Calculate the size of the compressed string\n",
    "\tsize = 0\n",
    "\tlast_char = string[0]\n",
    "\tfor char in string:\n",
    "\t\tif char != last_char:\n",
    "\t\t\tsize += 2\n",
    "\t\t\tlast_char = char\n",
    "\tsize += 2\n",
    "\n",
    "\t# If the compressed string size is greater than\n",
    "\t# or equal to string size, return original string\n",
    "\tif size >= len(string):\n",
    "\t\treturn string\n",
    "\n",
    "\t# Create compressed_string\n",
    "\t# New objective:\n",
    "\t\t# Single characters are to be left as is\n",
    "\t\t# Double characters are to be left as are\n",
    "\tcompressed_string = list()\n",
    "\tcount = 0\n",
    "\tlast_char = string[0]\n",
    "\tfor char in string:\n",
    "\t\tif char == last_char:\n",
    "\t\t\tcount += 1\n",
    "\t\telse:\n",
    "\t\t\t# Do the old compression tricks only if count exceeds two\n",
    "\t\t\tif count > 2:\n",
    "\t\t\t\tcompressed_string.append(last_char)\n",
    "\t\t\t\tcompressed_string.append(str(count))\n",
    "\t\t\t\tcount = 1\n",
    "\t\t\t\tlast_char = char\n",
    "\t\t\t# If count is either 1 or 2 (or 0?)\n",
    "\t\t\t# FIXME: CAN COUNT BE 0?\n",
    "\t\t\telse:\n",
    "\t\t\t\t# If count is 1, leave the char as is\n",
    "\t\t\t\tif count == 1:\n",
    "\t\t\t\t\tcompressed_string.append(last_char)\n",
    "\t\t\t\t\tcount = 1\n",
    "\t\t\t\t\tlast_char = char\n",
    "\t\t\t\t# If count is 2, append the character twice\n",
    "\t\t\t\telse:\n",
    "\t\t\t\t\tcompressed_string.append(last_char)\n",
    "\t\t\t\t\tcompressed_string.append(last_char)\n",
    "\t\t\t\t\tcount = 1\n",
    "\t\t\t\t\tlast_char = char\n",
    "\tcompressed_string.append(last_char)\n",
    "\tcompressed_string.append(str(count))\n",
    "\n",
    "\t# Convert the characters in the list to a string\n",
    "\treturn \"\".join(compressed_string)"
    "\tif string is None or len(string) == 0:\n",
    "\t\treturn string\n",
    "\n",
    "\t# Calculate the size of the compressed string\n",
    "\tsize = 0\n",
    "\tlast_char = string[0]\n",
    "\tfor char in string:\n",
    "\t\tif char != last_char:\n",
    "\t\t\tsize += 2\n",
    "\t\t\tlast_char = char\n",
    "\tsize += 2\n",
    "\n",
    "\t# If the compressed string size is greater than\n",
    "\t# or equal to string size, return original string\n",
    "\tif size >= len(string):\n",
    "\t\treturn string\n",
    "\n",
    "\t# Create compressed_string\n",
    "\t# New objective:\n",
    "\t\t# Single characters are to be left as is\n",
    "\t\t# Double characters are to be left as are\n",
    "\tcompressed_string = list()\n",
    "\tcount = 0\n",
    "\tlast_char = string[0]\n",
    "\tfor char in string:\n",
    "\t\tif char == last_char:\n",
    "\t\t\tcount += 1\n",
    "\t\telse:\n",
    "\t\t\t# Do the old compression tricks only if count exceeds two\n",
    "\t\t\tif count > 2:\n",
    "\t\t\t\tcompressed_string.append(last_char)\n",
    "\t\t\t\tcompressed_string.append(str(count))\n",
    "\t\t\t\tcount = 1\n",
    "\t\t\t\tlast_char = char\n",
    "\t\t\t# If count is either 1 or 2 (or 0?)\n",
    "\t\t\t# FIXME: CAN COUNT BE 0?\n",
    "\t\t\telse:\n",
    "\t\t\t\t# If count is 1, leave the char as is\n",
    "\t\t\t\tif count == 1:\n",
    "\t\t\t\t\tcompressed_string.append(last_char)\n",
    "\t\t\t\t\tcount = 1\n",
    "\t\t\t\t\tlast_char = char\n",
    "\t\t\t\t# If count is 2, append the character twice\n",
    "\t\t\t\telse:\n",
    "\t\t\t\t\tcompressed_string.append(last_char)\n",
    "\t\t\t\t\tcompressed_string.append(last_char)\n",
    "\t\t\t\t\tcount = 1\n",
    "\t\t\t\t\tlast_char = char\n",
    "\tcompressed_string.append(last_char)\n",
    "\tcompressed_string.append(str(count))\n",
    "\n",
    "\t# Convert the characters in the list to a string\n",
    "\treturn \"\".join(compressed_string)"
    "\tif string is None or len(string) == 0:\n",
    "\t\treturn string\n",
    "\n",
    "\t# Calculate the size of the compressed string\n",
    "\tsize = 0\n",
    "\tlast_char = string[0]\n",
    "\tfor char in string:\n",
    "\t\tif char != last_char:\n",
    "\t\t\tsize += 2\n",
    "\t\t\tlast_char = char\n",
    "\tsize += 2\n",
    "\n",
    "\t# If the compressed string size is greater than\n",
    "\t# or equal to string size, return original string\n",
    "\tif size >= len(string):\n",
    "\t\treturn string\n",
    "\n",
    "\t# Create compressed_string\n",
    "\t# New objective:\n",
    "\t\t# Single characters are to be left as is\n",
    "\t\t# Double characters are to be left as are\n",
    "\tcompressed_string = list()\n",
    "\tcount = 0\n",
    "\tlast_char = string[0]\n",
    "\tfor char in string:\n",
    "\t\tif char == last_char:\n",
    "\t\t\tcount += 1\n",
    "\t\telse:\n",
    "\t\t\t# Do the old compression tricks only if count exceeds two\n",
    "\t\t\tif count > 2:\n",
    "\t\t\t\tcompressed_string.append(last_char)\n",
    "\t\t\t\tcompressed_string.append(str(count))\n",
    "\t\t\t\tcount = 1\n",
    "\t\t\t\tlast_char = char\n",
    "\t\t\t# If count is either 1 or 2 (or 0?)\n",
    "\t\t\t# FIXME: CAN COUNT BE 0?\n",
    "\t\t\telse:\n",
    "\t\t\t\t# If count is 1, leave the char as is\n",
    "\t\t\t\tif count == 1:\n",
    "\t\t\t\t\tcompressed_string.append(last_char)\n",
    "\t\t\t\t\tcount = 1\n",
    "\t\t\t\t\tlast_char = char\n",
    "\t\t\t\t# If count is 2, append the character twice\n",
    "\t\t\t\telse:\n",
    "\t\t\t\t\tcompressed_string.append(last_char)\n",
    "\t\t\t\t\tcompressed_string.append(last_char)\n",
    "\t\t\t\t\tcount = 1\n",
    "\t\t\t\t\tlast_char = char\n",
    "\tcompressed_string.append(last_char)\n",
    "\tcompressed_string.append(str(count))\n",
    "\n",
    "\t# Convert the characters in the list to a string\n",
    "\treturn \"\".join(compressed_string)"
    "\tif string is None or len(string) == 0:\n",
    "\t\treturn string\n",
    "\n",
    "\t# Calculate the size of the compressed string\n",
    "\tsize = 0\n",
    "\tlast_char = string[0]\n",
    "\tfor char in string:\n",
    "\t\tif char != last_char:\n",
    "\t\t\tsize += 2\n",
    "\t\t\tlast_char = char\n",
    "\tsize += 2\n",
    "\n",
    "\t# If the compressed string size is greater than\n",
    "\t# or equal to string size, return original string\n",
    "\tif size >= len(string):\n",
    "\t\treturn string\n",
    "\n",
    "\t# Create compressed_string\n",
    "\t# New objective:\n",
    "\t\t# Single characters are to be left as is\n",
    "\t\t# Double characters are to be left as are\n",
    "\tcompressed_string = list()\n",
    "\tcount = 0\n",
    "\tlast_char = string[0]\n",
    "\tfor char in string:\n",
    "\t\tif char == last_char:\n",
    "\t\t\tcount += 1\n",
    "\t\telse:\n",
    "\t\t\t# Do the old compression tricks only if count exceeds two\n",
    "\t\t\tif count > 2:\n",
    "\t\t\t\tcompressed_string.append(last_char)\n",
    "\t\t\t\tcompressed_string.append(str(count))\n",
    "\t\t\t\tcount = 1\n",
    "\t\t\t\tlast_char = char\n",
    "\t\t\t# If count is either 1 or 2 (or 0?)\n",
    "\t\t\t# FIXME: CAN COUNT BE 0?\n",
    "\t\t\telse:\n",
    "\t\t\t\t# If count is 1, leave the char as is\n",
    "\t\t\t\tif count == 1:\n",
    "\t\t\t\t\tcompressed_string.append(last_char)\n",
    "\t\t\t\t\tcount = 1\n",
    "\t\t\t\t\tlast_char = char\n",
    "\t\t\t\t# If count is 2, append the character twice\n",
    "\t\t\t\telse:\n",
    "\t\t\t\t\tcompressed_string.append(last_char)\n",
    "\t\t\t\t\tcompressed_string.append(last_char)\n",
    "\t\t\t\t\tcount = 1\n",
    "\t\t\t\t\tlast_char = char\n",
    "\tcompressed_string.append(last_char)\n",
    "\tcompressed_string.append(str(count))\n",
    "\n",
    "\t# Convert the characters in the list to a string\n",
    "\treturn \"\".join(compressed_string)"
    "\tif string is None or len(string) == 0:\n",
    "\t\treturn string\n",
    "\n",
    "\t# Calculate the size of the compressed string\n",
    "\tsize = 0\n",
    "\tlast_char = string[0]\n",
    "\tfor char in string:\n",
    "\t\tif char != last_char:\n",
    "\t\t\tsize += 2\n",
    "\t\t\tlast_char = char\n",
    "\tsize += 2\n",
    "\n",
    "\t# If the compressed string size is greater than\n",
    "\t# or equal to string size, return original string\n",
    "\tif size >= len(string):\n",
    "\t\treturn string\n",
    "\n",
    "\t# Create compressed_string\n",
    "\t# New objective:\n",
    "\t\t# Single characters are to be left as is\n",
    "\t\t# Double characters are to be left as are\n",
    "\tcompressed_string = list()\n",
    "\tcount = 0\n",
    "\tlast_char = string[0]\n",
    "\tfor char in string:\n",
    "\t\tif char == last_char:\n",
    "\t\t\tcount += 1\n",
    "\t\telse:\n",
    "\t\t\t# Do the old compression tricks only if count exceeds two\n",
    "\t\t\tif count > 2:\n",
    "\t\t\t\tcompressed_string.append(last_char)\n",
    "\t\t\t\tcompressed_string.append(str(count))\n",
    "\t\t\t\tcount = 1\n",
    "\t\t\t\tlast_char = char\n",
    "\t\t\t# If count is either 1 or 2 (or 0?)\n",
    "\t\t\t# FIXME: CAN COUNT BE 0?\n",
    "\t\t\telse:\n",
    "\t\t\t\t# If count is 1, leave the char as is\n",
    "\t\t\t\tif count == 1:\n",
    "\t\t\t\t\tcompressed_string.append(last_char)\n",
    "\t\t\t\t\tcount = 1\n",
    "\t\t\t\t\tlast_char = char\n",
    "\t\t\t\t# If count is 2, append the character twice\n",
    "\t\t\t\telse:\n",
    "\t\t\t\t\tcompressed_string.append(last_char)\n",
    "\t\t\t\t\tcompressed_string.append(last_char)\n",
    "\t\t\t\t\tcount = 1\n",
    "\t\t\t\t\tlast_char = char\n",
    "\tcompressed_string.append(last_char)\n",
    "\tcompressed_string.append(str(count))\n",
    "\n",
    "\t# Convert the characters in the list to a string\n",
    "\treturn \"\".join(compressed_string)"
    "\tif string is None or len(string) == 0:\n",
    "\t\treturn string\n",
    "\n",
    "\t# Calculate the size of the compressed string\n",
    "\tsize = 0\n",
    "\tlast_char = string[0]\n",
    "\tfor char in string:\n",
    "\t\tif char != last_char:\n",
    "\t\t\tsize += 2\n",
    "\t\t\tlast_char = char\n",
    "\tsize += 2\n",
    "\n",
    "\t# If the compressed string size is greater than\n",
    "\t# or equal to string size, return original string\n",
    "\tif size >= len(string):\n",
    "\t\treturn string\n",
    "\n",
    "\t# Create compressed_string\n",
    "\t# New objective:\n",
    "\t\t# Single characters are to be left as is\n",
    "\t\t# Double characters are to be left as are\n",
    "\tcompressed_string = list()\n",
    "\tcount = 0\n",
    "\tlast_char = string[0]\n",
    "\tfor char in string:\n",
    "\t\tif char == last_char:\n",
    "\t\t\tcount += 1\n",
    "\t\telse:\n",
    "\t\t\t# Do the old compression tricks only if count exceeds two\n",
    "\t\t\tif count > 2:\n",
    "\t\t\t\tcompressed_string.append(last_char)\n",
    "\t\t\t\tcompressed_string.append(str(count))\n",
    "\t\t\t\tcount = 1\n",
    "\t\t\t\tlast_char = char\n",
    "\t\t\t# If count is either 1 or 2 (or 0?)\n",
    "\t\t\t# FIXME: CAN COUNT BE 0?\n",
    "\t\t\telse:\n",
    "\t\t\t\t# If count is 1, leave the char as is\n",
    "\t\t\t\tif count == 1:\n",
    "\t\t\t\t\tcompressed_string.append(last_char)\n",
    "\t\t\t\t\tcount = 1\n",
    "\t\t\t\t\tlast_char = char\n",
    "\t\t\t\t# If count is 2, append the character twice\n",
    "\t\t\t\telse:\n",
    "\t\t\t\t\tcompressed_string.append(last_char)\n",
    "\t\t\t\t\tcompressed_string.append(last_char)\n",
    "\t\t\t\t\tcount = 1\n",
    "\t\t\t\t\tlast_char = char\n",
    "\tcompressed_string.append(last_char)\n",
    "\tcompressed_string.append(str(count))\n",
    "\n",
    "\t# Convert the characters in the list to a string\n",
    "\treturn \"\".join(compressed_string)"
    "\tif string is None or len(string) == 0:\n",
    "\t\treturn string\n",
    "\n",
    "\t# Calculate the size of the compressed string\n",
    "\tsize = 0\n",
    "\tlast_char = string[0]\n",
    "\tfor char in string:\n",
    "\t\tif char != last_char:\n",
    "\t\t\tsize += 2\n",
    "\t\t\tlast_char = char\n",
    "\tsize += 2\n",
    "\n",
    "\t# If the compressed string size is greater than\n",
    "\t# or equal to string size, return original string\n",
    "\tif size >= len(string):\n",
    "\t\treturn string\n",
    "\n",
    "\t# Create compressed_string\n",
    "\t# New objective:\n",
    "\t\t# Single characters are to be left as is\n",
    "\t\t# Double characters are to be left as are\n",
    "\tcompressed_string = list()\n",
    "\tcount = 0\n",
    "\tlast_char = string[0]\n",
    "\tfor char in string:\n",
    "\t\tif char == last_char:\n",
    "\t\t\tcount += 1\n",
    "\t\telse:\n",
    "\t\t\t# Do the old compression tricks only if count exceeds two\n",
    "\t\t\tif count > 2:\n",
    "\t\t\t\tcompressed_string.append(last_char)\n",
    "\t\t\t\tcompressed_string.append(str(count))\n",
    "\t\t\t\tcount = 1\n",
    "\t\t\t\tlast_char = char\n",
    "\t\t\t# If count is either 1 or 2 (or 0?)\n",
    "\t\t\t# FIXME: CAN COUNT BE 0?\n",
    "\t\t\telse:\n",
    "\t\t\t\t# If count is 1, leave the char as is\n",
    "\t\t\t\tif count == 1:\n",
    "\t\t\t\t\tcompressed_string.append(last_char)\n",
    "\t\t\t\t\tcount = 1\n",
    "\t\t\t\t\tlast_char = char\n",
    "\t\t\t\t# If count is 2, append the character twice\n",
    "\t\t\t\telse:\n",
    "\t\t\t\t\tcompressed_string.append(last_char)\n",
    "\t\t\t\t\tcompressed_string.append(last_char)\n",
    "\t\t\t\t\tcount = 1\n",
    "\t\t\t\t\tlast_char = char\n",
    "\tcompressed_string.append(last_char)\n",
    "\tcompressed_string.append(str(count))\n",
    "\n",
    "\t# Convert the characters in the list to a string\n",
    "\treturn \"\".join(compressed_string)"
    "\tif string is None or len(string) == 0:\n",
    "\t\treturn string\n",
    "\n",
    "\t# Calculate the size of the compressed string\n",
    "\tsize = 0\n",
    "\tlast_char = string[0]\n",
    "\tfor char in string:\n",
    "\t\tif char != last_char:\n",
    "\t\t\tsize += 2\n",
    "\t\t\tlast_char = char\n",
    "\tsize += 2\n",
    "\n",
    "\t# If the compressed string size is greater than\n",
    "\t# or equal to string size, return original string\n",
    "\tif size >= len(string):\n",
    "\t\treturn string\n",
    "\n",
    "\t# Create compressed_string\n",
    "\t# New objective:\n",
    "\t\t# Single characters are to be left as is\n",
    "\t\t# Double characters are to be left as are\n",
    "\tcompressed_string = list()\n",
    "\tcount = 0\n",
    "\tlast_char = string[0]\n",
    "\tfor char in string:\n",
    "\t\tif char == last_char:\n",
    "\t\t\tcount += 1\n",
    "\t\telse:\n",
    "\t\t\t# Do the old compression tricks only if count exceeds two\n",
    "\t\t\tif count > 2:\n",
    "\t\t\t\tcompressed_string.append(last_char)\n",
    "\t\t\t\tcompressed_string.append(str(count))\n",
    "\t\t\t\tcount = 1\n",
    "\t\t\t\tlast_char = char\n",
    "\t\t\t# If count is either 1 or 2 (or 0?)\n",
    "\t\t\t# FIXME: CAN COUNT BE 0?\n",
    "\t\t\telse:\n",
    "\t\t\t\t# If count is 1, leave the char as is\n",
    "\t\t\t\tif count == 1:\n",
    "\t\t\t\t\tcompressed_string.append(last_char)\n",
    "\t\t\t\t\tcount = 1\n",
    "\t\t\t\t\tlast_char = char\n",
    "\t\t\t\t# If count is 2, append the character twice\n",
    "\t\t\t\telse:\n",
    "\t\t\t\t\tcompressed_string.append(last_char)\n",
    "\t\t\t\t\tcompressed_string.append(last_char)\n",
    "\t\t\t\t\tcount = 1\n",
    "\t\t\t\t\tlast_char = char\n",
    "\tcompressed_string.append(last_char)\n",
    "\tcompressed_string.append(str(count))\n",
    "\n",
    "\t# Convert the characters in the list to a string\n",
    "\treturn \"\".join(compressed_string)"
    "\tif string is None or len(string) == 0:\n",
    "\t\treturn string\n",
    "\n",
    "\t# Calculate the size of the compressed string\n",
    "\tsize = 0\n",
    "\tlast_char = string[0]\n",
    "\tfor char in string:\n",
    "\t\tif char != last_char:\n",
    "\t\t\tsize += 2\n",
    "\t\t\tlast_char = char\n",
    "\tsize += 2\n",
    "\n",
    "\t# If the compressed string size is greater than\n",
    "\t# or equal to string size, return original string\n",
    "\tif size >= len(string):\n",
    "\t\treturn string\n",
    "\n",
    "\t# Create compressed_string\n",
    "\t# New objective:\n",
    "\t\t# Single characters are to be left as is\n",
    "\t\t# Double characters are to be left as are\n",
    "\tcompressed_string = list()\n",
    "\tcount = 0\n",
    "\tlast_char = string[0]\n",
    "\tfor char in string:\n",
    "\t\tif char == last_char:\n",
    "\t\t\tcount += 1\n",
    "\t\telse:\n",
    "\t\t\t# Do the old compression tricks only if count exceeds two\n",
    "\t\t\tif count > 2:\n",
    "\t\t\t\tcompressed_string.append(last_char)\n",
    "\t\t\t\tcompressed_string.append(str(count))\n",
    "\t\t\t\tcount = 1\n",
    "\t\t\t\tlast_char = char\n",
    "\t\t\t# If count is either 1 or 2 (or 0?)\n",
    "\t\t\t# FIXME: CAN COUNT BE 0?\n",
    "\t\t\telse:\n",
    "\t\t\t\t# If count is 1, leave the char as is\n",
    "\t\t\t\tif count == 1:\n",
    "\t\t\t\t\tcompressed_string.append(last_char)\n",
    "\t\t\t\t\tcount = 1\n",
    "\t\t\t\t\tlast_char = char\n",
    "\t\t\t\t# If count is 2, append the character twice\n",
    "\t\t\t\telse:\n",
    "\t\t\t\t\tcompressed_string.append(last_char)\n",
    "\t\t\t\t\tcompressed_string.append(last_char)\n",
    "\t\t\t\t\tcount = 1\n",
    "\t\t\t\t\tlast_char = char\n",
    "\tcompressed_string.append(last_char)\n",
    "\tcompressed_string.append(str(count))\n",
    "\n",
    "\t# Convert the characters in the list to a string\n",
    "\treturn \"\".join(compressed_string)"
    "\tif string is None or len(string) == 0:\n",
    "\t\treturn string\n",
    "\n",
    "\t# Calculate the size of the compressed string\n",
    "\tsize = 0\n",
    "\tlast_char = string[0]\n",
    "\tfor char in string:\n",
    "\t\tif char != last_char:\n",
    "\t\t\tsize += 2\n",
    "\t\t\tlast_char = char\n",
    "\tsize += 2\n",
    "\n",
    "\t# If the compressed string size is greater than\n",
    "\t# or equal to string size, return original string\n",
    "\tif size >= len(string):\n",
    "\t\treturn string\n",
    "\n",
    "\t# Create compressed_string\n",
    "\t# New objective:\n",
    "\t\t# Single characters are to be left as is\n",
    "\t\t# Double characters are to be left as are\n",
    "\tcompressed_string = list()\n",
    "\tcount = 0\n",
    "\tlast_char = string[0]\n",
    "\tfor char in string:\n",
    "\t\tif char == last_char:\n",
    "\t\t\tcount += 1\n",
    "\t\telse:\n",
    "\t\t\t# Do the old compression tricks only if count exceeds two\n",
    "\t\t\tif count > 2:\n",
    "\t\t\t\tcompressed_string.append(last_char)\n",
    "\t\t\t\tcompressed_string.append(str(count))\n",
    "\t\t\t\tcount = 1\n",
    "\t\t\t\tlast_char = char\n",
    "\t\t\t# If count is either 1 or 2 (or 0?)\n",
    "\t\t\t# FIXME: CAN COUNT BE 0?\n",
    "\t\t\telse:\n",
    "\t\t\t\t# If count is 1, leave the char as is\n",
    "\t\t\t\tif count == 1:\n",
    "\t\t\t\t\tcompressed_string.append(last_char)\n",
    "\t\t\t\t\tcount = 1\n",
    "\t\t\t\t\tlast_char = char\n",
    "\t\t\t\t# If count is 2, append the character twice\n",
    "\t\t\t\telse:\n",
    "\t\t\t\t\tcompressed_string.append(last_char)\n",
    "\t\t\t\t\tcompressed_string.append(last_char)\n",
    "\t\t\t\t\tcount = 1\n",
    "\t\t\t\t\tlast_char = char\n",
    "\tcompressed_string.append(last_char)\n",
    "\tcompressed_string.append(str(count))\n",
    "\n",
    "\t# Convert the characters in the list to a string\n",
    "\treturn \"\".join(compressed_string)"
    "\tif string is None or len(string) == 0:\n",
    "\t\treturn string\n",
    "\n",
    "\t# Calculate the size of the compressed string\n",
    "\tsize = 0\n",
    "\tlast_char = string[0]\n",
    "\tfor char in string:\n",
    "\t\tif char != last_char:\n",
    "\t\t\tsize += 2\n",
    "\t\t\tlast_char = char\n",
    "\tsize += 2\n",
    "\n",
    "\t# If the compressed string size is greater than\n",
    "\t# or equal to string size, return original string\n",
    "\tif size >= len(string):\n",
    "\t\treturn string\n",
    "\n",
    "\t# Create compressed_string\n",
    "\t# New objective:\n",
    "\t\t# Single characters are to be left as is\n",
    "\t\t# Double characters are to be left as are\n",
    "\tcompressed_string = list()\n",
    "\tcount = 0\n",
    "\tlast_char = string[0]\n",
    "\tfor char in string:\n",
    "\t\tif char == last_char:\n",
    "\t\t\tcount += 1\n",
    "\t\telse:\n",
    "\t\t\t# Do the old compression tricks only if count exceeds two\n",
    "\t\t\tif count > 2:\n",
    "\t\t\t\tcompressed_string.append(last_char)\n",
    "\t\t\t\tcompressed_string.append(str(count))\n",
    "\t\t\t\tcount = 1\n",
    "\t\t\t\tlast_char = char\n",
    "\t\t\t# If count is either 1 or 2 (or 0?)\n",
    "\t\t\t# FIXME: CAN COUNT BE 0?\n",
    "\t\t\telse:\n",
    "\t\t\t\t# If count is 1, leave the char as is\n",
    "\t\t\t\tif count == 1:\n",
    "\t\t\t\t\tcompressed_string.append(last_char)\n",
    "\t\t\t\t\tcount = 1\n",
    "\t\t\t\t\tlast_char = char\n",
    "\t\t\t\t# If count is 2, append the character twice\n",
    "\t\t\t\telse:\n",
    "\t\t\t\t\tcompressed_string.append(last_char)\n",
    "\t\t\t\t\tcompressed_string.append(last_char)\n",
    "\t\t\t\t\tcount = 1\n",
    "\t\t\t\t\tlast_char = char\n",
    "\tcompressed_string.append(last_char)\n",
    "\tcompressed_string.append(str(count))\n",
    "\n",
    "\t# Convert the characters in the list to a string\n",
    "\treturn \"\".join(compressed_string)"
    "\tif string is None or len(string) == 0:\n",
    "\t\treturn string\n",
    "\n",
    "\t# Calculate the size of the compressed string\n",
    "\tsize = 0\n",
    "\tlast_char = string[0]\n",
    "\tfor char in string:\n",
    "\t\tif char != last_char:\n",
    "\t\t\tsize += 2\n",
    "\t\t\tlast_char = char\n",
    "\tsize += 2\n",
    "\n",
    "\t# If the compressed string size is greater than\n",
    "\t# or equal to string size, return original string\n",
    "\tif size >= len(string):\n",
    "\t\treturn string\n",
    "\n",
    "\t# Create compressed_string\n",
    "\t# New objective:\n",
    "\t\t# Single characters are to be left as is\n",
    "\t\t# Double characters are to be left as are\n",
    "\tcompressed_string = list()\n",
    "\tcount = 0\n",
    "\tlast_char = string[0]\n",
    "\tfor char in string:\n",
    "\t\tif char == last_char:\n",
    "\t\t\tcount += 1\n",
    "\t\telse:\n",
    "\t\t\t# Do the old compression tricks only if count exceeds two\n",
    "\t\t\tif count > 2:\n",
    "\t\t\t\tcompressed_string.append(last_char)\n",
    "\t\t\t\tcompressed_string.append(str(count))\n",
    "\t\t\t\tcount = 1\n",
    "\t\t\t\tlast_char = char\n",
    "\t\t\t# If count is either 1 or 2 (or 0?)\n",
    "\t\t\t# FIXME: CAN COUNT BE 0?\n",
    "\t\t\telse:\n",
    "\t\t\t\t# If count is 1, leave the char as is\n",
    "\t\t\t\tif count == 1:\n",
    "\t\t\t\t\tcompressed_string.append(last_char)\n",
    "\t\t\t\t\tcount = 1\n",
    "\t\t\t\t\tlast_char = char\n",
    "\t\t\t\t# If count is 2, append the character twice\n",
    "\t\t\t\telse:\n",
    "\t\t\t\t\tcompressed_string.append(last_char)\n",
    "\t\t\t\t\tcompressed_string.append(last_char)\n",
    "\t\t\t\t\tcount = 1\n",
    "\t\t\t\t\tlast_char = char\n",
    "\tcompressed_string.append(last_char)\n",
    "\tcompressed_string.append(str(count))\n",
    "\n",
    "\t# Convert the characters in the list to a string\n",
    "\treturn \"\".join(compressed_string)"
    "\tif string is None or len(string) == 0:\n",
    "\t\treturn string\n",
    "\n",
    "\t# Calculate the size of the compressed string\n",
    "\tsize = 0\n",
    "\tlast_char = string[0]\n",
    "\tfor char in string:\n",
    "\t\tif char != last_char:\n",
    "\t\t\tsize += 2\n",
    "\t\t\tlast_char = char\n",
    "\tsize += 2\n",
    "\n",
    "\t# If the compressed string size is greater than\n",
    "\t# or equal to string size, return original string\n",
    "\tif size >= len(string):\n",
    "\t\treturn string\n",
    "\n",
    "\t# Create compressed_string\n",
    "\t# New objective:\n",
    "\t\t# Single characters are to be left as is\n",
    "\t\t# Double characters are to be left as are\n",
    "\tcompressed_string = list()\n",
    "\tcount = 0\n",
    "\tlast_char = string[0]\n",
    "\tfor char in string:\n",
    "\t\tif char == last_char:\n",
    "\t\t\tcount += 1\n",
    "\t\telse:\n",
    "\t\t\t# Do the old compression tricks only if count exceeds two\n",
    "\t\t\tif count > 2:\n",
    "\t\t\t\tcompressed_string.append(last_char)\n",
    "\t\t\t\tcompressed_string.append(str(count))\n",
    "\t\t\t\tcount = 1\n",
    "\t\t\t\tlast_char = char\n",
    "\t\t\t# If count is either 1 or 2 (or 0?)\n",
    "\t\t\t# FIXME: CAN COUNT BE 0?\n",
    "\t\t\telse:\n",
    "\t\t\t\t# If count is 1, leave the char as is\n",
    "\t\t\t\tif count == 1:\n",
    "\t\t\t\t\tcompressed_string.append(last_char)\n",
    "\t\t\t\t\tcount = 1\n",
    "\t\t\t\t\tlast_char = char\n",
    "\t\t\t\t# If count is 2, append the character twice\n",
    "\t\t\t\telse:\n",
    "\t\t\t\t\tcompressed_string.append(last_char)\n",
    "\t\t\t\t\tcompressed_string.append(last_char)\n",
    "\t\t\t\t\tcount = 1\n",
    "\t\t\t\t\tlast_char = char\n",
    "\tcompressed_string.append(last_char)\n",
    "\tcompressed_string.append(str(count))\n",
    "\n",
    "\t# Convert the characters in the list to a string\n",
    "\treturn \"\".join(compressed_string)"
    "\tif string is None or len(string) == 0:\n",
    "\t\treturn string\n",
    "\n",
    "\t# Calculate the size of the compressed string\n",
    "\tsize = 0\n",
    "\tlast_char = string[0]\n",
    "\tfor char in string:\n",
    "\t\tif char != last_char:\n",
    "\t\t\tsize += 2\n",
    "\t\t\tlast_char = char\n",
    "\tsize += 2\n",
    "\n",
    "\t# If the compressed string size is greater than\n",
    "\t# or equal to string size, return original string\n",
    "\tif size >= len(string):\n",
    "\t\treturn string\n",
    "\n",
    "\t# Create compressed_string\n",
    "\t# New objective:\n",
    "\t\t# Single characters are to be left as is\n",
    "\t\t# Double characters are to be left as are\n",
    "\tcompressed_string = list()\n",
    "\tcount = 0\n",
    "\tlast_char = string[0]\n",
    "\tfor char in string:\n",
    "\t\tif char == last_char:\n",
    "\t\t\tcount += 1\n",
    "\t\telse:\n",
    "\t\t\t# Do the old compression tricks only if count exceeds two\n",
    "\t\t\tif count > 2:\n",
    "\t\t\t\tcompressed_string.append(last_char)\n",
    "\t\t\t\tcompressed_string.append(str(count))\n",
    "\t\t\t\tcount = 1\n",
    "\t\t\t\tlast_char = char\n",
    "\t\t\t# If count is either 1 or 2 (or 0?)\n",
    "\t\t\t# FIXME: CAN COUNT BE 0?\n",
    "\t\t\telse:\n",
    "\t\t\t\t# If count is 1, leave the char as is\n",
    "\t\t\t\tif count == 1:\n",
    "\t\t\t\t\tcompressed_string.append(last_char)\n",
    "\t\t\t\t\tcount = 1\n",
    "\t\t\t\t\tlast_char = char\n",
    "\t\t\t\t# If count is 2, append the character twice\n",
    "\t\t\t\telse:\n",
    "\t\t\t\t\tcompressed_string.append(last_char)\n",
    "\t\t\t\t\tcompressed_string.append(last_char)\n",
    "\t\t\t\t\tcount = 1\n",
    "\t\t\t\t\tlast_char = char\n",
    "\tcompressed_string.append(last_char)\n",
    "\tcompressed_string.append(str(count))\n",
    "\n",
    "\t# Convert the characters in the list to a string\n",
    "\treturn \"\".join(compressed_string)"
    "\tif string is None or len(string) == 0:\n",
    "\t\treturn string\n",
    "\n",
    "\t# Calculate the size of the compressed string\n",
    "\tsize = 0\n",
    "\tlast_char = string[0]\n",
    "\tfor char in string:\n",
    "\t\tif char != last_char:\n",
    "\t\t\tsize += 2\n",
    "\t\t\tlast_char = char\n",
    "\tsize += 2\n",
    "\n",
    "\t# If the compressed string size is greater than\n",
    "\t# or equal to string size, return original string\n",
    "\tif size >= len(string):\n",
    "\t\treturn string\n",
    "\n",
    "\t# Create compressed_string\n",
    "\t# New objective:\n",
    "\t\t# Single characters are to be left as is\n",
    "\t\t# Double characters are to be left as are\n",
    "\tcompressed_string = list()\n",
    "\tcount = 0\n",
    "\tlast_char = string[0]\n",
    "\tfor char in string:\n",
    "\t\tif char == last_char:\n",
    "\t\t\tcount += 1\n",
    "\t\telse:\n",
    "\t\t\t# Do the old compression tricks only if count exceeds two\n",
    "\t\t\tif count > 2:\n",
    "\t\t\t\tcompressed_string.append(last_char)\n",
    "\t\t\t\tcompressed_string.append(str(count))\n",
    "\t\t\t\tcount = 1\n",
    "\t\t\t\tlast_char = char\n",
    "\t\t\t# If count is either 1 or 2 (or 0?)\n",
    "\t\t\t# FIXME: CAN COUNT BE 0?\n",
    "\t\t\telse:\n",
    "\t\t\t\t# If count is 1, leave the char as is\n",
    "\t\t\t\tif count == 1:\n",
    "\t\t\t\t\tcompressed_string.append(last_char)\n",
    "\t\t\t\t\tcount = 1\n",
    "\t\t\t\t\tlast_char = char\n",
    "\t\t\t\t# If count is 2, append the character twice\n",
    "\t\t\t\telse:\n",
    "\t\t\t\t\tcompressed_string.append(last_char)\n",
    "\t\t\t\t\tcompressed_string.append(last_char)\n",
    "\t\t\t\t\tcount = 1\n",
    "\t\t\t\t\tlast_char = char\n",
    "\tcompressed_string.append(last_char)\n",
    "\tcompressed_string.append(str(count))\n",
    "\n",
    "\t# Convert the characters in the list to a string\n",
    "\treturn \"\".join(compressed_string)"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
keep keep keep keep replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace keep keep keep keep keep
 Improved compression by only appending count if the count is more than 2 
arrays_strings/compress/compress_solution.ipynb