In this example you have to validate if a user input string is alphanumeric. The given string is not nil/null/NULL/None, so you don't have to check that.

The string has the following conditions to be alphanumeric:

• At least one character ("" is not valid)
• Allowed characters are uppercase / lowercase Latin letters and digits from 0 to 9
• No whitespaces / underscore

The Function Signature:

def alphanumeric(password):
    pass

First, some imports.

# python
from string import ascii_letters, digits
from typing import Callable

import random
import re

# pypy
from expects import expect, equal

The problem-page on CodeWars shows a "RegularExpressions" tag so I'm going to assume that that's the way to solve it. My first thought was to use the \w special character, but the documentation says:

Matches Unicode word characters; this includes alphanumeric characters (as defined by str.isalnum()) as well as the underscore (_). If the ASCII flag is used, only [a-zA-Z0-9_] is matched.

The description says that it's equivalent to [a-zA-Z0-9_], so we can't use it (we don't want underscores), but if we use the same character ranges and leave out the underscore, it should work.

ALPHANUMERIC = "[a-zA-Z0-9]"
ONE_OR_MORE = "+"

PATTERN_ONE = re.compile(ALPHANUMERIC + ONE_OR_MORE)

def submitted(password: str) -> bool:
    """Check if the input is alphanumeric

    Args:

     - password: string to check

    Returns:

      True if alphanumeric False otherwise
    """
    return PATTERN_ONE.fullmatch(password) is not None

tester(submitted)

As a check, I'll see what happens if I used the \w instead.

WITH_UNDERSCORES = re.compile("\w" + ONE_OR_MORE)

def allows_underscores(password: str) -> bool:
    """Checks if the password has only alphanumeric or underscore characters

    Args:

      - password: input to check

    Returns:

     - True if valid
    """
    return WITH_UNDERSCORES.fullmatch(password) is not None

JUST_UNDERSCORES = "____"
print(JUST_UNDERSCORES.isalnum())
print(allows_underscores(JUST_UNDERSCORES))

tester(allows_underscores)

False
True

So, that was a surprise. Why did allows_underscores pass the tests? If you look back at the test-cases you'll see that none of them have just letters, digits, and underscores, if there's an underscore then there's also white-space or some other invalid character. Seems like there's a hole in their testing.

Let's add in a couple of cases that should fail.

EXTRA = "".join(random.choices(ascii_letters + digits + "_", k=25)) + "_"
TEST_CASES_2 = TEST_CASES + [EXTRA, JUST_UNDERSCORES]

tester(allows_underscores, TEST_CASES_2, throw=False)

That's better.

So, another not so exciting problem, but I did learn that there's a fullmatch function now, spurring me to look up what the match and search methods do again, which was useful. As a note to my future self, match and fullmatch are essentially shortcuts so you don't have to use the beginning and ending of line characters. That is to say, search("^[a-z]+") is the equivalent of match("[a-z]+") and search("^[a-z]+$") is the equivalent of fullmatch("[a-z]+")". There might be other differences, but for simple cases like this that'll do.

This is the first time I took a look at edabit, their problems seem simpler than LeetCode, although I haven't gone too deep into it. Here's there description of the problem.

Create a function that returns a base-2 (binary) representation of a base-10 (decimal) string number. To convert is simple: ((2) means base-2 and (10) means base-10) 010101001(2) = 1 + 8 + 32 + 128.

Going from right to left, the value of the most right bit is 1, now from that every bit to the left will be x2 the value, value of an 8 bit binary numbers are (256, 128, 64, 32, 16, 8, 4, 2, 1).

Examples:

binary(1) ➞ "1"
binary(5) ➞ "101"
binary(10) ➞ "1010"

Notes

• Numbers will always be below 1024 (not including 1024).
• The strings will always go to the length at which the most left bit's value gets bigger than the number in decimal.
• If a binary conversion for 0 is attempted, return "0".

Now that I have the problem statement I can create a test function for it. First, I'll do some importing.

# python
import math
import random

from typing import Callable

# from pypi
from expects import equal, expect

There's probably an even more brute-force way to do this, but the first thing that came into my mind was to use the \(\log_2\) function to find out what exponent of 2 is needed to create the input (without going over) so I'd know how many bits I'd need (this actually gives one less than what you need, since we need an extra bit for the \(2^0\) digit). After finding the exponent the function will then traverses a range in backwards order \(\{n, n-1, \ldots, 1, 0\}\), using the values as the exponent for the next power of 2 to test. If the power is less than the amount remaining to convert I add a 1 to the bit-list and subtract the power from the remainder and if not I add a 0 to the list and move to the next exponent to check.

def solution_one(value: int) -> str:
    """Convert the integer to a binary string

    Args:
     - value: base-10 integer to convert

    Returns:
     - binary string version of the input
    """
    ZERO, ONE = "0", "1"
    if value == 0:
        return ZERO

    digits = math.floor(math.log2(value)) + 1
    remainder = value
    bits = []

    for exponent in reversed(range(digits)):
        if 2**exponent <= remainder:
            bits.append(ONE)
            remainder -= 2**exponent
        else:
            bits.append(ZERO)
    return "".join(bits)

tester_tester(solution_one, verbose=True)

decimal: 0 binary: 0
decimal: 1 binary: 1
decimal: 5 binary: 101
decimal: 10 binary: 1010
decimal: 242 binary: 11110010

While I was checking out python's Power and Logarithmic functions I noticed that there was a helpful box noting that python's integers have a built in method called bit_length that will tell you how many bits you need to represent the integer. This should give the the same result as what I did with floor and log2 but since they went to all the trouble of adding it as a method it seemed like it'd be a shame not to use it.

def solution_three(value: int) -> str:
    """Convert the integer to a binary string

    Args:
     - value: base-10 integer to convert

    Returns:
     - binary string version of the input
    """
    ZERO, ONE = "0", "1"
    digits = value.bit_length()
    bits = []
    remainder = value

    for exponent in reversed(range(digits)):
        if 2**exponent <= remainder:
            bits.append(ONE)
            remainder -= 2**exponent
        else:
            bits.append(ZERO)
    return "".join(bits) if bits else ZERO

tester_tester(solution_three, verbose=True)

decimal: 0 binary: 0
decimal: 1 binary: 1
decimal: 5 binary: 101
decimal: 10 binary: 1010
decimal: 926 binary: 1110011110

So, there you go. I wasn't expecting to learn anything from this problem, but I didn't know the bit_length method exists so I guess it just goes to show that there's always something more to learn. Not that I can think of a use for it…