fork download
copy 
  1. //********************************************************
  2. //
  3. // Assignment 8 - Structures and Strings and Pointers
  4. //
  5. // Name: Andrea Huskey
  6. //
  7. // Class: C Programming, Summer 2026
  8. //
  9. // Date: July 18, 2026
  10. //
  11. // Description: Program which determines overtime and
  12. // gross pay for a set of employees with outputs sent
  13. // to standard output (the screen).
  14. //
  15. // This assignment also adds the employee name, their tax state,
  16. // and calculates the state tax, federal tax, and net pay. It
  17. // also calculates totals, averages, minimum, and maximum values.
  18. //
  19. // Dynamically allocated linked list version
  20. //
  21. // Call by Reference design (using pointers)
  22. //
  23. //********************************************************
  24.  
  25. #include <stdio.h>
  26. #include <string.h>
  27. #include <ctype.h>
  28. #include <stdlib.h>
  29.  
  30. #define SIZE 5
  31. #define STD_HOURS 40.0
  32. #define OT_RATE 1.5
  33. #define MA_TAX_RATE 0.05
  34. #define NH_TAX_RATE 0.0
  35. #define VT_TAX_RATE 0.06
  36. #define CA_TAX_RATE 0.07
  37. #define DEFAULT_TAX_RATE 0.08
  38. #define TAX_STATE_SIZE 3
  39. #define FED_TAX_RATE 0.25
  40. #define FIRST_NAME_SIZE 20
  41. #define LAST_NAME_SIZE 20
  42.  
  43. struct name
  44. {
  45.     char firstName[FIRST_NAME_SIZE];
  46.     char lastName[LAST_NAME_SIZE];
  47. };
  48.  
  49. struct employee
  50. {
  51.     struct name empName;
  52.     char taxState[TAX_STATE_SIZE];
  53.     long int clockNumber;
  54.     float wageRate;
  55.     float hours;
  56.     float overtimeHrs;
  57.     float grossPay;
  58.     float stateTax;
  59.     float fedTax;
  60.     float netPay;
  61.     struct employee *next;
  62. };
  63.  
  64. struct totals
  65. {
  66.     float total_wageRate;
  67.     float total_hours;
  68.     float total_overtimeHrs;
  69.     float total_grossPay;
  70.     float total_stateTax;
  71.     float total_fedTax;
  72.     float total_netPay;
  73. };
  74.  
  75. struct min_max
  76. {
  77.     float min_wageRate;
  78.     float min_hours;
  79.     float min_overtimeHrs;
  80.     float min_grossPay;
  81.     float min_stateTax;
  82.     float min_fedTax;
  83.     float min_netPay;
  84.     float max_wageRate;
  85.     float max_hours;
  86.     float max_overtimeHrs;
  87.     float max_grossPay;
  88.     float max_stateTax;
  89.     float max_fedTax;
  90.     float max_netPay;
  91. };
  92.  
  93. struct employee *getEmpData(int theSize);
  94. void printEmp(struct employee *emp_ptr);
  95.  
  96. void calcOvertimeHrs(struct employee *emp_ptr);
  97. void calcGrossPay(struct employee *emp_ptr);
  98. void calcStateTax(struct employee *emp_ptr);
  99. void calcFedTax(struct employee *emp_ptr);
  100. void calcNetPay(struct employee *emp_ptr);
  101.  
  102. void calcEmployeeTotals(struct employee *emp_ptr,
  103.                         struct totals *emp_totals_ptr);
  104.  
  105. void calcEmployeeMinMax(struct employee *emp_ptr,
  106.                         struct min_max *emp_MinMax_ptr);
  107.  
  108. void printHeader(void);
  109. void printEmpStatistics(struct totals *employeeTotals_ptr,
  110.                         struct min_max *employeeMinMax_ptr,
  111.                         int theSize);
  112.  
  113. int main()
  114. {
  115.     struct employee *head_ptr = NULL;
  116.     struct employee *free_ptr = NULL;
  117.  
  118.     struct totals employeeTotals = {0, 0, 0, 0, 0, 0, 0};
  119.     struct totals *emp_totals_ptr = &employeeTotals;
  120.  
  121.     struct min_max employeeMinMax = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
  122.     struct min_max *employeeMinMax_ptr = &employeeMinMax;
  123.  
  124.     head_ptr = getEmpData(SIZE);
  125.  
  126.     calcOvertimeHrs(head_ptr);
  127.     calcGrossPay(head_ptr);
  128.     calcStateTax(head_ptr);
  129.     calcFedTax(head_ptr);
  130.     calcNetPay(head_ptr);
  131.  
  132.     calcEmployeeTotals(head_ptr, emp_totals_ptr);
  133.     calcEmployeeMinMax(head_ptr, employeeMinMax_ptr);
  134.  
  135.     printHeader();
  136.     printEmp(head_ptr);
  137.     printEmpStatistics(emp_totals_ptr, employeeMinMax_ptr, SIZE);
  138.  
  139.     while (head_ptr != NULL)
  140.     {
  141.         free_ptr = head_ptr;
  142.         head_ptr = head_ptr->next;
  143.         free(free_ptr);
  144.     }
  145.  
  146.     return 0;
  147. }
  148.  
  149. struct employee *getEmpData(int theSize)
  150. {
  151.     struct employee *head_ptr = NULL;
  152.     struct employee *tail_ptr = NULL;
  153.     struct employee *emp_ptr = NULL;
  154.     int i;
  155.  
  156.     for (i = 0; i < theSize; ++i)
  157.     {
  158.         emp_ptr = (struct employee *)malloc(sizeof(struct employee));
  159.         if (emp_ptr == NULL)
  160.         {
  161.             printf("Memory allocation failed.\n");
  162.             return head_ptr;
  163.         }
  164.  
  165.         printf("Enter first name: ");
  166.         scanf("%19s", emp_ptr->empName.firstName);
  167.  
  168.         printf("Enter last name: ");
  169.         scanf("%19s", emp_ptr->empName.lastName);
  170.  
  171.         printf("Enter tax state: ");
  172.         scanf("%2s", emp_ptr->taxState);
  173.  
  174.         printf("Enter clock number: ");
  175.         scanf("%ld", &emp_ptr->clockNumber);
  176.  
  177.         printf("Enter wage rate: ");
  178.         scanf("%f", &emp_ptr->wageRate);
  179.  
  180.         printf("Enter hours worked: ");
  181.         scanf("%f", &emp_ptr->hours);
  182.  
  183.         emp_ptr->overtimeHrs = 0;
  184.         emp_ptr->grossPay = 0;
  185.         emp_ptr->stateTax = 0;
  186.         emp_ptr->fedTax = 0;
  187.         emp_ptr->netPay = 0;
  188.         emp_ptr->next = NULL;
  189.  
  190.         if (head_ptr == NULL)
  191.         {
  192.             head_ptr = emp_ptr;
  193.             tail_ptr = emp_ptr;
  194.         }
  195.         else
  196.         {
  197.             tail_ptr->next = emp_ptr;
  198.             tail_ptr = emp_ptr;
  199.         }
  200.     }
  201.  
  202.     return head_ptr;
  203. }
  204.  
  205. void printHeader(void)
  206. {
  207.     printf("\n\n*** Pay Calculator ***\n");
  208.     printf("\n---------------------------------------------------------------------------------");
  209.     printf("\nName                Tax  Clock#  Wage   Hours  OT   Gross   State  Fed      Net");
  210.     printf("\n                    State                           Pay     Tax    Tax      Pay");
  211.     printf("\n---------------------------------------------------------------------------------");
  212. }
  213.  
  214. void printEmp(struct employee *emp_ptr)
  215. {
  216.     char name[FIRST_NAME_SIZE + LAST_NAME_SIZE + 2];
  217.  
  218.     while (emp_ptr != NULL)
  219.     {
  220.         snprintf(name, sizeof(name), "%s %s", emp_ptr->empName.firstName, emp_ptr->empName.lastName);
  221.         printf("\n%-20.20s %-2s  %06ld  %5.2f  %4.1f  %4.1f  %7.2f  %6.2f  %7.2f  %8.2f",
  222.                name, emp_ptr->taxState, emp_ptr->clockNumber,
  223.                emp_ptr->wageRate, emp_ptr->hours, emp_ptr->overtimeHrs,
  224.                emp_ptr->grossPay, emp_ptr->stateTax,
  225.                emp_ptr->fedTax, emp_ptr->netPay);
  226.         emp_ptr = emp_ptr->next;
  227.     }
  228. }
  229.  
  230. void printEmpStatistics(struct totals *employeeTotals_ptr,
  231.                         struct min_max *employeeMinMax_ptr,
  232.                         int theSize)
  233. {
  234.     printf("\n---------------------------------------------------------------------------------");
  235.  
  236.     printf("\nTotals:                          %5.2f %5.1f %5.1f %7.2f %6.2f %7.2f %8.2f",
  237.            employeeTotals_ptr->total_wageRate,
  238.            employeeTotals_ptr->total_hours,
  239.            employeeTotals_ptr->total_overtimeHrs,
  240.            employeeTotals_ptr->total_grossPay,
  241.            employeeTotals_ptr->total_stateTax,
  242.            employeeTotals_ptr->total_fedTax,
  243.            employeeTotals_ptr->total_netPay);
  244.  
  245.     printf("\nAverages:                        %5.2f %5.1f %5.1f %7.2f %6.2f %7.2f %8.2f",
  246.            employeeTotals_ptr->total_wageRate / theSize,
  247.            employeeTotals_ptr->total_hours / theSize,
  248.            employeeTotals_ptr->total_overtimeHrs / theSize,
  249.            employeeTotals_ptr->total_grossPay / theSize,
  250.            employeeTotals_ptr->total_stateTax / theSize,
  251.            employeeTotals_ptr->total_fedTax / theSize,
  252.            employeeTotals_ptr->total_netPay / theSize);
  253.  
  254.     printf("\nMinimum:                         %5.2f %5.1f %5.1f %7.2f %6.2f %7.2f %8.2f",
  255.            employeeMinMax_ptr->min_wageRate,
  256.            employeeMinMax_ptr->min_hours,
  257.            employeeMinMax_ptr->min_overtimeHrs,
  258.            employeeMinMax_ptr->min_grossPay,
  259.            employeeMinMax_ptr->min_stateTax,
  260.            employeeMinMax_ptr->min_fedTax,
  261.            employeeMinMax_ptr->min_netPay);
  262.  
  263.     printf("\nMaximum:                         %5.2f %5.1f %5.1f %7.2f %6.2f %7.2f %8.2f",
  264.            employeeMinMax_ptr->max_wageRate,
  265.            employeeMinMax_ptr->max_hours,
  266.            employeeMinMax_ptr->max_overtimeHrs,
  267.            employeeMinMax_ptr->max_grossPay,
  268.            employeeMinMax_ptr->max_stateTax,
  269.            employeeMinMax_ptr->max_fedTax,
  270.            employeeMinMax_ptr->max_netPay);
  271. }
  272.  
  273. void calcOvertimeHrs(struct employee *emp_ptr)
  274. {
  275.     while (emp_ptr != NULL)
  276.     {
  277.         emp_ptr->overtimeHrs = (emp_ptr->hours > STD_HOURS) ? (emp_ptr->hours - STD_HOURS) : 0;
  278.         emp_ptr = emp_ptr->next;
  279.     }
  280. }
  281.  
  282. void calcGrossPay(struct employee *emp_ptr)
  283. {
  284.     while (emp_ptr != NULL)
  285.     {
  286.         emp_ptr->grossPay = (emp_ptr->wageRate * emp_ptr->hours) + (emp_ptr->overtimeHrs * emp_ptr->wageRate * 0.5f);
  287.         emp_ptr = emp_ptr->next;
  288.     }
  289. }
  290.  
  291. void calcStateTax(struct employee *emp_ptr)
  292. {
  293.     while (emp_ptr != NULL)
  294.     {
  295.         if (strcmp(emp_ptr->taxState, "MA") == 0)
  296.             emp_ptr->stateTax = emp_ptr->grossPay * MA_TAX_RATE;
  297.         else if (strcmp(emp_ptr->taxState, "NH") == 0)
  298.             emp_ptr->stateTax = emp_ptr->grossPay * NH_TAX_RATE;
  299.         else if (strcmp(emp_ptr->taxState, "VT") == 0)
  300.             emp_ptr->stateTax = emp_ptr->grossPay * VT_TAX_RATE;
  301.         else if (strcmp(emp_ptr->taxState, "CA") == 0)
  302.             emp_ptr->stateTax = emp_ptr->grossPay * CA_TAX_RATE;
  303.         else
  304.             emp_ptr->stateTax = emp_ptr->grossPay * DEFAULT_TAX_RATE;
  305.  
  306.         emp_ptr = emp_ptr->next;
  307.     }
  308. }
  309.  
  310. void calcFedTax(struct employee *emp_ptr)
  311. {
  312.     while (emp_ptr != NULL)
  313.     {
  314.         emp_ptr->fedTax = emp_ptr->grossPay * FED_TAX_RATE;
  315.         emp_ptr = emp_ptr->next;
  316.     }
  317. }
  318.  
  319. void calcNetPay(struct employee *emp_ptr)
  320. {
  321.     while (emp_ptr != NULL)
  322.     {
  323.         emp_ptr->netPay = emp_ptr->grossPay - emp_ptr->stateTax - emp_ptr->fedTax;
  324.         emp_ptr = emp_ptr->next;
  325.     }
  326. }
  327.  
  328. void calcEmployeeTotals(struct employee *emp_ptr,
  329.                         struct totals *emp_totals_ptr)
  330. {
  331.     while (emp_ptr != NULL)
  332.     {
  333.         emp_totals_ptr->total_wageRate += emp_ptr->wageRate;
  334.         emp_totals_ptr->total_hours += emp_ptr->hours;
  335.         emp_totals_ptr->total_overtimeHrs += emp_ptr->overtimeHrs;
  336.         emp_totals_ptr->total_grossPay += emp_ptr->grossPay;
  337.         emp_totals_ptr->total_stateTax += emp_ptr->stateTax;
  338.         emp_totals_ptr->total_fedTax += emp_ptr->fedTax;
  339.         emp_totals_ptr->total_netPay += emp_ptr->netPay;
  340.         emp_ptr = emp_ptr->next;
  341.     }
  342. }
  343.  
  344. void calcEmployeeMinMax(struct employee *emp_ptr,
  345.                         struct min_max *emp_minMax_ptr)
  346. {
  347.     if (emp_ptr == NULL) return;
  348.  
  349.     emp_minMax_ptr->min_wageRate = emp_ptr->wageRate;
  350.     emp_minMax_ptr->min_hours = emp_ptr->hours;
  351.     emp_minMax_ptr->min_overtimeHrs = emp_ptr->overtimeHrs;
  352.     emp_minMax_ptr->min_grossPay = emp_ptr->grossPay;
  353.     emp_minMax_ptr->min_stateTax = emp_ptr->stateTax;
  354.     emp_minMax_ptr->min_fedTax = emp_ptr->fedTax;
  355.     emp_minMax_ptr->min_netPay = emp_ptr->netPay;
  356.  
  357.     emp_minMax_ptr->max_wageRate = emp_ptr->wageRate;
  358.     emp_minMax_ptr->max_hours = emp_ptr->hours;
  359.     emp_minMax_ptr->max_overtimeHrs = emp_ptr->overtimeHrs;
  360.     emp_minMax_ptr->max_grossPay = emp_ptr->grossPay;
  361.     emp_minMax_ptr->max_stateTax = emp_ptr->stateTax;
  362.     emp_minMax_ptr->max_fedTax = emp_ptr->fedTax;
  363.     emp_minMax_ptr->max_netPay = emp_ptr->netPay;
  364.  
  365.     emp_ptr = emp_ptr->next;
  366.  
  367.     while (emp_ptr != NULL)
  368.     {
  369.         if (emp_ptr->wageRate < emp_minMax_ptr->min_wageRate) emp_minMax_ptr->min_wageRate = emp_ptr->wageRate;
  370.         if (emp_ptr->hours < emp_minMax_ptr->min_hours) emp_minMax_ptr->min_hours = emp_ptr->hours;
  371.         if (emp_ptr->overtimeHrs < emp_minMax_ptr->min_overtimeHrs) emp_minMax_ptr->min_overtimeHrs = emp_ptr->overtimeHrs;
  372.         if (emp_ptr->grossPay < emp_minMax_ptr->min_grossPay) emp_minMax_ptr->min_grossPay = emp_ptr->grossPay;
  373.         if (emp_ptr->stateTax < emp_minMax_ptr->min_stateTax) emp_minMax_ptr->min_stateTax = emp_ptr->stateTax;
  374.         if (emp_ptr->fedTax < emp_minMax_ptr->min_fedTax) emp_minMax_ptr->min_fedTax = emp_ptr->fedTax;
  375.         if (emp_ptr->netPay < emp_minMax_ptr->min_netPay) emp_minMax_ptr->min_netPay = emp_ptr->netPay;
  376.  
  377.         if (emp_ptr->wageRate > emp_minMax_ptr->max_wageRate) emp_minMax_ptr->max_wageRate = emp_ptr->wageRate;
  378.         if (emp_ptr->hours > emp_minMax_ptr->max_hours) emp_minMax_ptr->max_hours = emp_ptr->hours;
  379.         if (emp_ptr->overtimeHrs > emp_minMax_ptr->max_overtimeHrs) emp_minMax_ptr->max_overtimeHrs = emp_ptr->overtimeHrs;
  380.         if (emp_ptr->grossPay > emp_minMax_ptr->max_grossPay) emp_minMax_ptr->max_grossPay = emp_ptr->grossPay;
  381.         if (emp_ptr->stateTax > emp_minMax_ptr->max_stateTax) emp_minMax_ptr->max_stateTax = emp_ptr->stateTax;
  382.         if (emp_ptr->fedTax > emp_minMax_ptr->max_fedTax) emp_minMax_ptr->max_fedTax = emp_ptr->fedTax;
  383.         if (emp_ptr->netPay > emp_minMax_ptr->max_netPay) emp_minMax_ptr->max_netPay = emp_ptr->netPay;
  384.  
  385.         emp_ptr = emp_ptr->next;
  386.     }
  387. }
