amandhanjal
BAN USERpackage com.practice.careercup;
import java.util.Date;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
public class FB {
public static void main(String[] args) {
FB facebook = new FB();
List<TimeInterval> allMeetings = new LinkedList<FB.TimeInterval>();
//1427207458;//Tue, 24 Mar 2015 14:30:58 GMT
//1427211058;//Tue, 24 Mar 2015 15:30:58 GMT
TimeInterval interval = new TimeInterval(new Date(1427207458), new Date(1427211058));
//1427209258 Tue, 24 Mar 2015 15:00:58 GMT
//1427211898 Tue, 24 Mar 2015 15:44:58 GMT
TimeInterval interval2 = new TimeInterval(new Date(1427209258), new Date(1427211898));
allMeetings.add(interval);
allMeetings.add(interval2);
facebook.hasConflicts(allMeetings);
allMeetings.remove(interval2);
//1427295658 Wed, 25 Mar 2015 15:00:58 GMT
//1427297458 Wed, 25 Mar 2015 15:30:58 GMT
interval2 = new TimeInterval(new Date(1427295658), new Date(1427297458));
allMeetings.add(interval2);
facebook.hasConflicts(allMeetings);
}
public boolean hasConflicts(List<TimeInterval> meetings){
if(meetings != null && !meetings.isEmpty()){
//this meetings could be in any order
Map<String, List<String>> allMeetings = new HashMap<String, List<String>>();
for(TimeInterval interval : meetings){
long currIntervalStartTime = interval.getStartTimeInMillSeconds();
long currIntervalEndTime = interval.getEndTimeInMillSeconds();
String currentIntervalTimeRange = currIntervalStartTime + "-" + currIntervalEndTime;
String currentIntervalDay = interval.getStartMonthDayYear();
List<String> meetingTime = null;
if(allMeetings.containsKey(currentIntervalDay)){
meetingTime = allMeetings.get(currentIntervalDay);
for(String tR : meetingTime){
String[] split = tR.split("-");
long currMeetStartTime = Long.valueOf(split[0]);
long currMeetEndTime = Long.valueOf(split[1]);
if(fallsInRange(currMeetStartTime, currMeetEndTime, currIntervalStartTime)
|| fallsInRange(currMeetStartTime, currMeetEndTime, currIntervalEndTime)){
System.out.println("Meetings have conflicts");
return true;
}
}
}else{
meetingTime = new LinkedList<String>();
}
meetingTime.add(currentIntervalTimeRange);
allMeetings.put(currentIntervalDay, meetingTime);
}
}
System.out.println("No conflicts in meetings.");
return false;
}
public boolean fallsInRange(long startTime, long endTime, long currentValue){
return currentValue >= startTime && currentValue <= endTime;
}
public static class TimeInterval{
public Date startTime;
public Date endTime;
public TimeInterval(Date startTime, Date endTIme){
setStartTime(startTime);
setEndTime(endTIme);
}
public String getStartMonthDayYear(){
return startTime.getMonth()+"/"+startTime.getDay()+"/"+startTime.getYear();
}
public Date getStartTime() {
return startTime;
}
public void setStartTime(Date startTime) {
this.startTime = startTime;
}
public Date getEndTime() {
return endTime;
}
public void setEndTime(Date endTime) {
this.endTime = endTime;
}
public long getStartTimeInMillSeconds(){
return getStartTime().getTime();
}
public long getEndTimeInMillSeconds(){
return getEndTime().getTime();
}
}
}
package com.practice.careercup;
import java.nio.Buffer;
import java.util.ArrayList;
import java.util.List;
public class ReadDataInBytes {
public static BlockOfData readData(byte size){
BlockOfData data = new BlockOfData();
if(size > 0){
while (size > data.size()){
data.add(readFromDisk());
}
if(data.size() > size){
data.trim(0, data.size()-size);
}
}
return data;
}
public static class BlockOfData{
List<Byte[]> data = new ArrayList<Byte[]>();
byte size(){
if(!data.isEmpty()){
return (byte) (data.size() * data.get(0).length);
}
return 0;
}
void add(Byte[] e){
data.add(e);
}
void trim(int indexStart, int indexEnd){
if(!data.isEmpty()){
int sizePerBlock = data.get(0).length;
int numberOfBlocks = data.size();
int indexNumberOfBlocks = numberOfBlocks - 1;
int totalBytes = sizePerBlock * numberOfBlocks;
if(indexStart > totalBytes){
//wrong range supplied;
return;
}
int startIndexBlock = getIndexBlock(indexStart, sizePerBlock);;
int endIndexBlock = getIndexBlock(indexEnd, sizePerBlock) - startIndexBlock;
if(startIndexBlock > 0){
for (int i = 0; i < startIndexBlock; i++) {
data.remove(i);
indexNumberOfBlocks--;
}
indexStart = indexStart - (startIndexBlock * sizePerBlock);
//reset the index
startIndexBlock = 0;
}
//index fits in this range of block now the values in this block to start index
Byte[] arr = data.get(startIndexBlock);
for (int j = 0; j < indexStart; j++) {
arr[j] = Byte.MIN_VALUE;
}
if(endIndexBlock < indexNumberOfBlocks){
for (int i = indexNumberOfBlocks; i > endIndexBlock; i--) {
data.remove(i);
}
indexEnd = indexEnd - (endIndexBlock * sizePerBlock);
}
//index fits in this range of block now the values in this block to start index
Byte[] arry = data.get(endIndexBlock);
for (int j = indexEnd; j < sizePerBlock; j++) {
arry[j] = Byte.MIN_VALUE;
}
}
}
protected int getIndexBlock(int index, int sizePerBlock) {
int currentBlockSize = sizePerBlock;
int blockCount = 0;
while(index >= currentBlockSize){
currentBlockSize += sizePerBlock;
blockCount++;
}
return blockCount;
}
}
}
- amandhanjal April 09, 2015