Test results - Codility

Tasks Details

easy

1. LongestPassword

Given a string containing words, find the longest word that satisfies specific conditions.

Task Score

100%

Correctness

100%

Performance

Not assessed

You would like to set a password for a bank account. However, there are three restrictions on the format of the password:

it has to contain only alphanumerical characters (a−z, A−Z, 0−9);

there should be an even number of letters;

there should be an odd number of digits.

You are given a string S consisting of N characters. String S can be divided into words by splitting it at, and removing, the spaces. The goal is to choose the longest word that is a valid password. You can assume that if there are K spaces in string S then there are exactly K + 1 words.

For example, given "test 5 a0A pass007 ?xy1", there are five words and three of them are valid passwords: "5", "a0A" and "pass007". Thus the longest password is "pass007" and its length is 7. Note that neither "test" nor "?xy1" is a valid password, because "?" is not an alphanumerical character and "test" contains an even number of digits (zero).

Write a function:

def solution(S)

that, given a non-empty string S consisting of N characters, returns the length of the longest word from the string that is a valid password. If there is no such word, your function should return −1.

For example, given S = "test 5 a0A pass007 ?xy1", your function should return 7, as explained above.

Assume that:

N is an integer within the range [1..200];

string S consists only of printable ASCII characters and spaces.

In your solution, focus on correctness. The performance of your solution will not be the focus of the assessment.

Solution

Programming language used Python

Time spent on task 34 minutes

Notes

not defined yet

Task timeline

Code: 03:56:40 UTC, java, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11

// you can also use imports, for example:
// import java.util.*;

// you can write to stdout for debugging purposes, e.g.
// System.out.println("this is a debug message");

class Solution {
    public int solution(String S) {
        // write your code in Java SE 8
    }
}

Code: 03:59:11 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

def solution(S):
    # write your code in Python 3.6
    pass

Code: 03:59:54 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

def solution(S):

Code: 04:00:09 UTC, py, verify, result: Failed

show code in pop-up

1 2 3 4 5 6 7 8

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

def solution(S):
    
    lst = S.split(" ")

    print(lst)

Analysis

expand all Example tests

▶

example
example test

✘

RUNTIME ERROR
tested program terminated with exit code 1

0.036 s

RUNTIME ERROR, tested program terminated with exit code 1

stderr:

Invalid result type, int expected, <class 'NoneType'> found.

stdout:

['test', '5', 'a0A', 'pass007', '?xy1']

Code: 04:00:42 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")



def solution(S):
    
    lst = S.split(" ")

    print(lst)

Code: 04:00:59 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

def valid_check()

def solution(S):
    
    lst = S.split(" ")

    print(lst)

Code: 04:01:10 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

def valid_check(s):

    

def solution(S):
    
    lst = S.split(" ")

    print(lst)

Code: 04:01:48 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")



def valid_check(s):

    

def solution(S):
    
    lst = S.split(" ")

    print(lst)

Code: 04:01:59 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

import regedit

def valid_check(s):

    

def solution(S):
    
    lst = S.split(" ")

    print(lst)

Code: 04:02:28 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

import re

def valid_check(s):

    

def solution(S):
    
    lst = S.split(" ")

    print(lst)

Code: 04:02:39 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

import re

def valid_check(s):
    

    

def solution(S):
    
    lst = S.split(" ")

    print(lst)

Code: 04:03:09 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

import re

def valid_check(s):

    pattern = re.comp
    

def solution(S):
    
    lst = S.split(" ")

    print(lst)

Code: 04:03:24 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

import re

def valid_check(s):

    pattern = re.compile('[a-z]')
    

def solution(S):
    
    lst = S.split(" ")

    print(lst)

Code: 04:03:34 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

import re

def valid_check(s):

    pattern = re.compile('[a-zA-Z]')
    

def solution(S):
    
    lst = S.split(" ")

    print(lst)

Code: 04:03:45 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

import re

def valid_check(s):

    pattern = re.compile('[a-zA-Z0-9]')
    

def solution(S):
    
    lst = S.split(" ")

    print(lst)

Code: 04:04:05 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

import re

def valid_check(s):

    pattern = re.compile('[a-zA-Z0-9]')
    pattern.match(s)
    print()

def solution(S):
    
    lst = S.split(" ")

    print(lst)

Code: 04:04:41 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

import re

def valid_check(s):

    pattern = re.compile('[a-zA-Z0-9]')

    print()

def solution(S):
    
    lst = S.split(" ")

    print(lst)

Code: 04:05:01 UTC, py, verify, result: Failed

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

import re

def valid_check(s):

    pattern = re.compile('[a-zA-Z0-9]')
    print(pattern.match(s))

def solution(S):
    
    lst = S.split(" ")

    for l in lst:
        valid_check(l)

Analysis

expand all Example tests

▶

example
example test

✘

RUNTIME ERROR
tested program terminated with exit code 1

0.044 s

RUNTIME ERROR, tested program terminated with exit code 1

stderr:

Invalid result type, int expected, <class 'NoneType'> found.

stdout:

<_sre.SRE_Match object; span=(0, 1), match='t'>
<_sre.SRE_Match object; span=(0, 1), match='5'>
<_sre.SRE_Match object; span=(0, 1), match='a'>
<_sre.SRE_Match object; span=(0, 1), match='p'>
None

Code: 04:07:02 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

import re

def valid_check(s):

    pattern = re.compile('[a-zA-Z0-9]*')
    print(pattern.match(s))

def solution(S):
    
    lst = S.split(" ")

    for l in lst:
        valid_check(l)

Code: 04:07:04 UTC, py, verify, result: Failed

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

import re

def valid_check(s):

    pattern = re.compile('[a-zA-Z0-9]*')
    print(pattern.match(s))

def solution(S):
    
    lst = S.split(" ")

    for l in lst:
        valid_check(l)

Analysis

expand all Example tests

▶

example
example test

✘

RUNTIME ERROR
tested program terminated with exit code 1

0.040 s

RUNTIME ERROR, tested program terminated with exit code 1

stderr:

Invalid result type, int expected, <class 'NoneType'> found.

stdout:

<_sre.SRE_Match object; span=(0, 4), match='test'>
<_sre.SRE_Match object; span=(0, 1), match='5'>
<_sre.SRE_Match object; span=(0, 3), match='a0A'>
<_sre.SRE_Match object; span=(0, 7), match='pass007'>
<_sre.SRE_Match object; span=(0, 0), match=''>

Code: 04:08:18 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

import re

def valid_check(s):

    pattern = re.compile('[a-z]*')
    print(pattern.match(s))

def solution(S):
    
    lst = S.split(" ")

    for l in lst:
        valid_check(l)

Code: 04:08:18 UTC, py, verify, result: Failed

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

import re

def valid_check(s):

    pattern = re.compile('[a-z]*')
    print(pattern.match(s))

def solution(S):
    
    lst = S.split(" ")

    for l in lst:
        valid_check(l)