Success #stdin #stdout 0s 5316KB
comments (?)
stdin
copy 
Connie
Cobol
MA
98401
10.60
51.0
Y
Mary
Apl
NH
526488
9.75
42.5
Y
Frank
Fortran
VT
765349
10.50
37.0
Y
Jeff
Ada
NY
34645
12.25
45
Y
Anton
Pascal
CA
127615
8.35
40.0
N
stdout
copy 
Enter first name: Enter last name: Enter tax state: Enter clock number: Enter wage rate: Enter hours worked: Enter first name: Enter last name: Enter tax state: Enter clock number: Enter wage rate: Enter hours worked: Enter first name: Enter last name: Enter tax state: Enter clock number: Enter wage rate: Enter hours worked: Enter first name: Enter last name: Enter tax state: Enter clock number: Enter wage rate: Enter hours worked: Enter first name: Enter last name: Enter tax state: Enter clock number: Enter wage rate: Enter hours worked: 

*** Pay Calculator ***

---------------------------------------------------------------------------------
Name                Tax  Clock#  Wage   Hours  OT   Gross   State  Fed      Net
                    State                           Pay     Tax    Tax      Pay
---------------------------------------------------------------------------------
Connie Cobol         MA  098401  10.60  51.0  11.0   598.90   29.95   149.73    419.23
Y Mary               Ap  000000   0.00   0.0   0.0     0.00    0.00     0.00      0.00
l NH                 52  006488   9.75  42.5   2.5   426.56   34.12   106.64    285.80
Y Frank              Fo  000000   0.00   0.0   0.0     0.00    0.00     0.00      0.00
rtran VT             76  005349  10.50  37.0   0.0   388.50   31.08    97.12    260.30
---------------------------------------------------------------------------------
Totals:                          30.85 130.5  13.5 1413.96  95.15  353.49   965.32
Averages:                         6.17  26.1   2.7  282.79  19.03   70.70   193.06
Minimum:                          0.00   0.0   0.0    0.00   0.00    0.00     0.00
Maximum:                         10.60  51.0  11.0  598.90  34.12  149.73   419.23
https://ideone.com/xVzVb9
language:
C (gcc 8.3)
created:
3 hours ago
visibility:
public

Share or Embed source code

Discover > Sphere Engine API

The brand new service which powers Ideone!

Discover > IDE Widget

Widget for compiling and running the source code in a web browser!