string_walker.py

class StringWalker:
    """
    A class that allows walking through a string forward and backward,
    getting characters at positions, and replacing characters.
    """
    
    def __init__(self, text):
        """
        Initialize the StringWalker with a string.
        
        Args:
            text (str): The string to walk through
        """
        self.text = text
        self.position = 0
        self.length = len(text)
    
    def get_current_position(self):
        """Return the current position in the string."""
        return self.position
    
    def get_current_character(self):
        """Return the character at the current position."""
        if 0 <= self.position < self.length:
            return self.text[self.position]
        return None
    
    def get_character_at(self, position):
        """
        Return the character at a specific position.
        
        Args:
            position (int): The position to get the character from
            
        Returns:
            str or None: The character at the position, or None if out of bounds
        """
        if 0 <= position < self.length:
            return self.text[position]
        return None
    
    def walk_forward(self, steps=1):
        """
        Walk forward through the string by the specified number of steps.
        
        Args:
            steps (int): Number of steps to move forward (default: 1)
            
        Returns:
            bool: True if the move was successful, False if out of bounds
        """
        new_position = self.position + steps
        if 0 <= new_position < self.length:
            self.position = new_position
            return True
        return False
    
    def walk_backward(self, steps=1):
        """
        Walk backward through the string by the specified number of steps.
        
        Args:
            steps (int): Number of steps to move backward (default: 1)
            
        Returns:
            bool: True if the move was successful, False if out of bounds
        """
        new_position = self.position - steps
        if 0 <= new_position < self.length:
            self.position = new_position
            return True
        return False
    
    def go_to_position(self, position):
        """
        Move to a specific position in the string.
        
        Args:
            position (int): The position to move to
            
        Returns:
            bool: True if the move was successful, False if out of bounds
        """
        if 0 <= position < self.length:
            self.position = position
            return True
        return False
    
    def go_to_start(self):
        """Move to the beginning of the string."""
        self.position = 0
    
    def go_to_end(self):
        """Move to the end of the string."""
        self.position = self.length - 1
    
    def replace_character_at(self, position, new_char):
        """
        Replace a character at a specific position.
        
        Args:
            position (int): The position to replace the character at
            new_char (str): The new character to place at the position
            
        Returns:
            bool: True if the replacement was successful, False if out of bounds
        """
        if 0 <= position < self.length and len(new_char) == 1:
            # Convert string to list for modification
            text_list = list(self.text)
            text_list[position] = new_char
            self.text = ''.join(text_list)
            return True
        return False
    
    def replace_current_character(self, new_char):
        """
        Replace the character at the current position.
        
        Args:
            new_char (str): The new character to place at the current position
            
        Returns:
            bool: True if the replacement was successful, False if out of bounds
        """
        return self.replace_character_at(self.position, new_char)
    
    def get_string(self):
        """Return the current string."""
        return self.text
    
    def get_length(self):
        """Return the length of the string."""
        return self.length
    
    def is_at_start(self):
        """Check if the walker is at the beginning of the string."""
        return self.position == 0
    
    def is_at_end(self):
        """Check if the walker is at the end of the string."""
        return self.position == self.length - 1
    
    def __str__(self):
        """String representation showing current position and character."""
        current_char = self.get_current_character()
        return f"StringWalker at position {self.position} (char: '{current_char}') of '{self.text}'"


# Example usage and demonstration
if __name__ == "__main__":
    # Create a StringWalker with a sample string
    walker = StringWalker("Hello, World!")
    
    print("=== StringWalker Demo ===")
    print(f"Initial string: '{walker.get_string()}'")
    print(f"Length: {walker.get_length()}")
    print(f"Current position: {walker.get_current_position()}")
    print(f"Current character: '{walker.get_current_character()}'")
    print()
    
    # Walk forward
    print("Walking forward 3 steps...")
    walker.walk_forward(3)
    print(f"Position: {walker.get_current_position()}, Character: '{walker.get_current_character()}'")
    print()
    
    # Walk backward
    print("Walking backward 1 step...")
    walker.walk_backward(1)
    print(f"Position: {walker.get_current_position()}, Character: '{walker.get_current_character()}'")
    print()
    
    # Get character at specific position
    print("Getting character at position 7...")
    char_at_7 = walker.get_character_at(7)
    print(f"Character at position 7: '{char_at_7}'")
    print()
    
    # Replace character
    print("Replacing character at position 7 with 'X'...")
    walker.replace_character_at(7, 'X')
    print(f"Updated string: '{walker.get_string()}'")
    print()
    
    # Go to specific position
    print("Going to position 10...")
    walker.go_to_position(10)
    print(f"Position: {walker.get_current_position()}, Character: '{walker.get_current_character()}'")
    print()
    
    # Replace current character
    print("Replacing current character with 'Y'...")
    walker.replace_current_character('Y')
    print(f"Updated string: '{walker.get_string()}'")
    print()
    
    # Go to start and end
    print("Going to start...")
    walker.go_to_start()
    print(f"Position: {walker.get_current_position()}, Character: '{walker.get_current_character()}'")
    
    print("Going to end...")
    walker.go_to_end()
    print(f"Position: {walker.get_current_position()}, Character: '{walker.get_current_character()}'")
    print()
    
    print("=== Final State ===")
    print(walker)