மணிகள் எண்ணி கணக்கீட்டாளர்

Count Hours Calculator

Introduction

Count Hours Calculator என்பது குறிப்பிட்ட வேலைக்கு செலவான மொத்த மணிநேரத்தை கண்டறிய உதவும் ஒரு சக்திவாய்ந்த கருவி. இந்த கணக்கீட்டாளர் திட்ட மேலாண்மை, நேர கண்காணிப்பு மற்றும் உற்பத்தி பகுப்பாய்வு ஆகியவற்றிற்காக முக்கியமாக உள்ளது. ஆரம்ப தேதி, முடிவு தேதி மற்றும் தினசரி வேலை மணிநேரங்களை உள்ளீடு செய்வதன் மூலம், நீங்கள் குறிப்பிட்ட செயல்பாட்டில் முதலீடு செய்யப்பட்ட மொத்த நேரத்தை விரைவாக மற்றும் துல்லியமாக கணக்கிடலாம்.

Formula

மொத்த மணிநேரங்களை கணக்கிடுவதற்கான அடிப்படை சூத்திரம்:

$\text{Total Hours} = \text{Number of Days} \times \text{Daily Hours}$

எங்கு:

• Number of Days என்பது ஆரம்ப மற்றும் முடிவு தேதிகளுக்கு இடையிலான நாட்களின் எண்ணிக்கை (உள்ளடக்கம்)
• Daily Hours என்பது தினசரி வேலை செய்யப்படும் சராசரி மணிநேரங்கள்

இரு தேதிகளுக்கு இடையிலான நாட்களின் எண்ணிக்கையை கணக்கிட, கீழ்காணும் சூத்திரத்தை பயன்படுத்துகிறோம்:

$\text{Number of Days} = \text{End Date} - \text{Start Date} + 1$

1-ஐச் சேர்க்குவதன் மூலம், ஆரம்ப மற்றும் முடிவு தேதிகள் கணக்கீட்டில் உள்ளடக்கப்படுவதை உறுதி செய்கிறது.

Calculation

கணக்கீட்டாளர் மொத்த மணிநேரங்களை கணக்கிடுவதற்கான கீழ்காணும் படிகளை செயல்படுத்துகிறது:

1. ஆரம்ப மற்றும் முடிவு தேதிகளுக்கு இடையிலான நாட்களின் எண்ணிக்கையை (உள்ளடக்கம்) கணக்கிடுங்கள்
2. நாட்களின் எண்ணிக்கையை தினசரி மணிநேரங்களால் பலிக்கவும்
3. வாசிப்புக்கு இரண்டு புள்ளிகளுக்கு அருகிலுள்ள முடிவை சுற்றுங்கள்

Mathematical Analysis and Edge Cases

கணக்கீட்டின் கணித அம்சங்களை ஆழமாக ஆராய்வோம்:

1. தேதியின் மாறுபாட்டை கணக்கிடுதல்: இரண்டு தேதிகளுக்கு இடையிலான நாட்களின் எண்ணிக்கையை கணக்கிட, கீழ்காணும் சூத்திரத்தை பயன்படுத்தலாம்: $\text{Days} = \left\lfloor\frac{\text{End Date} - \text{Start Date}}{86400}\right\rfloor + 1$ 86400 என்பது ஒரு நாளில் உள்ள விநாடிகளின் எண்ணிக்கையாகும், மற்றும் பின்வட்ட செயல்பாடு நமக்கு முழு நாட்களின் எண்ணிக்கையை பெறுவதற்காக உறுதி செய்கிறது.

2. நேர மண்டலங்களை கையாளுதல்: வெவ்வேறு நேர மண்டலங்களை கையாளும்போது, UTC மாற்றத்தை கருத்தில் கொள்ள வேண்டும்: $\text{Adjusted Start} = \text{Start Date} + \text{UTC Offset}_{\text{Start}}$ $\text{Adjusted End} = \text{End Date} + \text{UTC Offset}_{\text{End}}$

