import numpy as np

def strides(T, window_size=50, stride=10):
    """
    Generates strided views of a NumPy array.

    Args:
        T: The input NumPy array.
        window_size: The size of each window/slice.
        stride: The step size between consecutive windows.

    Returns:
        A list of NumPy array views representing the strided windows.  If the last window would extend beyond the bounds of T, it is truncated to fit.
    """

    n = T.shape[0]
    num_windows = (n - window_size) // stride + 1  # Calculate number of full windows
    result = []

    for i in range(num_windows):
        start = i * stride
        end = start + window_size
        result.append(T[start:end])


    # Handle potential partial last window if stride doesn't perfectly divide
    last_start = num_windows * stride
    if last_start + window_size > n and last_start < n:
        result.append(T[last_start:])

    return result


# Example usage:
T = np.arange(100)
windows = strides(T)
print(len(windows))  # Output: 6 (5 full windows + 1 partial)
for window in windows:
    print(window)

windows = strides(T, window_size=20, stride=5)
print(len(windows))
for window in windows:
    print(window)

windows = strides(T, window_size=20, stride=30) # Example with larger stride where not all elements are included
print(len(windows))
for window in windows:
    print(window)


T = np.arange(55) # Example where the last window perfectly fits
windows = strides(T, window_size=50, stride=10)
print(len(windows))
for window in windows:
    print(window)

import numpy as np

def strides(T, window_size=50, stride=10):
    """
    Generates strided views of a NumPy array.

    Args:
        T: The input NumPy array.
        window_size: The size of each window/slice.
        stride: The step size between consecutive windows.

    Returns:
        A list of NumPy array views representing the strided windows.  If the last window would extend beyond the bounds of T, it is truncated to fit.
    """

    n = T.shape[0]
    num_windows = (n - window_size) // stride + 1  # Calculate number of full windows
    result = []

    for i in range(num_windows):
        start = i * stride
        end = start + window_size
        result.append(T[start:end])


    # Handle potential partial last window if stride doesn't perfectly divide
    last_start = num_windows * stride
    if last_start + window_size > n and last_start < n:
        result.append(T[last_start:])

    return result


# Example usage:
T = np.arange(100)
windows = strides(T)
print(len(windows))  # Output: 6 (5 full windows + 1 partial)
for window in windows:
    print(window)

windows = strides(T, window_size=20, stride=5)
print(len(windows))
for window in windows:
    print(window)

windows = strides(T, window_size=20, stride=30) # Example with larger stride where not all elements are included
print(len(windows))
for window in windows:
    print(window)


T = np.arange(55) # Example where the last window perfectly fits
windows = strides(T, window_size=50, stride=10)
print(len(windows))
for window in windows:
    print(window)

import numpy as np

def strides(T, window_size=50, stride=10):
    """
    Generates strided views of a NumPy array.

    Args:
        T: The input NumPy array.
        window_size: The size of each window/slice.
        stride: The step size between consecutive windows.

    Returns:
        A list of NumPy array views representing the strided windows.  If the last window would extend beyond the bounds of T, it is truncated to fit.
    """

    n = T.shape[0]
    num_windows = (n - window_size) // stride + 1  # Calculate number of full windows
    result = []

    for i in range(num_windows):
        start = i * stride
        end = start + window_size
        result.append(T[start:end])


    # Handle potential partial last window if stride doesn't perfectly divide
    last_start = num_windows * stride
    if last_start + window_size > n and last_start < n:
        result.append(T[last_start:])

    return result


# Example usage:
T = np.arange(100)
windows = strides(T)
print(len(windows))  # Output: 6 (5 full windows + 1 partial)
for window in windows:
    print(window)

windows = strides(T, window_size=20, stride=5)
print(len(windows))
for window in windows:
    print(window)

windows = strides(T, window_size=20, stride=30) # Example with larger stride where not all elements are included
print(len(windows))
for window in windows:
    print(window)


T = np.arange(55) # Example where the last window perfectly fits
windows = strides(T, window_size=50, stride=10)
print(len(windows))
for window in windows:
    print(window)







