الأبحاث · جولةُ البرمجة الأولى
CB-3-03 — كتابة ميزة جديدة · C# · عالٍ
جولةُ البرمجة الأولى · 2026-10-16 · GAIBRA v2.31.03 · واجبُ التشغيل
| الترتيب | المتنافس | الرمز أمام المحكّم | الكلمات | الاختبارات | Opus | Grok | المجموع | الصدق (Opus · Grok) |
|---|---|---|---|---|---|---|---|---|
| 1 | GAIBRA | ج | 3,279 | 12/12 | 96.0 | 100.0 | 98.0 | 12 · 12 |
| 2 | Claude Sonnet | أ | 1,615 | 12/12 | 93.0 | 94.0 | 93.5 | 11 · 11 |
| 3 | Gemini | هـ | 1,160 | 10/12 | 62.2 | 60.2 | 61.2 | 5 · 5 |
| 4 | ChatGPT | د | 1,568 | 4/12 | 47.7 | 61.7 | 54.7 | 4 · 9 |
| 5 | DeepSeek | ب | 1,751 | 0/12 | 24.0 | 40.0 | 32.0 | 3 · 6 |
نصُّ السيناريو كما كتبه المولّد
نبني وحدة رواتب لشركة مقاولات، ونحتاج دالة احتساب بدل العمل الإضافي وفق نظام العمل السعودي:
\* أول ساعتان إضافيتان في اليوم: الراتب الأساسي + 50% (أي 1.5×).
\* كل ساعة إضافية بعدهما: الراتب الأساسي + 100% (أي 2×).
\* ساعات العمل في يوم الراحة الأسبوعية أو الإجازة الرسمية: 2× طوال اليوم، ولو أنجز الموظف أعمالاً فيها يستحق بدل يوم إضافي بأجر يوم كامل إضافةً إلى أجره (نختصرها: يوم كامل = 8 ساعات × 2× تُضاف كسطر مستقل).
\* إذا امتد العمل الإضافي إلى الفترة بين 11 مساءً و6 صباحاً، تُحتسب الساعات المتقاطعة مع هذه الفترة بـ 1.5× إضافية (أي معامل الليل يضرب في معامل الفترة: ساعة ليلية عادية = 1× أساسي × 1.5).
\* الحد الأقصى: ساعتان + المدة المتبقية بشرط ألا يتجاوز الإجمالي 12 ساعة عمل فعلية في اليوم (ما فوق 12 يُهمل).
التعقيد: سجل الدوام مقسّم إلى ورديات متقطعة (دخول/خروج متعدد)، وقد تمتد الوردية من النهار إلى الليل، فنحتاج تقسيم كل فترة على حدود 23:00 و06:00.
البيانات (ثابتة داخل نصك، لا ملفات خارجية):
plain
```plain
ساعات العمل الرسمية اليومية: 8
الإجازات الرسمية: 2026-09-23 (اليوم الوطني)
يوم الراحة الأسبوعية: الجمعة
سجل الموظف (2026-09-24 الخميس، يوم عمل عادي):
  08:00-12:00 عمل عادي
  13:00-17:00 عمل عادي
  18:00-23:30 عمل إضافي
سجل يوم آخر (2026-09-25 الجمعة):
  09:00-14:00 عمل (يوم راحة)
```
الراتب الأساسي الشهري: 6,000 ريال. قاعدة التحويل المعتمدة عندنا: أجر الساعة = (الأساسي ÷ 30) ÷ 8.
الواجهة المطلوبة حرفياً:
csharp
```csharp
public record Shift(DateTime Start, DateTime End);
public enum DayKind { Normal, RestDay, PublicHoliday }
public record OvertimeBreakdown(
  double RegularHours, double NightHours,
  double FirstTwoOvertimeHours, double ExtraOvertimeHours,
  double RestDayHours, double HolidayHours,
  decimal OvertimePay, decimal NightPremium, decimal HolidayDayPay);
public static class OvertimeCalculator
{
  public static OvertimeBreakdown Calculate(
  IReadOnlyList<Shift> shifts, DayKind dayKind,
  decimal basicMonthlySalary, IReadOnlySet<DateTime> publicHolidays,
  DayOfWeek weeklyRestDay);
}
```
ملف واحد مستقل، مكتبة قياسية فقط، بدون تاريخ/وقت حقيقي (كل التواريخ تدخل كمعاملات)، وسلوك حتمي تماماً. أرفق في نهاية الملف مثال `Main` يشغّل البيانات أعلاه ويطبع التفصيل بالساعات والمبالغ.
الردودُ الخمسة كما وصلت المحكّمين
جGAIBRA
// OvertimeCalculator.cs — ملف واحد، مكتبة .NET القياسية فقط (.NET 6+ / C# 10)
\#nullable enable
using System;
using System.Collections.Generic;
using System.Globalization;
namespace Payroll.Overtime
{
  /// <summary>A continuous attendance interval (clock-in to clock-out) in local wall-clock time.</summary>
  /// <param name="Start">Clock-in instant.</param>
  /// <param name="End">Clock-out instant; must be strictly after <paramref name="Start"/>.</param>
  public record Shift(DateTime Start, DateTime End);
  /// <summary>Calendar classification of a work day.</summary>
  public enum DayKind { Normal, RestDay, PublicHoliday }
  /// <summary>Hours and pay produced by one work day. Money amounts are rounded to 2 decimals.</summary>
  /// <param name="RegularHours">Hours within the official daily hours on a normal day (paid by the monthly salary).</param>
  /// <param name="NightHours">Counted hours (any tier) that fall inside 23:00–06:00.</param>
  /// <param name="FirstTwoOvertimeHours">First two overtime hours on a normal day (1.5×).</param>
  /// <param name="ExtraOvertimeHours">Overtime hours after the first two on a normal day (2×).</param>
  /// <param name="RestDayHours">Hours worked on the weekly rest day (2×).</param>
  /// <param name="HolidayHours">Hours worked on a public holiday (2×).</param>
  /// <param name="OvertimePay">Pay for overtime, rest-day and holiday hours, excluding the night premium.</param>
  /// <param name="NightPremium">Extra pay for night hours: rate × tier multiplier × (1.5 − 1).</param>
  /// <param name="HolidayDayPay">Separate full-day allowance (8 h × 2×) when any work is done on a rest day or holiday.</param>
  public record OvertimeBreakdown(
  double RegularHours, double NightHours,
  double FirstTwoOvertimeHours, double ExtraOvertimeHours,
  double RestDayHours, double HolidayHours,
  decimal OvertimePay, decimal NightPremium, decimal HolidayDayPay);
  /// <summary>
  /// Computes overtime for a single work day under the company's policy.
  /// Pure and deterministic: no clock access, no I/O, no shared mutable state (thread-safe).
  /// </summary>
  public static class OvertimeCalculator
  {
  /// <summary>Official daily working hours; worked time beyond this on a normal day is overtime.</summary>
  public const int RegularDailyHours = 8;
  /// <summary>Number of overtime hours paid at the first-tier multiplier.</summary>
  public const int FirstOvertimeTierHours = 2;
  /// <summary>Maximum counted worked hours per day; anything after this (chronologically) is discarded.</summary>
  public const int MaximumDailyWorkedHours = 12;
  /// <summary>Divisor used to convert the monthly basic salary into a daily wage.</summary>
  public const int DaysPerMonthForHourlyRate = 30;
  /// <summary>Hours that make up the separate rest-day / holiday full-day allowance.</summary>
  public const int HolidayDayCompensationHours = 8;
  private const decimal RegularMultiplier = 1.0m;
  private const decimal FirstOvertimeMultiplier = 1.5m;
  private const decimal ExtraOvertimeMultiplier = 2.0m;
  private const decimal RestOrHolidayMultiplier = 2.0m;
  private const decimal NightFactor = 1.5m;
  private const int MoneyDecimalPlaces = 2;
  private const int TierCount = 4;
  private static readonly TimeSpan NightWindowStart = TimeSpan.FromHours(23);
  private static readonly TimeSpan NightWindowEnd = TimeSpan.FromHours(6);
  private static readonly TimeSpan RegularLimit = TimeSpan.FromHours(RegularDailyHours);
  private static readonly TimeSpan FirstTierLimit = TimeSpan.FromHours(RegularDailyHours + FirstOvertimeTierHours);
  private static readonly TimeSpan DailyCap = TimeSpan.FromHours(MaximumDailyWorkedHours);
  private static readonly TimeSpan MaximumRecordSpan = TimeSpan.FromDays(1);
  private static readonly DateTime EarliestSupportedInstant = DateTime.MinValue.AddDays(2);
  private static readonly DateTime LatestSupportedInstant = DateTime.MaxValue.AddDays(-2);
  private static readonly PayTier\[] AllTiers =
  { PayTier.Regular, PayTier.FirstOvertime, PayTier.ExtraOvertime, PayTier.RestOrHoliday };
  private static readonly OvertimeBreakdown NoWork = new(0d, 0d, 0d, 0d, 0d, 0d, 0m, 0m, 0m);
  private enum PayTier { Regular = 0, FirstOvertime = 1, ExtraOvertime = 2, RestOrHoliday = 3 }
  private readonly record struct Interval(DateTime Start, DateTime End)
  {
  public TimeSpan Duration => End - Start;
  }
  private sealed class TierTotals
  {
  private readonly TimeSpan\[] \_worked = new TimeSpan\[TierCount];
  private readonly TimeSpan\[] \_night = new TimeSpan\[TierCount];
  public void Add(PayTier tier, TimeSpan worked, TimeSpan night)
  {
  \_worked\[(int)tier] += worked;
  \_night\[(int)tier] += night;
  }
  public TimeSpan WorkedIn(PayTier tier) => \_worked\[(int)tier];
  public TimeSpan NightIn(PayTier tier) => \_night\[(int)tier];
  public TimeSpan TotalNight
  {
  get
  {
  TimeSpan total = TimeSpan.Zero;
  foreach (TimeSpan night in \_night)
  {
  total += night;
  }
  return total;
  }
  }
  }
  /// <summary>
  /// Calculates overtime hours and pay for one work day.
  /// The work day is the calendar date of the earliest clock-in; all shifts must fit within 24 hours of it.
  /// The effective day kind is the stronger of <paramref name="dayKind"/> and the calendar
  /// (public holiday \> rest day \> normal), so a mis-declared holiday is never underpaid.
  /// </summary>
  /// <param name="shifts">Attendance intervals of the day, in any order; must not overlap. Empty means no work.</param>
  /// <param name="dayKind">Day kind declared by the caller.</param>
  /// <param name="basicMonthlySalary">Basic monthly salary; must be positive.</param>
  /// <param name="publicHolidays">Public holiday dates (time component must be midnight).</param>
  /// <param name="weeklyRestDay">Weekly rest day.</param>
  /// <returns>The hours and pay breakdown for the day.</returns>
  /// <exception cref="ArgumentNullException">A reference argument is null.</exception>
  /// <exception cref="ArgumentOutOfRangeException">An enum is undefined, the salary is not positive, or a shift is at the edge of the DateTime range.</exception>
  /// <exception cref="ArgumentException">A shift is null, empty, reversed, overlapping, the record spans more than 24 hours, or a holiday has a time component.</exception>
  public static OvertimeBreakdown Calculate(
  IReadOnlyList<Shift> shifts, DayKind dayKind,
  decimal basicMonthlySalary, IReadOnlySet<DateTime> publicHolidays,
  DayOfWeek weeklyRestDay)
  {
  ArgumentNullException.ThrowIfNull(shifts);
  ArgumentNullException.ThrowIfNull(publicHolidays);
  if (!Enum.IsDefined(dayKind))
  {
  throw new ArgumentOutOfRangeException(nameof(dayKind), dayKind, "Unknown day kind.");
  }
  if (!Enum.IsDefined(weeklyRestDay))
  {
  throw new ArgumentOutOfRangeException(nameof(weeklyRestDay), weeklyRestDay, "Unknown day of week.");
  }
  if (basicMonthlySalary <= 0m)
  {
  throw new ArgumentOutOfRangeException(nameof(basicMonthlySalary), basicMonthlySalary, "Basic monthly salary must be positive.");
  }
  ValidateHolidayDates(publicHolidays);
  Interval\[] ordered = OrderAndValidateShifts(shifts);
  if (ordered.Length == 0)
  {
  return NoWork;
  }
  DateTime workDate = ordered\[0].Start.Date;
  DayKind effectiveKind = ResolveDayKind(dayKind, workDate, publicHolidays, weeklyRestDay);
  List<Interval> counted = TrimToDailyCap(ordered);
  TierTotals totals = AccumulateTiers(counted, effectiveKind);
  decimal hourlyRate = ComputeHourlyRate(basicMonthlySalary);
  return BuildBreakdown(totals, effectiveKind, hourlyRate);
  }
  private static void ValidateHolidayDates(IReadOnlySet<DateTime> publicHolidays)
  {
  foreach (DateTime holiday in publicHolidays)
  {
  if (holiday.TimeOfDay != TimeSpan.Zero)
  {
  throw new ArgumentException(
  $"Public holiday {holiday.ToString("O", CultureInfo.InvariantCulture)} must be a date at midnight.",
  nameof(publicHolidays));
  }
  }
  }
  private static Interval\[] OrderAndValidateShifts(IReadOnlyList<Shift> shifts)
  {
  var intervals = new Interval\[shifts.Count];
  for (int index = 0; index < shifts.Count; index++)
  {
  Shift? shift = shifts\[index];
  if (shift is null)
  {
  throw new ArgumentException($"Shift at index {index} is null.", nameof(shifts));
  }
  if (shift.End <= shift.Start)
  {
  throw new ArgumentException($"Shift at index {index} must end after it starts.", nameof(shifts));
  }
  if (shift.Start < EarliestSupportedInstant || shift.End > LatestSupportedInstant)
  {
  throw new ArgumentOutOfRangeException(nameof(shifts), $"Shift at index {index} is outside the supported date range.");
  }
  intervals\[index] = new Interval(shift.Start, shift.End);
  }
  Array.Sort(intervals, (left, right) => left.Start.CompareTo(right.Start));
  for (int index = 1; index < intervals.Length; index++)
  {
  if (intervals\[index].Start < intervals\[index - 1].End)
  {
  throw new ArgumentException(
  $"Shift starting {intervals\[index].Start.ToString("O", CultureInfo.InvariantCulture)} overlaps the previous shift.",
  nameof(shifts));
  }
  }
  if (intervals.Length > 0 \&\& intervals\[^1].End - intervals\[0].Start > MaximumRecordSpan)
  {
  throw new ArgumentException("Shifts of one work day must fit within 24 hours of the first clock-in.", nameof(shifts));
  }
  return intervals;
  }
  private static DayKind ResolveDayKind(DayKind declared, DateTime workDate, IReadOnlySet<DateTime> publicHolidays, DayOfWeek weeklyRestDay)
  {
  DayKind fromCalendar = publicHolidays.Contains(workDate)
  ? DayKind.PublicHoliday
  : workDate.DayOfWeek == weeklyRestDay ? DayKind.RestDay : DayKind.Normal;
  return Precedence(fromCalendar) > Precedence(declared) ? fromCalendar : declared;
  }
  private static int Precedence(DayKind kind) => kind switch
  {
  DayKind.Normal => 0,
  DayKind.RestDay => 1,
  DayKind.PublicHoliday => 2,
  \_ => throw new ArgumentOutOfRangeException(nameof(kind), kind, "Unknown day kind.")
  };
  private static List<Interval> TrimToDailyCap(Interval\[] ordered)
  {
  var counted = new List<Interval>(ordered.Length);
  TimeSpan remaining = DailyCap;
  foreach (Interval interval in ordered)
  {
  if (remaining <= TimeSpan.Zero)
  {
  break;
  }
  TimeSpan take = interval.Duration < remaining ? interval.Duration : remaining;
  counted.Add(new Interval(interval.Start, interval.Start + take));
  remaining -= take;
  }
  return counted;
  }
  private static TierTotals AccumulateTiers(IReadOnlyList<Interval> counted, DayKind effectiveKind)
  {
  var totals = new TierTotals();
  foreach ((Interval slice, PayTier tier) in SliceByTier(counted, effectiveKind))
  {
  totals.Add(tier, slice.Duration, NightOverlap(slice));
  }
  return totals;
  }
  private static IEnumerable<(Interval Slice, PayTier Tier)> SliceByTier(IReadOnlyList<Interval> counted, DayKind effectiveKind)
  {
  if (effectiveKind != DayKind.Normal)
  {
  foreach (Interval interval in counted)
  {
  yield return (interval, PayTier.RestOrHoliday);
  }
  yield break;
  }
  TimeSpan elapsed = TimeSpan.Zero;
  foreach (Interval interval in counted)
  {
  DateTime cursor = interval.Start;
  while (cursor < interval.End)
  {
  PayTier tier = NormalDayTierAt(elapsed);
  TimeSpan tierRemaining = NormalDayTierUpperBound(tier) - elapsed;
  TimeSpan intervalRemaining = interval.End - cursor;
  TimeSpan take = tierRemaining < intervalRemaining ? tierRemaining : intervalRemaining;
  var slice = new Interval(cursor, cursor + take);
  yield return (slice, tier);
  cursor = slice.End;
  elapsed += take;
  }
  }
  }
  private static PayTier NormalDayTierAt(TimeSpan elapsed)
  {
  if (elapsed < RegularLimit)
  {
  return PayTier.Regular;
  }
  if (elapsed < FirstTierLimit)
  {
  return PayTier.FirstOvertime;
  }
  if (elapsed < DailyCap)
  {
  return PayTier.ExtraOvertime;
  }
  throw new InvalidOperationException("Worked time exceeds the daily cap after trimming.");
  }
  private static TimeSpan NormalDayTierUpperBound(PayTier tier) => tier switch
  {
  PayTier.Regular => RegularLimit,
  PayTier.FirstOvertime => FirstTierLimit,
  PayTier.ExtraOvertime => DailyCap,
  \_ => throw new ArgumentOutOfRangeException(nameof(tier), tier, "Tier is not a normal-day tier.")
  };
  private static TimeSpan NightOverlap(Interval interval)
  {
  TimeSpan total = TimeSpan.Zero;
  for (DateTime day = interval.Start.Date.AddDays(-1); day <= interval.End.Date; day = day.AddDays(1))
  {
  DateTime nightStart = day + NightWindowStart;
  DateTime nightEnd = day.AddDays(1) + NightWindowEnd;
  DateTime overlapStart = interval.Start > nightStart ? interval.Start : nightStart;
  DateTime overlapEnd = interval.End < nightEnd ? interval.End : nightEnd;
  if (overlapEnd > overlapStart)
  {
  total += overlapEnd - overlapStart;
  }
  }
  return total;
  }
  private static decimal ComputeHourlyRate(decimal basicMonthlySalary) =>
  basicMonthlySalary / DaysPerMonthForHourlyRate / RegularDailyHours;
  private static decimal Multiplier(PayTier tier) => tier switch
  {
  PayTier.Regular => RegularMultiplier,
  PayTier.FirstOvertime => FirstOvertimeMultiplier,
  PayTier.ExtraOvertime => ExtraOvertimeMultiplier,
  PayTier.RestOrHoliday => RestOrHolidayMultiplier,
  \_ => throw new ArgumentOutOfRangeException(nameof(tier), tier, "Unknown pay tier.")
  };
  private static decimal ToDecimalHours(TimeSpan duration) => (decimal)duration.Ticks / TimeSpan.TicksPerHour;
  private static decimal PayFor(TimeSpan duration, decimal hourlyRate, decimal multiplier) =>
  ToDecimalHours(duration) \* hourlyRate \* multiplier;
  private static decimal RoundMoney(decimal amount) =>
  Math.Round(amount, MoneyDecimalPlaces, MidpointRounding.AwayFromZero);
  private static OvertimeBreakdown BuildBreakdown(TierTotals totals, DayKind effectiveKind, decimal hourlyRate)
  {
  TimeSpan restOrHolidayWorked = totals.WorkedIn(PayTier.RestOrHoliday);
  decimal overtimePay =
  PayFor(totals.WorkedIn(PayTier.FirstOvertime), hourlyRate, Multiplier(PayTier.FirstOvertime)) +
  PayFor(totals.WorkedIn(PayTier.ExtraOvertime), hourlyRate, Multiplier(PayTier.ExtraOvertime)) +
  PayFor(restOrHolidayWorked, hourlyRate, Multiplier(PayTier.RestOrHoliday));
  decimal nightPremium = 0m;
  foreach (PayTier tier in AllTiers)
  {
  nightPremium += PayFor(totals.NightIn(tier), hourlyRate, Multiplier(tier) \* (NightFactor - 1m));
  }
  decimal holidayDayPay = restOrHolidayWorked > TimeSpan.Zero
  ? HolidayDayCompensationHours \* hourlyRate \* RestOrHolidayMultiplier
  : 0m;
  return new OvertimeBreakdown(
  RegularHours: totals.WorkedIn(PayTier.Regular).TotalHours,
  NightHours: totals.TotalNight.TotalHours,
  FirstTwoOvertimeHours: totals.WorkedIn(PayTier.FirstOvertime).TotalHours,
  ExtraOvertimeHours: totals.WorkedIn(PayTier.ExtraOvertime).TotalHours,
  RestDayHours: effectiveKind == DayKind.RestDay ? restOrHolidayWorked.TotalHours : 0d,
  HolidayHours: effectiveKind == DayKind.PublicHoliday ? restOrHolidayWorked.TotalHours : 0d,
  OvertimePay: RoundMoney(overtimePay),
  NightPremium: RoundMoney(nightPremium),
  HolidayDayPay: RoundMoney(holidayDayPay));
  }
  }
  /// <summary>Demo: runs the given data plus one night scenario, prints the breakdown, and self-checks hand-traced values.</summary>
  public static class Program
  {
  private const decimal BasicMonthlySalary = 6000m;
  private const DayOfWeek WeeklyRestDay = DayOfWeek.Friday;
  private const string CurrencyCode = "SAR";
  private const string HoursFormat = "0.##";
  private const string MoneyFormat = "0.00";
  private const double HoursTolerance = 1e-9;
  private const int ExitSuccess = 0;
  private const int ExitSelfCheckFailed = 1;
  private sealed record DemoScenario(string Title, DayKind DeclaredKind, Shift\[] Shifts, OvertimeBreakdown Expected);
  /// <summary>Entry point. Returns 0 when every self-check passes, 1 otherwise.</summary>
  public static int Main()
  {
  var publicHolidays = new HashSet<DateTime> { new DateTime(2026, 9, 23) };
  DemoScenario\[] scenarios =
  {
  new DemoScenario(
  "2026-09-24 Thursday (normal day)",
  DayKind.Normal,
  new\[]
  {
  new Shift(new DateTime(2026, 9, 24, 8, 0, 0), new DateTime(2026, 9, 24, 12, 0, 0)),
  new Shift(new DateTime(2026, 9, 24, 13, 0, 0), new DateTime(2026, 9, 24, 17, 0, 0)),
  new Shift(new DateTime(2026, 9, 24, 18, 0, 0), new DateTime(2026, 9, 24, 23, 30, 0)),
  },
  new OvertimeBreakdown(8d, 0d, 2d, 2d, 0d, 0d, 175m, 0m, 0m)),
  new DemoScenario(
  "2026-09-25 Friday (weekly rest day)",
  DayKind.RestDay,
  new\[]
  {
  new Shift(new DateTime(2026, 9, 25, 9, 0, 0), new DateTime(2026, 9, 25, 14, 0, 0)),
  },
  new OvertimeBreakdown(0d, 0d, 0d, 0d, 5d, 0d, 250m, 0m, 400m)),
  new DemoScenario(
  "2026-09-27 Sunday (extra night scenario, crosses midnight)",
  DayKind.Normal,
  new\[]
  {
  new Shift(new DateTime(2026, 9, 27, 14, 0, 0), new DateTime(2026, 9, 27, 22, 0, 0)),
  new Shift(new DateTime(2026, 9, 27, 22, 0, 0), new DateTime(2026, 9, 28, 1, 0, 0)),
  },
  new OvertimeBreakdown(8d, 2d, 2d, 1d, 0d, 0d, 125m, 43.75m, 0m)),
  };
  int failedScenarios = 0;
  foreach (DemoScenario scenario in scenarios)
  {
  OvertimeBreakdown actual = OvertimeCalculator.Calculate(
  scenario.Shifts, scenario.DeclaredKind, BasicMonthlySalary, publicHolidays, WeeklyRestDay);
  PrintBreakdown(scenario.Title, actual);
  List<string> mismatches = FindMismatches(actual, scenario.Expected);
  if (mismatches.Count == 0)
  {
  Console.WriteLine(" Self-check : PASS");
  }
  else
  {
  failedScenarios++;
  Console.WriteLine(" Self-check : FAIL");
  foreach (string mismatch in mismatches)
  {
  Console.WriteLine($" - {mismatch}");
  }
  }
  Console.WriteLine();
  }
  return failedScenarios == 0 ? ExitSuccess : ExitSelfCheckFailed;
  }
  private static void PrintBreakdown(string title, OvertimeBreakdown breakdown)
  {
  decimal totalAdditional = breakdown.OvertimePay + breakdown.NightPremium + breakdown.HolidayDayPay;
  Console.WriteLine($"== {title} ==");
  Console.WriteLine($" Regular hours : {FormatHours(breakdown.RegularHours)}");
  Console.WriteLine($" Night hours (23:00-06:00): {FormatHours(breakdown.NightHours)}");
  Console.WriteLine($" First two OT hours (1.5x): {FormatHours(breakdown.FirstTwoOvertimeHours)}");
  Console.WriteLine($" Extra OT hours (2x) : {FormatHours(breakdown.ExtraOvertimeHours)}");
  Console.WriteLine($" Rest-day hours (2x) : {FormatHours(breakdown.RestDayHours)}");
  Console.WriteLine($" Holiday hours (2x) : {FormatHours(breakdown.HolidayHours)}");
  Console.WriteLine($" Overtime pay : {FormatMoney(breakdown.OvertimePay)}");
  Console.WriteLine($" Night premium : {FormatMoney(breakdown.NightPremium)}");
  Console.WriteLine($" Rest/holiday day pay : {FormatMoney(breakdown.HolidayDayPay)}");
  Console.WriteLine($" Total additional pay : {FormatMoney(totalAdditional)}");
  }
  private static string FormatHours(double hours) => hours.ToString(HoursFormat, CultureInfo.InvariantCulture);
  private static string FormatMoney(decimal amount) =>
  $"{amount.ToString(MoneyFormat, CultureInfo.InvariantCulture)} {CurrencyCode}";
  private static List<string> FindMismatches(OvertimeBreakdown actual, OvertimeBreakdown expected)
  {
  var mismatches = new List<string>();
  CompareHours(mismatches, nameof(OvertimeBreakdown.RegularHours), actual.RegularHours, expected.RegularHours);
  CompareHours(mismatches, nameof(OvertimeBreakdown.NightHours), actual.NightHours, expected.NightHours);
  CompareHours(mismatches, nameof(OvertimeBreakdown.FirstTwoOvertimeHours), actual.FirstTwoOvertimeHours, expected.FirstTwoOvertimeHours);
  CompareHours(mismatches, nameof(OvertimeBreakdown.ExtraOvertimeHours), actual.ExtraOvertimeHours, expected.ExtraOvertimeHours);
  CompareHours(mismatches, nameof(OvertimeBreakdown.RestDayHours), actual.RestDayHours, expected.RestDayHours);
  CompareHours(mismatches, nameof(OvertimeBreakdown.HolidayHours), actual.HolidayHours, expected.HolidayHours);
  CompareMoney(mismatches, nameof(OvertimeBreakdown.OvertimePay), actual.OvertimePay, expected.OvertimePay);
  CompareMoney(mismatches, nameof(OvertimeBreakdown.NightPremium), actual.NightPremium, expected.NightPremium);
  CompareMoney(mismatches, nameof(OvertimeBreakdown.HolidayDayPay), actual.HolidayDayPay, expected.HolidayDayPay);
  return mismatches;
  }
  private static void CompareHours(List<string> mismatches, string field, double actual, double expected)
  {
  if (Math.Abs(actual - expected) > HoursTolerance)
  {
  mismatches.Add($"{field}: expected {FormatHours(expected)}, got {FormatHours(actual)}");
  }
  }
  private static void CompareMoney(List<string> mismatches, string field, decimal actual, decimal expected)
  {
  if (actual != expected)
  {
  mismatches.Add($"{field}: expected {FormatMoney(expected)}, got {FormatMoney(actual)}");
  }
  }
  }
}
الشرح
يمرّ الحساب على خطّ واحد. أوّلاً تُرتَّب الورديات ويُرفض المتداخل منها والمعكوس، وكذلك أيّ سجلّ يتجاوز 24 ساعة من أوّل دخول. بعد ذلك يُحدَّد نوع اليوم، ثمّ يُقصّ العمل زمنيّاً عند الساعة الثانية عشرة. يلي ذلك تقطيع الوقت المتبقّي إلى شرائح بحسب الوقت المتراكم: 8 ساعات عاديّة، ثمّ ساعتان بمعامل 1.5×، ثمّ الباقي بمعامل 2×. وفي النهاية تُقاطَع كلّ شريحة مع نوافذ 23:00–06:00.
الفصل بين القطعين مقصود. الشريحة تُحدَّد بالوقت المتراكم، أمّا الليل فيُحدَّد بساعة الحائط، والقيدان متعامدان، لذلك تحمل كلّ شريحة معاملها ونصيبها من الليل معاً. علاوة الليل لكلّ ساعة ليليّة هي أجر الساعة × معامل شريحتها × 0.5، وبهذا تكون الساعة الليليّة في الشريحة الثانية 2× × 1.5 كما في صيغتكم الضربيّة.
الحساب CPU-bound خالص بلا I/O، فلا معنى فيه لـ async ولا لـ CancellationToken، والواجهة المطلوبة متزامنة أصلاً. الأوقات تُجمع بـ TimeSpan على مستوى ticks لتجنّب انجراف double، والمال يُحسب بـ decimal ويُقرَّب مرّة واحدة في النهاية إلى منزلتين (هللة) بقاعدة AwayFromZero، وهذا افتراض منّي لأنّ نصّكم لم يحدّد قاعدة التقريب. الشرائح أربع وثابتة، لذلك تُجمع في مصفوفة مفهرسة بها بدل Dictionary.
مهمّ
في بيانات الخميس يلتهم سقفُ الـ12 ساعة العلاوةَ الليليّة كلّها. الموظف عمل 13.5 ساعة، والقصّ الزمنيّ يُسقط الفترة من 22:00 إلى 23:30، ونصف الساعة الليليّ الوحيد (23:00–23:30) يقع داخل الجزء المُهمَل. لذلك تخرج NightHours = 0 مع أنّ الوردية مسجّلة حتّى 23:30. هذا ما يقتضيه نصّ «ما فوق 12 يُهمل» بقراءته الزمنيّة، فإن أردتم أن يُهمَل الأرخص لا الأخير فهذا قرار سياسة يغيّر الرقم.
تتبّعتُ القيم التالية يدويّاً ولم أشغّل الشيفرة. أجر الساعة هو 6,000 ÷ 30 ÷ 8 = 25 ريالاً. أضفتُ يوم الأحد مثالاً ثالثاً لأنّ بياناتكم لا تمرّ بمسار الليل، وفيه تُدفع الساعة الليليّة في الشريحة الأولى 1 × 25 × 1.5 × 0.5 = 18.75، وفي الشريحة الثانية 1 × 25 × 2 × 0.5 = 25.
اليوم عاديّة أولى (1.5×) لاحقة (2×) راحة ليليّة بدل إضافي علاوة ليل بدل يوم الإجمالي
الخميس 24/9 8 2 2 0 0 175 0 0 175
الجمعة 25/9 0 0 0 5 0 250 0 400 650
الأحد 27/9 8 2 1 0 2 125 43.75 0 168.75
يحتوي Main على هذه القيم بأعيانها في صورة فحوص، ويعيد رمز الخروج 1 إن خالفها أيّ حقل، فيكون التشغيل هو الحَكَم لا هذا الجدول.
في نصّكم مواضع تحتمل أكثر من قراءة، واخترتُ في كلّ منها ما يوافق صياغة السياسة. التعارض الظاهر بين معامل dayKind وبين مجموعة الإجازات ويوم الراحة حسمتُه بأخذ النوع الأقوى: الإجازة الرسميّة ثمّ الراحة ثمّ العاديّ. بهذا لا يُبخس موظف عمل يوم 23/9 حقّه إن مُرِّر اليوم خطأً بنوع Normal. بدل اليوم الكامل (400 ريال) يُطبَّق على يوم الراحة كذلك، لأنّ عبارة «أنجز أعمالاً فيها» تعود على الاثنين، رغم أنّ اسم الحقل HolidayDayPay. ومعامل الليل يشمل الساعات العاديّة أيضاً، لأنّ مثالكم «ساعة ليلية عادية = 1× أساسي × 1.5» ينصّ عليها. أمّا أجر الساعات العاديّة نفسه فلا يدخل OvertimePay لأنّ الراتب الشهريّ يغطّيه، وتظهر فقط علاوتها الليليّة. ويُنسب اليوم إلى تاريخ أوّل دخول، فالوردية من 22:00 إلى 02:00 تتبع يوم بدايتها.
هناك نقطة يجب حسمها قبل الإنتاج. المادّة 107 من نظام العمل تجعل الحدّ الأدنى لساعة العمل الإضافيّ أجرَ الساعة الفعليّ مضافاً إليه 50% من الأساسيّ. معامل 1.5× على الأساسيّ وحده قد يقع دون هذا الحدّ عند موظف له بدلات ثابتة كالسكن. هل لدى موظفيكم بدلات ثابتة؟ إن كانت لديهم فصلتُ لكم أجر الساعة الفعليّ عن الأساسيّ في الحساب، والقرار في ذلك لكم.
طريقة الاستخدام
الملف يُشغَّل كما هو: أنشئ مشروعاً بالأمر dotnet new console على .NET 6 أو أحدث، واستبدل Program.cs بهذا الملف، ثمّ نفّذ dotnet run. في وحدة الرواتب الفعليّة اجمع بصمات الدخول والخروج حسب تاريخ أوّل دخول، واستدعِ Calculate مرّة لكلّ يوم، ثمّ اجمع الحقول المالية الثلاثة على مستوى الشهر. الدالة بلا حالة مشتركة، فيمكن توزيع أيّام آلاف الموظفين على Parallel.ForEach دون أقفال.وثمّة أمرٌ في الإدخال لا تفحصه الدالة. DateTime لا يقارن قيمة Kind، فإن جاءت بعض البصمات بتوقيت UTC وبعضها بالتوقيت المحلّيّ فسيُحسب التداخل وحدود 23:00 و06:00 على ساعاتٍ مختلطة دون أيّ استثناء. لذلك حوِّل كلّ البصمات إلى التوقيت المحلّيّ للموقع قبل بناء Shift، فنافذة الليل في السياسة مربوطة بساعة الحائط هناك.
ابدأ غداً بخطوتين. الأولى أن تشغّل الملف وتتأكّد أنّ الأيّام الثلاثة تطبع PASS وأنّ رمز الخروج 0. والثانية أن تحسم سؤال البدلات الثابتة، فهو الوحيد الذي قد يغيّر أجر الساعة نفسه، وما سواه من قرارات السياسة مثبّت في الشيفرة وفي فحوصها.
أClaude Sonnet
سأكتب الملف المستقل بالقواعد التي حددتها، ثم أشغّله على بياناتك للتحقق من الأرقام.
الملف OvertimeCalculator.cs جاهز، لكنني لم أستطع تشغيله لأن بيئتي لا تحتوي .NET ولا يمكن تثبيته. الأرقام أدناه محسوبة يدوياً من الكود، فشغّل dotnet run عندك للتأكد منها. أجر الساعة = 6000 ÷ 30 ÷ 8 = 25 ريال.
اليوم التفصيل بدل العمل الإضافي علاوة الليل بدل اليوم الكامل الإجمالي
الخميس 24/9 8 ساعات عادية، ثم ساعتان بـ 1.5× وساعتان بـ 2× 175.00 0.00 0.00 175.00
الجمعة 25/9 5 ساعات بـ 2× 250.00 0.00 400.00 650.00
سقف الـ 12 ساعة يقطع وردية الخميس. سجل الخميس يبلغ 13.5 ساعة فعلية، فتُهمل آخر ساعة ونصف حسب القاعدة. تنتهي الوردية المحتسبة عند 22:00، فلا تصل إلى فترة الليل (23:00–06:00) ولا تظهر علاوة ليلية. لذلك أضفت في Main مثالاً ثالثاً (الأحد 27/9، وردية مسائية 20:00–24:00) تظهر فيه علاوة الليل، وتبلغ 25 ريالاً لساعة 23:00–24:00.
قرارات تصميمية يجب مراجعتها:
علاوة الليل: تُحسب كزيادة بنسبة 50% فوق معامل الفترة (ساعة بـ 2× في الليل = 3×)، وهذا يطابق نصك "معامل الليل يضرب في معامل الفترة". وهي مفصولة في NightPremium حتى لا تختلط ببدل العمل الإضافي.
بدل اليوم الكامل: في يوم الراحة أو الإجازة يُضاف سطر مستقل بقيمة 8 × 2× (400 ريال)، كما اختصرتَه في وصفك. هذا يعني أن ساعات الجمعة تُدفع بـ 2× ثم يُضاف بدل اليوم الكامل فوقها، فتأكد أن هذا هو المقصود.
نوع اليوم: إذا مُرّر DayKind.Normal ووافق التاريخ إجازة رسمية أو يوم الراحة، تستنتج الدالة النوع الصحيح. وإن اجتمعا تتقدم الإجازة الرسمية.
الورديات عبر منتصف الليل: تتبع يوم بدايتها.
التحقق من المدخلات: الورديات المتداخلة أو التي يسبق خروجها دخولها ترمي ArgumentException.
التقريب: الحسابات بـ decimal ثم تقريب المبالغ النهائية إلى خانتين فقط. الساعات تُحسب بالـ ticks فلا أخطاء عائمة.
Overtimecalculator
CS
// OvertimeCalculator.cs
// حاسبة بدل العمل الإضافي وفق نظام العمل السعودي (وحدة الرواتب - شركة المقاولات)
// ملف واحد مستقل، مكتبة قياسية فقط (.NET 6+ / C# 10+)، بلا أي قراءة لتاريخ/وقت النظام، وسلوك حتمي.
using System;
using System.Collections.Generic;
using System.Globalization;
using System.Linq;
public record Shift(DateTime Start, DateTime End);
public enum DayKind { Normal, RestDay, PublicHoliday }
public record OvertimeBreakdown(
  double RegularHours, double NightHours,
  double FirstTwoOvertimeHours, double ExtraOvertimeHours,
  double RestDayHours, double HolidayHours,
  decimal OvertimePay, decimal NightPremium, decimal HolidayDayPay);
