Ads Performance Analysis

In the world of digital marketing, understanding the performance of advertisements is crucial for optimizing campaigns and maximizing return on investment. This challenge requires you to analyze a dataset of ad impressions and clicks to calculate key performance metrics. This skill is fundamental for data analysts and marketing professionals working with ad platforms.

Problem Description

Your task is to process a list of ad events, where each event represents either an impression or a click for a specific advertisement. You need to calculate the Click-Through Rate (CTR) for each unique advertisement.

Requirements:

1. Data Structure: You will receive a list of events. Each event object will contain:

   • ad_id: A unique identifier for the advertisement (string or integer).
   • event_type: The type of event, either "impression" or "click" (string).

2. CTR Calculation: The Click-Through Rate (CTR) is calculated as: CTR = (Total Clicks / Total Impressions) * 100

3. Output Format: The output should be a collection (e.g., a list of objects, a dictionary/map) where each entry represents an ad_id and its corresponding calculated CTR.

Expected Behavior:

• For each unique ad_id, you must count the total number of "impression" events and "click" events.
• If an ad_id has zero impressions, its CTR should be reported as 0.0.
• If an ad_id has impressions but no clicks, its CTR should be reported as 0.0.
• The CTR should be a floating-point number, possibly with a few decimal places for precision.

Edge Cases to Consider:

• An ad_id with only impressions and no clicks.
• An ad_id with only clicks and no impressions (should be treated as 0 impressions for CTR calculation).
• An empty input list of events.
• ad_ids that appear only once.

Examples

Example 1:

Input: [
  {"ad_id": "ad1", "event_type": "impression"},
  {"ad_id": "ad1", "event_type": "impression"},
  {"ad_id": "ad1", "event_type": "click"},
  {"ad_id": "ad2", "event_type": "impression"},
  {"ad_id": "ad2", "event_type": "click"},
  {"ad_id": "ad2", "event_type": "click"},
  {"ad_id": "ad3", "event_type": "impression"}
]

Output: [
  {"ad_id": "ad1", "ctr": 50.0},
  {"ad_id": "ad2", "ctr": 66.666666...},
  {"ad_id": "ad3", "ctr": 0.0}
]

Explanation:
- ad1: 2 impressions, 1 click. CTR = (1/2) * 100 = 50.0
- ad2: 1 impression, 2 clicks. CTR = (2/1) * 100 = 200.0. Wait, this is wrong. The problem states "clicks / impressions". This means if clicks > impressions, the ratio can exceed 100. Let's re-evaluate the problem statement: "CTR = (Total Clicks / Total Impressions) * 100".  If we follow this literally, ad2's CTR is (2/1)*100 = 200.0. However, in a real-world scenario, a click without a preceding impression is usually not counted towards CTR calculation for that impression. Let's assume for this challenge that each click *must* be associated with a prior impression for the purpose of CTR. Thus, if clicks > impressions for an ad_id, it implies a data anomaly or a specific business rule not fully captured by the input. A common interpretation is to cap CTR at 100% if clicks exceed impressions, or to only count clicks that logically follow an impression.  Given the ambiguity, let's stick to the MOST COMMON interpretation for ad performance: clicks cannot exceed impressions for valid CTR calculation. If `clicks > impressions`, the CTR is often considered 100% (maximum possible) or 0% if the clicks are invalid. For *this* challenge, we will assume that **the number of clicks can not exceed the number of impressions for a given ad_id in a meaningful CTR calculation.** Therefore, if `Total Clicks > Total Impressions`, we will cap the `clicks` used in the calculation at `Total Impressions`.

Let's re-calculate Example 1 with this assumption:
- ad1: 2 impressions, 1 click. CTR = (1 / 2) * 100 = 50.0
- ad2: 1 impression, 2 clicks. Clicks are capped at 1 (impressions). CTR = (1 / 1) * 100 = 100.0
- ad3: 1 impression, 0 clicks. CTR = (0 / 1) * 100 = 0.0

Revised Output for Example 1:
[
  {"ad_id": "ad1", "ctr": 50.0},
  {"ad_id": "ad2", "ctr": 100.0},
  {"ad_id": "ad3", "ctr": 0.0}
]

Explanation:
- ad1: 2 impressions, 1 click. CTR = (1 / 2) * 100 = 50.0
- ad2: 1 impression, 2 clicks. Clicks are capped at 1 (max impressions). CTR = (1 / 1) * 100 = 100.0
- ad3: 1 impression, 0 clicks. CTR = (0 / 1) * 100 = 0.0

**Example 2:**

Input: [ {"ad_id": "campaign_A", "event_type": "impression"}, {"ad_id": "campaign_A", "event_type": "impression"}, {"ad_id": "campaign_A", "event_type": "impression"}, {"ad_id": "campaign_A", "event_type": "click"}, {"ad_id": "campaign_B", "event_type": "impression"}, {"ad_id": "campaign_B", "event_type": "click"} ]

Output: [ {"ad_id": "campaign_A", "ctr": 33.333333...}, {"ad_id": "campaign_B", "ctr": 100.0} ]

Explanation:

• campaign_A: 3 impressions, 1 click. CTR = (1 / 3) * 100 = 33.333...
• campaign_B: 1 impression, 1 click. CTR = (1 / 1) * 100 = 100.0

**Example 3: Edge Case - No Impressions for an Ad**

Input: [ {"ad_id": "promo_x", "event_type": "click"}, {"ad_id": "promo_x", "event_type": "click"} ]

Output: [ {"ad_id": "promo_x", "ctr": 0.0} ]

Explanation:

• promo_x: 0 impressions, 2 clicks. Since there are no impressions, CTR is 0.0 as per the requirement.

## Constraints

*   The input list will contain between 0 and 100,000 events.
*   `ad_id` will be a string or an integer.
*   `event_type` will only be "impression" or "click".
*   The solution should be efficient enough to process up to 100,000 events within a reasonable time frame (e.g., a few seconds). Aim for a time complexity of O(N), where N is the number of events.

## Notes

*   When calculating CTR, ensure you handle division by zero. If an ad has zero impressions, its CTR is 0.0.
*   Remember the assumption about capping clicks at the number of impressions for CTR calculation.
*   Consider using a data structure like a hash map or dictionary to efficiently store and update impression and click counts per `ad_id`.
*   The precision of the floating-point output can be flexible, but typically 2-4 decimal places are sufficient in reporting.