



'''simple docstring'''





from __future__ import annotations




def 							lowerCamelCase	(					_snake_case	:    dict  ,_snake_case	:    str							):





    '''simple docstring'''


    lowercase__							,							lowercase__									=    set(_snake_case							), [start]

    while stack:
        lowercase__									=    stack.pop()
        explored.add(_snake_case							)
        # Differences from BFS:
        # 1) pop last element instead of first one
        # 2) add adjacent elements to stack without exploring them
        for adj in reversed(graph[v]							):
            if adj not in explored:
                stack.append(_snake_case							)
    return explored


SCREAMING_SNAKE_CASE__          =  {
    "A": ["B", "C", "D"],
    "B": ["A", "D", "E"],
    "C": ["A", "F"],
    "D": ["B", "D"],
    "E": ["B", "F"],
    "F": ["C", "E", "G"],
    "G": ["F"],
}

if __name__ == "__main__":
 import doctest

 doctest.testmod()
 print(depth_first_search(G, "A"))









'''simple docstring'''





SCREAMING_SNAKE_CASE__          =  256
# Modulus to hash a string
SCREAMING_SNAKE_CASE__          =  100_0003




def 							lowerCamelCase	(					_snake_case	:    str  ,_snake_case	:    str							):





    '''simple docstring'''


    lowercase__									=    len(_snake_case							)
    lowercase__									=    len(_snake_case							)
    if p_len > t_len:
        return False

    lowercase__									=    0
    lowercase__									=    0
    lowercase__									=    1

    # Calculating the hash of pattern and substring of text
    for i in range(_snake_case							):
        lowercase__									=    (ord(pattern[i]							) + p_hash * alphabet_size) % modulus
        lowercase__									=    (ord(text[i]							) + text_hash * alphabet_size) % modulus
        if i == p_len - 1:
            continue
        lowercase__									=    (modulus_power * alphabet_size) % modulus

    for i in range(0  ,t_len - p_len + 1							):
        if text_hash == p_hash and text[i : i + p_len] == pattern:
            return True
        if i == t_len - p_len:
            continue
        # Calculate the https://en.wikipedia.org/wiki/Rolling_hash
        lowercase__									=    (
            (text_hash - ord(text[i]							) * modulus_power) * alphabet_size
            + ord(text[i + p_len]							)
        ) % modulus
    return False




def 							lowerCamelCase	(					):





    '''simple docstring'''


    lowercase__									=    "abc1abc12"
    lowercase__									=    "alskfjaldsabc1abc1abc12k23adsfabcabc"
    lowercase__									=    "alskfjaldsk23adsfabcabc"
    assert rabin_karp(_snake_case  ,_snake_case							) and not rabin_karp(_snake_case  ,_snake_case							)

    # Test 2)
    lowercase__									=    "ABABX"
    lowercase__									=    "ABABZABABYABABX"
    assert rabin_karp(_snake_case  ,_snake_case							)

    # Test 3)
    lowercase__									=    "AAAB"
    lowercase__									=    "ABAAAAAB"
    assert rabin_karp(_snake_case  ,_snake_case							)

    # Test 4)
    lowercase__									=    "abcdabcy"
    lowercase__									=    "abcxabcdabxabcdabcdabcy"
    assert rabin_karp(_snake_case  ,_snake_case							)

    # Test 5)
    lowercase__									=    "Lü"
    lowercase__									=    "Lüsai"
    assert rabin_karp(_snake_case  ,_snake_case							)
    lowercase__									=    "Lue"
    assert not rabin_karp(_snake_case  ,_snake_case							)
    print("Success."							)


if __name__ == "__main__":
 test_rabin_karp()