answer = strides(np.arange(100)).shape
expected = (6, 50)
assert answer == expected, f'Wrong answer; got {answer} instead of {expected}'

answer = strides(np.arange(100)).sum()
expected = 14850
assert answer == expected, f'Wrong answer; got {answer} instead of {expected}'
print('All tests passed')

import numpy as np

def strides(T, window_size=50, stride=10):
    """
    Generates strided views of a NumPy array.

    Args:
        T: The input NumPy array.
        window_size: The size of each window/slice.
        stride: The step size between consecutive windows.

    Returns:
        A list of NumPy array views representing the strided windows.  
        Returns an empty list if the input array is too small for even one window.
    """

    n = T.shape[0]
    if n < window_size:
        return []  # Handle cases where the array is too small

    result = []
    start = 0
    while start + window_size <= n:
        result.append(T[start:start + window_size])
        start += stride

    return result


# Example usage:
T = np.arange(100)
strided_views = strides(T)

for view in strided_views:
    print(view)


T_small = np.arange(20)
strided_views_small = strides(T_small) # Example with a small array
print("Strided views for small array:", strided_views_small) # Should print an empty list


T_edge_case = np.arange(60)
strided_views_edge = strides(T_edge_case)
print("Strided views for edge case:", strided_views_edge) # Should produce one window [0...49] if stride=10 and window=50




# Using as_strided (Advanced - Be cautious about memory management)

def strides_as_strided(T, window_size=50, stride=10):
    """
    Generates strided views using np.lib.stride_tricks.as_strided.

    WARNING:  as_strided can create views that point to overlapping or 
              unallocated memory if not used carefully.  Incorrect usage
              can lead to memory corruption or crashes.  Ensure your 
              parameters are correct.  This version includes some basic
              checks but does not guarantee safety in all cases.

    Args:
        T: The input NumPy array.
        window_size: The size of each window/slice.
        stride: The step size between consecutive windows.

    Returns:
        A NumPy array of strided views. May return an empty array if input is too small.
    """
    n = T.shape[0]

    if n < window_size:
        return []

    num_strides = (n - window_size) // stride + 1
    if num_strides <= 0:
        return []


    new_shape = (num_strides, window_size)
    new_strides = (T.strides[0] * stride, T.strides[0])

    try:  # Added a try-except for added safety but still exercise caution!
        strided = np.lib.stride_tricks.as_strided(T, shape=new_shape, strides=new_strides)
        return strided
    except ValueError: # Catch potential errors from as_strided
        print("Error creating strided view - Check parameters")
        return []


strided_as = strides_as_strided(T)
print("\nUsing as_strided:")
print(strided_as)

import numpy as np

def strides(T, window_size=50, stride=10):
    """
    Generates strided views of a NumPy array.

    Args:
        T: The input NumPy array.
        window_size: The size of each window/slice.
        stride: The step size between consecutive windows.

    Returns:
        A list of NumPy array views representing the strided windows.  
        Returns an empty list if the input array is too small for even one window.
    """

    n = T.shape[0]
    if n < window_size:
        return []  # Handle cases where the array is too small

    result = []
    start = 0
    while start + window_size <= n:
        result.append(T[start:start + window_size])
        start += stride

    return result


# Example usage:
T = np.arange(100)
strided_views = strides(T)

for view in strided_views:
    print(view)


T_small = np.arange(20)
strided_views_small = strides(T_small) # Example with a small array
print("Strided views for small array:", strided_views_small) # Should print an empty list


T_edge_case = np.arange(60)
strided_views_edge = strides(T_edge_case)
print("Strided views for edge case:", strided_views_edge) # Should produce one window [0...49] if stride=10 and window=50




# Using as_strided (Advanced - Be cautious about memory management)

