{"version":"https:\/\/jsonfeed.org\/version\/1","title":"mathspp.com feed","home_page_url":"https:\/\/mathspp.com\/blog\/tags\/algorithms","feed_url":"https:\/\/mathspp.com\/blog\/tags\/algorithms.json","description":"Stay up-to-date with the articles on mathematics and programming that get published to mathspp.com.","author":{"name":"Rodrigo Gir\u00e3o Serr\u00e3o"},"items":[{"title":"Remove extra spaces","date_published":"2026-03-02T13:39:00+01:00","id":"https:\/\/mathspp.com\/blog\/remove-extra-spaces","url":"https:\/\/mathspp.com\/blog\/remove-extra-spaces","content_html":"

Learn how to remove extra spaces from a string using regex, string splitting, a fixed point, and itertools.groupby<\/code>.<\/p>\n\n

In this article you'll learn about three different ways in which you can remove extra spaces from the middle of a string.\nThat is, you'll learn how to go from a string like<\/p>\n

string = \"This is  a   perfectly    normal     sentence.\"<\/code><\/pre>\n
to a string like<\/p>\n
string = \"This is a perfectly normal sentence.\"<\/code><\/pre>\n
The best solution to remove extra spaces from a string<\/a><\/h2>\n
The best solution for this task, which is both readable and performant, uses the regex module re<\/code>:<\/p>\n
import re\n\ndef remove_extra_spaces(string):\n    return re.sub(\" {2,}\", \" \", string)<\/code><\/pre>\n
The function sub<\/code> can be used to sub<\/strong>stitute a pattern for a replacement you specify.\nThe pattern \" {2,}\"<\/code> finds runs of 2 or more consecutive spaces and replaces them with a single space.<\/p>\n
String splitting<\/a><\/h2>\n
Using the string method split<\/code> can also be a good approach:<\/p>\n
def remove_extra_spaces(string):\n    return \" \".join(string.split(\" \"))<\/code><\/pre>\n
If you're using string splitting, you'll want to provide the space \" \"<\/code> as an argument.\nIf you call split<\/code> with no arguments, you'll be splitting on all<\/em> whitespace, which is not what you want if you have newlines and other whitespace characters you should preserve.<\/p>\n
This solution is great, except it doesn't work:<\/p>\n
print(remove_extra_spaces(string))\n# 'This is  a   perfectly    normal     sentence.'<\/code><\/pre>\n
The problem is that splitting on the space will produce a list with empty strings:<\/p>\n
print(string.split(\" \"))\n# ['This', 'is', '', 'a', '', '', 'perfectly', '', '', '', 'normal', '', '', '', '', 'sentence.']<\/code><\/pre>\n
These empty strings will be joined back together and you'll end up with the same string you started with.\nFor this to work, you'll have to filter the empty strings first:<\/p>\n
def remove_extra_spaces(string):\n    return \" \".join(filter(None, string.split(\" \")))<\/code><\/pre>\n
Using filter(None, ...)<\/code> filters out the Falsy<\/a> strings, so that the final joining operation only joins the strings that matter.<\/p>\n
This solution has a problem, though, in that it will completely remove any leading or trailing whitespace, which may or may not be a problem.<\/p>\n
The two solutions presented so far — using regular expressions and string splitting — are pretty reasonable.\nBut they're also boring.\nYou'll now learn about two other solutions.<\/p>\n
Replacing spaces until you hit a fixed point<\/a><\/h2>\n
You can think about the task of removing extra spaces as the task of replacing extra spaces by the empty string.\nAnd if you think about doing string replacements, you should think about the string method replace<\/code>.<\/p>\n
You can't do something like string.replace(\" \", \"\")<\/code>, otherwise you'd remove all<\/em> spaces, so you have to be a bit more careful:<\/p>\n
def remove_extra_spaces(string):\n    while True:\n        new_string = string.replace(\"  \", \" \")\n        if new_string == string:\n            break\n        string = new_string\n    return string<\/code><\/pre>\n
You can replace two consecutive spaces by a single space, and you repeat this operation until nothing changes in your string.<\/p>\n
The idea of running a function until its output doesn't change is common enough in maths that they call...<\/p>","summary":"Learn how to remove extra spaces from a string using regex, string splitting, a fixed point, and itertools.groupby.","date_modified":"2026-03-02T16:25:02+01:00","tags":["programming","python","algorithms","regex"],"image":"\/user\/pages\/02.blog\/remove-extra-spaces\/thumbnail.webp"},{"title":"Generalising itertools.pairwise","date_published":"2025-11-24T19:36:00+01:00","id":"https:\/\/mathspp.com\/blog\/generalising-itertools-pairwise","url":"https:\/\/mathspp.com\/blog\/generalising-itertools-pairwise","content_html":"
In this article you will learn about itertools.pairwise, how to use it, and how to generalise it.<\/p>\n\n
In this tutorial you will learn to use and generalise itertools.pairwise<\/code>.\nYou will understand what itertools.pairwise<\/code> does, how to use it, and how to implement a generalised version for when itertools.pairwise<\/code> isn't enough.<\/p>\n
itertools.pairwise<\/code><\/a><\/h2>\n
itertools.pairwise<\/code> is an iterable from the standard module itertools<\/code> that lets you access overlapping pairs of consecutive elements of the input iterable.\nThat's quite a mouthful, so let me translate:<\/p>\n
\n
You give pairwise<\/code> an iterable, like \"ABCD\"<\/code>, and pairwise<\/code> gives you pairs back, like (\"A\", \"B\")<\/code>, (\"B\", \"C\")<\/code>, and (\"C\", \"D\")<\/code>.<\/p>\n<\/blockquote>\n
In loops, it is common to unpack the pairs directly to perform some operation on both values.\nThe example below uses pairwise<\/code> to determine how the balance of a bank account changed based on the balance history:<\/p>\n
from itertools import pairwise  # Python 3.10+\n\nbalance_history = [700, 1000, 800, 750]\n\nfor before, after in pairwise(balance_history):\n    change = after - before\n    print(f\"Balance changed by {change:+}.\")<\/code><\/pre>\n
Balance changed by +300.\nBalance changed by -200.\nBalance changed by -50.<\/code><\/pre>\n
How to implement pairwise<\/code><\/a><\/h2>\n
If you had to implement pairwise<\/code>, you might think of something like the code below:<\/p>\n
def my_pairwise(iterable):\n    for prev_, next_ in zip(iterable, iterable[1:]):\n        yield (prev_, next_)<\/code><\/pre>\n
Which directly translates to<\/p>\n
def my_pairwise(iterable):\n    yield from zip(iterable, iterable[1:])<\/code><\/pre>\n
But there is a problem with this implementation, and that is the slicing operation.\npairwise<\/code> is supposed to work with any iterable and not all iterables are sliceable.\nFor example, files are iterables but are not sliceable.<\/p>\n
There are a couple of different ways to fix this but my favourite uses collections.deque<\/code> with its parameter maxlen<\/code><\/a>:<\/p>\n
from collections import deque\nfrom itertools import islice\n\ndef my_pairwise(data):\n    data = iter(data)\n    window = deque(islice(data, 1), maxlen=2)\n    for value in data:\n        window.append(value)\n        yield tuple(window)<\/code><\/pre>\n
Generalising itertools.pairwise<\/code><\/a><\/h2>\n
pairwise<\/code> will always produce pairs<\/strong> of consecutive elements, but sometimes you might want tuples of different sizes.\nFor example, you might want something like “triplewise<\/code>”, to get triples of consecutive elements, but pairwise<\/code> can't be used for that.\nSo, how do you implement that generalisation?<\/p>\n
In the upcoming subsections I will present different ways of implementing the function nwise(iterable, n)<\/code> that accepts an iterable and a positive integer n<\/code> and produces overlapping tuples of n<\/code> elements taken from the given iterable.<\/p>\n
Some example applications:<\/p>\n
nwise(\"ABCD\", 2) -> (\"A\", \"B\"), (\"B\", \"C\"), (\"C\", \"D\")\nnwise(\"ABCD\", 3) -> (\"A\", \"B\", \"C\"), (\"B\", \"C\", \"D\")\nnwise(\"ABCD\", 4) -> (\"A\", \"B\", \"C\", \"D\")<\/code><\/pre>\n
Using deque<\/code><\/a><\/h3>\n
The implementation of pairwise<\/code> that I showed above can be adapted for nwise<\/code>:<\/p>\n
from collections import deque\nfrom itertools import islice\n\ndef nwise(iterable, n):\n    iterable = iter(iterable)\n    window = deque(islice(iterable, n - 1), maxlen=n)\n    for value in iterable:\n        window.append(value)\n        yield tuple(window)<\/code><\/pre>\n
Note that you have to change maxlen=2<\/code> to maxlen=n<\/code>, but also islice(iterable, 1)<\/code> to islice(iterable, n - 1)<\/code>.<\/p>\n
Using tee<\/code><\/a><\/h3>\n
Another fundamentally different way of implement nwise<\/code> is by using itertools.tee<\/code> to split the input...<\/p>","summary":"In this article you will learn about itertools.pairwise, how to use it, and how to generalise it.","date_modified":"2025-12-03T10:07:01+01:00","tags":["programming","python","algorithms"],"image":"\/user\/pages\/02.blog\/generalising-itertools-pairwise\/thumbnail.webp"},{"title":"Floodfill algorithm in Python","date_published":"2025-11-17T16:49:00+01:00","id":"https:\/\/mathspp.com\/blog\/floodfill-algorithm-in-python","url":"https:\/\/mathspp.com\/blog\/floodfill-algorithm-in-python","content_html":"
Learn how to implement and use the floodfill algorithm in Python.<\/p>\n\n