3. தினசரி சேமிப்பு நேரம் (DST) சரிசெய்யல்கள்: DST மாற்றங்களின் போது, ஒரு நாளில் 23 அல்லது 25 மணிநேரங்கள் இருக்கலாம். இதற்காக: $\text{Total Hours} = \sum_{i=1}^{n} (\text{Daily Hours} + \text{DST Adjustment}_i)$ எங்கு $\text{DST Adjustment}_i$ என்பது ஒவ்வொரு நாளுக்கும் -1, 0 அல்லது 1 மணிநேரமாகும்.

4. பகுதி நாட்கள்: பகுதி ஆரம்ப மற்றும் முடிவு நாட்களுக்கு: $\text{Total Hours} = (\text{Full Days} \times \text{Daily Hours}) + \text{Start Day Hours} + \text{End Day Hours}$

5. மாறுபட்ட தினசரி மணிநேரங்கள்: தினசரி மணிநேரங்கள் மாறுபட்டால்: $\text{Total Hours} = \sum_{i=1}^{n} \text{Daily Hours}_i$

இந்த சூத்திரங்கள் பல்வேறு எட்ஜ் கேஸ்களை கணக்கில் கொண்டு வருகின்றன மற்றும் கணக்கீட்டின் செயல்முறை பற்றிய முழுமையான புரிதலை வழங்குகின்றன.

Use Cases

Count Hours Calculator பல்வேறு துறைகளில் பல பயன்பாடுகளை கொண்டுள்ளது:

1. திட்ட மேலாண்மை:

   • நிலைமை: ஒரு மென்பொருள் மேம்பாட்டு குழு வெவ்வேறு திட்ட கட்டங்களுக்கான செலவான நேரத்தை கணக்கிட வேண்டும்.
   • தீர்வு: வடிவமைப்பு, குறியீட்டு, சோதனை மற்றும் வெளியீட்டு கட்டங்களில் செலவான மணிநேரங்களை கூட்டுவதற்கு கணக்கீட்டாளரை பயன்படுத்தவும்.

2. சுயதொழில் வேலை:

   • நிலைமை: ஒரு கிராஃபிக் வடிவமைப்பாளர் பல கிளையன்ட் திட்டங்களில் மாறுபட்ட மணிநேர விகிதங்களுடன் வேலை செய்கிறார்.
   • தீர்வு: ஒவ்வொரு திட்டத்திற்கும் மொத்த மணிநேரங்களை கணக்கிடுங்கள், சரியான பில்லிங்கை உறுதி செய்யவும்.

3. ஊழியர் நேர கண்காணிப்பு:

   • நிலைமை: ஒரு உற்பத்தி நிறுவனத்திற்கு மாறுபட்ட வேலை நேரங்களை கணக்கிட வேண்டும்.
   • தீர்வு: ஊழியர்களின் மொத்த மற்றும் மேலதிக மணிநேரங்களை கணக்கிடுவதற்காக கணக்கீட்டாளரை பயன்படுத்தவும்.

4. கல்வி ஆராய்ச்சி:

   • நிலைமை: ஒரு பிஹெச்.டி மாணவர் தனது தேசத்தில் செலவான நேரத்தை கணக்கிடுகிறார்.
   • தீர்வு: இலக்கிய ஆய்வு, பரிசோதனை மற்றும் எழுதுவதற்கான மணிநேரங்களை கணக்கிடுங்கள்.

5. தனிப்பட்ட உற்பத்தி:

   • நிலைமை: ஒரு நபர் தனிப்பட்ட வளர்ச்சி செயல்களில் செலவான நேரத்தை பகுப்பாய்வு செய்ய விரும்புகிறார்.
   • தீர்வு: ஒரு மாதம் முழுவதும் வாசிப்பு, ஆன்லைன் பாடங்கள் மற்றும் திறன் பயிற்சியில் செலவான மணிநேரங்களை கணக்கிடுங்கள்.

