Meetup in C: Complete Solution & Deep Dive Guide

---

The Ultimate Guide to Mastering Date Calculation in C

Calculating a specific meetup date in C, such as 'the third Tuesday of August', involves determining the month's starting weekday and iterating through its days using modular arithmetic. This guide breaks down the logic, from handling leap years to parsing textual descriptions like 'teenth' and 'last'.

You’ve been there before. Staring at a calendar, manually counting weeks, trying to figure out the exact date of a recurring event. "Is the third Friday on the 17th or the 24th this month?" It's a surprisingly common and tedious task that screams for automation. For developers, especially those working in systems programming with C, this isn't just a convenience—it's a foundational skill. Manually managing dates is error-prone and inefficient, and in the world of software, precision is everything.

What if you could build a robust function that instantly translates a human-readable request like "the last Sunday of October" into a concrete date? This guide will walk you through exactly that. We'll explore a fascinating challenge from the exclusive kodikra.com C learning path that demystifies date and time manipulation. By the end, you'll not only solve the "Meetup" problem but also gain a deep understanding of the C standard library's time-handling capabilities, a skill essential for building everything from schedulers to financial applications.

---

What is the Meetup Date Calculation Problem?

At its core, the Meetup problem is a logic puzzle that requires you to translate a set of abstract scheduling rules into a specific calendar date. It simulates a real-world scenario where you need to pinpoint a date based on relative, rather than absolute, terms. This is a common requirement in calendar applications, booking systems, and automated report generation.

The Core Inputs and Desired Output

The function you'll build needs to accept four key pieces of information:

• Year: An integer representing the year (e.g., 2023).
• Month: An integer for the month (e.g., 10 for October).
• Week Descriptor: A string that specifies which week of the month to target. This is the most interesting part and includes values like "first", "second", "third", "fourth", "last", and a special case, "teenth".
• Day of the Week: A string representing the target weekday (e.g., "Monday", "Tuesday").

Given these inputs, the desired output is a single integer: the day of the month that satisfies all conditions. For instance, if you provide (2023, 10, "third", "Tuesday"), the function should return 17, because the third Tuesday of October 2023 is the 17th.

Decoding the "Week Descriptors"

Understanding the week descriptors is crucial. While most are straightforward, "teenth" and "last" require special attention.

• "first", "second", "third", "fourth": These are ordinal. "First" means the very first occurrence of the specified weekday in the month. "Second" means the second, and so on.
• "teenth": This is a unique and clever constraint. It refers to the one occurrence of the specified weekday that falls on a day ending in "-teenth," meaning any day from the 13th to the 19th, inclusive. Every weekday (Sunday through Saturday) appears exactly once in this seven-day range.
• "last": This refers to the final occurrence of the specified weekday within the month. This requires you to know the total number of days in the month to calculate correctly.

---

Why This is a Foundational C Programming Challenge

Solving the Meetup problem is more than just a date-finding exercise; it's a comprehensive workout for several fundamental C programming concepts. It forces you to move beyond basic syntax and engage with standard libraries, data structures, and algorithmic thinking. Mastering this challenge from the kodikra module provides tangible skills applicable across many domains.

Key Concepts You'll Master

• Standard Library Usage (time.h): You'll learn to leverage C's powerful, if somewhat arcane, time.h library. This includes working with the struct tm data structure, which holds broken-down time information, and using functions like mktime() to normalize dates and find weekdays.
• Algorithmic Logic: The problem requires a clear, step-by-step algorithm. You must first establish a baseline (like the first day of the month), then iterate or calculate offsets based on the given criteria. This hones your ability to break down complex problems into manageable steps.
• Handling Edge Cases: Date calculation is riddled with edge cases. What about leap years and the length of February? What if a month doesn't have a "fourth" or "fifth" occurrence of a certain day? A robust solution must account for all these scenarios.
• String and Data Manipulation: You'll need to parse input strings (like "Monday", "teenth") and map them to numerical values that your algorithm can use. This often involves creating lookup tables using arrays of structs, a common and efficient pattern in C.
• Modular Arithmetic: The relationship between days of the week is inherently cyclical. Understanding and using the modulo operator (%) is essential for cleanly handling weekday calculations.

