You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
168 lines
5.0 KiB
168 lines
5.0 KiB
use std::fmt;
|
|
use std::{io::{self, BufRead}};
|
|
|
|
#[derive(Clone, Copy)]
|
|
struct Entry {
|
|
previous_value: usize,
|
|
next_value: usize,
|
|
}
|
|
|
|
struct GameState {
|
|
current_cup: usize,
|
|
state: Vec<Entry>,
|
|
}
|
|
|
|
impl GameState {
|
|
fn new(raw_data: &[usize]) -> GameState {
|
|
let data: Vec<_> = raw_data.iter().map(|&x| x-1).collect();
|
|
let mut state = vec![None; data.len()];
|
|
state[data[0]] = Some(Entry {
|
|
previous_value: data[data.len()-1],
|
|
next_value: data[1],
|
|
});
|
|
for i in 1..data.len()-1 {
|
|
state[data[i]] = Some(Entry {
|
|
previous_value: data[i-1],
|
|
next_value: data[i+1],
|
|
});
|
|
}
|
|
state[data[data.len()-1]] = Some(Entry {
|
|
previous_value: data[data.len()-2],
|
|
next_value: data[0],
|
|
});
|
|
|
|
GameState {
|
|
current_cup: data[0],
|
|
state: state.into_iter().collect::<Option<_>>().unwrap(),
|
|
}
|
|
}
|
|
|
|
fn get_next_value(&self, value: usize) -> usize {
|
|
self.state[value].next_value
|
|
}
|
|
|
|
// unsafe, leaves self in an inconsistent state, only invoke from link_values
|
|
fn set_next_value(&mut self, value: usize, new_next_value: usize) {
|
|
self.state[value] = Entry {
|
|
next_value: new_next_value,
|
|
..self.state[value]
|
|
}
|
|
}
|
|
|
|
// unsafe, leaves self in an inconsistent state, only invoke from link_values
|
|
fn set_previous_value(&mut self, value: usize, new_previous_value: usize) {
|
|
self.state[value] = Entry {
|
|
previous_value: new_previous_value,
|
|
..self.state[value]
|
|
}
|
|
}
|
|
|
|
// unsafe, leaves self in an inconsistent state, only invoke from move_value
|
|
fn link_values(&mut self, previous_value: usize, next_value: usize) {
|
|
self.set_next_value(previous_value, next_value);
|
|
self.set_previous_value(next_value, previous_value);
|
|
}
|
|
|
|
fn move_value(&mut self, value: usize, new_previous: usize) {
|
|
let old_previous = self.state[value].previous_value;
|
|
let old_next = self.state[value].next_value;
|
|
let new_next = self.state[new_previous].next_value;
|
|
self.link_values(old_previous, old_next);
|
|
self.link_values(new_previous, value);
|
|
self.link_values(value, new_next);
|
|
}
|
|
|
|
fn get_destination_cup(&self, current_cup: usize) -> usize {
|
|
let blacklisted_cups = [
|
|
current_cup,
|
|
self.get_next_value(current_cup),
|
|
self.get_next_value(self.get_next_value(current_cup)),
|
|
self.get_next_value(self.get_next_value(self.get_next_value(current_cup))),
|
|
];
|
|
|
|
let mut destination_label = current_cup;
|
|
loop {
|
|
if destination_label == 0 {
|
|
destination_label = self.state.len();
|
|
}
|
|
destination_label -= 1;
|
|
|
|
if !blacklisted_cups.contains(&destination_label) {
|
|
return destination_label;
|
|
}
|
|
}
|
|
}
|
|
|
|
fn mutate_next_step(&mut self) {
|
|
let current_cup = self.current_cup;
|
|
let mut destination_cup = self.get_destination_cup(current_cup);
|
|
for _i in 0..3 {
|
|
let value_to_move = self.get_next_value(current_cup);
|
|
self.move_value(value_to_move, destination_cup);
|
|
destination_cup = value_to_move;
|
|
}
|
|
|
|
self.current_cup = self.get_next_value(current_cup);
|
|
}
|
|
|
|
fn get_hard_result(&self) -> u64 {
|
|
(self.get_next_value(0) as u64 + 1) * (self.get_next_value(self.get_next_value(0)) as u64 + 1)
|
|
}
|
|
}
|
|
|
|
impl fmt::Debug for GameState {
|
|
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
|
let mut list = Vec::with_capacity(self.state.len());
|
|
list.push(1);
|
|
let mut current_value = self.get_next_value(0);
|
|
while current_value != 0 {
|
|
list.push(current_value + 1);
|
|
current_value = self.get_next_value(current_value);
|
|
}
|
|
|
|
f.debug_struct("GameState")
|
|
.field("current_cup", &(self.current_cup + 1))
|
|
.field("cups", &list)
|
|
.finish()
|
|
}
|
|
}
|
|
|
|
fn game_simple(original_data: &[usize]) {
|
|
let mut state = GameState::new(&original_data);
|
|
|
|
for i in 0..=100 {
|
|
println!("{}: {:?}", i, state);
|
|
state.mutate_next_step();
|
|
}
|
|
}
|
|
|
|
fn game_hard(original_data: &[usize]) {
|
|
let mut state = GameState::new(&original_data);
|
|
|
|
for i in 0..10_000_000 {
|
|
if i % 10_000 == 0 {
|
|
println!("Step {}", i);
|
|
}
|
|
state.mutate_next_step();
|
|
}
|
|
|
|
println!("{}", state.get_hard_result());
|
|
}
|
|
|
|
fn main() {
|
|
let stdin = io::stdin();
|
|
let mut lines = stdin.lock().lines();
|
|
let line = lines.next().unwrap().unwrap();
|
|
let original_state: Vec<usize> = line.chars().map(|ch| ch.to_string().parse().unwrap()).collect();
|
|
game_simple(&original_state);
|
|
|
|
let mut hard_state = Vec::with_capacity(1_000_000);
|
|
for i in 0..original_state.len() {
|
|
hard_state.push(original_state[i]);
|
|
}
|
|
|
|
for i in original_state.len()..1_000_000 {
|
|
hard_state.push(i+1);
|
|
}
|
|
game_hard(&hard_state);
|
|
}
|
|
|