6. சுகாதாரம்:

   • நிலைமை: ஒரு மருத்துவமனை வெவ்வேறு பிரிவுகளுக்கான நர்ச் பணியாளர்களின் மணிநேரங்களை கணக்கிட வேண்டும்.
   • தீர்வு: ஒவ்வொரு பிரிவிலும் நர்ச் பணியாளர்களால் வேலை செய்யப்படும் மொத்த மணிநேரங்களை கணக்கிடுவதற்காக கணக்கீட்டாளரை பயன்படுத்தவும்.

7. கட்டிடம்:

   • நிலைமை: ஒரு கட்டிடக் கழகம் பில்லிங் நோக்கத்திற்காக உபகரணங்கள் பயன்படுத்தும் நேரத்தை கணக்கிட வேண்டும்.
   • தீர்வு: ஒவ்வொரு திட்டத்திற்கும் உபகரண செயல்பாட்டின் மொத்த மணிநேரங்களை கணக்கிடுங்கள்.

8. நிகழ்ச்சி திட்டமிடல்:

   • நிலைமை: ஒரு நிகழ்ச்சி திட்டமிடுபவர் பல நாள்கள் நடைபெறும் மாநாட்டிற்கான ஊழியர் மணிநேரங்களை கணக்கிட வேண்டும்.
   • தீர்வு: அமைப்பு, நிகழ்ச்சி காலம் மற்றும் மீள்தொடர்விற்கான மொத்த வேலை மணிநேரங்களை கணக்கிடுவதற்காக கணக்கீட்டாளரை பயன்படுத்தவும்.

Alternatives

Count Hours Calculator பல்வேறு நிலைகளில் பயன்படுவதற்கான பல மாற்று அணுகுமுறைகள் உள்ளன:

1. நேர கண்காணிப்பு மென்பொருள்:

   • எடுத்துக்காட்டுகள்: Toggl, RescueTime, Harvest
   • அம்சங்கள்: நேரம் கண்காணிப்பு, விவரமான அறிக்கைகள், திட்ட மேலாண்மை கருவிகளுடன் ஒருங்கிணைப்புகள்
   • சிறந்தது: விவரமான நேர பகுப்பாய்வுகள் மற்றும் திட்ட அடிப்படையிலான கண்காணிப்புக்கு தேவையான குழுக்கள்

2. பஞ்ச் கிளாக் அமைப்புகள்:

   • எடுத்துக்காட்டுகள்: பாரம்பரிய பஞ்ச் கார்டுகள், டிஜிட்டல் நேரக் கிளாக்கள்
   • அம்சங்கள்: எளிமையான உள்ளீடு/வெளியீடு கண்காணிப்பு, பெரும்பாலும் மாறுபட்ட வேலைகளுக்கு பயன்படுத்தப்படுகிறது
   • சிறந்தது: நிலையான அட்டவணைகள் மற்றும் இடத்தில் உள்ள ஊழியர்களுக்கான வேலைகள்

3. ஆகைல் முறைகள்:

   • எடுத்துக்காட்டுகள்: பொமோடோரோ உத்தி, நேரம்-பிடிப்பு
   • அம்சங்கள்: மொத்த மணிநேரங்களைப் பதிலாக குறிப்பிட்ட இடைவெளிகளில் நேரத்தை நிர்வகிப்பதில் கவனம் செலுத்துகிறது
   • சிறந்தது: உற்பத்தியை மேம்படுத்துவதற்கான மற்றும் சிக்கலான பணிகளை நிர்வகிப்பதற்கான

4. ஸ்பிரெட்‌ஷீட் மாதிரிகள்:

   • எடுத்துக்காட்டுகள்: Excel அல்லது Google Sheets நேர கண்காணிப்பு மாதிரிகள்
   • அம்சங்கள்: தனிப்பயனாக்கக்கூடியது, பகிர்ந்து கொள்ளலாம் மற்றும் கூட்டாக திருத்தலாம்
   • சிறந்தது: கைமுறையாக தரவுகளை உள்ளீடு செய்ய விரும்பும் சிறிய குழுக்கள் அல்லது நபர்களுக்கு