def strides_as_strided(T, window_size=50, stride=10):
    """
    Generates strided views using np.lib.stride_tricks.as_strided.

    WARNING:  as_strided can create views that point to overlapping or 
              unallocated memory if not used carefully.  Incorrect usage
              can lead to memory corruption or crashes.  Ensure your 
              parameters are correct.  This version includes some basic
              checks but does not guarantee safety in all cases.

    Args:
        T: The input NumPy array.
        window_size: The size of each window/slice.
        stride: The step size between consecutive windows.

    Returns:
        A NumPy array of strided views. May return an empty array if input is too small.
    """
    n = T.shape[0]

    if n < window_size:
        return []

    num_strides = (n - window_size) // stride + 1
    if num_strides <= 0:
        return []


    new_shape = (num_strides, window_size)
    new_strides = (T.strides[0] * stride, T.strides[0])

    try:  # Added a try-except for added safety but still exercise caution!
        strided = np.lib.stride_tricks.as_strided(T, shape=new_shape, strides=new_strides)
        return strided
    except ValueError: # Catch potential errors from as_strided
        print("Error creating strided view - Check parameters")
        return []


strided_as = strides_as_strided(T)
print("\nUsing as_strided:")
print(strided_as)

import numpy as np

def strides(T, window_size=50, stride=10):
    """
    Generates strided views of a NumPy array.

    Args:
        T: The input NumPy array.
        window_size: The size of each window/slice.
        stride: The step size between consecutive windows.

    Returns:
        A list of NumPy array views representing the strided windows.  
        Returns an empty list if the input array is too small for even one window.
    """

    n = T.shape[0]
    if n < window_size:
        return []  # Handle cases where the array is too small

    result = []
    start = 0
    while start + window_size <= n:
        result.append(T[start:start + window_size])
        start += stride

    return result


# Example usage:
T = np.arange(100)
strided_views = strides(T)

for view in strided_views:
    print(view)


T_small = np.arange(20)
strided_views_small = strides(T_small) # Example with a small array
print("Strided views for small array:", strided_views_small) # Should print an empty list


T_edge_case = np.arange(60)
strided_views_edge = strides(T_edge_case)
print("Strided views for edge case:", strided_views_edge) # Should produce one window [0...49] if stride=10 and window=50




# Using as_strided (Advanced - Be cautious about memory management)

def strides_as_strided(T, window_size=50, stride=10):
    """
    Generates strided views using np.lib.stride_tricks.as_strided.

    WARNING:  as_strided can create views that point to overlapping or 
              unallocated memory if not used carefully.  Incorrect usage
              can lead to memory corruption or crashes.  Ensure your 
              parameters are correct.  This version includes some basic
              checks but does not guarantee safety in all cases.

    Args:
        T: The input NumPy array.
        window_size: The size of each window/slice.
        stride: The step size between consecutive windows.

    Returns:
        A NumPy array of strided views. May return an empty array if input is too small.
    """
    n = T.shape[0]

    if n < window_size:
        return []

    num_strides = (n - window_size) // stride + 1
    if num_strides <= 0:
        return []


    new_shape = (num_strides, window_size)
    new_strides = (T.strides[0] * stride, T.strides[0])

    try:  # Added a try-except for added safety but still exercise caution!
        strided = np.lib.stride_tricks.as_strided(T, shape=new_shape, strides=new_strides)
        return strided
    except ValueError: # Catch potential errors from as_strided
        print("Error creating strided view - Check parameters")
        return []


strided_as = strides_as_strided(T)
print("\nUsing as_strided:")
print(strided_as)







answer = strides(np.arange(100)).shape
expected = (6, 50)
assert answer == expected, f'Wrong answer; got {answer} instead of {expected}'

answer = strides(np.arange(100)).sum()
expected = 14850
assert answer == expected, f'Wrong answer; got {answer} instead of {expected}'
print('All tests passed')

import numpy as np

