func genomicRangeQuery(s string, p, q []int) []int {
	result := make([]int, len(p))

	for k, pi := range p {
		sub := s[pi : q[k]+1]
		switch {
		case strings.Contains(sub, "A"):
			result[k] = 1
		case strings.Contains(sub, "C"):
			result[k] = 2
		case strings.Contains(sub, "G"):
			result[k] = 3
		default:
			result[k] = 4
		}
	}

	return result
}

genomicRangeQuery :: String -> [Int] -> [Int] -> [Int]
genomicRangeQuery s p q = [classify (substr pi' qi) | (pi', qi) <- zip p q]
  where
    substr pi' qi = take (qi - pi' + 1) (drop pi' s)
    classify sub
      | 'A' `elem` sub = 1
      | 'C' `elem` sub = 2
      | 'G' `elem` sub = 3
      | otherwise      = 4

public class Solution {
    public static int[] genomicRangeQuery(String s, int[] p, int[] q) {
        int[] r = new int[p.length];

        for (int k = 0; k < p.length; k++) {
            int pi = p[k];
            int qi = q[k] - pi + 1;
            String subStr = s.substring(pi, pi + qi);

            if (subStr.contains("A")) {
                r[k] = 1;
            } else if (subStr.contains("C")) {
                r[k] = 2;
            } else if (subStr.contains("G")) {
                r[k] = 3;
            } else {
                r[k] = 4;
            }
        }

        return r;
    }
}

(defun genomic-range-query (s p q)
  (loop for pi in p
        for qi in q
        collect (let ((sub (subseq s pi (1+ qi))))
                  (cond
                    ((find #\A sub) 1)
                    ((find #\C sub) 2)
                    ((find #\G sub) 3)
                    (t 4)))))

function genomicRangeQuery(string $s, array $p, array $q): array
{
    $r = [];
    foreach ($p as $k => $pi) {
        $qi     = $q[$k] - $pi + 1;
        $subStr = substr($s, $pi, $qi);
        if (str_contains($subStr, 'A')) {
            $r[] = 1;
        } elseif (str_contains($subStr, 'C')) {
            $r[] = 2;
        } elseif (str_contains($subStr, 'G')) {
            $r[] = 3;
        } else {
            $r[] = 4;
        }
    }

    return $r;
}

def genomic_range_query(s: str, p: list[int], q: list[int]) -> list[int]:
    result = []
    for pi, qi in zip(p, q):
        sub = s[pi:qi + 1]
        if "A" in sub:
            result.append(1)
        elif "C" in sub:
            result.append(2)
        elif "G" in sub:
            result.append(3)
        else:
            result.append(4)

    return result

fn genomic_range_query(s: &str, p: &[usize], q: &[usize]) -> Vec<i64> {
    let chars: Vec<char> = s.chars().collect();
    p.iter()
        .zip(q.iter())
        .map(|(&pi, &qi)| {
            let sub = &chars[pi..=qi];
            if sub.contains(&'A') {
                1
            } else if sub.contains(&'C') {
                2
            } else if sub.contains(&'G') {
                3
            } else {
                4
            }
        })
        .collect()
}

function genomicRangeQuery(s: string, p: number[], q: number[]): number[] {
  const r: number[] = [];

  for (let k = 0; k < p.length; k++) {
    const subStr = s.slice(p[k], q[k] + 1);
    if (subStr.includes("A")) {
      r.push(1);
    } else if (subStr.includes("C")) {
      r.push(2);
    } else if (subStr.includes("G")) {
      r.push(3);
    } else {
      r.push(4);
    }
  }

  return r;
}

is_ipv4_address() {
    local _s=$1
    local -a _parts
    IFS='.' read -ra _parts <<< "$_s"
    if (( ${#_parts[@]} != 4 )); then echo false; return; fi
    local _v
    for _v in "${_parts[@]}"; do
        if [[ -z "$_v" ]] || ! [[ "$_v" =~ ^[0-9]+$ ]]; then
            echo false; return
        fi
        if (( ${#_v} > 1 && ${_v:0:1} == 0 )); then
            echo false; return
        fi
        if (( _v > 255 )); then
            echo false; return
        fi
    done
    echo true
}

#include <algorithm>
#include <cctype>
#include <string>
#include <vector>

bool isIPv4Address(const std::string& inputString)
{
    std::vector<std::string> parts;
    std::string cur;
    for (char c : inputString) {
        if (c == '.') {
            parts.push_back(cur);
            cur.clear();
        } else {
            cur += c;
        }
    }
    parts.push_back(cur);

    for (const auto& v : parts) {
        if (v.empty() || !std::all_of(v.begin(), v.end(), [](unsigned char c) { return std::isdigit(c); })) {
            return false;
        }
        if (v.size() > 1 && v[0] == '0') {
            return false; // rejects leading zeros, mirrors $v !== (string)(int)$v
        }
        if (std::stol(v) > 255) {
            return false;
        }
    }

    return parts.size() == 4;
}