5. மொபைல் செயலிகள்:

   • எடுத்துக்காட்டுகள்: ATracker, Hours Tracker, Timesheet
   • அம்சங்கள்: செல்லும் நேரம் கண்காணிப்பு, பெரும்பாலும் GPS திறன்களுடன்
   • சிறந்தது: செல்லும் பணியாளர்கள் அல்லது பல இடங்களில் நேரத்தை கணக்கிட வேண்டும்

6. நேர கண்காணிப்புடன் கூடிய திட்ட மேலாண்மை கருவிகள்:

   • எடுத்துக்காட்டுகள்: Jira, Asana, Trello நேர கண்காணிப்பு அடிப்படையுடன்
   • அம்சங்கள்: பணியாளர்களின் மேலாண்மை அமைப்புகளில் ஒருங்கிணைந்த நேர கண்காணிப்பு
   • சிறந்தது: திட்ட மேலாண்மை மற்றும் நேர கண்காணிப்பை இணைக்க விரும்பும் குழுக்கள்

ஒவ்வொரு மாற்றத்திற்கும் அதன் பலன்கள் உள்ளன மற்றும் வெவ்வேறு வேலை சூழல்களுக்கும் கணக்கீட்டு தேவைகளுக்கும் ஏற்ப அமைக்கப்பட்டுள்ளது. தேர்வு குழுவின் அளவு, திட்டத்தின் சிக்கலான தன்மை மற்றும் நேரக் கணிப்பில் தேவையான விவரங்கள் போன்ற காரணிகளைக் கொண்டுள்ளது.

History

நேரத்தை கணக்கிடுதல் மற்றும் வேலை மணிநேரங்களை கணக்கிடுவதற்கான கருத்து, தொழிலாளர் சட்டங்கள் மற்றும் திட்ட மேலாண்மை நடைமுறைகளின் வளர்ச்சியுடன் நெருங்கிய தொடர்பில் உள்ளது:

• பழங்கால நாகரிகங்கள் நேரத்தை அளவிடுவதற்காக சூரியக் கால அளவுகள் மற்றும் நீர் கடிகாரங்களைப் பயன்படுத்தின, ஆனால் வேலைக்கான அதிகாரப்பூர்வ நேர கண்காணிப்பு பொதுவாக இல்லை.
• 18வது மற்றும் 19வது நூற்றாண்டுகளில் தொழில்துறை புரட்சி, தொழிற்சாலைகளில் மேலும் துல்லியமான நேர கண்காணிப்புக்கான தேவையை உருவாக்கியது.
• 1913 இல், ஊழியர்களின் மணிநேரங்களை கணக்கிடுவதற்கான முதல் இயந்திர நேரக் கிளாக் IBM மூலம் காப்புரிமை பெற்றது.
• 1938 இல் அமெரிக்காவில் நடைமுறைக்கு வந்த Fair Labor Standards Act, மேலதிக பணிக்கு ஊதியம் வழங்குவதைக் கட்டாயமாக்கியது, இதனால் நிறுவனங்களுக்கு துல்லியமான நேர கணக்கீடு முக்கியமாக மாறியது.
• டிஜிட்டல் யுகம், நேர கண்காணிப்பு மற்றும் மணிநேரக் கணக்கீட்டிற்கான பல மென்பொருள் தீர்வுகளை கொண்டுவரியது, இதனால் செயல்முறை மேலும் திறமையாகவும் துல்லியமாகவும் மாறியது.

இன்று, தொலைதூர வேலை மற்றும் மாறுபட்ட அட்டவணைகளின் வளர்ச்சியுடன், Count Hours Calculator போன்ற கருவிகள், வேலை நேரத்தை திறமையாக நிர்வகிக்க மற்றும் பகுப்பாய்வு செய்ய வேலைதர மற்றும் ஊழியர்களுக்காக மேலும் முக்கியமாக மாறிவருகின்றன.

Examples

இங்கு வெவ்வேறு நிலைகளுக்கான மொத்த மணிநேரங்களை கணக்கிடுவதற்கான சில குறியீட்டு எடுத்துக்காட்டுகள் உள்ளன:

' Excel VBA Function for Calculating Total Hours
Function CalculateTotalHours(startDate As Date, endDate As Date, dailyHours As Double) As Double
    Dim days As Long
    days = DateDiff("d", startDate, endDate) + 1
    CalculateTotalHours = days * dailyHours
End Function

' Usage:
' =CalculateTotalHours(A1, B1, C1)

from datetime import datetime, timedelta

def calculate_total_hours(start_date, end_date, daily_hours):
    date_format = "%Y-%m-%d"
    start = datetime.strptime(start_date, date_format)
    end = datetime.strptime(end_date, date_format)
    days = (end - start).days + 1
    return days * daily_hours

## Example usage:
start_date = "2023-01-01"
end_date = "2023-01-10"
daily_hours = 8

total_hours = calculate_total_hours(start_date, end_date, daily_hours)
print(f"Total Hours: {total_hours:.2f}")

function calculateTotalHours(startDate, endDate, dailyHours) {
  const start = new Date(startDate);
  const end = new Date(endDate);
  const days = (end - start) / (1000 * 60 * 60 * 24) + 1;
  return days * dailyHours;
}

// Example usage:
const startDate = '2023-01-01';
const endDate = '2023-01-10';
const dailyHours = 8;

const totalHours = calculateTotalHours(startDate, endDate, dailyHours);
console.log(`Total Hours: ${totalHours.toFixed(2)}`);

import java.time.LocalDate;
import java.time.temporal.ChronoUnit;

public class HourCalculator {
    public static double calculateTotalHours(LocalDate startDate, LocalDate endDate, double dailyHours) {
        long days = ChronoUnit.DAYS.between(startDate, endDate) + 1;
        return days * dailyHours;
    }

    public static void main(String[] args) {
        LocalDate startDate = LocalDate.of(2023, 1, 1);
        LocalDate endDate = LocalDate.of(2023, 1, 10);
        double dailyHours = 8.0;

        double totalHours = calculateTotalHours(startDate, endDate, dailyHours);
        System.out.printf("Total Hours: %.2f%n", totalHours);
    }
}

calculate_total_hours <- function(start_date, end_date, daily_hours) {
  start <- as.Date(start_date)
  end <- as.Date(end_date)
  days <- as.numeric(difftime(end, start, units = "days")) + 1
  total_hours <- days * daily_hours
  return(total_hours)
}

## Example usage:
start_date <- "2023-01-01"
end_date <- "2023-01-10"
daily_hours <- 8

total_hours <- calculate_total_hours(start_date, end_date, daily_hours)
cat(sprintf("Total Hours: %.2f\n", total_hours))

function totalHours = calculateTotalHours(startDate, endDate, dailyHours)
    startDateNum = datenum(startDate);
    endDateNum = datenum(endDate);
    days = endDateNum - startDateNum + 1;
    totalHours = days * dailyHours;
end

% Example usage:
startDate = '2023-01-01';
endDate = '2023-01-10';
dailyHours = 8;

totalHours = calculateTotalHours(startDate, endDate, dailyHours);
fprintf('Total Hours: %.2f\n', totalHours);

#include <iostream>
#include <ctime>
#include <string>
#include <iomanip>

double calculateTotalHours(const std::string& startDate, const std::string& endDate, double dailyHours) {
    std::tm start = {}, end = {};
    std::istringstream ss_start(startDate);
    std::istringstream ss_end(endDate);
    ss_start >> std::get_time(&start, "%Y-%m-%d");
    ss_end >> std::get_time(&end, "%Y-%m-%d");
    
    std::time_t start_time = std::mktime(&start);
    std::time_t end_time = std::mktime(&end);
    
    double days = std::difftime(end_time, start_time) / (60 * 60 * 24) + 1;
    return days * dailyHours;
}

int main() {
    std::string startDate = "2023-01-01";
    std::string endDate = "2023-01-10";
    double dailyHours = 8.0;
    
    double totalHours = calculateTotalHours(startDate, endDate, dailyHours);
    std::cout << "Total Hours: " << std::fixed << std::setprecision(2) << totalHours << std::endl;
    
    return 0;
}