def strides(T, window_size=50, stride=10):
    """
    Generates strided views of a NumPy array.

    Args:
        T: The input NumPy array.
        window_size: The size of each window/stride.
        stride: The step size between consecutive windows.

    Returns:
        A list of NumPy array views representing the strided windows.  If the last window
        would go past the end of the array, it is truncated to fit.
    """

    n = T.shape[0]  # Length of the input array
    result = []

    for i in range(0, n, stride):
        start = i
        end = min(i + window_size, n)  # Ensure the window doesn't go out of bounds
        if end - start == window_size: # Add only if the window has the specified size
             result.append(T[start:end]) 
        elif end == n:  # Handle the last window which may be shorter
            result.append(T[start:end])


    return result




# Example usage:
T = np.arange(100)
strided_views = strides(T)
print(len(strided_views)) # Output: 10 (because 100 - 50 = 50 and 50/10 = 5 and 5 + the first one = 6)

for view in strided_views:
    print(view)

strided_views_different_stride = strides(T, window_size=50, stride=20)
print(len(strided_views_different_stride))


T_short = np.arange(65) # A shorter array
strided_views_short = strides(T_short) # It will handle the last window being shorter
print(len(strided_views_short)) # Output: 2 (because 65 - 50 = 15 and 15/10 = 1.5, so 1 + the first = 2)
for view in strided_views_short:
    print(view)



T_very_short = np.arange(30)
strided_views_very_short = strides(T_very_short) # It will handle the case where even the first window is too short
print(len(strided_views_very_short)) # Output: 1 because the first window would be truncated, but it's the only one.
for view in strided_views_very_short:
    print(view)

import numpy as np

def strides(T, window_size=50, stride=10):
    """
    Generates strided views of a NumPy array.

    Args:
        T: The input NumPy array.
        window_size: The size of each window/stride.
        stride: The step size between consecutive windows.

    Returns:
        A list of NumPy array views representing the strided windows.  If the last window
        would go past the end of the array, it is truncated to fit.
    """

    n = T.shape[0]  # Length of the input array
    result = []

    for i in range(0, n, stride):
        start = i
        end = min(i + window_size, n)  # Ensure the window doesn't go out of bounds
        if end - start == window_size: # Add only if the window has the specified size
             result.append(T[start:end]) 
        elif end == n:  # Handle the last window which may be shorter
            result.append(T[start:end])


    return result




# Example usage:
T = np.arange(100)
strided_views = strides(T)
print(len(strided_views)) # Output: 10 (because 100 - 50 = 50 and 50/10 = 5 and 5 + the first one = 6)

for view in strided_views:
    print(view)

strided_views_different_stride = strides(T, window_size=50, stride=20)
print(len(strided_views_different_stride))


T_short = np.arange(65) # A shorter array
strided_views_short = strides(T_short) # It will handle the last window being shorter
print(len(strided_views_short)) # Output: 2 (because 65 - 50 = 15 and 15/10 = 1.5, so 1 + the first = 2)
for view in strided_views_short:
    print(view)



T_very_short = np.arange(30)
strided_views_very_short = strides(T_very_short) # It will handle the case where even the first window is too short
print(len(strided_views_very_short)) # Output: 1 because the first window would be truncated, but it's the only one.
for view in strided_views_very_short:
    print(view)

import numpy as np

def strides(T, window_size=50, stride=10):
    """
    Generates strided views of a NumPy array.

    Args:
        T: The input NumPy array.
        window_size: The size of each window/stride.
        stride: The step size between consecutive windows.

    Returns:
        A list of NumPy array views representing the strided windows.  If the last window
        would go past the end of the array, it is truncated to fit.
    """

    n = T.shape[0]  # Length of the input array
    result = []

    for i in range(0, n, stride):
        start = i
        end = min(i + window_size, n)  # Ensure the window doesn't go out of bounds
        if end - start == window_size: # Add only if the window has the specified size
             result.append(T[start:end]) 
        elif end == n:  # Handle the last window which may be shorter
            result.append(T[start:end])


    return result




# Example usage:
T = np.arange(100)
strided_views = strides(T)
print(len(strided_views)) # Output: 10 (because 100 - 50 = 50 and 50/10 = 5 and 5 + the first one = 6)

for view in strided_views:
    print(view)

