import Data.List.Split import qualified Data.List as L import Data.Vector as V import Data.Char import Control.DeepSeq as DeepSeq data OutAction = Continue | Output | Halt deriving (Enum, Eq, Show) data Mode = Position | Immediate | Relative deriving (Enum, Eq, Show) type Tape = Vector Int type TapeSection = Vector Int type TuringMachine = (Tape,Int) main = do content <- readFile "input" let tape = fromList $ L.concatMap (L.map read . splitOn ",") (lines content) print $ findMax tape [0..4] print $ findMax tape [5..9] findMax :: Tape -> [Int] -> Int findMax tape range = L.maximum [runAmps tape xs | xs <- L.permutations range] runAmps :: Tape -> [Int] -> Int runAmps tape intseq = L.head $ runAmps' tms intseq [0] where tms = L.replicate 5 (tape,0) runAmps' :: [TuringMachine] -> [Int] -> [Int] -> [Int] runAmps' ((t,p):tms) intseq prev = if halt == Halt then prev else runAmps' (tms L.++ [tm_new]) tailseq tm_out where (tm_new,tm_in,tm_out,halt) = execSteps ((t,p),xprev,[],Continue) tailseq = if L.null intseq then [] else L.tail intseq xprev = if L.null intseq then prev else L.head intseq:prev opLength :: Int -> Int opLength x | n`L.elem`"1278"=4 | n`L.elem`"56"=3 | n`L.elem`"34"=2 | otherwise=1 where n = L.last $ show x parseModes :: String -> [Bool] parseModes m = L.replicate (3 - L.length l) False L.++ l where l = L.map (toEnum . digitToInt) m paramChange :: [Bool] -> TapeSection -> Tape -> TapeSection paramChange m opvec t = imap f (V.tail opvec) where f i a = if L.reverse m !! i then a else t ! a getOpModes :: TapeSection -> (String, [Bool]) getOpModes opvec = (op_dedup,parsed_modes) where (op,modes) = L.splitAt 2 $ L.reverse $ show $ opvec ! 0 parsed_modes = parseModes $ L.reverse modes op_dedup = if L.last op == '0' then [L.head op] else op step :: TapeSection -> (TuringMachine, [Int], [Int]) -> (TuringMachine, OutAction, [Int], [Int]) step opvec ((t,p),input,output) = case op of "1" -> (tm_binop (+),Continue,input,output) "2" -> (tm_binop (*),Continue,input,output) "3" -> (new_tm t $ L.head input,Continue,L.tail input,output) "4" -> ((t,p),Output,input,V.last params:output) "5" -> ((t, if params ! 0/=0 then params ! 1 else p),Continue,input,output) "6" -> ((t, if params ! 0==0 then params ! 1 else p),Continue,input,output) "7" -> (tm_binop (\x y->if x (tm_binop (\x y->if x==y then 1 else 0),Continue,input,output) "99" -> ((t,p),Halt,input,output) where (op,m) = getOpModes opvec params = paramChange m opvec t tm_binop x = new_tm t ((params ! 0) `x` (params ! 1)) new_tm t x = DeepSeq.force (t // [(V.last opvec, x)],p) execSteps :: (TuringMachine, [Int], [Int], OutAction) -> (TuringMachine, [Int], [Int], OutAction) execSteps ((t,p),input,output,halt) = let command_length = opLength $ t ! p opvec = slice p command_length t ((t_new,p_new),cond,input_new,output_new) = step opvec ((t,p+command_length),input,output) in if cond `L.elem` [Output, Halt] then ((t_new,p_new),input_new,output_new,cond) else execSteps ((t_new,p_new),input_new,output_new,cond)