Analysis

expand all Example tests

▶

example
example test

✘

RUNTIME ERROR
tested program terminated with exit code 1

0.040 s

RUNTIME ERROR, tested program terminated with exit code 1

stderr:

Invalid result type, int expected, <class 'NoneType'> found.

stdout:

<_sre.SRE_Match object; span=(0, 4), match='test'>
<_sre.SRE_Match object; span=(0, 0), match=''>
<_sre.SRE_Match object; span=(0, 1), match='a'>
<_sre.SRE_Match object; span=(0, 4), match='pass'>
<_sre.SRE_Match object; span=(0, 0), match=''>

Code: 04:08:49 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

import re

def valid_check(s):

    lower = re.compile('[a-z]*')
    lower = re.compile('[a-z]*')
    lower = re.compile('[a-z]*')
    print(pattern.match(s))

def solution(S):
    
    lst = S.split(" ")

    for l in lst:
        valid_check(l)

Code: 04:08:59 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

import re

def valid_check(s):

    lower = re.compile('[a-z]*')
    upper = re.compile('[a-z]*')
    n = re.compile('[a-z]*')
    print(pattern.match(s))

def solution(S):
    
    lst = S.split(" ")

    for l in lst:
        valid_check(l)

Code: 04:09:16 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

import re

def valid_check(s):

    lower = re.compile('[a-z]*')
    upper = re.compile('[A-Z]*')
    numeric = re.compile('[0-9]*')
    print(pattern.match(s))

def solution(S):
    
    lst = S.split(" ")

    for l in lst:
        valid_check(l)

Code: 04:09:18 UTC, py, verify, result: Failed

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

import re

def valid_check(s):

    lower = re.compile('[a-z]*')
    upper = re.compile('[A-Z]*')
    numeric = re.compile('[0-9]*')
    print(lower.match(s))

def solution(S):
    
    lst = S.split(" ")

    for l in lst:
        valid_check(l)

Analysis

expand all Example tests

▶

example
example test

✘

RUNTIME ERROR
tested program terminated with exit code 1

0.044 s

RUNTIME ERROR, tested program terminated with exit code 1

stderr:

Invalid result type, int expected, <class 'NoneType'> found.

stdout:

<_sre.SRE_Match object; span=(0, 4), match='test'>
<_sre.SRE_Match object; span=(0, 0), match=''>
<_sre.SRE_Match object; span=(0, 1), match='a'>
<_sre.SRE_Match object; span=(0, 4), match='pass'>
<_sre.SRE_Match object; span=(0, 0), match=''>

Code: 04:09:50 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

import re

def valid_check(s):

    lower = re.compile('[a-z]*')
    upper = re.compile('[A-Z]*')
    numeric = re.compile('?[0-9]*')
    print(lower.match(s))

def solution(S):
    
    lst = S.split(" ")

    for l in lst:
        valid_check(l)

Code: 04:09:53 UTC, py, verify, result: Failed

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

import re

def valid_check(s):

    lower = re.compile('?[a-z]*')
    upper = re.compile('?[A-Z]*')
    numeric = re.compile('?[0-9]*')
    print(lower.match(s))

def solution(S):
    
    lst = S.split(" ")

    for l in lst:
        valid_check(l)

Analysis

expand all Example tests

▶

example
example test

✘

RUNTIME ERROR
tested program terminated with exit code 1

0.044 s

RUNTIME ERROR, tested program terminated with exit code 1

stderr:

Traceback (most recent call last):
  File "exec.py", line 123, in <module>
    main()
  File "exec.py", line 85, in main
    result = solution( S )
  File "/tmp/solution.py", line 18, in solution
    valid_check(l)
  File "/tmp/solution.py", line 8, in valid_check
    lower = re.compile('?[a-z]*')
  File "/opt/lang/python3/lib/python3.6/re.py", line 233, in compile
    return _compile(pattern, flags)
  File "/opt/lang/python3/lib/python3.6/re.py", line 301, in _compile
    p = sre_compile.compile(pattern, flags)
  File "/opt/lang/python3/lib/python3.6/sre_compile.py", line 562, in compile
    p = sre_parse.parse(p, flags)
  File "/opt/lang/python3/lib/python3.6/sre_parse.py", line 855, in parse
    p = _parse_sub(source, pattern, flags & SRE_FLAG_VERBOSE, 0)
  File "/opt/lang/python3/lib/python3.6/sre_parse.py", line 416, in _parse_sub
    not nested and not items))
  File "/opt/lang/python3/lib/python3.6/sre_parse.py", line 616, in _parse
    source.tell() - here + len(this))
sre_constants.error: nothing to repeat at position 0

Code: 04:10:03 UTC, py, verify, result: Failed

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

import re

def valid_check(s):

    lower = re.compile(r'[a-z]*')
    upper = re.compile(r'[A-Z]*')
    numeric = re.compile(r'[0-9]*')
    print(lower.match(s))

def solution(S):
    
    lst = S.split(" ")

    for l in lst:
        valid_check(l)

Analysis

expand all Example tests

▶

example
example test

✘

RUNTIME ERROR
tested program terminated with exit code 1

0.040 s

RUNTIME ERROR, tested program terminated with exit code 1

stderr:

Invalid result type, int expected, <class 'NoneType'> found.

stdout:

<_sre.SRE_Match object; span=(0, 4), match='test'>
<_sre.SRE_Match object; span=(0, 0), match=''>
<_sre.SRE_Match object; span=(0, 1), match='a'>
<_sre.SRE_Match object; span=(0, 4), match='pass'>
<_sre.SRE_Match object; span=(0, 0), match=''>

Code: 04:10:39 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

import re

def valid_check(s):

    lower = re.compile(r'[a-z]*')
    upper = re.compile(r'[A-Z]*')
    numeric = re.compile(r'[0-9]*')
    print(lower.(s))

def solution(S):
    
    lst = S.split(" ")

    for l in lst:
        valid_check(l)

Code: 04:10:42 UTC, py, verify, result: Failed

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

import re

def valid_check(s):

    lower = re.compile(r'[a-z]*')
    upper = re.compile(r'[A-Z]*')
    numeric = re.compile(r'[0-9]*')
    print(lower.findall(s))

def solution(S):
    
    lst = S.split(" ")

    for l in lst:
        valid_check(l)

Analysis

expand all Example tests

▶

example
example test

✘

RUNTIME ERROR
tested program terminated with exit code 1

0.040 s

RUNTIME ERROR, tested program terminated with exit code 1

stderr:

Invalid result type, int expected, <class 'NoneType'> found.

stdout:

['test', '']
['', '']
['a', '', '', '']
['pass', '', '', '', '']
['', 'xy', '', '']

Code: 04:11:19 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

import re

def valid_check(s):

    lower = re.compile(r'[a-z]*')
    upper = re.compile(r'[A-Z]*')
    numeric = re.compile(r'[0-9]*')
    print(lower.find(s))

