Livestock Lineup

#include <bits/stdc++.h>
 
using namespace std;
 
const int RESTRICT_LEN = 6;
// lista de vacas, en orden alfabético
const vector<string> COWS = {"Beatrice", "Belinda", "Bella",     "Bessie",
                             "Betsy",    "Blue",    "Buttercup", "Sue"};
 
vector<vector<string>> orderings;
void build(vector<string> ordering) {
	// terminamos de construir la permutación
	if ((int)(ordering.size()) == 8) {
		orderings.push_back(ordering);
		return;
	}
 
	for (const string &COW : COWS) {
		if (find(ordering.begin(), ordering.end(), COW) == ordering.end()) {
			ordering.push_back(COW);
			build(ordering);
			ordering.pop_back();
		}
	}
}
 
// devuelve el índice de una vaca en un orden
int loc(const vector<string> &order, const string &cow) {
	return find(order.begin(), order.end(), cow) - order.begin();
}
 
int main() {
	freopen("lineup.in", "r", stdin);
	freopen("lineup.out", "w", stdout);
	int n;
	cin >> n;
 
	vector<pair<string, string>> restrictions;
	for (int i = 0; i < n; i++) {
		string cow1 = "";
		string cow2 = "";
		for (int j = 0; j < RESTRICT_LEN; j++) {
			string word;
			cin >> word;
			cow1 = cow1.empty() ? word : cow1;
			cow2 = word;
		}
		restrictions.emplace_back(cow1, cow2);
	}
 
	// construimos todos los órdenes posibles de vacas
	build({});
	for (vector<string> &order : orderings) {
		bool ok = true;
		for (const pair<string, string> &rule : restrictions) {
			if (abs(loc(order, rule.first) - loc(order, rule.second)) > 1) {
				ok = 0;
				break;
			}
		}
 
		if (ok) {
			for (const string &i : order) { cout << i << '\n'; }
			break;
		}
	}
}

import java.io.*;
import java.util.*;
 
 
class Pair<T, U> {
	T first;
	U second;
 
	public Pair(T first, U second) {
		this.first = first;
		this.second = second;
	}
}
 
public class Lineup {
	private static final int RESTRICT_LEN = 6;
	// lista de vacas, en orden alfabético
	private static final List<String> COWS = Arrays.asList(
	    "Beatrice", "Belinda", "Bella", "Bessie", "Betsy", "Blue", "Buttercup", "Sue");
 
	private static List<List<String>> orderings = new ArrayList<>();
 
	private static void build(List<String> ordering) {
		// terminamos de construir la permutación
		if (ordering.size() == 8) {
			orderings.add(new ArrayList<>(ordering));
			return;
		}
 
		for (String cow : COWS) {
			if (!ordering.contains(cow)) {
				ordering.add(cow);
				build(ordering);
				ordering.remove(ordering.size() - 1);
			}
		}
	}
 
	// devuelve el índice de una vaca en un orden
	private static int loc(List<String> order, String cow) {
		return order.indexOf(cow);
	}
 
	public static void main(String[] args) throws IOException {
		BufferedReader br = new BufferedReader(new FileReader("lineup.in"));
 
		int n = Integer.parseInt(br.readLine().trim());
		List<Pair<String, String>> restrictions = new ArrayList<>();
 
		for (int i = 0; i < n; i++) {
			String[] words = br.readLine().split(" ");
			restrictions.add(new Pair<>(words[0], words[words.length - 1]));
		}
 
		br.close();
 
		// construimos todos los órdenes posibles de vacas
		build(new ArrayList<>());
 
		PrintWriter pw =
		    new PrintWriter(new BufferedWriter(new FileWriter("lineup.out")));
		for (List<String> order : orderings) {
			boolean ok = true;
			for (Pair<String, String> rule : restrictions) {
				if (Math.abs(loc(order, rule.first) - loc(order, rule.second)) > 1) {
					ok = false;
					break;
				}
			}
 
			if (ok) {
				for (String cow : order) { pw.println(cow); }
				break;
			}
		}
 
		pw.close();
	}
}

from typing import List
 
# lista de vacas, en orden alfabético
COWS = ["Beatrice", "Belinda", "Bella", "Bessie", "Betsy", "Blue", "Buttercup", "Sue"]
 
orderings = []
 
 
def build(ordering: List[str]):
	# terminamos de construir la permutación
	if len(ordering) == 8:
		orderings.append(ordering.copy())
		return
 
	for cow in COWS:
		if cow not in ordering:
			ordering.append(cow)
			build(ordering)
			ordering.pop()
 
 
with open("lineup.in") as read:
	n = int(read.readline())
	restrictions = []
	for _ in range(n):
		line = read.readline().split()
		cow1 = line[0]
		cow2 = line[-1]
		restrictions.append((cow1, cow2))
 
# construimos todos los órdenes posibles de vacas
build([])
for order in orderings:
	for rule in restrictions:
		if abs(order.index(rule[0]) - order.index(rule[1])) > 1:
			break
	else:
		with open("lineup.out", "w") as written:
			for cow in order:
				print(cow, file=written)
		break