require 'date'

def calculate_total_hours(start_date, end_date, daily_hours)
  start = Date.parse(start_date)
  end_date = Date.parse(end_date)
  days = (end_date - start).to_i + 1
  days * daily_hours
end

## Example usage:
start_date = "2023-01-01"
end_date = "2023-01-10"
daily_hours = 8

total_hours = calculate_total_hours(start_date, end_date, daily_hours)
puts "Total Hours: #{total_hours.round(2)}"

<?php

function calculateTotalHours($startDate, $endDate, $dailyHours) {
    $start = new DateTime($startDate);
    $end = new DateTime($endDate);
    $days = $end->diff($start)->days + 1;
    return $days * $dailyHours;
}

// Example usage:
$startDate = '2023-01-01';
$endDate = '2023-01-10';
$dailyHours = 8;

$totalHours = calculateTotalHours($startDate, $endDate, $dailyHours);
echo "Total Hours: " . number_format($totalHours, 2);

?>

use chrono::NaiveDate;

fn calculate_total_hours(start_date: &str, end_date: &str, daily_hours: f64) -> f64 {
    let start = NaiveDate::parse_from_str(start_date, "%Y-%m-%d").unwrap();
    let end = NaiveDate::parse_from_str(end_date, "%Y-%m-%d").unwrap();
    let days = (end - start).num_days() + 1;
    days as f64 * daily_hours
}

fn main() {
    let start_date = "2023-01-01";
    let end_date = "2023-01-10";
    let daily_hours = 8.0;

    let total_hours = calculate_total_hours(start_date, end_date, daily_hours);
    println!("Total Hours: {:.2}", total_hours);
}

using System;

class HourCalculator
{
    static double CalculateTotalHours(DateTime startDate, DateTime endDate, double dailyHours)
    {
        int days = (endDate - startDate).Days + 1;
        return days * dailyHours;
    }

    static void Main()
    {
        DateTime startDate = new DateTime(2023, 1, 1);
        DateTime endDate = new DateTime(2023, 1, 10);
        double dailyHours = 8.0;

        double totalHours = CalculateTotalHours(startDate, endDate, dailyHours);
        Console.WriteLine($"Total Hours: {totalHours:F2}");
    }
}

package main

import (
    "fmt"
    "time"
)

func calculateTotalHours(startDate, endDate string, dailyHours float64) float64 {
    start, _ := time.Parse("2006-01-02", startDate)
    end, _ := time.Parse("2006-01-02", endDate)
    days := end.Sub(start).Hours()/24 + 1
    return days * dailyHours
}

func main() {
    startDate := "2023-01-01"
    endDate := "2023-01-10"
    dailyHours := 8.0

    totalHours := calculateTotalHours(startDate, endDate, dailyHours)
    fmt.Printf("Total Hours: %.2f\n", totalHours)
}

import Foundation

func calculateTotalHours(startDate: String, endDate: String, dailyHours: Double) -> Double {
    let dateFormatter = DateFormatter()
    dateFormatter.dateFormat = "yyyy-MM-dd"
    
    guard let start = dateFormatter.date(from: startDate),
          let end = dateFormatter.date(from: endDate) else {
        return 0
    }
    
    let days = Calendar.current.dateComponents([.day], from: start, to: end).day! + 1
    return Double(days) * dailyHours
}

// Example usage:
let startDate = "2023-01-01"
let endDate = "2023-01-10"
let dailyHours = 8.0

let totalHours = calculateTotalHours(startDate: startDate, endDate: endDate, dailyHours: dailyHours)
print(String(format: "Total Hours: %.2f", totalHours))

-- SQL function to calculate total hours
CREATE FUNCTION calculate_total_hours(
    start_date DATE,
    end_date DATE,
    daily_hours DECIMAL(5,2)
) RETURNS DECIMAL(10,2) AS $$
BEGIN
    RETURN (end_date - start_date + 1) * daily_hours;
