Lifeguards

#include <bits/stdc++.h>
using namespace std;
 
int32_t main() {
 
	freopen("lifeguards.in", "r", stdin);
	freopen("lifeguards.out", "w", stdout);
 
	int cows;
	cin >> cows;
	int startT[cows];
	int endT[cows];
	int times[1000];
	int shiftTotal = -1;
 
	for (int q = 0; q < 1000; q++) { times[q] = 0; }
	for (int c = 0; c < cows; c++) {
		cin >> startT[c] >> endT[c];
		for (int k = startT[c]; k < endT[c]; k++) { times[k]++; }
	}
 
	for (int i = 0; i < cows; i++) {
		for (int t = startT[i]; t < endT[i]; t++) { times[t]--; }
 
		int covered = 0;
		for (int t = 0; t < 1000; t++) {
			if (times[t] > 0) { covered++; }
		}
		shiftTotal = max(shiftTotal, covered);
 
		for (int t = startT[i]; t < endT[i]; t++) { times[t]++; }
	}
 
	cout << shiftTotal;
}

import java.io.*;
import java.util.*;
 
public class Lifeguards {
	public static void main(String[] args) throws IOException {
		PrintWriter pw = new PrintWriter(new File("lifeguards.out"));
		BufferedReader br =
		    new BufferedReader(new FileReader(new File("lifeguards.in")));
		StringTokenizer st;
 
		int cows = Integer.parseInt(br.readLine());
		int[] startT = new int[cows];
		int[] endT = new int[cows];
		int[] times = new int[1000];
		int shiftTotal = -1;
 
		for (int c = 0; c < cows; c++) {
			st = new StringTokenizer(br.readLine());
			startT[c] = Integer.parseInt(st.nextToken());
			endT[c] = Integer.parseInt(st.nextToken());
			for (int k = startT[c]; k < endT[c]; k++) { times[k]++; }
		}
 
		for (int i = 0; i < cows; i++) {
			for (int t = startT[i]; t < endT[i]; t++) { times[t]--; }
 
			int covered = 0;
			for (int t = 0; t < 1000; t++) {
				if (times[t] > 0) { covered++; }
			}
			shiftTotal = Math.max(shiftTotal, covered);
 
			for (int t = startT[i]; t < endT[i]; t++) { times[t]++; }
		}
		pw.println(shiftTotal);
		pw.close();
		br.close();
	}
}

#include <algorithm>
#include <fstream>
#include <iostream>
#include <vector>
 
using std::cout;
using std::endl;
using std::vector;
 
constexpr int MAX_TIME = 1000;
 
int main() {
	std::ifstream read("lifeguards.in");
	int guard_num;
	read >> guard_num;
	vector<std::pair<int, int>> guards(guard_num);
	for (auto &[start, end] : guards) { read >> start >> end; }
 
	int max_time = 0;
	// Probamos todos los salvavidas que podemos quitar
	for (int g = 0; g < guard_num; g++) {
		// Vemos qué instantes cubren los salvavidas restantes
		vector<bool> covered(MAX_TIME);
		for (int i = 0; i < guard_num; i++) {
			if (i == g) { continue; }
			for (int t = guards[i].first; t < guards[i].second; t++) {
				covered[t] = true;
			}
		}
 
		int time = 0;
		for (bool c : covered) { time += c; }
		max_time = std::max(max_time, time);
	}
 
	std::ofstream("lifeguards.out") << max_time << endl;
}

import java.io.*;
import java.util.*;
 
public class Lifeguards {
	private static final int MAX_TIME = 1000;
 
	public static void main(String[] args) throws IOException {
		BufferedReader read = new BufferedReader(new FileReader("lifeguards.in"));
		int guardNum = Integer.parseInt(read.readLine());
		int[][] guards = new int[guardNum][2];
		for (int[] g : guards) {
			StringTokenizer time = new StringTokenizer(read.readLine());
			g[0] = Integer.parseInt(time.nextToken());
			g[1] = Integer.parseInt(time.nextToken());
		}
		read.close();
 
		int maxTime = 0;
		// Probamos todos los salvavidas que podemos quitar
		for (int g = 0; g < guardNum; g++) {
			// Vemos qué instantes cubren los salvavidas restantes
			boolean[] covered = new boolean[MAX_TIME];
			for (int i = 0; i < guardNum; i++) {
				if (i == g) { continue; }
				for (int t = guards[i][0]; t < guards[i][1]; t++) { covered[t] = true; }
			}
 
			int time = 0;
			for (boolean c : covered) { time += c ? 1 : 0; }
			maxTime = Math.max(maxTime, time);
		}
 
		PrintWriter written = new PrintWriter("lifeguards.out");
		written.println(maxTime);
		written.close();
	}
}

MAX_TIME = 1000
 
with open("lifeguards.in") as read:
	guards = []
	for _ in range(int(read.readline())):
		guards.append(tuple(int(i) for i in read.readline().split()))
 
max_time = 0
# Probamos todos los salvavidas que podemos quitar
for g in range(len(guards)):
	# Vemos qué instantes cubren los salvavidas restantes
	covered = [False for _ in range(MAX_TIME)]
	for start, end in guards[:g] + guards[g + 1 :]:
		for t in range(start, end):
			covered[t] = True
 
	max_time = max(max_time, sum(covered))
 
print(max_time, file=open("lifeguards.out", "w"))