def solution(S):
    
    lst = S.split(" ")

    for l in lst:
        valid_check(l)

Code: 04:11:19 UTC, py, verify, result: Failed

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

import re

def valid_check(s):

    lower = re.compile(r'[a-z]*')
    upper = re.compile(r'[A-Z]*')
    numeric = re.compile(r'[0-9]*')
    print(lower.find(s))

def solution(S):
    
    lst = S.split(" ")

    for l in lst:
        valid_check(l)

Analysis

expand all Example tests

▶

example
example test

✘

RUNTIME ERROR
tested program terminated with exit code 1

0.040 s

RUNTIME ERROR, tested program terminated with exit code 1

stderr:

Traceback (most recent call last):
  File "exec.py", line 123, in <module>
    main()
  File "exec.py", line 85, in main
    result = solution( S )
  File "/tmp/solution.py", line 18, in solution
    valid_check(l)
  File "/tmp/solution.py", line 11, in valid_check
    print(lower.find(s))
AttributeError: '_sre.SRE_Pattern' object has no attribute 'find'

Code: 04:11:29 UTC, py, verify, result: Failed

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

import re

def valid_check(s):

    lower = re.compile(r'[a-z]*')
    upper = re.compile(r'[A-Z]*')
    numeric = re.compile(r'[0-9]*')
    print(lower.findall(s))

def solution(S):
    
    lst = S.split(" ")

    for l in lst:
        valid_check(l)

Analysis

expand all Example tests

▶

example
example test

✘

RUNTIME ERROR
tested program terminated with exit code 1

0.040 s

RUNTIME ERROR, tested program terminated with exit code 1

stderr:

Invalid result type, int expected, <class 'NoneType'> found.

stdout:

['test', '']
['', '']
['a', '', '', '']
['pass', '', '', '', '']
['', 'xy', '', '']

Code: 04:11:40 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

import re

def valid_check(s):

    lower = re.compile(r'[a-zA-Z0-9]*')
    upper = re.compile(r'[A-Z]*')
    numeric = re.compile(r'[0-9]*')
    print(lower.findall(s))

def solution(S):
    
    lst = S.split(" ")

    for l in lst:
        valid_check(l)

Code: 04:11:46 UTC, py, verify, result: Failed

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

import re

def valid_check(s):

    lower = re.compile(r'[a-zA-Z0-9]*')
    # upper = re.compile(r'[A-Z]*')
    # numeric = re.compile(r'[0-9]*')
    print(lower.findall(s))

def solution(S):
    
    lst = S.split(" ")

    for l in lst:
        valid_check(l)

Analysis

expand all Example tests

▶

example
example test

✘

RUNTIME ERROR
tested program terminated with exit code 1

0.040 s

RUNTIME ERROR, tested program terminated with exit code 1

stderr:

Invalid result type, int expected, <class 'NoneType'> found.

stdout:

['test', '']
['5', '']
['a0A', '']
['pass007', '']
['', 'xy1', '']

Code: 04:12:07 UTC, py, verify, result: Failed

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

import re

def valid_check(s):

    lower = re.compile(r'[a-zA-Z0-9]*')
    # upper = re.compile(r'[A-Z]*')
    # numeric = re.compile(r'[0-9]*')
    print(lower.findall(s))

def solution(S):
    
    lst = S.split(" ")

    print(lst)

    for l in lst:
        valid_check(l)

Analysis

expand all Example tests

▶

example
example test

✘

RUNTIME ERROR
tested program terminated with exit code 1

0.040 s

RUNTIME ERROR, tested program terminated with exit code 1

stderr:

Invalid result type, int expected, <class 'NoneType'> found.

stdout:

['test', '5', 'a0A', 'pass007', '?xy1']
['test', '']
['5', '']
['a0A', '']
['pass007', '']
['', 'xy1', '']

Code: 04:12:49 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

import re

def valid_check(s):

    lower = re.compile(r'[a-zA-Z0-9]*')
    # upper = re.compile(r'[A-Z]*')
    # numeric = re.compile(r'[0-9]*')
    print(lower.s(s))

def solution(S):
    
    lst = S.split(" ")

    print(lst)

    for l in lst:
        valid_check(l)

Code: 04:12:52 UTC, py, verify, result: Failed

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

import re

def valid_check(s):

    lower = re.compile(r'[a-zA-Z0-9]*')
    # upper = re.compile(r'[A-Z]*')
    # numeric = re.compile(r'[0-9]*')
    print(lower.search(s))

def solution(S):
    
    lst = S.split(" ")

    print(lst)

    for l in lst:
        valid_check(l)

Analysis

expand all Example tests

▶

example
example test

✘

RUNTIME ERROR
tested program terminated with exit code 1

0.040 s

RUNTIME ERROR, tested program terminated with exit code 1

stderr:

Invalid result type, int expected, <class 'NoneType'> found.

stdout:

['test', '5', 'a0A', 'pass007', '?xy1']
<_sre.SRE_Match object; span=(0, 4), match='test'>
<_sre.SRE_Match object; span=(0, 1), match='5'>
<_sre.SRE_Match object; span=(0, 3), match='a0A'>
<_sre.SRE_Match object; span=(0, 7), match='pass007'>
<_sre.SRE_Match object; span=(0, 0), match=''>

Code: 04:13:11 UTC, py, verify, result: Failed

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

import re

def valid_check(s):

    lower = re.compile(r'[a-zA-Z0-9]*')
    # upper = re.compile(r'[A-Z]*')
    # numeric = re.compile(r'[0-9]*')
    print(lower.findall(s))

def solution(S):
    
    lst = S.split(" ")

    print(lst)

    for l in lst:
        valid_check(l)

Analysis

expand all Example tests

▶

example
example test

✘

RUNTIME ERROR
tested program terminated with exit code 1

0.044 s

RUNTIME ERROR, tested program terminated with exit code 1

stderr:

Invalid result type, int expected, <class 'NoneType'> found.

stdout:

['test', '5', 'a0A', 'pass007', '?xy1']
['test', '']
['5', '']
['a0A', '']
['pass007', '']
['', 'xy1', '']

Code: 04:13:39 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

import re

def valid_check(s):

    lower = re.compile(r'[a-z]*')
    # upper = re.compile(r'[A-Z]*')
    # numeric = re.compile(r'[0-9]*')
    print(lower.findall(s))

def solution(S):
    
    lst = S.split(" ")

    print(lst)

    for l in lst:
        valid_check(l)

Code: 04:13:39 UTC, py, verify, result: Failed

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

import re

def valid_check(s):

    lower = re.compile(r'[a-z]*')
    # upper = re.compile(r'[A-Z]*')
    # numeric = re.compile(r'[0-9]*')
    print(lower.findall(s))

def solution(S):
    
    lst = S.split(" ")

    print(lst)

    for l in lst:
        valid_check(l)

Analysis

expand all Example tests

▶

example
example test

✘

RUNTIME ERROR
tested program terminated with exit code 1