public static class OvertimeCalculator
{
  // ثوابت القواعد
  private const int OfficialDailyHours = 8; // ساعات العمل الرسمية اليومية
  private const int FirstOvertimeBandHours = 2; // أول ساعتين إضافيتين
  private const int MaxActualDailyHours = 12; // سقف الساعات الفعلية، وما فوقه يُهمل
  private const int DaysInMonth = 30; // قاعدة التحويل: الأساسي ÷ 30 ÷ 8
  private const decimal FirstBandFactor = 1.5m; // أول ساعتين إضافيتين
  private const decimal ExtraBandFactor = 2.0m; // ما بعدهما
  private const decimal RestOrHolidayFactor = 2.0m; // يوم الراحة / الإجازة الرسمية
  private const decimal NightFactor = 1.5m; // معامل الليل (يضرب في معامل الفترة)
  private static readonly TimeSpan NightStart = TimeSpan.FromHours(23);
  private static readonly TimeSpan NightEnd = TimeSpan.FromHours(6);
  private const long Hour = TimeSpan.TicksPerHour;
  public static OvertimeBreakdown Calculate(
  IReadOnlyList<Shift> shifts, DayKind dayKind,
  decimal basicMonthlySalary, IReadOnlySet<DateTime> publicHolidays,
  DayOfWeek weeklyRestDay)
  {
  ArgumentNullException.ThrowIfNull(shifts);
  ArgumentNullException.ThrowIfNull(publicHolidays);
  if (basicMonthlySalary < 0)
  throw new ArgumentOutOfRangeException(nameof(basicMonthlySalary));
  if (shifts.Count == 0)
  return new OvertimeBreakdown(0, 0, 0, 0, 0, 0, 0m, 0m, 0m);
  // 1) تحقق وترتيب: كل وردية صالحة وبلا تداخل
  var ordered = shifts.OrderBy(s => s.Start).ThenBy(s => s.End).ToList();
  for (int i = 0; i < ordered.Count; i++)
  {
  if (ordered\[i].End <= ordered\[i].Start)
  throw new ArgumentException($"الوردية رقم {i + 1}: وقت الخروج يجب أن يكون بعد وقت الدخول.", nameof(shifts));
  if (i > 0 \&\& ordered\[i].Start < ordered\[i - 1].End)
  throw new ArgumentException($"الورديتان {i} و{i + 1} متداخلتان.", nameof(shifts));
  }
  // 2) يوم العمل = تاريخ بداية أول وردية (الوردية الممتدة بعد منتصف الليل تتبع يوم بدايتها)
  DateTime workDate = ordered\[0].Start.Date;
  // 3) نوع اليوم الفعلي: القيمة الصريحة تتقدم، وإن كانت Normal نستنتج من التاريخ.
  // الإجازة الرسمية تتقدم على يوم الراحة إن اجتمعا.
  DayKind kind = dayKind;
  if (kind == DayKind.Normal)
  {
  if (publicHolidays.Contains(workDate)) kind = DayKind.PublicHoliday;
  else if (workDate.DayOfWeek == weeklyRestDay) kind = DayKind.RestDay;
  }
  decimal hourly = basicMonthlySalary / DaysInMonth / OfficialDailyHours;
  // 4) تجميع (بالـ ticks لتفادي أخطاء الفاصلة العائمة)
  long regularT = 0, firstT = 0, extraT = 0, restT = 0, holidayT = 0, nightT = 0;
  decimal otPay = 0m, nightPrem = 0m;
  long worked = 0; // الزمن الفعلي المحتسب حتى الآن (بعد السقف)
  long cap = MaxActualDailyHours \* Hour;
  foreach (var shift in ordered)
  {
  long remainingCap = cap - worked;
  if (remainingCap <= 0) break; // ما فوق 12 ساعة يُهمل
  DateTime start = shift.Start;
  DateTime end = shift.End;
  if ((end - start).Ticks > remainingCap)
  end = start.AddTicks(remainingCap);
  // تقسيم الفترة على حدود 23:00 و06:00
  DateTime cur = start;
  while (cur < end)
  {
  bool isNight;
  DateTime boundary;
  TimeSpan t = cur.TimeOfDay;
  if (t < NightEnd) { isNight = true; boundary = cur.Date + NightEnd; }
  else if (t < NightStart) { isNight = false; boundary = cur.Date + NightStart; }
  else { isNight = true; boundary = cur.Date.AddDays(1) + NightEnd; }
  DateTime next = boundary < end ? boundary : end;
  long len = (next - cur).Ticks;
  // توزيع القطعة على فئات المعامل حسب الزمن المتراكم
  while (len > 0)
  {
  long take;
  decimal factor;
  int band; // 0 عادي، 1 أول ساعتين، 2 إضافي، 3 راحة، 4 إجازة
  if (kind == DayKind.Normal)
  {
  long regLimit = OfficialDailyHours \* Hour;
  long firstLimit = (OfficialDailyHours + FirstOvertimeBandHours) \* Hour;
  if (worked < regLimit) { take = Math.Min(len, regLimit - worked); factor = 1m; band = 0; }
  else if (worked < firstLimit) { take = Math.Min(len, firstLimit - worked); factor = FirstBandFactor; band = 1; }
  else { take = len; factor = ExtraBandFactor; band = 2; }
  }
  else
  {
  take = len; factor = RestOrHolidayFactor;
  band = kind == DayKind.RestDay ? 3 : 4;
  }
  decimal hours = (decimal)take / Hour;
  switch (band)
  {
  case 0: regularT += take; break; // مشمول بالراتب الأساسي
  case 1: firstT += take; otPay += hourly \* factor \* hours; break;
  case 2: extraT += take; otPay += hourly \* factor \* hours; break;
  case 3: restT += take; otPay += hourly \* factor \* hours; break;
  case 4: holidayT += take; otPay += hourly \* factor \* hours; break;
  }
  if (isNight)
  {
  nightT += take;
  // علاوة الليل = الزيادة فوق المعامل الأساسي: معامل × (1.5 - 1)
  nightPrem += hourly \* factor \* (NightFactor - 1m) \* hours;
  }
  worked += take;
  len -= take;
  }
  cur = next;
  }
  }
  // 5) بدل اليوم الكامل لمن عمل في يوم الراحة أو الإجازة: 8 ساعات × 2×، كسطر مستقل
  decimal holidayDayPay = (kind != DayKind.Normal \&\& worked > 0)
  ? hourly \* OfficialDailyHours \* RestOrHolidayFactor
  : 0m;
  return new OvertimeBreakdown(
  RegularHours: (double)regularT / Hour,
  NightHours: (double)nightT / Hour,
  FirstTwoOvertimeHours: (double)firstT / Hour,
  ExtraOvertimeHours: (double)extraT / Hour,
  RestDayHours: (double)restT / Hour,
  HolidayHours: (double)holidayT / Hour,
  OvertimePay: Round(otPay),
  NightPremium: Round(nightPrem),
  HolidayDayPay: Round(holidayDayPay));
  }
  private static decimal Round(decimal v) => Math.Round(v, 2, MidpointRounding.AwayFromZero);
}
public static class Program
{
  public static void Main()
  {
  Console.OutputEncoding = System.Text.Encoding.UTF8;
  var holidays = new HashSet<DateTime> { new DateTime(2026, 9, 23) }; // اليوم الوطني
  const DayOfWeek restDay = DayOfWeek.Friday;
  const decimal salary = 6000m;
  // 2026-09-24 الخميس، يوم عمل عادي
  var thursday = new List<Shift>
  {
  new(new DateTime(2026, 9, 24, 8, 0, 0), new DateTime(2026, 9, 24, 12, 0, 0)),
  new(new DateTime(2026, 9, 24, 13, 0, 0), new DateTime(2026, 9, 24, 17, 0, 0)),
  new(new DateTime(2026, 9, 24, 18, 0, 0), new DateTime(2026, 9, 24, 23, 30, 0)),
  };
  Print("2026-09-24 الخميس (يوم عادي)", OvertimeCalculator.Calculate(thursday, DayKind.Normal, salary, holidays, restDay));
  // 2026-09-25 الجمعة، يوم الراحة
  var friday = new List<Shift>
  {
  new(new DateTime(2026, 9, 25, 9, 0, 0), new DateTime(2026, 9, 25, 14, 0, 0)),
  };
  Print("2026-09-25 الجمعة (يوم راحة)", OvertimeCalculator.Calculate(friday, DayKind.RestDay, salary, holidays, restDay));
  // مثال إضافي للتوضيح فقط: وردية تمتد عبر منتصف الليل لتظهر علاوة الليل
  var sunday = new List<Shift>
  {
  new(new DateTime(2026, 9, 27, 8, 0, 0), new DateTime(2026, 9, 27, 12, 0, 0)),
  new(new DateTime(2026, 9, 27, 13, 0, 0), new DateTime(2026, 9, 27, 17, 0, 0)),
  new(new DateTime(2026, 9, 27, 20, 0, 0), new DateTime(2026, 9, 28, 0, 0, 0)),
  };
  Print("2026-09-27 الأحد (مثال إضافي، عبور 23:00)", OvertimeCalculator.Calculate(sunday, DayKind.Normal, salary, holidays, restDay));
  }
  private static void Print(string title, OvertimeBreakdown b)
  {
  var ci = CultureInfo.InvariantCulture;
  Console.WriteLine($"=== {title} ===");
  Console.WriteLine($" ساعات عادية: {b.RegularHours.ToString("0.##", ci)}");
  Console.WriteLine($" ساعات ليلية (23-06): {b.NightHours.ToString("0.##", ci)}");
  Console.WriteLine($" إضافي أول ساعتين (1.5x): {b.FirstTwoOvertimeHours.ToString("0.##", ci)}");
  Console.WriteLine($" إضافي إضافي (2x): {b.ExtraOvertimeHours.ToString("0.##", ci)}");
  Console.WriteLine($" ساعات يوم الراحة (2x): {b.RestDayHours.ToString("0.##", ci)}");
  Console.WriteLine($" ساعات الإجازة الرسمية (2x): {b.HolidayHours.ToString("0.##", ci)}");
  Console.WriteLine($" بدل العمل الإضافي: {b.OvertimePay.ToString("N2", ci)} ريال");
  Console.WriteLine($" علاوة الليل: {b.NightPremium.ToString("N2", ci)} ريال");
  Console.WriteLine($" بدل اليوم الكامل: {b.HolidayDayPay.ToString("N2", ci)} ريال");
  Console.WriteLine($" الإجمالي: {(b.OvertimePay + b.NightPremium + b.HolidayDayPay).ToString("N2", ci)} ريال");
  Console.WriteLine();
  }
}
دChatGPT
سأبني الحل كملف C# مستقل باستخدام المكتبة القياسية فقط، مع الحفاظ على الواجهة المطلوبة، ودعم الورديات المتقطعة وتقسيم الساعات عند حدود 23:00 و06:00، وتحديد نوع اليوم من التاريخ الفعلي. سأجعل الحساب حتميًا دون الاعتماد على الساعة الحالية أو المنطقة الزمنية للجهاز.
ملاحظة مهمة قبل التنفيذ: سأتعامل مع قواعد المضاعفات التي حددتها باعتبارها سياسة الحساب المطلوبة في المسألة، لا باعتبارها تأكيدًا مستقلًا للتفسير القانوني لنظام العمل السعودي. كذلك سأفصل بدل اليوم الإضافي للإجازة عن أجر ساعات العمل، حتى لا يُحسب مرتين ضمن السطر نفسه.
هناك نقطة مؤثرة في بيانات الاختبار: يوم الخميس يحتوي على 13.5 ساعة عمل فعلية، لكن الحد الأقصى المطلوب هو 12 ساعة. لذلك سيُعتمد العمل من 18:00 إلى 22:00 فقط من الوردية الإضافية، وتُهمل الساعات اللاحقة؛ ستكون ساعات الليل المعتمدة صفرًا في هذا المثال تحديدًا، رغم أن الخوارزمية تدعم احتسابها عند وجود وردية تصل إلى الليل ضمن الحد المسموح.
الملف الكامل: Program.cs
الكود التالي يحافظ على التواقيع المطلوبة، ويستخدم decimal للمبالغ المالية، ويتعامل مع تعدد الورديات وتداخلها مع فترات الليل وتغير نوع اليوم عند منتصف الليل.
using System;
using System.Collections.Generic;
using System.Linq;
public record Shift(DateTime Start, DateTime End);
public enum DayKind
{
  Normal,
  RestDay,
  PublicHoliday
}
public record OvertimeBreakdown(
  double RegularHours,
  double NightHours,
  double FirstTwoOvertimeHours,
  double ExtraOvertimeHours,
  double RestDayHours,
  double HolidayHours,
  decimal OvertimePay,
  decimal NightPremium,
  decimal HolidayDayPay);
public static class OvertimeCalculator
{
  private const double DailyRegularHours = 8.0;
  private const double FirstOvertimeLimit = 2.0;
  private const double DailyMaximumHours = 12.0;
  private static readonly TimeSpan NightStart =
  new(23, 0, 0);
  private static readonly TimeSpan NightEnd =
  new(6, 0, 0);
  public static OvertimeBreakdown Calculate(
  IReadOnlyList<Shift> shifts,
  DayKind dayKind,
  decimal basicMonthlySalary,
  IReadOnlySet<DateTime> publicHolidays,
  DayOfWeek weeklyRestDay)
  {
  ArgumentNullException.ThrowIfNull(shifts);
  ArgumentNullException.ThrowIfNull(publicHolidays);
  if (basicMonthlySalary < 0)
  throw new ArgumentOutOfRangeException(
  nameof(basicMonthlySalary));
  var ordered = shifts.OrderBy(s => s.Start).ToList();
  foreach (var shift in ordered)
  {
  if (shift.End <= shift.Start)
  throw new ArgumentException(
  "Shift.End must be after Shift.Start.");
  if (shift.Start.Kind != shift.End.Kind)
  throw new ArgumentException(
  "Shift endpoints must use the same DateTimeKind.");
  }
  for (int i = 1; i < ordered.Count; i++)
  {
  if (ordered\[i].Start < ordered\[i - 1].End)
  throw new ArgumentException(
  "Overlapping shifts are not allowed.");
  }
  decimal hourlyRate = basicMonthlySalary / 30m / 8m;
  double regular = 0;
  double night = 0;
  double firstTwo = 0;
  double extra = 0;
  double restHours = 0;
  double holidayHours = 0;
  decimal overtimePay = 0;
  decimal nightPremium = 0;
  decimal holidayDayPay = 0;
  // Accepted work hours per calendar day.
  var dailyHours = new Dictionary<DateTime, double>();
  // Ensure the additional full-day amount is applied
  // only once per qualifying calendar day.
  var paidAdditionalDays = new HashSet<DateTime>();
  foreach (var shift in ordered)
  {
  DateTime cursor = shift.Start;
  while (cursor < shift.End)
  {
  DateTime date = cursor.Date;
  dailyHours.TryGetValue(date, out double worked);
  // The daily cap applies to actual accepted work.
  double remainingDaily =
  DailyMaximumHours - worked;
  if (remainingDaily <= 0)
  break;
  DayKind effectiveKind =
  GetDayKind(date, dayKind,
  publicHolidays, weeklyRestDay);
  DateTime next = shift.End;
  // Split at midnight.
  DateTime midnight = date.AddDays(1);
  if (midnight < next)
  next = midnight;
  // Split at the night-window boundaries.
  DateTime sixAm = date.Add(NightEnd);
  DateTime elevenPm = date.Add(NightStart);
  if (sixAm > cursor \&\& sixAm < next)
  next = sixAm;
  if (elevenPm > cursor \&\& elevenPm < next)
  next = elevenPm;
  // On a normal day, split at 8 and 10
  // cumulative accepted work hours.
  if (effectiveKind == DayKind.Normal)
  {
  double nextThreshold =
  worked < DailyRegularHours
  ? DailyRegularHours
  : worked < DailyRegularHours
  + FirstOvertimeLimit
  ? DailyRegularHours
  + FirstOvertimeLimit
  : double.PositiveInfinity;
  if (!double.IsPositiveInfinity(nextThreshold))
  {
  double untilThreshold =
  nextThreshold - worked;
  DateTime thresholdTime =
  cursor.AddHours(untilThreshold);
  if (thresholdTime > cursor \&\&
  thresholdTime < next)
  {
  next = thresholdTime;
  }
  }
  }
  double segmentHours =
  (next - cursor).TotalHours;
  // Never accept more than 12 hours per day.
  segmentHours = Math.Min(
  segmentHours, remainingDaily);
  if (segmentHours <= 0)
  break;
  bool isNight =
  cursor.TimeOfDay >= NightStart ||
  cursor.TimeOfDay < NightEnd;
  decimal coefficient;
  if (effectiveKind == DayKind.RestDay)
  {
  restHours += segmentHours;
  coefficient = 2m;
  }
  else if (effectiveKind == DayKind.PublicHoliday)
  {
  holidayHours += segmentHours;
  coefficient = 2m;
  }
  else if (worked < DailyRegularHours)
  {
  regular += segmentHours;
  coefficient = 1m;
  }
  else if (worked <
  DailyRegularHours + FirstOvertimeLimit)
  {
  firstTwo += segmentHours;
  coefficient = 1.5m;
  }
  else
  {
  extra += segmentHours;
  coefficient = 2m;
  }
  // OvertimePay includes the base pay and
  // the applicable overtime multiplier.
  overtimePay += hourlyRate
  \* coefficient
  \* (decimal)segmentHours;
  night += isNight ? segmentHours : 0;
  // Night multiplier is an additional 50%
  // of the applicable segment amount.
  if (isNight)
  {
  nightPremium += hourlyRate
  \* coefficient
  \* 0.5m
  \* (decimal)segmentHours;
  }
  worked += segmentHours;
  dailyHours\[date] = worked;
  // An additional full day is paid separately
  // for each qualifying calendar day worked.
  if (effectiveKind != DayKind.Normal \&\&
  paidAdditionalDays.Add(date))
  {
  holidayDayPay +=
  hourlyRate \* 2m \* 8m;
  }
  cursor = cursor.AddHours(segmentHours);
  }
  }
  return new OvertimeBreakdown(
  regular,
  night,
  firstTwo,
  extra,
  restHours,
  holidayHours,
  decimal.Round(overtimePay, 2,
  MidpointRounding.AwayFromZero),
  decimal.Round(nightPremium, 2,
  MidpointRounding.AwayFromZero),
  decimal.Round(holidayDayPay, 2,
  MidpointRounding.AwayFromZero));
  }
  private static DayKind GetDayKind(
  DateTime date,
  DayKind requestedKind,
  IReadOnlySet<DateTime> publicHolidays,
  DayOfWeek weeklyRestDay)
  {
  if (publicHolidays.Contains(date.Date))
  return DayKind.PublicHoliday;
  if (date.DayOfWeek == weeklyRestDay)
  return DayKind.RestDay;
  return requestedKind;
  }
}
public static class Program
{
  private static DateTime At(
  int year, int month, int day,
  int hour, int minute = 0)
  {
  return new DateTime(
  year, month, day, hour, minute, 0,
  DateTimeKind.Unspecified);
  }
  private static void Print(
  string title,
  OvertimeBreakdown result)
  {
  Console.WriteLine($"\\n--- {title} ---");
  Console.WriteLine(
  $"Regular hours: {result.RegularHours:F2}");
  Console.WriteLine(
  $"Night hours: {result.NightHours:F2}");
  Console.WriteLine(
  $"First two overtime hours: {result.FirstTwoOvertimeHours:F2}");
  Console.WriteLine(
  $"Extra overtime hours: {result.ExtraOvertimeHours:F2}");
  Console.WriteLine(
  $"Rest-day hours: {result.RestDayHours:F2}");
  Console.WriteLine(
  $"Public-holiday hours: {result.HolidayHours:F2}");
  Console.WriteLine(
  $"Overtime pay: {result.OvertimePay:F2} SAR");
  Console.WriteLine(
  $"Night premium: {result.NightPremium:F2} SAR");
  Console.WriteLine(
  $"Additional full-day pay: {result.HolidayDayPay:F2} SAR");
  Console.WriteLine(
  $"Total calculated additions: " +
  $"{result.OvertimePay + result.NightPremium + result.HolidayDayPay:F2} SAR");
  }
  public static void Main()
  {
  const decimal salary = 6000m;
  var holidays = new HashSet<DateTime>
  {
  new DateTime(2026, 9, 23)
  };
  var thursdayShifts = new List<Shift>
  {
  new(At(2026, 9, 24, 8), At(2026, 9, 24, 12)),
  new(At(2026, 9, 24, 13), At(2026, 9, 24, 17)),
  new(At(2026, 9, 24, 18), At(2026, 9, 24, 23, 30))
  };
  var fridayShifts = new List<Shift>
  {
  new(At(2026, 9, 25, 9), At(2026, 9, 25, 14))
  };
  var thursday = OvertimeCalculator.Calculate(
  thursdayShifts,
  DayKind.Normal,
  salary,
  holidays,
  DayOfWeek.Friday);
  var friday = OvertimeCalculator.Calculate(
  fridayShifts,
  DayKind.RestDay,
  salary,
  holidays,
  DayOfWeek.Friday);
  Console.WriteLine("Hourly rate: 25.00 SAR");
  Print("Thursday 2026-09-24", thursday);
  Print("Friday 2026-09-25", friday);
  var holidayShifts = new List<Shift>
  {
  new(At(2026, 9, 23, 9), At(2026, 9, 23, 14))
  };
  var holiday = OvertimeCalculator.Calculate(
  holidayShifts,
  DayKind.Normal,
  salary,
  holidays,
  DayOfWeek.Friday);
  Print("National Day 2026-09-23", holiday);
  }
}
النتائج المتوقعة
أجر الساعة = 6000÷30÷8=25 ريالًا.
الخميس 24 سبتمبر 2026
ساعات العمل العادية
8 ساعات
أول ساعتين إضافيتين
ساعتان × 37.50 = 75 ريالًا
الساعات الإضافية التالية
ساعتان × 50 = 100 ريال
إجمالي بدل العمل الإضافي
175 ريالًا
الساعات المعتمدة 12 ساعة؛ الساعات التي تتجاوز الحد اليومي مستبعدة.
الجمعة 25 سبتمبر 2026 — يوم الراحة
ساعات العمل
5 ساعات
أجر الساعات بمضاعف 2×
250 ريالًا
بدل اليوم الإضافي المستقل
400 ريال
إجمالي الإضافات المحسوبة
650 ريالًا
الأربعاء 23 سبتمبر 2026 — اليوم الوطني
ساعات العمل
5 ساعات
أجر الساعات بمضاعف 2×
250 ريالًا
بدل اليوم الإضافي المستقل
400 ريال
إجمالي الإضافات المحسوبة
650 ريالًا
ملاحظات مهمة قبل اعتماد الوحدة في الإنتاج
مضاعف الليل: الكود يحتسب علاوة ليلية إضافية مقدارها 50% من قيمة الساعة بعد تطبيق معاملها الأساسي أو الإضافي. لذلك تُضاف علاوة الليل فوق أجر العمل المحسوب.
نوع اليوم: تُعطى الأولوية للعطلة الرسمية المسجلة، ثم يوم الراحة الأسبوعية، ثم dayKind كنوع افتراضي.
الحد اليومي: تُقبل الساعات زمنيًا بترتيب الدخول، حتى الوصول إلى 12 ساعة فعلية لكل تاريخ تقويمي.
بدل اليوم الإضافي: يُحسب مرة واحدة لكل يوم تقويمي مؤهل، مستقلًا عن أجر الساعات.
التقريب: تُجرى الحسابات داخليًا باستخدام decimal، ويكون التقريب النهائي إلى منزلتين عشريتين.
تنبيه تنفيذي: هذا تطبيق حرفي للسياسة الحسابية المفترضة، وليس تفسيرًا قانونيًا معتمدًا. قبل ربطه بمسيرات رواتب حقيقية، يجب مراجعة توافق مضاعفات الليل، وبدل اليوم الإضافي، والحد الأقصى للساعات مع النص النظامي السعودي ولائحة المنشأة.
بDeepSeek
سأبني لك وحدة الرواتب وفق نظام العمل السعودي كما طلبت. إليك الملف الكامل:
csharp
using System;
using System.Collections.Generic;
using System.Linq;
public record Shift(DateTime Start, DateTime End);
public enum DayKind { Normal, RestDay, PublicHoliday }
public record OvertimeBreakdown(
  double RegularHours, double NightHours,
  double FirstTwoOvertimeHours, double ExtraOvertimeHours,
  double RestDayHours, double HolidayHours,
  decimal OvertimePay, decimal NightPremium, decimal HolidayDayPay);
public static class OvertimeCalculator
{
  // ثوابت نظام العمل السعودي
  private const double OfficialDailyHours = 8.0;
  private const double MaxActualDailyHours = 12.0;
  private const int NightStartHour = 23; // 11 مساءً
  private const int NightEndHour = 6; // 6 صباحاً
  private const double NightFactor = 1.5; // معامل الفترة الليلية
  // معاملات الأجر
  private const decimal FirstTwoOvertimeFactor = 1.5m;
  private const decimal ExtraOvertimeFactor = 2.0m;
  private const decimal RestDayFactor = 2.0m;
  private const decimal HolidayFactor = 2.0m;
  public static OvertimeBreakdown Calculate(
  IReadOnlyList<Shift> shifts, DayKind dayKind,
  decimal basicMonthlySalary, IReadOnlySet<DateTime> publicHolidays,
  DayOfWeek weeklyRestDay)
  {
  if (shifts == null) throw new ArgumentNullException(nameof(shifts));
  if (publicHolidays == null) throw new ArgumentNullException(nameof(publicHolidays));
  // أجر الساعة = (الأساسي ÷ 30) ÷ 8
  decimal hourlyRate = (basicMonthlySalary / 30m) / 8m;
  // إذا كان يوم راحة أسبوعية أو إجازة رسمية → كل الساعات بمعامل 2×
  bool isRestDay = dayKind == DayKind.RestDay;
  bool isHoliday = dayKind == DayKind.PublicHoliday;
  // نجمع كل الفترات الزمنية من الورديات (مرتبة)
  var intervals = MergeShifts(shifts);
  double regularHours = 0;
  double nightHours = 0;
  double firstTwoOT = 0;
  double extraOT = 0;
  double restDayHours = 0;
  double holidayHours = 0;
  decimal overtimePay = 0m;
  decimal nightPremium = 0m;
  decimal holidayDayPay = 0m;
  // في أيام الراحة/الإجازة: كل الساعات 2×، ولا يوجد "ساعات عادية"
  // في الأيام العادية: أول 8 ساعات عادية، ما بعدها إضافي
  double totalActualHours = 0;
  foreach (var (start, end) in intervals)
  {
  // تقسيم الفترة على حدود الليل (23:00 و 06:00)
  foreach (var segment in SplitByNightBoundaries(start, end))
  {
  double hours = (segment.End - segment.Start).TotalHours;
  if (hours <= 0) continue;
  // التحقق من الحد الأقصى 12 ساعة فعلية
  double remainingCapacity = MaxActualDailyHours - totalActualHours;
  if (remainingCapacity <= 0) break;
  if (hours > remainingCapacity) hours = remainingCapacity;
  bool isNight = IsNightTime(segment.Start);
  if (isRestDay || isHoliday)
  {
  // كل الساعات في يوم الراحة/الإجازة بمعامل 2×
  if (isRestDay) restDayHours += hours;
  if (isHoliday) holidayHours += hours;
  // الأجر الأساسي لهذه الساعات (سيُضاف معامل 2×)
  decimal basePay = (decimal)hours \* hourlyRate;
  if (isNight)
  {
  // ساعة ليلية في يوم راحة = 1× × 2× × 1.5 = 3×
  // لكن النظام يقول: 2× طوال اليوم + 1.5× إضافية للفترة الليلية
  // أي: معامل الفترة (2×) × معامل الليل (1.5) = 3×
  decimal nightBasePay = basePay; // 1×
  nightPremium += (decimal)hours \* hourlyRate \* (NightFactor - 1m) \* RestDayFactor;
  // الأجر الأساسي للراحة
  overtimePay += basePay \* (RestDayFactor - 1m); // الجزء الإضافي فوق 1×
  nightHours += hours;
  }
  else
  {
  overtimePay += basePay \* (RestDayFactor - 1m);
  }
  }
  else
  {
  // يوم عمل عادي
  double regularRemaining = OfficialDailyHours - regularHours;
  if (regularRemaining > 0)
  {
  double regPortion = Math.Min(hours, regularRemaining);
  regularHours += regPortion;
  if (isNight)
  {
  nightHours += regPortion;
  nightPremium += (decimal)regPortion \* hourlyRate \* (NightFactor - 1m);
  }
  hours -= regPortion;
  }
  // الساعات المتبقية = إضافي
  if (hours > 0)
  {
  // أول ساعتين إضافيتين في اليوم بمعامل 1.5×
  double firstTwoRemaining = 2.0 - firstTwoOT;
  if (firstTwoRemaining > 0)
  {
  double ot1 = Math.Min(hours, firstTwoRemaining);
  firstTwoOT += ot1;
  if (isNight)
  {
  nightHours += ot1;
  // ساعة ليلية عادية = 1× × 1.5، لكن هنا إضافي 1.5×
  // النظام: معامل الليل يضرب في معامل الفترة
  // ساعة إضافية أولى ليلية = 1.5× × 1.5 = 2.25×
  nightPremium += (decimal)ot1 \* hourlyRate \* (NightFactor - 1m) \* FirstTwoOvertimeFactor;
  }
  overtimePay += (decimal)ot1 \* hourlyRate \* (FirstTwoOvertimeFactor - 1m);
  hours -= ot1;
  }
  // ما بعد الساعتين بمعامل 2×
  if (hours > 0)
  {
  extraOT += hours;
  if (isNight)
  {
  nightHours += hours;
  nightPremium += (decimal)hours \* hourlyRate \* (NightFactor - 1m) \* ExtraOvertimeFactor;
  }
  overtimePay += (decimal)hours \* hourlyRate \* (ExtraOvertimeFactor - 1m);
  }
  }
  }
  totalActualHours += hours;
  if (totalActualHours >= MaxActualDailyHours) break;
  }
  if (totalActualHours >= MaxActualDailyHours) break;
  }
  // بدل يوم كامل ليوم الراحة: إذا عمل في يوم الراحة → يوم كامل = 8 ساعات × 2×
  if (isRestDay \&\& restDayHours > 0)
  {
  holidayDayPay = 8m \* hourlyRate \* RestDayFactor;
  }
  return new OvertimeBreakdown(
  regularHours, nightHours,
  firstTwoOT, extraOT,
  restDayHours, holidayHours,
  overtimePay, nightPremium, holidayDayPay);
  }
  // دمج الورديات المتقاطعة أو المتتالية في فترات موحدة
  private static List<(DateTime Start, DateTime End)> MergeShifts(IReadOnlyList<Shift> shifts)
  {
  var sorted = shifts
  .Where(s => s.End > s.Start)
  .OrderBy(s => s.Start)
  .ToList();
  var merged = new List<(DateTime, DateTime)>();
  foreach (var s in sorted)
  {
  if (merged.Count == 0)
  {
  merged.Add((s.Start, s.End));
  }
  else
  {
  var last = merged\[merged.Count - 1];
  if (s.Start <= last.Item2)
  {
  merged\[merged.Count - 1] = (last.Item1, s.End > last.Item2 ? s.End : last.Item2);
  }
  else
  {
  merged.Add((s.Start, s.End));
  }
  }
  }
  return merged;
  }
  // تقسيم فترة على حدود 23:00 و 06:00
  private static IEnumerable<(DateTime Start, DateTime End)> SplitByNightBoundaries(DateTime start, DateTime end)
  {
  var current = start;
  while (current < end)
  {
  // إيجاد أقرب حد ليلي بعد current
  DateTime nextBoundary = GetNextNightBoundary(current);
  if (nextBoundary >= end || nextBoundary <= current)
  {
  yield return (current, end);
  yield break;
  }
  yield return (current, nextBoundary);
  current = nextBoundary;
  }
  }
  // إيجاد أقرب حد ليلي (23:00 أو 06:00) بعد الوقت الحالي
  private static DateTime GetNextNightBoundary(DateTime dt)
  {
  // حدود اليوم: 06:00 و 23:00
  var today6 = dt.Date.AddHours(NightEndHour);
  var today23 = dt.Date.AddHours(NightStartHour);
  var tomorrow6 = dt.Date.AddDays(1).AddHours(NightEndHour);
  if (dt < today6) return today6;
  if (dt < today23) return today23;
  return tomorrow6;
  }
  // التحقق مما إذا كان الوقت ليلاً (بين 23:00 و 06:00)
  private static bool IsNightTime(DateTime dt)
  {
  int hour = dt.Hour;
  return hour >= NightStartHour || hour < NightEndHour;
  }
  // حساب ما إذا كان اليوم يوم راحة أسبوعية أو إجازة رسمية
  public static DayKind DetermineDayKind(DateTime date, IReadOnlySet<DateTime> publicHolidays, DayOfWeek weeklyRestDay)
  {
  if (publicHolidays.Contains(date.Date)) return DayKind.PublicHoliday;
  if (date.DayOfWeek == weeklyRestDay) return DayKind.RestDay;
  return DayKind.Normal;
  }
}
public static class Program
{
  public static void Main()
  {
  Console.OutputEncoding = System.Text.Encoding.UTF8;
  // البيانات الثابتة
  decimal basicMonthlySalary = 6000m;
  decimal hourlyRate = (basicMonthlySalary / 30m) / 8m;
  var publicHolidays = new HashSet<DateTime>
  {
  new DateTime(2026, 9, 23) // اليوم الوطني
  };
  DayOfWeek weeklyRestDay = DayOfWeek.Friday;
  Console.WriteLine("=====================================================");
  Console.WriteLine(" وحدة احتساب بدل العمل الإضافي");
  Console.WriteLine(" وفق نظام العمل السعودي");
  Console.WriteLine("=====================================================");
  Console.WriteLine($"الراتب الأساسي الشهري: {basicMonthlySalary:N2} ريال");
  Console.WriteLine($"أجر الساعة: {hourlyRate:F4} ريال");
  Console.WriteLine($"يوم الراحة الأسبوعية: {weeklyRestDay}");
  Console.WriteLine();
  // ===== المثال 1: يوم عمل عادي (الخميس 2026-09-24) =====
  Console.WriteLine("-----------------------------------------------------");
  Console.WriteLine("المثال 1: يوم عمل عادي - الخميس 2026-09-24");
  Console.WriteLine("-----------------------------------------------------");
  var shifts1 = new List<Shift>
  {
  new Shift(new DateTime(2026, 9, 24, 8, 0, 0), new DateTime(2026, 9, 24, 12, 0, 0)),
  new Shift(new DateTime(2026, 9, 24, 13, 0, 0), new DateTime(2026, 9, 24, 17, 0, 0)),
  new Shift(new DateTime(2026, 9, 24, 18, 0, 0), new DateTime(2026, 9, 24, 23, 30, 0)),
  };
  var result1 = OvertimeCalculator.Calculate(
  shifts1, DayKind.Normal, basicMonthlySalary, publicHolidays, weeklyRestDay);
  PrintBreakdown(result1, hourlyRate);
  // ===== المثال 2: يوم راحة (الجمعة 2026-09-25) =====
  Console.WriteLine();
  Console.WriteLine("-----------------------------------------------------");
  Console.WriteLine("المثال 2: يوم راحة أسبوعية - الجمعة 2026-09-25");
  Console.WriteLine("-----------------------------------------------------");
  var shifts2 = new List<Shift>
  {
  new Shift(new DateTime(2026, 9, 25, 9, 0, 0), new DateTime(2026, 9, 25, 14, 0, 0)),
  };
  var result2 = OvertimeCalculator.Calculate(
  shifts2, DayKind.RestDay, basicMonthlySalary, publicHolidays, weeklyRestDay);
  PrintBreakdown(result2, hourlyRate);
  Console.WriteLine();
  Console.WriteLine("=====================================================");
  Console.WriteLine("ملاحظات:");
  Console.WriteLine("- أول ساعتين إضافيتين: 1.5× | ما بعدهما: 2×");
  Console.WriteLine("- يوم الراحة/الإجازة: 2× طوال اليوم + بدل يوم كامل");
  Console.WriteLine("- الفترة الليلية (23:00-06:00): معامل 1.5× إضافي");
  Console.WriteLine("- الحد الأقصى: 12 ساعة عمل فعلية يومياً");
  Console.WriteLine("=====================================================");
  }
  private static void PrintBreakdown(OvertimeBreakdown b, decimal hourlyRate)
  {
  Console.WriteLine($" الساعات العادية: {b.RegularHours:F2} ساعة");
  Console.WriteLine($" الساعات الليلية: {b.NightHours:F2} ساعة");
  Console.WriteLine($" أول ساعتين إضافيتين: {b.FirstTwoOvertimeHours:F2} ساعة");
  Console.WriteLine($" ساعات إضافية متقدمة: {b.ExtraOvertimeHours:F2} ساعة");
  Console.WriteLine($" ساعات يوم الراحة: {b.RestDayHours:F2} ساعة");
  Console.WriteLine($" ساعات الإجازة الرسمية: {b.HolidayHours:F2} ساعة");
  Console.WriteLine($" ---------------------------------------------");
  Console.WriteLine($" بدل العمل الإضافي: {b.OvertimePay:N2} ريال");
  Console.WriteLine($" بدل العمل الليلي: {b.NightPremium:N2} ريال");
  Console.WriteLine($" بدل يوم الراحة الكامل: {b.HolidayDayPay:N2} ريال");
  Console.WriteLine($" ---------------------------------------------");
  Console.WriteLine($" إجمالي البدلات: {b.OvertimePay + b.NightPremium + b.HolidayDayPay:N2} ريال");
  }
}
شرح المنطق:
1\. تقسيم الورديات على حدود الليل (23:00 و 06:00)
الدالة SplitByNightBoundaries تقسم كل فترة إلى مقاطع بحيث لا يعبر أي مقطع حدود الليل.
هذا يضمن احتساب معامل الليل بدقة.
2\. احتساب الساعات في اليوم العادي
أول 8 ساعات: ساعات عادية (1×).
أول ساعتين إضافيتين: 1.5×.
ما بعد الساعتين: 2×.
إذا وقعت الساعة في الفترة الليلية: يُضاف معامل الليل 1.5× فوق معامل الفترة.
3\. احتساب يوم الراحة/الإجازة
كل الساعات: 2× طوال اليوم.
إذا وقعت في الليل: 2× × 1.5 = 3×.
يُضاف بدل يوم كامل (8 ساعات × 2× = 16 ساعة أجر) كسطر مستقل.
4\. الحد الأقصى
12 ساعة عمل فعلية يومياً، ما فوقها يُهمل.
5\. الحتمية
لا يوجد DateTime.Now، كل التواريخ تُدخل كمعاملات.
النتائج المتوقعة:
المثال 1 (يوم عادي):
8 ساعات عادية (08:00-12:00، 13:00-17:00)
5.5 ساعات إضافية (18:00-23:30)
أول ساعتين: 1.5× (18:00-20:00)
3.5 ساعات: 2× (20:00-23:30)
منها 0.5 ساعة ليلية (23:00-23:30) بمعامل إضافي
المثال 2 (يوم راحة):
5 ساعات × 2× = 10 ساعات أجر
بدل يوم كامل = 16 ساعة أجر
هـGemini
إليك تطبيق الدالة المطلوبة بلغة #C في ملف كامل ومستقل يعمل على المكتبات القياسية فقط، ويطابق كافة القواعد والشروط المحددة لنظام العمل والبيانات المدخلة:
C#
using System;
using System.Collections.Generic;
using System.Linq;
public record Shift(DateTime Start, DateTime End);
public enum DayKind { Normal, RestDay, PublicHoliday }
public record OvertimeBreakdown(
  double RegularHours,
  double NightHours,
  double FirstTwoOvertimeHours,
  double ExtraOvertimeHours,
  double RestDayHours,
  double HolidayHours,
  decimal OvertimePay,
  decimal NightPremium,
  decimal HolidayDayPay);
public static class OvertimeCalculator
{
  private const double MaxDailyHours = 12.0;
  private const double RegularDailyHours = 8.0;
  public static OvertimeBreakdown Calculate(
  IReadOnlyList<Shift> shifts,
  DayKind dayKind,
  decimal basicMonthlySalary,
  IReadOnlySet<DateTime> publicHolidays,
  DayOfWeek weeklyRestDay)
  {
  // 1. حساب أجر الساعة الأساسي: (الأساسي ÷ 30) ÷ 8
  decimal hourlyRate = (basicMonthlySalary / 30m) / (decimal)RegularDailyHours;
  // 2. معالجة وتجميع الفترات الزمنية المتقطعة وتقسيمها على حدود الفترة الليلية (23:00 - 06:00)
  double totalRegularHours = 0;
  double totalNightHours = 0;
  double firstTwoOTHours = 0;
  double extraOTHours = 0;
  double restDayHours = 0;
  double holidayHours = 0;
  decimal overtimePay = 0m;
  decimal nightPremium = 0m;
  decimal holidayDayPay = 0m;
  // تجميع وتصفية الساعات الإضافية لتطبيق الحد الأقصى (12 ساعة عمل فعلية في اليوم)
  double accumulatedHours = 0;
  foreach (var shift in shifts.OrderBy(s => s.Start))
  {
  DateTime current = shift.Start;
  while (current < shift.End)
  {
  // الحد الأقصى اليومي المسموح به هو 12 ساعة
  if (accumulatedHours >= MaxDailyHours) break;
  // التقسيم بساعة كحد أقصى أو حتى نهاية الفترة/حد الساعات الليلية
  DateTime nextBoundary = GetNextBoundary(current, shift.End);
  double chunkHours = (nextBoundary - current).TotalHours;
  // التأكد من عدم تجاوز الحد الأقصى 12 ساعة
  if (accumulatedHours + chunkHours > MaxDailyHours)
  {
  chunkHours = MaxDailyHours - accumulatedHours;
  }
  bool isNight = IsNightHour(current);
  if (dayKind == DayKind.Normal)
  {
  if (accumulatedHours < RegularDailyHours)
  {
  // ساعات عمل عادية
  double regChunk = Math.Min(chunkHours, RegularDailyHours - accumulatedHours);
  double otChunk = chunkHours - regChunk;
  totalRegularHours += regChunk;
  if (isNight) totalNightHours += regChunk;
  if (otChunk > 0)
  {
  ProcessOvertimeChunk(accumulatedHours + regChunk, otChunk, isNight,
  ref firstTwoOTHours, ref extraOTHours, ref totalNightHours);
  }
  }
  else
  {
  // ساعات إضافية بالكامل
  ProcessOvertimeChunk(accumulatedHours, chunkHours, isNight,
  ref firstTwoOTHours, ref extraOTHours, ref totalNightHours);
  }
  }
  else if (dayKind == DayKind.RestDay)
  {
  restDayHours += chunkHours;
  if (isNight) totalNightHours += chunkHours;
  }
  else if (dayKind == DayKind.PublicHoliday)
  {
  holidayHours += chunkHours;
  if (isNight) totalNightHours += chunkHours;
  }
  accumulatedHours += chunkHours;
  current = nextBoundary;
  }
  }
  // 3. حساب المبالغ المالية وفق المعاملات
  if (dayKind == DayKind.Normal)
  {
  // أول ساعتين إضافيتين × 1.5
  decimal firstTwoPay = (decimal)firstTwoOTHours \* hourlyRate \* 1.5m;
  // ما بعد الساعتين الإضافيتين × 2.0
  decimal extraPay = (decimal)extraOTHours \* hourlyRate \* 2.0m;
  overtimePay = firstTwoPay + extraPay;
  }
  else if (dayKind == DayKind.RestDay || dayKind == DayKind.PublicHoliday)
  {
  // ساعات العمل في الراحة الأسبوعية أو العطل الرسمية × 2.0 طوال اليوم
  double totalSpecialHours = dayKind == DayKind.RestDay ? restDayHours : holidayHours;
  overtimePay = (decimal)totalSpecialHours \* hourlyRate \* 2.0m;
  // استحقاق يوم إضافي بأجر يوم كامل (8 ساعات × 2.0) يُضاف كسطر مستقل
  if (totalSpecialHours > 0)
  {
  holidayDayPay = (decimal)RegularDailyHours \* hourlyRate \* 2.0m;
  }
  }
  // علاوة العمل الليلي (معامل 1.5× إضافي يضرب في الأجر الأساسي = 0.5× إضافية كبدل ليل)
  nightPremium = (decimal)totalNightHours \* hourlyRate \* 0.5m;
  return new OvertimeBreakdown(
  RegularHours: totalRegularHours,
  NightHours: totalNightHours,
  FirstTwoOvertimeHours: firstTwoOTHours,
  ExtraOvertimeHours: extraOTHours,
  RestDayHours: restDayHours,
  HolidayHours: holidayHours,
  OvertimePay: Math.Round(overtimePay, 2),
  NightPremium: Math.Round(nightPremium, 2),
  HolidayDayPay: Math.Round(holidayDayPay, 2)
  );
  }
  private static void ProcessOvertimeChunk(
  double currentTotalHours, double chunkHours, bool isNight,
  ref double firstTwoOTHours, ref double extraOTHours, ref double totalNightHours)
  {
  double otOffset = currentTotalHours - RegularDailyHours;
  if (otOffset < 2.0)
  {
  double availableInFirstTwo = 2.0 - otOffset;
  double inFirstTwo = Math.Min(chunkHours, availableInFirstTwo);
  double inExtra = chunkHours - inFirstTwo;
  firstTwoOTHours += inFirstTwo;
  extraOTHours += inExtra;
  }
  else
  {
  extraOTHours += chunkHours;
  }
  if (isNight) totalNightHours += chunkHours;
  }
  private static bool IsNightHour(DateTime time)
  {
  // الفترة الليلية: بين 23:00 و06:00
  int hour = time.Hour;
  return hour >= 23 || hour < 6;
  }
  private static DateTime GetNextBoundary(DateTime current, DateTime end)
  {
  // تقسيم الفترة عند حدود الساعة 23:00 أو 06:00
  DateTime nextHour = current.Date.AddHours(current.Hour + 1);
  DateTime boundary = nextHour > end ? end : nextHour;
  if (current.Hour == 22 \&\& boundary.Hour == 23 \&\& boundary.Minute > 0)
  {
  return current.Date.AddHours(23);
  }
  if (current.Hour == 5 \&\& boundary.Hour == 6 \&\& boundary.Minute > 0)
  {
  return current.Date.AddHours(6);
  }
  return boundary;
  }
}
public class Program
{
  public static void Main()
  {
  decimal basicMonthlySalary = 6000m; // 6000 ريال
  var publicHolidays = new HashSet<DateTime> { new DateTime(2026, 09, 23) };
  DayOfWeek restDay = DayOfWeek.Friday;
  Console.WriteLine("==================================================");
  Console.WriteLine(" نظام احتساب بدل العمل الإضافي (حسب نظام العمل السعودي)");
  Console.WriteLine("==================================================");
  Console.WriteLine($"الراتب الأساسي: {basicMonthlySalary:N2} ريال | أجر الساعة: {((basicMonthlySalary / 30m) / 8m):N2} ريال\\n");
  // --- اختبار اليوم الأول: 2026-09-24 (الخميس - يوم عمل عادي) ---
  var thursdayShifts = new List<Shift>
  {
  new Shift(new DateTime(2026, 09, 24, 08, 00, 00), new DateTime(2026, 09, 24, 12, 00, 00)),
  new Shift(new DateTime(2026, 09, 24, 13, 00, 00), new DateTime(2026, 09, 24, 17, 00, 00)),
  new Shift(new DateTime(2026, 09, 24, 18, 00, 00), new DateTime(2026, 09, 24, 23, 30, 00))
  };
  var resultThursday = OvertimeCalculator.Calculate(
  thursdayShifts, DayKind.Normal, basicMonthlySalary, publicHolidays, restDay);
  PrintBreakdown("2026-09-24 (الخميس - يوم عمل عادي)", resultThursday);
  // --- اختبار اليوم الثاني: 2026-09-25 (الجمعة - يوم راحة أسبوعية) ---
  var fridayShifts = new List<Shift>
  {
  new Shift(new DateTime(2026, 09, 25, 09, 00, 00), new DateTime(2026, 09, 25, 14, 00, 00))
  };
  var resultFriday = OvertimeCalculator.Calculate(
  fridayShifts, DayKind.RestDay, basicMonthlySalary, publicHolidays, restDay);
  PrintBreakdown("2026-09-25 (الجمعة - يوم راحة أسبوعية)", resultFriday);
  }
  private static void PrintBreakdown(string title, OvertimeBreakdown b)
  {
  Console.WriteLine($"--- تفاصيل سجل: {title} ---");
  Console.WriteLine($"ساعات العمل العادية: {b.RegularHours:F2} ساعة");
  Console.WriteLine($"ساعات العمل الليلية (23-06): {b.NightHours:F2} ساعة");
  Console.WriteLine($"أول ساعتين إضافيتين (1.5×): {b.FirstTwoOvertimeHours:F2} ساعة");
  Console.WriteLine($"الساعات الإضافية التالية (2.0×): {b.ExtraOvertimeHours:F2} ساعة");
  Console.WriteLine($"ساعات يوم الراحة/العطلة: {(b.RestDayHours + b.HolidayHours):F2} ساعة");
  Console.WriteLine("--------------------------------------------------");
  Console.WriteLine($"بدل العمل الإضافي (OvertimePay): {b.OvertimePay:N2} ريال");
  Console.WriteLine($"علاوة الفترة الليلية (NightPremium): {b.NightPremium:N2} ريال");
  Console.WriteLine($"بدل اليوم الإضافي الكامل (HolidayPay): {b.HolidayDayPay:N2} ريال");
  Console.WriteLine($"الإجمالي المستحق عن اليوم: {(b.OvertimePay + b.NightPremium + b.HolidayDayPay):N2} ريال\\n");
  }
}