strided_views_different_stride = strides(T, window_size=50, stride=20)
print(len(strided_views_different_stride))


T_short = np.arange(65) # A shorter array
strided_views_short = strides(T_short) # It will handle the last window being shorter
print(len(strided_views_short)) # Output: 2 (because 65 - 50 = 15 and 15/10 = 1.5, so 1 + the first = 2)
for view in strided_views_short:
    print(view)



T_very_short = np.arange(30)
strided_views_very_short = strides(T_very_short) # It will handle the case where even the first window is too short
print(len(strided_views_very_short)) # Output: 1 because the first window would be truncated, but it's the only one.
for view in strided_views_very_short:
    print(view)






answer = strides(np.arange(100)).shape
expected = (6, 50)
assert answer == expected, f'Wrong answer; got {answer} instead of {expected}'

answer = strides(np.arange(100)).sum()
expected = 14850
assert answer == expected, f'Wrong answer; got {answer} instead of {expected}'
print('All tests passed')

import numpy as np

def strides(T, window_size=50, stride=10):
    """
    Generates strided views of a NumPy array.

    Args:
        T: The input NumPy array.
        window_size: The size of each window/slice.
        stride: The step size between consecutive windows.

    Returns:
        A list of NumPy array views representing the strided windows. 
        Returns an empty list if the input array is too small for even one window.
    """

    if len(T) < window_size:
        return []  # Handle cases where the array is too small

    n_strides = (len(T) - window_size) // stride + 1
    strided_views = []

    for i in range(n_strides):
        start = i * stride
        end = start + window_size
        strided_views.append(T[start:end]) 

    return strided_views



# Example usage:
T = np.arange(100)  # Example array

strided_T = strides(T)
print(len(strided_T))  # Output: 6 (because (100-50)//10 + 1 = 6)

for view in strided_T:
    print(view)


strided_T_2 = strides(T, window_size=20, stride=5)
print(len(strided_T_2)) # Output: 17

# Example with a smaller array:
T_small = np.arange(30)
strided_T_small = strides(T_small) # Output: empty list as 30 < 50 (window_size)
print(len(strided_T_small))  # Output: 0 (empty list)


strided_T_small = strides(T_small, window_size=10, stride=5) # Now it works
print(len(strided_T_small)) # Output: 5

from numpy.lib.stride_tricks import as_strided

def strides_advanced(T, window_size=50, stride=10):
    if len(T) < window_size:
        return []

    n_strides = (len(T) - window_size) // stride + 1
    view_shape = (n_strides, window_size)
    strides_shape = (T.strides[0] * stride, T.strides[0])  # Crucial for correct strides
    strided_views = as_strided(T, shape=view_shape, strides=strides_shape)
    return strided_views.tolist() # convert to list of arrays as before


# Example
T = np.arange(100)
strided_T_adv = strides_advanced(T)
print(len(strided_T_adv))  # Output: 6
# ... (rest of the example usage is similar)

import numpy as np

def strides(T, window_size=50, stride=10):
    """
    Generates strided views of a NumPy array.

    Args:
        T: The input NumPy array.
        window_size: The size of each window/slice.
        stride: The step size between consecutive windows.

    Returns:
        A list of NumPy array views representing the strided windows. 
        Returns an empty list if the input array is too small for even one window.
    """

    if len(T) < window_size:
        return []  # Handle cases where the array is too small

    n_strides = (len(T) - window_size) // stride + 1
    strided_views = []

    for i in range(n_strides):
        start = i * stride
        end = start + window_size
        strided_views.append(T[start:end]) 

    return strided_views

import numpy as np

def strides(T, window_size=50, stride=10):
    """
    Generates strided views of a NumPy array.

    Args:
        T: The input NumPy array.
        window_size: The size of each window/slice.
        stride: The step size between consecutive windows.

    Returns:
        A list of NumPy array views representing the strided windows. 
        Returns an empty list if the input array is too small for even one window.
    """

    if len(T) < window_size:
        return []  # Handle cases where the array is too small

    n_strides = (len(T) - window_size) // stride + 1
    strided_views = []

    for i in range(n_strides):
        start = i * stride
        end = start + window_size
        strided_views.append(T[start:end]) 

    return strided_views





