Efficient Data Processing in Social Networking Logs Analysis

Introduction

Welcome to this exciting journey into data processing! 🚀 Let's dive into the world of log analysis and learn how to extract meaningful information from complex data!

Task Statement

Imagine a social networking application that allows users to form groups. Each group has a unique ID ranging from 1 up to n, the total number of groups. Interestingly, the app keeps track of when a group is created and deleted, logging all these actions in a string. The task before us is to create a Python function named analyze_logs() . This function will take as input a string of logs and output a list of tuples representing the groups with the longest lifetime. Each tuple contains two items: the group ID and the group's lifetime. By 'lifetime,' we mean the duration from when the group was created until its deletion. If a group has been created and deleted multiple times, the lifetime is the total sum of those durations. If multiple groups have the same longest lifetime, the function should return all such groups in ascending order of their IDs. For example, if we have a log string as follows: "1 create 09:00, 2 create 10:00, 1 delete 12:00, 3 create 13:00, 2 delete 15:00, 3 delete 16:00", the function will return: [(2, '05:00')] .

Solution Building: Step 1

Firstly, we import the datetime module from Python's standard library. This module provides functions and classes for working with dates and times. Once we separate the input string into individual operations, we use the datetime function to parse the timestamps contained in these operations. Python from datetime import datetime, timedelta #Importing datetime for handling timestamps def analyze_logs(logs): log_list = logs.split(", ") #Break down the log string into individual logs by splitting

Solution Building: Step 2

Next, we delve deeper into the logs. For each logged group operation in the string, we need to parse its components. These include the group ID, the type of operation (create or delete), and the time of action. Python from datetime import datetime, timedelta def analyze_logs(logs): log_list = logs.split(", ") #Splitting the logs string into a list of logs for log in log_list: G_ID, action, time = log.split() #Breaking down each log into group ID, action type, and its happening time

Join the 1M+ learners on CodeSignal

Be a part of our community of 1M+ users who develop and demonstrate their skills on CodeSignal

Solution Building: Step 3

Now that we can identify the action performed on each group and when, it's time to process these details. We convert the group ID into an integer and the timestamp into a datetime object. If the log entry marks a 'create' action, we register the time of creation in a dictionary under the group ID. If the entry signals 'delete,' we calculate the lifetime of the group and store it in another dictionary.

For tracking durations, we use Python's timedelta class which is specifically designed to represent time differences. When we subtract two datetime objects, Python automatically returns a timedelta object. We use timedelta(0) as the initial value for a group's lifetime, representing zero duration, which is more appropriate than creating a datetime object with "00:00".

Python

from datetime import datetime, timedelta


def analyze_logs(logs):
    log_list = logs.split(", ")
    time_dict = {}  #Dictionary to record the creation moment for each group
    life_dict = {}  #Dictionary to record the lifetime for each group
    format = '%H:%M'  #The expected timestamp format
    
    for log in log_list:
        G_ID, action, time = log.split()
        G_ID = int(G_ID)  #Casting the group's ID from string to integer
        time = datetime.strptime(time, format)  #Casting the timestamp from string to datetime object
        
        if action == 'create':
            time_dict[G_ID] = time  #If the group is created, log the creation time.
        else:
            if G_ID in time_dict:
                #If the group is deleted, calculate its total lifetime and remove it from the creation records.
                duration = time - time_dict[G_ID]  # This returns a timedelta object
                life_dict[G_ID] = life_dict.get(G_ID, timedelta(0)) + duration
                del time_dict[G_ID]

from datetime import datetime, timedelta


def analyze_logs(logs):
    log_list = logs.split(", ")
    time_dict = {}  #Dictionary to record the creation moment for each group
    life_dict = {}  #Dictionary to record the lifetime for each group
    format = '%H:%M'  #The expected timestamp format
    
    for log in log_list:
        G_ID, action, time = log.split()
        G_ID = int(G_ID)  #Casting the group's ID from string to integer
        time = datetime.strptime(time, format)  #Casting the timestamp from string to datetime object
        
        if action == 'create':
            time_dict[G_ID] = time  #If the group is created, log the creation time.
        else:
            if G_ID in time_dict:
                #If the group is deleted, calculate its total lifetime and remove it from the creation records.
                duration = time - time_dict[G_ID]  # This returns a timedelta object
                life_dict[G_ID] = life_dict.get(G_ID, timedelta(0)) + duration
                del time_dict[G_ID]

Solution Building: Step 4

After recording the lifetimes of all groups, we can compare them to determine which group or groups had the longest lifetime. Finally, we return the ID or IDs of that group or groups, sorted in ascending order, along with their lifetime.

To format the duration, we extract the total seconds from the timedelta object and convert it to hours and minutes. We use an f-string with format specifiers (:02d) to ensure both hours and minutes are always displayed with two digits, even if they're single-digit numbers.