Easy Challenges

"""
Finds the longest sub-string that contains, at most, two characters.

Input:
An all lower-case string, e.g.
    abbccc
    abcabcabcabccc
    qwertyytrewq

Output:
Print the longest sub-string of the given string that contains, at most, two
unique characters.
If you find multiple sub-strings that match the description, print the last
sub-string (furthest to the right).
    bbccc
    bccc
    tyyt

"""

import sys

def getLongestSubstring(longString, n = 2):
    """
    Find the longest substring containing at most n unique characters.

    Param(s):

    longString (str)
        The string for which we're looking for a substring.

    n (int)
        The maximum number of unique characters allowed in the substring.

    """
    charIndexes = {}
    currentStart = 0
    bestStart = 0
    length = 0
    bestLength = 0
    currentStart = 0
    index = 0

    for currentChar in longString:
        print(currentChar, end = " ...\n")

        # Case 1: The character is already in the set.
        if currentChar in charIndexes.keys():
            # Note the most recent position in which the char occurs
            charIndexes[currentChar][1] = index
            length += 1
            # print("Incremented: ", charIndexes[currentChar])

        # Case 2: The character is not in the set
        else:
            numChars = len(charIndexes)

            # If necessary, make room for the new char
            if numChars == n:
                charToRemove = longString[currentStart]
                length = index - charIndexes[charToRemove][0]

                # Store the best result that we've encountered.
                if length >= bestLength:
                    bestLength = length
                    bestStart = currentStart

                # Start the new substring after the last occurence of the char
                # being removed.
                currentStart = charIndexes[charToRemove][1] + 1

                # Remove the old char
                charIndexes.pop(charToRemove, None)

            # Add the new character
            charIndexes[currentChar] = [index, index]

        # Store the best result that we've encountered.
        if length > bestLength:
            bestLength = length
            bestStart = currentStart

        print(charIndexes)
        index += 1

    return longString[bestStart: bestStart+bestLength+1]

def main():
    """
    Run the longest substring algorithm. Print the results to standard output.

    """
    count = 0
    successful = 0

    with open(sys.argv[1], 'r') as fileToRead:
        for line in fileToRead:
            items = line.split()
            substring = getLongestSubstring(items[0], n = 2)
            if substring == items[1]:
                successful += 1
            else:
                pass
                #print('{:20}'.format(items[0]), "Got:", '{:15}'.format(substring), "\tExpected:", items[1])
            count += 1
            break

    print("\n_________________________\n")
    print(successful, "/", count, "tests passed!")
    print("\n_________________________\n")

if __name__ == "__main__":
    main()

"""
_380_smooshed_morse_code.py

Solve https://www.reddit.com/r/dailyprogrammer/comments/cmd1hb/20190805_challenge_380_easy_smooshed_morse_code_1/

"""

from typing import List, Iterable
from collections import defaultdict
import os

"""A mapping of `[a...z]` to Morse code."""
ALPHA_TO_MORSE = {
    "a": ".-", "b": "-...", "c": "-.-.", "d": "-..", "e": ".",  
    "f": "..-.", "g": "--.", "h": "....", "i": "..", "j": ".---", 
    "k": "-.-", "l": ".-..", "m": "--", "n": "-.", "o": "---", 
    "p": ".--.", "q": "--.-", "r": ".-.", "s": "...", "t": "-", 
    "u": "..-", "v": "...-", "w": ".--", "x": "-..-", "y": "-.--", 
    "z": "--.."
}

def smorse(alpha_text: str) -> str:
    """
    Args:
        alpha_text: The string whose characters are in `[a...z]`

    Returns:
        The smooshed morse code representation of `alpha_text`

    Raises:
        ValueError if any character in `alpha_text` is not in `[a...z]`
    """
    smooshed_morse_text = [None] * len(alpha_text)
    for idx, c in enumerate(alpha_text):
        if c not in ALPHA_TO_MORSE:
            raise ValueError(
                f"{c} is not a character in a...z (case-sensitive)"
            )
        smooshed_morse_text[idx] = ALPHA_TO_MORSE[c]
    return "".join(smooshed_morse_text)

def main():
    assert smorse("sos") == "...---..."
    assert smorse("daily") == "-...-...-..-.--"
    assert smorse("programmer") == ".--..-.-----..-..-----..-."
    assert smorse("bits") == "-.....-..."
    assert smorse("three") == "-.....-..."
    
if __name__ == "__main__":
    main()