Bovine Genomics

#include <fstream>
#include <iostream>
#include <map>
#include <string>
#include <vector>
 
 
using std::cout;
using std::endl;
using std::vector;
 
const std::map<char, int> GENOME_ID{{'A', 0}, {'T', 1}, {'C', 2}, {'G', 3}};
 
int main() {
	std::ifstream read("cownomics.in");
 
	int cow_num;
	int genome_len;
	read >> cow_num >> genome_len;
 
	vector<vector<int>> spotted(cow_num, vector<int>(genome_len));
	for (int s = 0; s < cow_num; s++) {
		std::string genome;
		read >> genome;
		for (int g = 0; g < genome_len; g++) {
			// A -> 0, C -> 1, T -> 2, G -> 3
			spotted[s][g] = GENOME_ID.at(genome[g]);
		}
	}
 
	vector<vector<int>> plain(cow_num, vector<int>(genome_len));
	for (int p = 0; p < cow_num; p++) {
		std::string genome;
		read >> genome;
		for (int g = 0; g < genome_len; g++) { plain[p][g] = GENOME_ID.at(genome[g]); }
	}
 
	int valid_sets = 0;
	// Recorremos cada grupo posible de 3.
	for (int a = 0; a < genome_len; a++) {
		for (int b = a + 1; b < genome_len; b++) {
			for (int c = b + 1; c < genome_len; c++) {
				vector<bool> spotted_ids(64);
				for (int sc = 0; sc < cow_num; sc++) {
					/*
					 * Al multiplicar el primer, segundo y
					 * tercer dígito por 16, 4 y 1 respectivamente, obtenemos
					 * un número único para esa combinación.
					 */
					int total =
					    (spotted[sc][a] * 16 + spotted[sc][b] * 4 + spotted[sc][c] * 1);
					spotted_ids[total] = true;
				}
 
				bool valid = true;
				for (int pc = 0; pc < cow_num; pc++) {
					int total =
					    (plain[pc][a] * 16 + plain[pc][b] * 4 + plain[pc][c] * 1);
					// No podemos distinguir las vacas con manchas de las lisas.
					if (spotted_ids[total]) {
						valid = false;
						break;
					}
				}
 
				valid_sets += valid;
			}
		}
	}
 
	std::ofstream("cownomics.out") << valid_sets << endl;
}

import java.io.*;
import java.util.*;
 
public class BovineGenomics {
	static final Map<Character, Integer> GENOME_ID = Map.ofEntries(
	    Map.entry('A', 0), Map.entry('T', 1), Map.entry('C', 2), Map.entry('G', 3));
 
	public static void main(String[] args) throws IOException {
		Kattio io = new Kattio("cownomics");
 
		int cowNum = io.nextInt();
		int genomeLen = io.nextInt();
 
		int[][] spotted = new int[cowNum][genomeLen];
		for (int s = 0; s < cowNum; s++) {
			String genome = io.next();
			for (int g = 0; g < genomeLen; g++) {
				// A -> 0, C -> 1, T -> 2, G -> 3
				spotted[s][g] = GENOME_ID.get(genome.charAt(g));
			}
		}
 
		int[][] plain = new int[cowNum][genomeLen];
		for (int p = 0; p < cowNum; p++) {
			String genome = io.next();
			for (int g = 0; g < genomeLen; g++) {
				plain[p][g] = GENOME_ID.get(genome.charAt(g));
			}
		}
 
		int validSets = 0;
		// Recorremos cada grupo posible de 3.
		for (int a = 0; a < genomeLen; a++) {
			for (int b = a + 1; b < genomeLen; b++) {
				for (int c = b + 1; c < genomeLen; c++) {
					boolean[] spottedIDs = new boolean[64];
					for (int sc = 0; sc < cowNum; sc++) {
						/*
						 * Al multiplicar el primer, segundo y
						 * tercer dígito por 16, 4 y 1 respectivamente, obtenemos
						 * un número único para esa combinación.
						 */
						int total = (spotted[sc][a] * 16 + spotted[sc][b] * 4 +
						             spotted[sc][c] * 1);
						spottedIDs[total] = true;
					}
 
					boolean valid = true;
					for (int pc = 0; pc < cowNum; pc++) {
						int total =
						    (plain[pc][a] * 16 + plain[pc][b] * 4 + plain[pc][c] * 1);
						// No podemos distinguir las vacas con manchas de las lisas.
						if (spottedIDs[total]) {
							valid = false;
							break;
						}
					}
 
					validSets += valid ? 1 : 0;
				}
			}
		}
 
		io.println(validSets);
		io.close();
	}
 
	// CodeSnip{Kattio}
}

GENOME_ID = {"A": 0, "T": 1, "C": 2, "G": 3}
 
with open("cownomics.in") as read:
	cow_num, genome_len = [int(i) for i in read.readline().split()]
 
	spotted = []
	for _ in range(cow_num):
		genome_str = read.readline()
		genome = []
		for g in range(genome_len):
			# A -> 0, C -> 1, T -> 2, G -> 3
			genome.append(GENOME_ID[genome_str[g]])
		spotted.append(genome)
 
	plain = []
	for _ in range(cow_num):
		genome_str = read.readline()
		genome = []
		for g in range(genome_len):
			genome.append(GENOME_ID[genome_str[g]])
		plain.append(genome)
 
valid_sets = 0
for a in range(genome_len):
	for b in range(a + 1, genome_len):
		for c in range(b + 1, genome_len):
			spotted_ids = [False for _ in range(64)]
			for sc in range(cow_num):
				total = spotted[sc][a] * 16 + spotted[sc][b] * 4 + spotted[sc][c] * 1
				spotted_ids[total] = True
 
			for pc in range(cow_num):
				total = plain[pc][a] * 16 + plain[pc][b] * 4 + plain[pc][c] * 1
				if spotted_ids[total]:
					break
			else:
				valid_sets += 1
 
print(valid_sets, file=open("cownomics.out", "w"))