GenomicRangeQuery

Solution.java

// you can also use imports, for example:
import java.util.Map;
import java.util.HashMap;

// you can write to stdout for debugging purposes, e.g.
// System.out.println("this is a debug message");

class Solution {
    public int[] solution(String S, int[] P, int[] Q) {
        Map<String, Integer> mapping = new HashMap<>();
        mapping.put("A", 1);
        mapping.put("C", 2);
        mapping.put("G", 3);
        mapping.put("T", 4);
        int[] factors = new int[S.length()];
        int min = 4;
        int i = 0;
        for (String letter: S.split("")) {
            int factor = mapping.get(letter);
            factors[i++] = factor;
            min = min > factor ? factor : min;
        }
        
        int[] impacts = new int[P.length];
        for (i = 0; i < P.length; i++) {
            for (int k = P[i]; k <=  Q[i]; k++) {
                if (factors[k] == min) {
                    impacts[i] = min;
                    break;
                }else if (impacts[i] == 0 || factors[k] < impacts[i]){
                    impacts[i] = factors[k];
                }
            }
        }
        return impacts;
    }
}

Solution1.java

// you can also use imports, for example:
import java.util.*;

// you can write to stdout for debugging purposes, e.g.
// System.out.println("this is a debug message");

class Solution {
    public int[] solution(String S, int[] P, int[] Q) {
        Map<String, Integer> mapping = new HashMap<>();
        mapping.put("A", 1);
        mapping.put("C", 2);
        mapping.put("G", 3);
        mapping.put("T", 4);

        Map<Integer, List<Integer>> starts = new HashMap<>();
        Map<Integer, List<Integer>> ends = new HashMap<>();
        for (int i = 0; i <  P.length; i++) {
            if (!starts.containsKey(P[i])) {
                starts.put(P[i], new ArrayList<Integer>());
            }
            starts.get(P[i]).add(i);
            if (!ends.containsKey(Q[i])) {
                ends.put(Q[i], new ArrayList<Integer>());
            }
            ends.get(Q[i]).add(i);
        }

        int[] impacts = new int[P.length];
        String[] letters = S.split("");
        Set<Integer> moving = new HashSet<>();
        for (int i = 0; i < letters.length; i++) {
            int impact = mapping.get(letters[i]);
            for (int index : moving) {
                impacts[index] = impacts[index] > impact ? impact : impacts[index];
            }

            if (starts.containsKey(i)) {
                for (int index : starts.get(i)) {
                    impacts[index] = impact;
                    moving.add(index);
                }
            }
            
            if (ends.containsKey(i)) {
                for (int index : ends.get(i)) {
                    moving.remove(index);
                }
            }
        }
      
        return impacts;
    }
}

Solution2.java

import java.util.List;
import java.util.Arrays;
import java.util.ArrayList;

class Solution {
    public int[] solution(String S, int[] P, int[] Q) {
        int a = 0, c = 0, g = 0;
        List<List<Integer>> times = new ArrayList<>();
        times.add(Arrays.asList(0, 0, 0));
        for (String letter : S.split("")) {
            switch(letter) {
                case("A"): a++;break;
                case("C"): c++;break;
                case("G"): g++;break;
            }
            times.add(Arrays.asList(a, c, g));
        }
        
        int[] impacts = new int[P.length];
        for (int i = 0; i < P.length; i++) {
            List<Integer> start = times.get(P[i]);
            List<Integer> end = times.get(Q[i] + 1);
            if (end.get(0) > start.get(0)) {
                impacts[i] = 1;
            } else if (end.get(1) > start.get(1)) {
                impacts[i] = 2;
            } else if (end.get(2) > start.get(2)) {
                impacts[i] = 3;
            } else {
                impacts[i] = 4;
            }
        }
        return impacts;
    }
}

Solution3.java

class Solution {
    public int[] solution(String S, int[] P, int[] Q) {
        int a = 0, c = 0, g = 0;
        String[] letters = S.split("");
        int[][] times = new int[letters.length + 1][3];
        times[0] = new int[]{0, 0, 0};
        int size = letters.length;
        for (int i = 0; i < size; i++) {
            int[] time = times[i + 1];
            switch(letters[i]) {
                case("A"): ++a;break;
                case("C"): ++c;break;
                case("G"): ++g;break;
            }
            time[0] = a;
            time[1] = c;
            time[2] = g;
        }

        int[] impacts = new int[P.length];
        for (int i = 0; i < P.length; i++) {
            int[] start = times[P[i]];
            int[] end = times[Q[i] + 1];
            if (end[0] > start[0]) {
                impacts[i] = 1;
            } else if (end[1] > start[1]) {
                impacts[i] = 2;
            } else if (end[2] > start[2]) {
                impacts[i] = 3;
            } else {
                impacts[i] = 4;
            }
        }
        return impacts;
    }
}