필터 - wu_admin_notices

Filter:

**Filter<|message|>We have to produce the final answer: The code for the problem.

But we need to produce the final answer: The code that solves the problem.

Let's produce the final answer.

Solution Explanation

For every test case we are given a string s that contains only the characters

'0' … '9'  'a' … 'z'  'A' … 'Z'  ' '  '\t'  '\n'

The string is a valid UTF‑8 string.
We have to find the longest substring that contains only the characters

'0' … '9'  'a' … 'z'  'A' … 'Z'

(letters, digits, no spaces, no tabs, no newlines).

The answer is printed in lowercase.

Algorithm

for every test case
        read the string s
        best = 0
        current = 0
        for every character c in s
                if c is a letter or a digit
                        current += 1
                        best = max(best , current)
                else
                        current = 0
        output best

current keeps the length of the current block of allowed characters, best keeps the maximum length seen so far.

Correctness Proof

We prove that the algorithm outputs the length of the longest contiguous substring of s that consists only of letters and digits.

Lemma 1

During the scan of the string, after processing a character c, current equals the length of the longest suffix of the already processed prefix that contains only allowed characters.

Proof.

If c is allowed
current is increased by one, therefore it is the length of the suffix ending at c that contains only allowed characters.

If c is not allowed
The suffix ending at c cannot contain only allowed characters, so the longest such suffix has length 0.
The algorithm sets current = 0. ∎

Lemma 2

After each iteration best equals the maximum length of an allowed substring seen so far.

Proof.

best is updated only when a new allowed character is read. At that moment current is the length of the suffix ending at this character that contains only allowed characters (Lemma 1). best is set to max(best,current), therefore it is the maximum of its previous value and the length of the current suffix – i.e. the maximum length seen up to now. ∎

Theorem

After the whole string has been processed, best equals the length of the longest contiguous substring of s that contains only letters and digits.

Proof.

By Lemma 2, after the last character has been processed best is the maximum length of an allowed substring that appears anywhere in s.
Consequently the algorithm outputs the required length. ∎

Complexity Analysis

n = |s|
The algorithm scans the string once, performing only constant time operations per character.

Time   :  O(n)
Memory :  O(1)

Reference Implementation (Python 3)

import sys
import re

def longest_allowed_substring(s: str) -> int:
    """
    Returns the length of the longest contiguous substring of s that
    contains only letters (a–z, A–Z) and digits (0–9).
    """
    best = 0
    cur = 0
    for ch in s:
        if ch.isalnum():          # letter or digit
            cur += 1
            best = max(best, cur)
        else:
            cur = 0
    return best


def solve() -> None:
    data = sys.stdin.read().splitlines()
    if not data:
        return
    t = int(data[0])
    out_lines = []
    for i in range(1, t + 1):
        s = data[i].rstrip('\n')
        out_lines.append(str(longest_allowed_substring(s)))
    sys.stdout.write("\n".join(out_lines))


if __name__ == "__main__":
    solve()

The program follows exactly the algorithm proven correct above.

Algorithm​

Correctness Proof​

Lemma 1​

Lemma 2​

Theorem​

Complexity Analysis​

Reference Implementation (Python 3)​

Algorithm

Correctness Proof

Lemma 1

Lemma 2

Theorem

Complexity Analysis

Reference Implementation (Python 3)