Year of the Cow

#include <algorithm>
#include <iostream>
#include <map>
#include <string>
#include <vector>
 
using std::cout;
using std::endl;
using std::string;
using std::vector;
 
const vector<string> ZODIAC{"Ox",   "Tiger",  "Rabbit",  "Dragon", "Snake", "Horse",
                            "Goat", "Monkey", "Rooster", "Dog",    "Pig",   "Rat"};
 
struct Relation {
	string name;
	bool prev;  // ¿es esta una relación "previous" o "next"?
	int year;
	string relative;
};
 
int mod(int n, int m) { return ((n % m) + m) % m; }
 
int main() {
	int n;
	std::cin >> n;
 
	vector<Relation> relations(n);
	for (Relation &r : relations) {
		string unused;
		string prev_str;
		string animal;
		std::cin >> r.name >> unused >> unused >> prev_str >> animal >> unused >>
		    unused >> r.relative;
 
		r.prev = prev_str == "previous";
		r.year = std::find(ZODIAC.begin(), ZODIAC.end(), animal) - ZODIAC.begin();
	}
 
	std::map<string, int> birthYears{{"Bessie", 0}};
	for (Relation r : relations) {
		int change = r.prev ? -1 : 1;
		// +change porque tiene que diferir en al menos 1 año
		int year = birthYears[r.relative] + change;
		while (mod(year, ZODIAC.size()) != r.year) { year += change; }
		birthYears[r.name] = year;
	}
 
	int dist = abs(birthYears["Bessie"] - birthYears["Elsie"]);
	cout << dist << endl;
}

import java.io.*;
import java.util.*;
 
public class YearOfTheCow {
	static final String[] ZODIAC = {"Ox",      "Tiger", "Rabbit", "Dragon",
	                                "Snake",   "Horse", "Goat",   "Monkey",
	                                "Rooster", "Dog",   "Pig",    "Rat"};
 
	// BeginCodeSnip{Relation Class}
	static class Relation {
		String name;
		boolean prev;  // ¿es esta una relación "previous" o "next"?
		int year;
		String relative;
		public Relation(String name, boolean prev, int year, String relative) {
			this.name = name;
			this.prev = prev;
			this.year = year;
			this.relative = relative;
		}
	}
	// EndCodeSnip
 
	public static void main(String[] args) {
		Kattio io = new Kattio();
		int n = io.nextInt();
 
		Relation[] relations = new Relation[n];
		for (int r = 0; r < n; r++) {
			String name = io.next();
			io.next();
			io.next();
			boolean prev = io.next().equals("previous");
			String animal = io.next();
			int year = -1;
			for (int i = 0; i < ZODIAC.length; i++) {
				if (ZODIAC[i].equals(animal)) { year = i; }
			}
			io.next();
			io.next();
			String relative = io.next();
			relations[r] = new Relation(name, prev, year, relative);
		}
 
		Map<String, Integer> birthYears = new HashMap<>();
		birthYears.put("Bessie", 0);
		for (Relation r : relations) {
			int change = r.prev ? -1 : 1;
			// +change porque tiene que diferir en al menos 1 año
			int year = birthYears.get(r.relative) + change;
			while (mod(year, ZODIAC.length) != r.year) { year += change; }
			birthYears.put(r.name, year);
		}
 
		int dist = Math.abs(birthYears.get("Bessie") - birthYears.get("Elsie"));
		io.println(dist);
		io.close();
	}
 
	static int mod(int n, int m) { return ((n % m) + m) % m; }
 
	// CodeSnip{Kattio}
}

from typing import NamedTuple
 
ZODIAC = [
	"OX",
	"TIGER",
	"RABBIT",
	"DRAGON",
	"SNAKE",
	"HORSE",
	"GOAT",
	"MONKEY",
	"ROOSTER",
	"DOG",
	"PIG",
	"RAT",
]
 
 
class Relation(NamedTuple):
	name: str
	prev: bool  # ¿es esta una relación "previous" o "next"?
	year: int
	relative: str
 
 
relations = []
for _ in range(int(input())):
	relation = input().upper().split()
	relations.append(
		Relation(
			relation[0],
			relation[3] == "PREVIOUS",
			ZODIAC.index(relation[4]),
			relation[7],
		)
	)
 
birth_years = {"BESSIE": 0}
for r in relations:
	change = -1 if r.previous else 1
	# +change porque tiene que diferir en al menos 1 año
	this_year = birth_years[r.relative] + change
	while this_year % len(ZODIAC) != r.year:
		this_year += change
	birth_years[r.name] = this_year
 
dist = abs(birth_years["BESSIE"] - birth_years["ELSIE"])
print(dist)