This challenge is a perfect microcosm of systems programming: it demands precision, efficiency, and a thorough understanding of the tools at your disposal. The skills you build here are directly transferable to any task involving scheduling, data logging, or time-series analysis. For a deeper dive into C programming, explore our complete C language guide.

---

How to Approach the Solution: A Step-by-Step Blueprint

Let's architect a solution from the ground up. A successful approach requires a logical progression of steps, from understanding the month's structure to pinpointing the exact day. We will rely on the time.h library, which is the standard C way to handle date and time.

Step 1: The Foundation - Setting Up the Time Structure

The first task is to determine the weekday of the very first day of the given month and year. The time.h library provides the struct tm and the mktime() function, which are perfect for this. The struct tm holds all the components of a calendar time.

You'll populate a struct tm instance with the given year, month, and set the day to 1. Note that tm_year is years since 1900, and tm_mon is months since January (0-11).

#include <time.h>

// ... inside the function
struct tm time_spec = {0};
time_spec.tm_year = year - 1900; // Years since 1900
time_spec.tm_mon = month - 1;    // Months since January (0-11)
time_spec.tm_mday = 1;           // First day of the month

// Normalize the time structure and get weekday info
mktime(&time_spec); 

// time_spec.tm_wday now holds the weekday of the 1st (0=Sun, 1=Mon, ...)

The call to mktime() is magical. It takes a potentially incomplete struct tm, fills in the missing fields (like tm_wday, the day of the week), and normalizes the values. After this call, time_spec.tm_wday gives us our crucial starting point.

Step 2: Calculating the Date of the First Target Weekday

