re clear solution for Keywords Finder by tom-tom - python coding challenges

Enable Javascript in your browser and then refresh this page, for a much enhanced experience.

re solution in Clear category for Keywords Finder by tom-tom

from re import finditer, escape

def checkio(text, words):
    spans = ([m.start(1), m.end(1)] for word in words.lower().split()
                                    for m in finditer(f'(?=({escape(word)}))', text.lower()))
    span, *others = sorted(spans) + [[None]]
    result = text[: span[0]]
    for other in others:
        if other[0] is None or other[0] >= span[1]:
            result += '' + text[span[0] : span[1]] + '' + text[span[1] : other[0]]
            span = other
        else:    
            span[1] = max(span[1], other[1])
    return result

May 17, 2019

Comments:

kurosawa4434 on May 21, 2019, 7:49 a.m.
awesome solution. I can learn a lot from this solution. However I do not understand why the following works well: <pre class='brush: python'>for m in finditer(f'(?=({escape(word)}))', text.lower())) ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ </pre>

tom-tom on May 21, 2019, 1:36 p.m.
Thank you for appreciation OK, we need to find all overlapping matches of the word: As word can contain special symbols (it revealed when I pressed Check :), `escape` was used. To find overlapping matches, a lookahead assertion `(?=...)` was used. A lookahead assertion is a zero-length assertion, but we need starts and ends, so adding a capturing group `(...)` (that's why `m.start(1)` and `m.end(1)`, not just `m.start()` and `m.end()`). f-string helps to combine them all.

kurosawa4434 on May 21, 2019, 2:53 p.m.
The interesting thing is that you can pass the following code except for `Edge 10 : checkio("aaaa", "aa a")`: <pre class='brush: python'>spans = ([m.start(), m.end()] for word in words.lower().split() for m in finditer(f'{escape(word)}', text.lower())) ~~~~~~~~~~~~~~~~~ </pre> I can understand the above code. But I feel the combination of `finditer()` and `lookahead assertion` is a little mysterious :-) Thanks !

tom-tom on May 21, 2019, 6:15 p.m.
Yes, that was this test that forced me to delve into the Python docs :)

CDG.Axel on Sept. 18, 2021, 11:06 p.m.
it looks like your solution will be wrong with text = 'aaaa', words = ['aa'] <pre class='brush: python'>your answer will be aaaa correct answer is aaaa </pre> I tried finditer, but throw it away because it start to find new substring right after previuos one.

colinmcnicholl on Jan. 10, 2020, 2:05 p.m.
Great solution. I know you solved it 8 months ago so you might have to go to the trouble of refreshing your memory but I wonder if you could explain how the f-string within the finditer(pattern, text) works. For example I tried: <pre class='brush: python'>spans = [] for word in words.split(): pattern = re.compile(fr'(?=({escape(word)}))') for m in pattern.finditer(text, I): spans.append([*m.span(1)]) </pre> But this would not work. For example on the assert with text: <blockquote> Hello World! Or LOL </blockquote> Coded this way it matches only the keywords "lo" and "or". Similarly not understanding how the f-string inside the pattern works prevented me from using re.VERBOSE. I got the error message: <blockquote> SyntaxError: f-string expression part cannot include '#' </blockquote>

tom-tom on Jan. 11, 2020, 3:20 p.m.
First, flags should be specified in `re.compile()` or `re.finditer()`, not in the `pattern.finditer()`. In your case `re.I` was treated as the start position, and the search started from index 2 (`int(re.I)`). Second, this error is not related to re. `re.VERBOSE` is only an option for re to interpret the pattern string. But you have to provide this string. I assume you occasionally put `#` (for comment) inside `{...}` in the f-string. Best wishes!

CDG.Axel on Sept. 18, 2021, 8:35 p.m.
great idea to merge spans and form output at ones!

H0r4c3 on Feb. 5, 2022, 7:34 a.m.
Great solution! We can learn a lot from it!

Hermit

0 %

CheckiO ClassRoom Don’t waste any time! Create your first class right now for free and help your students to learn programming more effectively.