Most counts on r/counting are made by two counters collaborating; the signature of this is that the n^th count and the (n + 2)^th count almost always have the same author. Usually we only consider such collaborative counting a run when the two counters reply to each other at a fairly rapid clip, but I’ve ignored that here

Firstly, I’ve looked at the longest runs by total time, which I’ve defined as the longest periods of time when only two people counted in main. Unfortunately, that doesn’t give anything very interesting: these are all from early in the subreddit history, where hours would frequently pass between replies, and the runs I’ve found are generally less than ten counts long. An example is from the 24k counting thread, where just over 23 hours passed between two counts here here1. There was only one exception to this trend in the 2M era. Apparently we had a bit of a problem with spammers & farmers back then, and a really long chain of counts was deleted, and the count was continued from a valid point some hours later. The whole thing caused a bit of confusion.

  • 1 Plus that was a late chain which somehow became official. I guess we were less strict back then.

    • Code 
    from pathlib import Path
import pandas as pd
import numpy as np
import re
import sqlite3
import matplotlib.pyplot as plt

from rcounting import side_threads, counters, analysis, thread_navigation as tn, parsing, units
from rcounting.reddit_interface import reddit
import seaborn as sns
sns.set_theme()
from IPython.display import Markdown
data_directory = Path("../data/")
db = sqlite3.connect(data_directory / "counting.sqlite")
df = pd.read_sql("select counters.canonical_username as username, timestamp, comment_id from comments join counters on comments.username=counters.username where comments.position > 0 order by timestamp", db)

    Looking at the longest runs by total number of counts in the run is more interesting. so let’s do that. We take all our ordered counts and shift them by two; if the two authors are different, that means one streak has ended and a new one started. Taking the cumulative sum of all these changes means that each run is assigned the same number; exactly what we want. Table 1 shows the top ten runs in r/counting history, as well as their total length.2:

  • 2 I haven’t checked through all of them, but it’s likely all the lengths are off by one. That’s because I’ve forced every comment to be part of only one run, but the first comment in each run should simultaneously be the last comment in the previous run.

    • Code 
    column = df['username']
is_different_group = (column != column.shift(2))
df['group'] = is_different_group.cumsum()
groups = df.groupby('group')
indices = (-groups.size().loc[groups.size() > 1]).sort_values(kind='mergesort').index
old = groups.first().loc[indices]
new = groups.last().loc[indices]
new['username'] = groups.nth(1).loc[indices]['username']
old['length'] = groups.size().loc[indices]
combined = old.join(new, rsuffix='2', lsuffix='1')
combined['dt'] = (combined['timestamp2'] - combined['timestamp1']) / units.HOUR
combined.drop(['timestamp1', 'timestamp2'], axis=1, inplace=True)

def link(comment):
    body, submission = pd.read_sql(f"select body, comment_id from comments where comment_id == '{comment}' order by timestamp desc limit 1", db).iloc[0]
    return f"[{parsing.find_count_in_text(body):,}](/comments/{submission}/_/{comment})"

final = combined.head(10).reset_index(drop=True).copy()

final["old_link"] = final["comment_id1"].apply(link)
final["new_link"] = final["comment_id2"].apply(link)
final.index += 1
def format_time(timedelta):
    hours, rem = divmod(timedelta.total_seconds(), 3600)
    minutes, seconds = divmod(rem, 60)
    return f"{int(hours):0>2}:{int(minutes):0>2}"
final['dt'] = pd.to_timedelta(final['dt'], unit='h').round('s').apply(format_time)
Markdown(final[['username1', 'username2', 'old_link', 'new_link', 'length', 'dt']].to_markdown(headers=['**Rank**', '**1st counter**', '**2nd counter**', '**Start**', '**End**', '**Length**', '**Duration**']))
    Table 1: The 10 longest runs in r/counting history
    Rank 1st counter 2nd counter Start End Length Duration
    1 davidjl123 Countletics 3,037,002 3,044,030 7029 02:44
    2 davidjl123 Countletics 3,190,001 3,195,027 5027 02:11
    3 Countletics davidjl123 3,101,028 3,105,791 4764 01:54
    4 Countletics davidjl123 3,072,012 3,076,715 4704 01:56
    5 Countletics davidjl123 3,201,005 3,205,000 3996 01:41
    6 Countletics davidjl123 3,090,222 3,094,002 3781 01:45
    7 Countletics Antichess 5,049,002 5,052,720 3719 01:37
    8 Countletics davidjl123 3,064,318 3,068,003 3686 01:37
    9 Countletics Antichess 5,142,034 5,145,081 3048 01:13
    10 Countletics LeMinerWithCheese 4,569,377 4,572,402 3026 02:43

    The first seven runs are by u/davidjl123 and u/Countletics in the early 3Ms, and all of the top ten involve either david or countletics. The first one which doesn’t either of them is number 17 between nonsensy and colby6666, starting at 3,456,003 and continuing for 2000 counts.