0.040 s

RUNTIME ERROR, tested program terminated with exit code 1

stderr:

Invalid result type, int expected, <class 'NoneType'> found.

stdout:

['test', '5', 'a0A', 'pass007', '?xy1']
['test', '']
['', '']
['a', '', '', '']
['pass', '', '', '', '']
['', 'xy', '', '']

Code: 04:13:45 UTC, py, verify, result: Failed

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

import re

def valid_check(s):

    lower = re.compile(r'[a-z]')
    # upper = re.compile(r'[A-Z]')
    # numeric = re.compile(r'[0-9]')
    print(lower.findall(s))

def solution(S):
    
    lst = S.split(" ")

    print(lst)

    for l in lst:
        valid_check(l)

Analysis

expand all Example tests

▶

example
example test

✘

RUNTIME ERROR
tested program terminated with exit code 1

0.040 s

RUNTIME ERROR, tested program terminated with exit code 1

stderr:

Invalid result type, int expected, <class 'NoneType'> found.

stdout:

['test', '5', 'a0A', 'pass007', '?xy1']
['t', 'e', 's', 't']
[]
['a']
['p', 'a', 's', 's']
['x', 'y']

Code: 04:14:18 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

import re

def valid_check(s):

    lower = re.compile(r'[a-z]+')
    # upper = re.compile(r'[A-Z]')
    # numeric = re.compile(r'[0-9]')
    print(lower.findall(s))

def solution(S):
    
    lst = S.split(" ")

    print(lst)

    for l in lst:
        valid_check(l)

Code: 04:14:18 UTC, py, verify, result: Failed

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

import re

def valid_check(s):

    lower = re.compile(r'[a-z]+')
    # upper = re.compile(r'[A-Z]')
    # numeric = re.compile(r'[0-9]')
    print(lower.findall(s))

def solution(S):
    
    lst = S.split(" ")

    print(lst)

    for l in lst:
        valid_check(l)

Analysis

expand all Example tests

▶

example
example test

✘

RUNTIME ERROR
tested program terminated with exit code 1

0.040 s

RUNTIME ERROR, tested program terminated with exit code 1

stderr:

Invalid result type, int expected, <class 'NoneType'> found.

stdout:

['test', '5', 'a0A', 'pass007', '?xy1']
['test']
[]
['a']
['pass']
['xy']

Code: 04:14:48 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

import re

def valid_check(s):
    
    lower = re.compile(r'[a-z]+')
    # upper = re.compile(r'[A-Z]')
    # numeric = re.compile(r'[0-9]')
    print(lower.findall(s))

def solution(S):
    
    lst = S.split(" ")

    print(lst)

    for l in lst:
        valid_check(l)

Code: 04:15:06 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

import re

def valid_check(s):
e =     lower = re.compile(r'[a-z]+')
    lower = re.compile(r'[a-z]+')
    # upper = re.compile(r'[A-Z]')
    # numeric = re.compile(r'[0-9]')
    print(lower.findall(s))

def solution(S):
    
    lst = S.split(" ")

    print(lst)

    for l in lst:
        valid_check(l)

Code: 04:15:19 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

import re

def valid_check(s):
    e = re.compile(r'^[a-zA-Z0-9]+')
    lower = re.compile(r'[a-z]+')
    # upper = re.compile(r'[A-Z]')
    # numeric = re.compile(r'[0-9]')
    print(lower.findall(s))

def solution(S):
    
    lst = S.split(" ")

    print(lst)

    for l in lst:
        valid_check(l)

Code: 04:15:21 UTC, py, verify, result: Failed

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

import re

def valid_check(s):
    e = re.compile(r'^[a-zA-Z0-9]+')
    lower = re.compile(r'[a-z]+')
    # upper = re.compile(r'[A-Z]')
    # numeric = re.compile(r'[0-9]')
    print(e.findall(s))

def solution(S):
    
    lst = S.split(" ")

    print(lst)

    for l in lst:
        valid_check(l)

Analysis

expand all Example tests

▶

example
example test

✘

RUNTIME ERROR
tested program terminated with exit code 1

0.040 s

RUNTIME ERROR, tested program terminated with exit code 1

stderr:

Invalid result type, int expected, <class 'NoneType'> found.

stdout:

['test', '5', 'a0A', 'pass007', '?xy1']
['test']
['5']
['a0A']
['pass007']
[]

Code: 04:15:40 UTC, py, verify, result: Failed

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

import re

def valid_check(s):
    e = re.compile(r'^[a-zA-Z0-9]+')
    # lower = re.compile(r'[a-z]+')
    # upper = re.compile(r'[A-Z]')
    # numeric = re.compile(r'[0-9]')
    print(e.findall(s))

def solution(S):
    
    lst = S.split(" ")

    for l in lst:
        valid_check(l)

Analysis

expand all Example tests

▶

example
example test

✘

RUNTIME ERROR
tested program terminated with exit code 1

0.040 s

RUNTIME ERROR, tested program terminated with exit code 1

stderr:

Invalid result type, int expected, <class 'NoneType'> found.

stdout:

['test']
['5']
['a0A']
['pass007']
[]

Code: 04:15:58 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

import re

def valid_check(s):
    e = re.compile(r'^[a-zA-Z0-9]+')
    # lower = re.compile(r'[a-z]+')
    # upper = re.compile(r'[A-Z]')
    # numeric = re.compile(r'[0-9]')
    print(e.findall(s))

def solution(S):
    
    lst = S.split(" ")

    for l in lst:
        valid_check(l)

Code: 04:16:08 UTC, py, verify, result: Failed

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

import re

def valid_check(s):
    e = re.compile(r'^[a-zA-Z0-9]+')
    # lower = re.compile(r'[a-z]+')
    # upper = re.compile(r'[A-Z]')
    # numeric = re.compile(r'[0-9]')
    print(e.findall(s))

def solution(S):
    
    lst = S.split(" ")

    for l in lst:
        valid_check(l)

User test case 1:

['a?xy1']

Analysis

expand all Example tests

▶

example
example test

✘

RUNTIME ERROR
tested program terminated with exit code 1

0.040 s

RUNTIME ERROR, tested program terminated with exit code 1

stderr:

Invalid result type, int expected, <class 'NoneType'> found.

stdout:

['test']
['5']
['a0A']
['pass007']
[]

expand all User tests

▶

test_data1

✘

RUNTIME ERROR
tested program terminated with exit code 1

0.040 s

RUNTIME ERROR, tested program terminated with exit code 1

stderr:

Invalid result type, int expected, <class 'NoneType'> found.

stdout:

['a']

Code: 04:17:02 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

import re

def valid_check(s):
    e = re.compile(r'[a-zA-Z0-9]+')
    # lower = re.compile(r'[a-z]+')
    # upper = re.compile(r'[A-Z]')
    # numeric = re.compile(r'[0-9]')
    print(e.findall(s))

def solution(S):
    
    lst = S.split(" ")

    for l in lst:
        valid_check(l)