Now that you know the weekday of the 1st of the month (let's call it first_day_weekday) and the weekday you're looking for (target_weekday), you can calculate the date of the first occurrence of your target day.

The logic uses modular arithmetic. The difference between the target weekday and the month's starting weekday tells you how many days to advance from the 1st.

// Example: target_weekday = 2 (Tuesday), first_day_weekday = 5 (Friday)
// We need to go from Friday to the *next* Tuesday.
// (2 - 5 + 7) % 7 = 4. So we add 4 days to the 1st.
// The first Tuesday is on the 1 + 4 = 5th.

int day_offset = (target_weekday - time_spec.tm_wday + 7) % 7;
int first_occurrence_date = 1 + day_offset;

This formula reliably finds the date of the first desired weekday in any month.

Step 3: Handling the Ordinal Weeks ("first", "second", etc.)

This is now straightforward. If you have the date of the first occurrence, the subsequent ones are simply 7 days apart.

• First: first_occurrence_date + (0 * 7)
• Second: first_occurrence_date + (1 * 7)
• Third: first_occurrence_date + (2 * 7)
• Fourth: first_occurrence_date + (3 * 7)

The overall logic flow for these cases is visualized below.

    ● Start(year, month, week, weekday)
    │
    ▼
  ┌───────────────────────────┐
  │ Setup `struct tm` for the │
  │ 1st of the month          │
  └────────────┬──────────────┘
               │
               ▼
  ┌───────────────────────────┐
  │ Call `mktime()` to find   │
  │ weekday of the 1st        │
  └────────────┬──────────────┘
               │
               ▼
  ┌───────────────────────────┐
  │ Calculate date of the     │
  │ *first* target weekday    │
  └────────────┬──────────────┘
               │
               ▼
  ◆ Is week "first"..."fourth"?
   ╲           │
    No         Yes
     ╲         │
      ╲        ▼
       ╲     ┌──────────────────────────┐
        ╲    │ Add (N-1) * 7 days to    │
         ╲   │ the first occurrence date│
          ╲  └────────────┬─────────────┘
           ╲             │
            ╲            ▼
             └─────▶ ● Return Date

Step 4: Solving the Special Cases: "teenth" and "last"

These two require slightly different logic.

The "teenth" Logic

The "teenth" days are 13, 14, 15, 16, 17, 18, and 19. We already calculated first_occurrence_date. We can simply start there and keep adding 7 until the date falls within the 13-19 range.

int teenth_date = first_occurrence_date;
while (teenth_date < 13) {
    teenth_date += 7;
}
// The result is the correct "teenth" date.

The "last" Logic

For the "last" occurrence, we first need to know how many days are in the month. This requires a helper function that accounts for leap years.

// Helper function
static bool is_leap_year(int year) {
    return ((((year % 4) == 0) && ((year % 100) != 0)) || ((year % 400) == 0));
}

static int days_in_month(int year, int month) {
    // ... logic for 30/31 day months ...
    if (month == 2) {
        return is_leap_year(year) ? 29 : 28;
    }
    // ...
}

Once you have the total number of days, you can start with the date of the fourth occurrence and see if adding another 7 days keeps you within the month. If it does, that's the fifth (and possibly last) occurrence. A simpler way is to start with the first occurrence and keep adding 7 until the next jump would take you out of the month.

    ◆ Is week "teenth" or "last"?
      │
      ├─ "teenth" ──────────────────────────┐
      │                                     │
      ▼                                     ▼
  ┌─────────────────────┐             ┌─────────────────────────┐
  │ Start with first    │             │ Calculate total days    │
  │ occurrence date     │             │ in the month            │
  └──────────┬──────────┘             └──────────┬──────────────┘
             │                                     │
             ▼                                     ▼
  ┌─────────────────────┐             ┌─────────────────────────┐
  │ Loop, adding 7,     │             │ Start with first        │
  │ until date >= 13    │             │ occurrence date         │
  └──────────┬──────────┘             └──────────┬──────────────┘
             │                                     │
             ▼                                     ▼
       ● Return Date                   ┌─────────────────────────┐
                                       │ Loop, adding 7, as long │
                                       │ as (date + 7) is still  │
                                       │ within the month        │
                                       └──────────┬──────────────┘
                                                  │
                                                  ▼
                                            ● Return Final Date

---

Detailed Code Walkthrough of the C Solution

Now, let's dissect a complete and robust C implementation based on the logic we've developed. This solution, adapted from the kodikra.com curriculum, demonstrates best practices for clarity and correctness.

#include <string.h>
#include <stdbool.h>
#include <time.h>
#include "meetup.h"

#define BAD_DATE_REQUESTED (0)

// A helper struct to map string descriptors to integer values
typedef struct {
   const char *text;
   int number;
} text_to_int_lookup_t;

// Helper function to determine if a year is a leap year
static bool is_leap_year(int year)
{
   return ((((year % 4) == 0) && ((year % 100) != 0)) || ((year % 400) == 0));
}

// Helper function to get the number of days in a given month
static int days_in_month(int year, int month)
{
   int number_of_days = 31;

   switch (month) {
      case 4:
      case 6:
      case 9:
      case 11:
         number_of_days = 30;
         break;
      case 2:
         number_of_days = (is_leap_year(year) ? 29 : 28);
         break;
   }
   return number_of_days;
}

int meetup_day_of_month(unsigned int year, unsigned int month, const char *week,
                        const char *day_of_week)
{
   // Lookup tables for parsing string inputs
   text_to_int_lookup_t week_lookup[] = {
      {"first", 1}, {"second", 2}, {"third", 3},
      {"fourth", 4}, {"fifth", 5}, {"last", 6}, {"teenth", 7}
   };
   text_to_int_lookup_t day_lookup[] = {
      {"Sunday", 0}, {"Monday", 1}, {"Tuesday", 2}, {"Wednesday", 3},
      {"Thursday", 4}, {"Friday", 5}, {"Saturday", 6}
   };

   // Convert string inputs to integers
   int week_as_int = 0;
   for (size_t i = 0; i < sizeof(week_lookup) / sizeof(week_lookup[0]); ++i) {
      if (strcmp(week, week_lookup[i].text) == 0) {
         week_as_int = week_lookup[i].number;
         break;
      }
   }

   int day_as_int = 0;
   for (size_t i = 0; i < sizeof(day_lookup) / sizeof(day_lookup[0]); ++i) {
      if (strcmp(day_of_week, day_lookup[i].text) == 0) {
         day_as_int = day_lookup[i].number;
         break;
      }
   }

   // Core logic starts here
   struct tm time_spec = { .tm_year = year - 1900, .tm_mon = month - 1, .tm_mday = 1 };
   mktime(&time_spec);
   int first_day_of_month_weekday = time_spec.tm_wday;

   int day_offset = (day_as_int - first_day_of_month_weekday + 7) % 7;
   int day = 1 + day_offset;

   if (week_as_int >= 1 && week_as_int <= 5) { // first, second, third, fourth, fifth
      day += (week_as_int - 1) * 7;
   } else if (week_as_int == 6) { // last
      while ((day + 7) <= days_in_month(year, month)) {
         day += 7;
      }
   } else if (week_as_int == 7) { // teenth
      while (day < 13) {
         day += 7;
      }
   }

   if (day > days_in_month(year, month)) {
      return BAD_DATE_REQUESTED; // e.g., "fifth Monday" in a month with only four.
   }

   return day;
}

Code Breakdown

Includes and Defines

• <string.h>: Included for strcmp() to compare the input strings.
• <stdbool.h>: Provides the bool type and true/false values for better readability in the is_leap_year function.
• <time.h>: The star of the show, providing struct tm and mktime().
• #define BAD_DATE_REQUESTED (0): A constant to return for invalid requests, like a "fifth Wednesday" in a month that doesn't have one.

Helper Functions: is_leap_year and days_in_month

These two functions encapsulate the fundamental rules of the Gregorian calendar. is_leap_year implements the standard algorithm: a year is a leap year if it's divisible by 4, unless it's divisible by 100 but not by 400. days_in_month uses a switch statement for a clean and efficient way to return the correct number of days, calling is_leap_year for the special case of February.

The Main Function: meetup_day_of_month

1. Lookup Tables: The function begins by defining two local lookup tables, week_lookup and day_lookup. Using an array of text_to_int_lookup_t structs is a classic and highly readable C pattern for mapping strings to integer codes. This avoids a long chain of if-else if statements.
2. Input Parsing: Two for loops iterate through these lookup tables. strcmp() compares the input strings (e.g., "third", "Tuesday") with the text in the structs. When a match is found, the corresponding integer value is stored in week_as_int and day_as_int.
3. Finding the First Day: A struct tm is initialized with the provided year and month. The designated initializer syntax (.tm_year = ...) is a modern C feature that improves clarity. As discussed, mktime() is called to populate tm_wday, giving us the weekday of the 1st of the month.
4. Calculating the First Occurrence: The modular arithmetic formula (day_as_int - first_day_of_month_weekday + 7) % 7 calculates the offset from the 1st to the first desired weekday. This is added to 1 to get the initial date, stored in day.
5. Handling Week Logic:
   • An if block handles "first" through "fifth". It calculates the final date by adding (week_as_int - 1) * 7 to the first occurrence.
   • An else if block handles "last". It enters a while loop, continuously adding 7 to the current date as long as the result doesn't exceed the number of days in the month.
   • A final else if handles "teenth". It uses a while loop to add 7 until the date is 13 or greater, guaranteeing it falls in the 13-19 range.
6. Validation and Return: Before returning, a final check ensures the calculated day is valid (e.g., a "fifth Monday" might calculate to the 36th). If it exceeds the number of days in the month, BAD_DATE_REQUESTED is returned. Otherwise, the correct day is returned.

---

Real-World Applications and Performance Considerations

While this might seem like an academic exercise, the underlying principles are ubiquitous in software development. Anytime a system needs to handle recurring events, this logic comes into play.

Where This Logic is Used

• Calendar and Scheduling Apps: The most obvious application. Think "repeat this event on the second Tuesday of every month."
• Financial Systems: Calculating dates like "the last business day of the quarter" for closing books or "the third Friday of the month" for options expiration.
• Automated Reporting: Generating a report that runs on the "first Monday of every month."
• System Maintenance Scripts: Scheduling tasks like backups or updates to run on a specific relative day, such as the "last Sunday of the month."
• Embedded Systems: Devices that need to perform actions based on a recurring schedule without relying on a constant network connection.

Performance and Optimization: Iterative vs. Mathematical

The provided solution is highly readable and uses an iterative (loop-based) approach for the "last" and "teenth" cases. For date calculations, this is almost always fast enough. However, it's worth comparing it to a more direct mathematical approach for a complete understanding.

Approach	Pros	Cons
Iterative (Loop-based)	- Extremely easy to read and understand the logic. - Less prone to complex off-by-one errors in formulas. - Handles all cases ("teenth", "last") with simple loops.	- Technically less performant as it involves looping (though the number of iterations is tiny). - Can feel slightly less "elegant" than a direct calculation.
Direct Mathematical	- Most performant, as it involves no loops, only arithmetic operations. - Considered more elegant by some programmers.	- Formulas can be more complex and harder to reason about. - Calculating the "last" day mathematically requires more complex logic involving the total days in the month and the weekday of the last day.

For the "last" day, a mathematical approach would involve finding the weekday of the last day of the month and working backward. While possible, the iterative approach of starting at the first occurrence and adding 7 until you can't anymore is often simpler to implement correctly and debug.

Verdict: For this problem, the clarity of the iterative solution outweighs the marginal performance gain of a purely mathematical one. The code is self-documenting, and the performance difference is negligible in any real-world scenario.

---

Frequently Asked Questions (FAQ)

What is the `time.h` library in C?

time.h is the standard C library for date and time functions. It provides data structures like struct tm to hold broken-down time (year, month, day, hour, etc.) and functions like time(), mktime(), and strftime() to manipulate and format this data.

Why is `mktime()` so important for this problem?

mktime() is a powerful normalization function. When you give it a struct tm with just the year, month, and day, it correctly calculates and fills in the other fields, most importantly tm_wday (the day of the week). This saves you from having to implement complex calendar algorithms like Zeller's congruence yourself.

How exactly do you handle the 'teenth' week descriptor?

The 'teenth' descriptor refers to the single occurrence of a weekday between the 13th and 19th of the month. The most reliable way to find it is to first find the date of the *first* occurrence of that weekday, and then keep adding 7 to that date until it falls within the 13-19 range. Since this range is 7 days long, a solution is always guaranteed.

Is it better to use loops or direct math for date calculations?

For most applications, a clear, loop-based iterative approach is better because it's easier to write, read, and debug. The performance difference is almost always irrelevant. A direct mathematical approach is faster but the formulas can be complex and prone to off-by-one errors. Prioritize clarity and correctness unless you are in an extremely performance-critical loop.

What are common pitfalls when working with dates in C?

The most common pitfalls include: forgetting that tm_year in struct tm is years since 1900, tm_mon is 0-11, and tm_wday starts with Sunday as 0. Another is failing to account for leap years. Finally, timezone issues can be complex, but for this specific problem (which deals with local calendar dates), mktime() handles it based on the system's local timezone settings.

How does C handle time zones with `struct tm`?

The C standard library's handling of time zones can be tricky. mktime() assumes the values in struct tm represent local time and converts it to a calendar time based on the system's configured time zone. For UTC-based calculations, you would typically use different functions or carefully manage environment variables, but that is beyond the scope of this specific calendar-date problem.

Could this logic be adapted for other calendar systems?

No, not directly. The entire logic, especially the is_leap_year and days_in_month functions, is hardcoded for the Gregorian calendar system. Adapting this for other calendars like the Julian, Islamic, or Hebrew calendars would require replacing these helper functions with rules specific to that system. The core algorithmic approach of finding a starting point and iterating, however, could still apply.

---

Conclusion: Beyond Just Finding a Date

We've journeyed deep into the mechanics of date calculation in C, transforming a seemingly simple request—"find the third Tuesday"—into a robust, well-structured program. By solving this challenge from the kodikra.com C 6 roadmap module, you've done more than just manipulate dates; you've practiced algorithmic thinking, leveraged standard libraries effectively, handled numerous edge cases, and created clean, maintainable code.

The ability to work confidently with time and dates is a non-negotiable skill for any serious programmer. The patterns you've learned here—using lookup tables, creating helper functions for complex logic, and using a step-by-step algorithmic approach—are universally applicable. This is the essence of programming: breaking down a complex, real-world problem into logical, computable steps.

Technology Disclaimer: The code and concepts discussed are based on the C11/C17 standard and utilize the standard time.h library. The behavior of these functions is consistent across all major C compilers (GCC, Clang, MSVC) and operating systems.

Ready to tackle your next challenge? Explore the full C learning path on kodikra.com to continue building your skills from the ground up.

---

Published by Kodikra — Your trusted C learning resource.