Declaring and Looping over a variable in one line

Question

Just for fun, I am trying to compress a programming problem into one line. I know this is typically a bad practice, but it is a fun challenge that I am asking for your help on.

I have a piece of code which declares the variables and in the second line which loops over a list created in the first line, until a number is not found anymore. Finally it returns that value.

The programming question is as follows. Given a sentence, convert each character to it's ascii representation. Then convert that ascii value to binary (filling the remaining spaces with 0 if the binary number is less than 8 digits), and combine the numbers into one string. Starting from the number 0, convert it to binary and check if it is in the string. If it is, add one to the number and check again. Return the last consecutive binary number that is in the string. Ex)

string = "0000010"

0 in string: add 1

1 in string: add 1

10 in string: add 1

11 not in string: the last consecutive binary number was 10₂=2₁₀. Return 2

You can see my code below

def findLastBinary(s: str):
    string, n = ''.join(['0'*(10-len(bin(ord(char))))+bin(ord(char))[2:] for char in s]), 0
    while bin(n)[2:] in string: n+=1
    return n-1

It would also be nice if I could combine the return statement and loop into one line as well.

EDIT

Fixed the code (it should work now). Also below, you will see a sample test case. Hope this helps with answering this question.

Sample test case

Input:

s="Roses and thorns"

Below you will see the steps my code follows to get the correct answer (obviously made more readable)

Organized into columns in the following order:

Character-Ascii-Binary Representation of ascii value:

R - 82 - 01010010

o - 111 - 01101111

s - 115 - 01110011

etc.

Keep in mind that if the binary number has less than 8 digits, zeros should be added to the beginning of the number until it is 8 digits.

Each binary integer is then concatenated into a single string (I added spaces for readability only):

01010010 01101111 01110011 01100101 01110011 00100000 01100001 01101110 01100100 00100000 01110100 01101000 01101111 01110010 01101110 01110011

Now we start from the binary number 0, and check if it is in the string. It is so we move on to 1. 1 is in the string, so we move on to 10. 10 is in the string. And so we continue until we find the binary string 11111 is not in our string. 11111₂=31₁₀. Since 31 was the first number whose decimal representation was not in the string, we return the last number whose decimal number was in the string: namely, 31-1=30. 30 is what the function should return.

Answer 1

The problem statement has changed. See the bottom of this answer for the updated solution.

---

The function can be defined the function this way, thanks to @treuss' observation (this applies to the original problem to find the largest base 10 integer which when converted to binary is in the string):

def largest_binary_number(sentence: str):
    return int(''.join([bin(ord(char))[2:].zfill(8) for char in sentence]), 2)

But suppose that the problem was to "find the smallest base 10 integer larger than 1000 whose binary representation is in the string." Then we have something like this:

def find(sentence: str):
    return list(iter(lambda: globals().__setitem__('_c', globals().get('_c', 1000-1) + 1) or bin(globals().get('_c'))[2:] in ''.join([bin(ord(c))[2:].zfill(8) for c in sentence]), True)) is type or globals().get('_c')

Let's break this down into four parts:

1. globals().__setitem__('_c', globals().get('_c', 1000-1) + 1) - initialize and increment a counter
2. ... or bin(globals().get('_c'))[2:] in ''.join([bin(ord(c))[2:].zfill(8) for c in sentence]) - check if the binary representation of the counter is in the binary representation of the sentence
3. list(iter(lambda: ..., True)) - inline while loop using black magic
4. ... is type or globals().get('_c') - get the final value of the counter, which satisfies our condition

Part 1: globals().__setitem__('_c', globals().get('_c', 1000-1) + 1)

Since we are confined to do everything in one line, we don't have the luxury of defining variables. This is where globals comes in: we can store and use arbitrary variables as dictionary entries using the __setitem__ and get methods. Here we name our counter variable _c, calling get to initialize and fetch the value, then immediately increment it by one and save the value with __setitem__. Now we have a counter variable.

Part 2: ... or bin(globals().get('_c'))[2:] in ''.join([bin(ord(c))[2:].zfill(8) for c in sentence])

bin(globals().get('_c'))[2:] converts the counter to binary and removes the 0b prefix. ''.join([bin(ord(c))[2:].zfill(8) for c in sentence]), as before, converts the input sentence to binary. We use in to check if the binary counter is a substring of the binary sentence. Because the __setitem__ call from part 1 returns None, we use or here to ignore that and execute this part.

Part 3: list(iter(lambda: ..., True))

This is the bread and butter, allowing us to perform inline iteration. iter is usually passed an iterable to create and iterator, but it actually has a second form that takes two arguments: a callable and a sentinel. When iterating over an iterator created using this two-argument form, the callable is successively called until it returns the sentinel value (beware infinite loops!). So we define a lambda function that returns True when the condition is satisfied, and set the sentinel to True. Finally we use the list constructor to begin iterating.

Part 4: ... is type or globals().get('_c')

Once the list constructor finishes iterating, we need to fetch and return the final value of the counter. We follow list(...) with is type to make an expression that always evaluates to False, then chain it with or globals().get('_c') at the end of this one-liner to return the counter. Et voilà!

Part 5:

Of course, what we had before was a two-liner.

find = lambda sentence: list(iter(lambda: globals().__setitem__('_c', globals().get('_c', 1000-1) + 1) or bin(globals().get('_c'))[2:] in ''.join([bin(ord(c))[2:].zfill(8) for c in sentence]), True)) is type or globals().get('_c')

Now we have a one-liner.

---

Note: In hindsight, maybe the walrus := could be used to make the counter, instead of having to call globals() every time. However, replacing globals with locals doesn't work for some reason.

Note 2: Using these techniques, we can make one-liners that satisfy various conditions.

---

Update: Here's another version using the walrus

find = lambda sentence: (_c := {'v': 1000-1}) and list(iter(lambda: _c.__setitem__('v', _c['v'] + 1) or bin(_c['v'])[2:] in ''.join([bin(ord(c))[2:].zfill(8) for c in sentence]), True)) is type or _c['v']

We initialize the counter at the top level and simply use _c everywhere else. Note how it is a dict instead of an int because outer variables cannot be assigned within the inner lambda (but mutating outer variables is fine).

---

Update 2: OP has updated the problem statement, so here's the new solution:

find = lambda s: (_c := {'v': 0-1}) and list(iter(lambda: _c.__setitem__('v', _c['v'] + 1) or bin(_c['v'])[2:] in ''.join([bin(ord(c))[2:].zfill(8) for c in s]), False)) is type or _c['v'] - 1

The techniques are the same, but now we start the counter from -1 (the first iteration increments it to 0 before anything else), the sentinel becomes False (because we stop the loop when the binary counter is not in the binary string), and decrement the return value by 1 to get the last number satisfying the condition.