Code: 04:17:04 UTC, py, verify, result: Failed

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

import re

def valid_check(s):
    e = re.compile(r'[^a-zA-Z0-9]+')
    # lower = re.compile(r'[a-z]+')
    # upper = re.compile(r'[A-Z]')
    # numeric = re.compile(r'[0-9]')
    print(e.findall(s))

def solution(S):
    
    lst = S.split(" ")

    for l in lst:
        valid_check(l)

User test case 1:

['a?xy1']

Analysis

expand all Example tests

▶

example
example test

✘

RUNTIME ERROR
tested program terminated with exit code 1

0.040 s

RUNTIME ERROR, tested program terminated with exit code 1

stderr:

Invalid result type, int expected, <class 'NoneType'> found.

stdout:

[]
[]
[]
[]
['?']

expand all User tests

▶

test_data1

✘

RUNTIME ERROR
tested program terminated with exit code 1

0.040 s

RUNTIME ERROR, tested program terminated with exit code 1

stderr:

Invalid result type, int expected, <class 'NoneType'> found.

stdout:

['?']

Code: 04:17:30 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

import re

def valid_check(s):
    e = re.compile(r'[^a-zA-Z0-9]+')
    print(e.findall(s))

def solution(S):
    
    lst = S.split(" ")

    for l in lst:
        valid_check(l)

Code: 04:18:14 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

import re

def valid_check(s):
    e = re.compile(r'[^a-zA-Z0-9]+')
    print(e.findall(s))
    

def solution(S):
    
    lst = S.split(" ")

    for l in lst:
        valid_check(l)

Code: 04:18:24 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

import re

def valid_check(s):
    e = re.compile(r'[^a-zA-Z0-9]+')
    print(e.findall(s))
    if e:
        return False

def solution(S):
    
    lst = S.split(" ")

    for l in lst:
        valid_check(l)

Code: 04:18:42 UTC, py, verify, result: Failed

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

import re

def valid_check(s):
    e = re.compile(r'[^a-zA-Z0-9]+')
    print(e.findall(s))
    if e:
        return False

def solution(S):
    
    lst = S.split(" ")

    for l in lst:
        if valid_check(l):
            print(len(l))

User test case 1:

['a?xy1']

Analysis

expand all Example tests

▶

example
example test

✘

RUNTIME ERROR
tested program terminated with exit code 1

0.040 s

RUNTIME ERROR, tested program terminated with exit code 1

stderr:

Invalid result type, int expected, <class 'NoneType'> found.

stdout:

[]
[]
[]
[]
['?']

expand all User tests

▶

test_data1

✘

RUNTIME ERROR
tested program terminated with exit code 1

0.040 s

RUNTIME ERROR, tested program terminated with exit code 1

stderr:

Invalid result type, int expected, <class 'NoneType'> found.

stdout:

['?']

Code: 04:18:49 UTC, py, verify, result: Failed

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

import re

def valid_check(s):
    e = re.compile(r'[^a-zA-Z0-9]+')
    if e:
        return False

def solution(S):
    
    lst = S.split(" ")

    for l in lst:
        if valid_check(l):
            print(len(l))

User test case 1:

['a?xy1']

Analysis

expand all Example tests

▶

example
example test

✘

RUNTIME ERROR
tested program terminated with exit code 1

0.040 s

RUNTIME ERROR, tested program terminated with exit code 1

stderr:

Invalid result type, int expected, <class 'NoneType'> found.

expand all User tests

▶

test_data1

✘

RUNTIME ERROR
tested program terminated with exit code 1

0.040 s

RUNTIME ERROR, tested program terminated with exit code 1

stderr:

Invalid result type, int expected, <class 'NoneType'> found.

Code: 04:19:08 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

import re

def valid_check(s):
    e = re.compile(r'[^a-zA-Z0-9]+')
    if e:
        return False
        

def solution(S):
    
    lst = S.split(" ")

    for l in lst:
        if valid_check(l):
            print(len(l))

Code: 04:19:11 UTC, py, verify, result: Failed

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

import re

def valid_check(s):
    e = re.compile(r'[^a-zA-Z0-9]+')
    if e:
        return False
    return True

def solution(S):
    
    lst = S.split(" ")

    for l in lst:
        if valid_check(l):
            print(len(l))

User test case 1:

['a?xy1']

Analysis

expand all Example tests

▶

example
example test

✘

RUNTIME ERROR
tested program terminated with exit code 1

0.040 s

RUNTIME ERROR, tested program terminated with exit code 1

stderr:

Invalid result type, int expected, <class 'NoneType'> found.

expand all User tests

▶

test_data1

✘

RUNTIME ERROR
tested program terminated with exit code 1

0.040 s

RUNTIME ERROR, tested program terminated with exit code 1

stderr:

Invalid result type, int expected, <class 'NoneType'> found.

Code: 04:19:39 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

import re

def valid_check(s):
    e = re.compile(r'[^a-zA-Z0-9]+')
    
    if e:
        return False
    return True

def solution(S):
    
    lst = S.split(" ")

    for l in lst:
        if valid_check(l):
            print(len(l))

Code: 04:19:52 UTC, py, verify, result: Failed

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

import re

def valid_check(s):
    e = re.compile(r'[^a-zA-Z0-9]+')
    check = e.findall(s)
    if check:
        return False
    return True

def solution(S):
    
    lst = S.split(" ")

    for l in lst:
        if valid_check(l):
            print(len(l))

User test case 1:

['a?xy1']

Analysis

expand all Example tests

▶

example
example test

✘

RUNTIME ERROR
tested program terminated with exit code 1

0.040 s

RUNTIME ERROR, tested program terminated with exit code 1

stderr:

Invalid result type, int expected, <class 'NoneType'> found.

stdout:

expand all User tests

▶

test_data1

✘

RUNTIME ERROR
tested program terminated with exit code 1

0.040 s

RUNTIME ERROR, tested program terminated with exit code 1

stderr:

Invalid result type, int expected, <class 'NoneType'> found.

Code: 04:20:17 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

import re

def valid_check(s):
    e = re.compile(r'[^a-zA-Z0-9]+')
    check = e.findall(s)
    if check:
        return False
        
    return True

def solution(S):
    
    lst = S.split(" ")

    for l in lst:
        if valid_check(l):
            print(len(l))

Code: 04:20:28 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

import re

def valid_check(s):
    e = re.compile(r'[^a-zA-Z0-9]+')
    check = e.findall(s)
    if check:
        return False

    
    
    return True

def solution(S):
    
    lst = S.split(" ")

    for l in lst:
        if valid_check(l):
            print(len(l))

Code: 04:20:52 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

import re

def valid_check(s):
    e = re.compile(r'[^a-zA-Z0-9]+')
    check = e.findall(s)
    if check:
        return False

    check
    
    return True

def solution(S):
    
    lst = S.split(" ")

    for l in lst:
        if valid_check(l):
            print(len(l))