answer = strides(np.arange(100)).shape
expected = (6, 50)
assert answer == expected, f'Wrong answer; got {answer} instead of {expected}'

answer = strides(np.arange(100)).sum()
expected = 14850
assert answer == expected, f'Wrong answer; got {answer} instead of {expected}'
print('All tests passed')

import numpy as np

def strides(T, window_size=50, stride=10):
    """
    Generates strided views of a numpy array.

    Args:
        T: The input numpy array of tokens.
        window_size: The size of each window/slice.
        stride: The step size between consecutive windows.

    Returns:
        A list of numpy array views, representing the strided windows.  
        Returns an empty list if the input array is too short for even a single window.
    """

    if len(T) < window_size:
        return []

    num_strides = (len(T) - window_size) // stride + 1
    result = []

    for i in range(num_strides):
        start = i * stride
        end = start + window_size
        result.append(T[start:end])

    return result


# Example usage:
T = np.array(range(100)) 
strided_views = strides(T)

for view in strided_views:
    print(view)


T_short = np.array(range(20))
strided_views_short = strides(T_short)  # Example with a short array
print(f"\nStrided views for short array: {strided_views_short}") # Will print an empty list


strided_views_custom = strides(T, window_size=25, stride=5) # Example with custom window and stride
print("\nStrided views with custom window and stride:")
for view in strided_views_custom:
    print(view)

import numpy as np

def strides(T, window_size=50, stride=10):
    """
    Generates strided views of a numpy array.

    Args:
        T: The input numpy array of tokens.
        window_size: The size of each window/slice.
        stride: The step size between consecutive windows.

    Returns:
        A list of numpy array views, representing the strided windows.  
        Returns an empty list if the input array is too short for even a single window.
    """

    if len(T) < window_size:
        return []

    num_strides = (len(T) - window_size) // stride + 1
    result = []

    for i in range(num_strides):
        start = i * stride
        end = start + window_size
        result.append(T[start:end])

    return result


# Example usage:
T = np.array(range(100)) 
strided_views = strides(T)

for view in strided_views:
    print(view)


T_short = np.array(range(20))
strided_views_short = strides(T_short)  # Example with a short array
print(f"\nStrided views for short array: {strided_views_short}") # Will print an empty list


strided_views_custom = strides(T, window_size=25, stride=5) # Example with custom window and stride
print("\nStrided views with custom window and stride:")
for view in strided_views_custom:
    print(view)

import numpy as np

def strides(T, window_size=50, stride=10):
    """
    Generates strided views of a numpy array.

    Args:
        T: The input numpy array of tokens.
        window_size: The size of each window/slice.
        stride: The step size between consecutive windows.

    Returns:
        A list of numpy array views, representing the strided windows.  
        Returns an empty list if the input array is too short for even a single window.
    """

    if len(T) < window_size:
        return []

    num_strides = (len(T) - window_size) // stride + 1
    result = []

    for i in range(num_strides):
        start = i * stride
        end = start + window_size
        result.append(T[start:end])

    return result


# Example usage:
T = np.array(range(100)) 
strided_views = strides(T)

for view in strided_views:
    print(view)


T_short = np.array(range(20))
strided_views_short = strides(T_short)  # Example with a short array
print(f"\nStrided views for short array: {strided_views_short}") # Will print an empty list


strided_views_custom = strides(T, window_size=25, stride=5) # Example with custom window and stride
print("\nStrided views with custom window and stride:")
for view in strided_views_custom:
    print(view)





answer = strides(np.arange(100)).shape
expected = (6, 50)
assert answer == expected, f'Wrong answer; got {answer} instead of {expected}'

answer = strides(np.arange(100)).sum()
expected = 14850
assert answer == expected, f'Wrong answer; got {answer} instead of {expected}'
print('All tests passed')