END;
$$ LANGUAGE plpgsql;

-- Example usage:
SELECT calculate_total_hours('2023-01-01', '2023-01-10', 8.0) AS total_hours;

இந்த எடுத்துக்காட்டுகள் வெவ்வேறு நிரலாக்க மொழிகளைப் பயன்படுத்தி மொத்த மணிநேரங்களை கணக்கிடுவதைக் காட்டுகின்றன. நீங்கள் இந்த செயல்பாடுகளை உங்கள் குறிப்பிட்ட தேவைகளுக்கேற்ப மாற்றலாம் அல்லது பெரிய நேர கண்காணிப்பு அமைப்புகளில் ஒருங்கிணைக்கலாம்.

Numerical Examples

1. தரநிலையிலான வேலை வாரம்:

   • ஆரம்ப தேதி: 2023-01-02 (திங்கட்கிழமை)
   • முடிவு தேதி: 2023-01-06 (வெள்ளிக்கிழமை)
   • தினசரி மணிநேரங்கள்: 8
   • மொத்த மணிநேரங்கள்: 5 நாட்கள் * 8 மணிநேரங்கள் = 40 மணிநேரங்கள்

2. இரண்டு வார திட்டம்:

   • ஆரம்ப தேதி: 2023-01-01 (ஞாயிறு)
   • முடிவு தேதி: 2023-01-14 (சனிக்கிழமை)
   • தினசரி மணிநேரங்கள்: 6
   • மொத்த மணிநேரங்கள்: 14 நாட்கள் * 6 மணிநேரங்கள் = 84 மணிநேரங்கள்

3. மாதம் முழுவதும் உள்ள வேலை:

   • ஆரம்ப தேதி: 2023-02-01
   • முடிவு தேதி: 2023-02-28
   • தினசரி மணிநேரங்கள்: 4.5
   • மொத்த மணிநேரங்கள்: 28 நாட்கள் * 4.5 மணிநேரங்கள் = 126 மணிநேரங்கள்

4. பகுதி நாள் வேலை:

   • ஆரம்ப தேதி: 2023-03-15
   • முடிவு தேதி: 2023-03-15
   • தினசரி மணிநேரங்கள்: 3.5
   • மொத்த மணிநேரங்கள்: 1 நாள் * 3.5 மணிநேரங்கள் = 3.5 மணிநேரங்கள்

5. வேலை வாரம் மற்றும் விடுமுறை:

   • ஆரம்ப தேதி: 2023-03-20 (திங்கட்கிழமை)
   • முடிவு தேதி: 2023-03-26 (ஞாயிறு)
   • தினசரி மணிநேரங்கள்: 8 (வேலை நாட்கள் மட்டுமே)
   • மொத்த மணிநேரங்கள்: 5 நாட்கள் * 8 மணிநேரங்கள் = 40 மணிநேரங்கள் (சனிக்கிழமை மற்றும் ஞாயிற்றுக்கிழமை தவிர)

குறிப்பு: இந்த எடுத்துக்காட்டு கணக்கீட்டாளர் விடுமுறை நாட்களை கணக்கில் எடுக்காது என்று கருதுகிறது. நடைமுறையில், கணக்கீட்டாளர் விடுமுறை மற்றும் விடுமுறை நாட்களை தவிர்க்க கூடுதல் உத்திகளைச் சேர்க்க வேண்டும்.

References

1. "Time Tracking." Wikipedia, Wikimedia Foundation, https://en.wikipedia.org/wiki/Time_tracking. Accessed 13 Sep. 2024.
2. "Project Management Institute." PMI, https://www.pmi.org/. Accessed 13 Sep. 2024.
3. Macan, Therese HoffMacan. "Time management: Test of a process model." Journal of applied psychology 79.3 (1994): 381.
4. "Fair Labor Standards Act of 1938." United States Department of Labor, https://www.dol.gov/agencies/whd/flsa. Accessed 13 Sep. 2024.

Time (Days) Hours

Start Date End Date

Daily Hours

Total Hours