Code: 04:21:02 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

import re

def valid_check(s):
    e = re.compile(r'[^a-zA-Z0-9]+')
    check = e.findall(s)
    if check:
        return False

    re.compile(r'[^a-zA-Z0-9]+')
    
    return True

def solution(S):
    
    lst = S.split(" ")

    for l in lst:
        if valid_check(l):
            print(len(l))

Code: 04:21:32 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

import re

def valid_check(s):
    e = re.compile(r'[^a-zA-Z0-9]+')
    check = e.findall(s)
    if check:
        return False


    return True

def solution(S):
    
    lst = S.split(" ")

    for l in lst:
        if valid_check(l):
            print(len(l))

Code: 04:21:43 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

import re

def valid_check(s):
    e = re.compile(r'[^a-zA-Z0-9]+')
    check = e.findall(s)
    if check:
        return False
    return True

def solution(S):
    
    lst = S.split(" ")

    for l in lst:
        if valid_check(l):
            print(len(l))

Code: 04:21:58 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

import re

def valid_check(s):
    e = re.compile(r'[^a-zA-Z0-9]+')
    check = e.findall(s)
    if check:
        return False

    


    return True

def solution(S):
    
    lst = S.split(" ")

    for l in lst:
        if valid_check(l):
            print(len(l))

Code: 04:22:08 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

import re

def valid_check(s):
    e = re.compile(r'[^a-zA-Z0-9]+')
    check = e.findall(s)
    if check:
        return False

    letter = re.compile(r'[^a-zA-Z0-9]+')


    return True

def solution(S):
    
    lst = S.split(" ")

    for l in lst:
        if valid_check(l):
            print(len(l))

Code: 04:22:19 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

import re

def valid_check(s):
    e = re.compile(r'[^a-zA-Z0-9]+')
    check = e.findall(s)
    if check:
        return False

    letter = re.compile(r'[^a-zA-Z]+')
    digit = 

    return True

def solution(S):
    
    lst = S.split(" ")

    for l in lst:
        if valid_check(l):
            print(len(l))

Code: 04:22:43 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

import re

def valid_check(s):
    e = re.compile(r'[^a-zA-Z0-9]+')
    check = e.findall(s)
    if check:
        return False

    letter = re.compile(r'[^a-zA-Z]+')
    digit = re.compile(r'[^0-9]+')

    return True

def solution(S):
    
    lst = S.split(" ")

    for l in lst:
        if valid_check(l):
            print(len(l))

Code: 04:22:53 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

import re

def valid_check(s):
    e = re.compile(r'[^a-zA-Z0-9]+')
    check = e.findall(s)
    if check:
        return False

    letter = re.compile(r'[^a-zA-Z]+')

    

    digit = re.compile(r'[^0-9]+')

    return True

def solution(S):
    
    lst = S.split(" ")

    for l in lst:
        if valid_check(l):
            print(len(l))

Code: 04:23:09 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

import re

def valid_check(s):
    e = re.compile(r'[^a-zA-Z0-9]+')
    check = e.findall(s)
    if check:
        return False

    letter = re.compile(r'[^a-zA-Z]+')
    check = letter.findall()

    digit = re.compile(r'[^0-9]+')

    return True

def solution(S):
    
    lst = S.split(" ")

    for l in lst:
        if valid_check(l):
            print(len(l))

Code: 04:23:33 UTC, py, verify, result: Failed

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

import re

def valid_check(s):
    e = re.compile(r'[^a-zA-Z0-9]+')
    check = e.findall(s)
    if check:
        return False

    print(check)

    # letter = re.compile(r'[^a-zA-Z]+')
    # check = letter.findall()

    # digit = re.compile(r'[^0-9]+')

    return True

def solution(S):
    
    lst = S.split(" ")

    for l in lst:
        if valid_check(l):
            print(len(l))

User test case 1:

['a?xy1']

Analysis

expand all Example tests

▶

example
example test

✘

RUNTIME ERROR
tested program terminated with exit code 1

0.040 s

RUNTIME ERROR, tested program terminated with exit code 1

stderr:

Invalid result type, int expected, <class 'NoneType'> found.

stdout:

[]
4
[]
1
[]
3
[]
7

expand all User tests

▶

test_data1

✘

RUNTIME ERROR
tested program terminated with exit code 1

0.040 s

RUNTIME ERROR, tested program terminated with exit code 1

stderr:

Invalid result type, int expected, <class 'NoneType'> found.

Code: 04:23:58 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

import re

def valid_check(s):
    e = re.compile(r'[^a-zA-Z0-9]+')
    check = e.findall(s)
    if check:
        return False

    print(check)

    letter = re.compile(r'[^a-zA-Z]+')
    check = letter.findall()

    digit = re.compile(r'[^0-9]+')

    return True

def solution(S):
    
    lst = S.split(" ")

    for l in lst:
        if valid_check(l):
            print(len(l))

Code: 04:24:09 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

import re

def valid_check(s):
    e = re.compile(r'[^a-zA-Z0-9]+')
    check = e.findall(s)
    if check:
        return False

    letter = re.compile(r'[^a-zA-Z]+')
    check = letter.findall(s)

    digit = re.compile(r'[^0-9]+')

    return True

def solution(S):
    
    lst = S.split(" ")

    for l in lst:
        if valid_check(l):
            print(len(l))

Code: 04:24:15 UTC, py, verify, result: Failed

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

import re

def valid_check(s):
    e = re.compile(r'[^a-zA-Z0-9]+')
    check = e.findall(s)
    if check:
        return False

    letter = re.compile(r'[^a-zA-Z]+')
    check = letter.findall(s)
    print(check)

    # digit = re.compile(r'[^0-9]+')

    return True

def solution(S):
    
    lst = S.split(" ")

    for l in lst:
        if valid_check(l):
            print(len(l))

User test case 1:

['a?xy1']

Analysis

expand all Example tests

▶

example
example test

✘

RUNTIME ERROR
tested program terminated with exit code 1

0.040 s

RUNTIME ERROR, tested program terminated with exit code 1

stderr:

Invalid result type, int expected, <class 'NoneType'> found.

stdout:

[]
4
['5']
1
['0']
3
['007']
7

expand all User tests

▶

test_data1

✘

RUNTIME ERROR
tested program terminated with exit code 1

0.040 s

RUNTIME ERROR, tested program terminated with exit code 1

stderr:

Invalid result type, int expected, <class 'NoneType'> found.

Code: 04:24:23 UTC, py, verify, result: Failed

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

import re

def valid_check(s):
    e = re.compile(r'[^a-zA-Z0-9]+')
    check = e.findall(s)
    if check:
        return False

    letter = re.compile(r'[a-zA-Z]+')
    check = letter.findall(s)
    print(check)

    # digit = re.compile(r'[0-9]+')

    return True

def solution(S):
    
    lst = S.split(" ")

    for l in lst:
        if valid_check(l):
            print(len(l))

User test case 1:

['a?xy1']

Analysis

expand all Example tests

▶

example
example test

✘

RUNTIME ERROR
tested program terminated with exit code 1

0.040 s

RUNTIME ERROR, tested program terminated with exit code 1

stderr:

Invalid result type, int expected, <class 'NoneType'> found.

stdout:

['test']
4
[]
1
['a', 'A']
3
['pass']
7

expand all User tests

▶

test_data1

✘

RUNTIME ERROR
tested program terminated with exit code 1

0.040 s

RUNTIME ERROR, tested program terminated with exit code 1

stderr:

Invalid result type, int expected, <class 'NoneType'> found.

Code: 04:25:25 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

import re

def valid_check(s):
    e = re.compile(r'[^a-zA-Z0-9]+')
    check = e.findall(s)
    if check:
        return False

    letter = re.compile(r'[a-zA-Z]+')
    check = letter.findall(s)
    print(''check)

    # digit = re.compile(r'[0-9]+')

    return True

def solution(S):
    
    lst = S.split(" ")

    for l in lst:
        if valid_check(l):
            print(len(l))

Code: 04:25:30 UTC, py, verify, result: Failed

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

import re

def valid_check(s):
    e = re.compile(r'[^a-zA-Z0-9]+')
    check = e.findall(s)
    if check:
        return False

    letter = re.compile(r'[a-zA-Z]+')
    check = letter.findall(s)
    print(''.join(check))

    # digit = re.compile(r'[0-9]+')

    return True

def solution(S):
    
    lst = S.split(" ")

    for l in lst:
        if valid_check(l):
            print(len(l))

User test case 1:

['a?xy1']

Analysis

expand all Example tests

▶

example
example test

✘

RUNTIME ERROR
tested program terminated with exit code 1

0.040 s

RUNTIME ERROR, tested program terminated with exit code 1

stderr:

Invalid result type, int expected, <class 'NoneType'> found.

stdout:

test
4

1
aA
3
pass
7

expand all User tests

▶

test_data1

✘

RUNTIME ERROR
tested program terminated with exit code 1

0.040 s

RUNTIME ERROR, tested program terminated with exit code 1

stderr:

Invalid result type, int expected, <class 'NoneType'> found.

Code: 04:25:55 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

import re

def valid_check(s):
    e = re.compile(r'[^a-zA-Z0-9]+')
    check = e.findall(s)
    if check:
        return False

    letter = re.compile(r'[a-zA-Z]+')
    check = letter.findall(s)
    if len(''.join(check))

    # digit = re.compile(r'[0-9]+')

    return True

def solution(S):
    
    lst = S.split(" ")

    for l in lst:
        if valid_check(l):
            print(len(l))

Code: 04:26:12 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

import re

def valid_check(s):
    e = re.compile(r'[^a-zA-Z0-9]+')
    check = e.findall(s)
    if check:
        return False

    letter = re.compile(r'[a-zA-Z]+')
    check = letter.findall(s)
    if len(''.join(check)) % 2 == 0:
        

    # digit = re.compile(r'[0-9]+')

    return True

def solution(S):
    
    lst = S.split(" ")

    for l in lst:
        if valid_check(l):
            print(len(l))

Code: 04:26:22 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

import re

def valid_check(s):
    e = re.compile(r'[^a-zA-Z0-9]+')
    check = e.findall(s)
    if check:
        return False

    letter = re.compile(r'[a-zA-Z]+')
    check = letter.findall(s)
    if len(''.join(check)) % 2 != 0:
        return False


    # digit = re.compile(r'[0-9]+')

    return True

def solution(S):
    
    lst = S.split(" ")

    for l in lst:
        if valid_check(l):
            print(len(l))

Code: 04:26:34 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

import re

def valid_check(s):
    e = re.compile(r'[^a-zA-Z0-9]+')
    check = e.findall(s)
    if check:
        return False

    letter = re.compile(r'[a-zA-Z]+')
    check = letter.findall(s)
    if len(''.join(check)) % 2 != 0:
        return False

    letter = re.compile(r'[a-zA-Z]+')
    check = letter.findall(s)
    if len(''.join(check)) % 2 != 0:
        return False

    return True

def solution(S):
    
    lst = S.split(" ")

    for l in lst:
        if valid_check(l):
            print(len(l))

Code: 04:26:47 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

import re

def valid_check(s):
    e = re.compile(r'[^a-zA-Z0-9]+')
    check = e.findall(s)
    if check:
        return False

    letter = re.compile(r'[a-zA-Z]+')
    check = letter.findall(s)
    if len(''.join(check)) % 2 != 0:
        return False

    letter = re.compile(r'[0-9]+')
    check = letter.findall(s)
    if len(''.join(check)) % 2 == 0:
        return False

    return True

def solution(S):
    
    lst = S.split(" ")

    for l in lst:
        if valid_check(l):
            print(len(l))

Code: 04:27:03 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

import re

def valid_check(s):
    e = re.compile(r'[^a-zA-Z0-9]+')
    check = e.findall(s)
    if check:
        return False

    letter = re.compile(r'[a-zA-Z]+')
    check = letter.findall(s)
    if len(''.join(check)) % 2 == 1:
        return False

    letter = re.compile(r'[0-9]+')
    check = letter.findall(s)
    if len(''.join(check)) % 2 == 0:
        return False

    return True

def solution(S):
    
    lst = S.split(" ")

    for l in lst:
        if valid_check(l):
            print(len(l))

Code: 04:27:13 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

import re

def valid_check(s):
    e = re.compile(r'[^a-zA-Z0-9]+')
    check = e.findall(s)
    if check:
        return False

    letter = re.compile(r'[a-zA-Z]+')
    check = letter.findall(s)
    if len(''.join(check)) % 2 == 1:
        return False

    digit = re.compile(r'[0-9]+')
    check = digit.findall(s)
    if len(''.join(check)) % 2 == 0:
        return False

    return True

def solution(S):
    
    lst = S.split(" ")

    for l in lst:
        if valid_check(l):
            print(len(l))

Code: 04:27:27 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

import re

def valid_check(s):
    na = re.compile(r'[^a-zA-Z0-9]+')
    check = na.findall(s)
    if check:
        return False

    letter = re.compile(r'[a-zA-Z]+')
    check = letter.findall(s)
    if len(''.join(check)) % 2 == 1:
        return False

    digit = re.compile(r'[0-9]+')
    check = digit.findall(s)
    if len(''.join(check)) % 2 == 0:
        return False

    return True

def solution(S):
    
    lst = S.split(" ")

    for l in lst:
        if valid_check(l):
            print(len(l))

Code: 04:27:31 UTC, py, verify, result: Failed

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

import re

def valid_check(s):
    na = re.compile(r'[^a-zA-Z0-9]+')
    check = na.findall(s)
    if check:
        return False

    letter = re.compile(r'[a-zA-Z]+')
    check = letter.findall(s)
    if len(''.join(check)) % 2 == 1:
        return False

    digit = re.compile(r'[0-9]+')
    check = digit.findall(s)
    if len(''.join(check)) % 2 == 0:
        return False

    return True

def solution(S):
    
    lst = S.split(" ")

    for l in lst:
        if valid_check(l):
            print(len(l))

User test case 1:

['a?xy1']

Analysis

expand all Example tests

▶

example
example test

✘

RUNTIME ERROR
tested program terminated with exit code 1

0.044 s

RUNTIME ERROR, tested program terminated with exit code 1

stderr:

Invalid result type, int expected, <class 'NoneType'> found.

stdout:

1
3
7

expand all User tests

▶

test_data1

✘

RUNTIME ERROR
tested program terminated with exit code 1

0.040 s

RUNTIME ERROR, tested program terminated with exit code 1

stderr:

Invalid result type, int expected, <class 'NoneType'> found.

Code: 04:29:00 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

import re

def valid_check(s):
    na = re.compile(r'[^a-zA-Z0-9]+')
    check = na.findall(s)
    if check:
        return False

    letter = re.compile(r'[a-zA-Z]+')
    check = letter.findall(s)
    if len(''.join(check)) % 2 == 1:
        return False

    digit = re.compile(r'[0-9]+')
    check = digit.findall(s)
    if len(''.join(check)) % 2 == 0:
        return False

    return True

def solution(S):
    
    m
    lst = S.split(" ")

    for l in lst:
        if valid_check(l):
            print(len(l))

Code: 04:29:10 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

import re

def valid_check(s):
    na = re.compile(r'[^a-zA-Z0-9]+')
    check = na.findall(s)
    if check:
        return False

    letter = re.compile(r'[a-zA-Z]+')
    check = letter.findall(s)
    if len(''.join(check)) % 2 == 1:
        return False

    digit = re.compile(r'[0-9]+')
    check = digit.findall(s)
    if len(''.join(check)) % 2 == 0:
        return False

    return True

def solution(S):
    
    answer = 0
    
    lst = S.split(" ")

    for l in lst:
        if valid_check(l):
            print(len(l))

Code: 04:29:21 UTC, py, verify, result: Passed

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

import re

def valid_check(s):
    na = re.compile(r'[^a-zA-Z0-9]+')
    check = na.findall(s)
    if check:
        return False

    letter = re.compile(r'[a-zA-Z]+')
    check = letter.findall(s)
    if len(''.join(check)) % 2 == 1:
        return False

    digit = re.compile(r'[0-9]+')
    check = digit.findall(s)
    if len(''.join(check)) % 2 == 0:
        return False

    return True

def solution(S):
    
    answer = 0

    lst = S.split(" ")

    for l in lst:
        if valid_check(l):
            answer = max(answer, len(l))

    return answer

User test case 1:

['a?xy1']

Analysis

expand all Example tests

▶

example
example test

✔

0.040 s

expand all User tests

▶

test_data1

✔

0.040 s

OK
function result: 0

Code: 04:29:44 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

import re

def valid_check(s):
    na = re.compile(r'[^a-zA-Z0-9]+')
    check = na.findall(s)
    if check:
        return False

    letter = re.compile(r'[a-zA-Z]+')
    check = letter.findall(s)
    if len(''.join(check)) % 2 == 1:
        return False

    digit = re.compile(r'[0-9]+')
    check = digit.findall(s)
    if len(''.join(check)) % 2 == 0:
        return False

    return True

def solution(S):
    
    answer = -

    lst = S.split(" ")

    for l in lst:
        if valid_check(l):
            answer = max(answer, len(l))

    return answer

Code: 04:29:46 UTC, py, verify, result: Passed

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

import re

def valid_check(s):
    na = re.compile(r'[^a-zA-Z0-9]+')
    check = na.findall(s)
    if check:
        return False

    letter = re.compile(r'[a-zA-Z]+')
    check = letter.findall(s)
    if len(''.join(check)) % 2 == 1:
        return False

    digit = re.compile(r'[0-9]+')
    check = digit.findall(s)
    if len(''.join(check)) % 2 == 0:
        return False

    return True

def solution(S):
    
    answer = -1

    lst = S.split(" ")

    for l in lst:
        if valid_check(l):
            answer = max(answer, len(l))

    return answer

User test case 1:

['a?xy1']

Analysis

expand all Example tests

▶

example
example test

✔

0.040 s

expand all User tests

▶

test_data1

✔

0.040 s

OK
function result: -1

Code: 04:29:57 UTC, py, verify, result: Passed

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

import re

def valid_check(s):
    na = re.compile(r'[^a-zA-Z0-9]+')
    check = na.findall(s)
    if check:
        return False

    letter = re.compile(r'[a-zA-Z]+')
    check = letter.findall(s)
    if len(''.join(check)) % 2 == 1:
        return False

    digit = re.compile(r'[0-9]+')
    check = digit.findall(s)
    if len(''.join(check)) % 2 == 0:
        return False

    return True

def solution(S):
    
    answer = -1

    lst = S.split(" ")

    for l in lst:
        if valid_check(l):
            answer = max(answer, len(l))

    return answer

User test case 1:

['a?xy1']

Analysis

expand all Example tests

▶

example
example test

✔

0.040 s

expand all User tests

▶

test_data1

✔

0.040 s

OK
function result: -1

Code: 04:29:59 UTC, py, final, score: 100

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

import re

def valid_check(s):
    na = re.compile(r'[^a-zA-Z0-9]+')
    check = na.findall(s)
    if check:
        return False

    letter = re.compile(r'[a-zA-Z]+')
    check = letter.findall(s)
    if len(''.join(check)) % 2 == 1:
        return False

    digit = re.compile(r'[0-9]+')
    check = digit.findall(s)
    if len(''.join(check)) % 2 == 0:
        return False

    return True

def solution(S):
    
    answer = -1

    lst = S.split(" ")

    for l in lst:
        if valid_check(l):
            answer = max(answer, len(l))

    return answer

Analysis summary

The solution obtained perfect score.

Analysis

expand all Example tests

▶

example
example test

✔

0.040 s

expand all Correctness tests

▶

simple
short and simple tests

✔

0.040 s

0.044 s

▶

one_character
one character words

✔

0.044 s

0.048 s

0.044 s

0.040 s

▶

one_word
tests that contains one word only

✔

0.040 s

0.044 s

0.040 s

0.048 s

▶

even_letters
all words have even number of letters

✔

0.040 s

▶

odd_digits
all words have odd number of digits

✔

0.040 s

▶

odd_length
it's sufficient to test validity of characters and if length of word is odd

✔

0.040 s

▶

all_alphanumerical
all words contain only alphanumerical characters

✔

0.040 s

▶

extra_characters
valid passwords joined with some invalid characters

✔

0.040 s

0.044 s

0.040 s

▶

large_random
random tests

✔

0.040 s

▶

maximum
biggest possible tests with mixed types of words

✔

0.040 s