<< Precedente Successivo >>

Sfida

Ora che Babbo Natale ha finalmente capito come entrare nel suo caveau attuale, si rende conto che in qualche modo gli elfi sono entrati prima di lui e hanno rubato alcuni dei suoi regali! Non hanno ancora capito come lasciare il caveau, quindi Babbo Natale deve cercare di catturarli tutti. Babbo Natale e gli elfi hanno entrambi un'energia infinita per correre, ma sfortunatamente gli elfi hanno una maggiore infinità di energia, quindi se finiscono per correre in loop ovunque, gli elfi si sono liberati.

Dato un grafico di nnodi e ebordi con una camminata esistente tra due nodi qualsiasi, e le posizioni degli elfi e di Babbo Natale, determina quanti elfi Babbo Natale può catturare prima che si stanchi.

L'inseguimento è a turni. Ad ogni ciclo, gli elfi prima si muovono tutti contemporaneamente (possono spostarsi l'uno nell'altro e anche sullo stesso nodo), quindi Babbo Natale si sposterà. Se Babbo Natale si sposta sullo stesso nodo di un elfo, allora ha catturato quell'elfo. Ogni elfo può spostarsi da un nodo al suo vicino in un solo passo. Lo stesso vale per Babbo Natale all'inizio, ma per ogni elfo che ha catturato, Babbo Natale può fare un passo in più. Quindi, se Babbo Natale ha catturato un elfo, allora può spostarsi da un nodo al vicino del vicino. Ciò significa che potrebbe spostarsi su un nodo e poi indietro. Tuttavia, poiché Babbo Natale corre troppo rapidamente durante questo periodo di tempo, non catturerà alcun elfo che passi nei passaggi intermedi (quindi se è su A, A è collegato a B, B è collegato a C, c'è un elfo su B, e Babbo Natale si sposta da A -> B -> C, l'elfo non è ancora stato catturato). Tuttavia, Babbo Natale non deve muovere più passi contemporaneamente; si sposta fino a 1 + (numero di elfi catturati) ogni turno.

Nota che tutti gli elfi devono muovere ogni turno e se un elfo si sposta sul nodo di Babbo Natale, vengono catturati.

Tutte le entità (elfi, Babbo Natale) saranno su nodi distinti all'inizio.

Specifiche e regole

Il tuo programma dovrebbe teoricamente funzionare per input di qualsiasi dimensione. L'input verrà dato come un grafico, le posizioni degli elfi e la posizione di Babbo Natale. Puoi prendere il grafico in qualsiasi formato ragionevole (elenco dei nodi + elenco dei bordi, elenco dei bordi, matrice di adiacenza, notazione del ciclo, ecc.) E puoi assumere le posizioni in qualsiasi formato ragionevole che funzioni con il tuo formato di input del grafico (indice nell'elenco dei nodi, ecc.). L'output dovrebbe essere un singolo numero intero positivo che indica il numero massimo di elfi che Babbo Natale può catturare.

Casi test

Questi sono indicati come elenchi di bordi e numeri di nodo per le posizioni.

Input -> Output
[(0, 1), (1, 2)], [0, 2], 1 -> 2 # Easy win for Santa, the elves get themselves caught :P
[(0, 1), (1, 2), (2, 3), (3, 0)], [0, 1], 2 -> 2 # The elf opposite of Santa cannot escape but the other one can always just run away each turn, until Santa catches the first elf. Then he can easily just catch the rest.
[(0, 1), (1, 2), (2, 3), (3, 0)], [1], 0 -> 0 # Santa will never catch up
[(0, 1), (1, 2), (2, 3), (3, 0), (1, 4), (4, 5), ..., (10, 11), (11, 3)], [2, 6], 0 -> 2 # The first elf moves to either 1 or 3 and then gets caught. Then, Santa can use his 2-step move to catch up to the second elf no matter what.

^{Credo che Babbo Natale può prendere sia nessun elfi o tutti gli elfi, quindi questa sfida potrebbe essere proprio "egli può prendere un elfo" suggerimento suggerimento}

Regole

• Si applicano scappatoie standard
• Questa è una sfida di code-golf , quindi vince la risposta più breve in byte
• Nessuna risposta sarà accettata

Buon golf!

^{Nota: ho tratto ispirazione per questa serie di sfide da Advent Of Code . Non ho affiliazione con questo sito}

Puoi vedere un elenco di tutte le sfide della serie guardando la sezione "Linked" della prima sfida qui .

Wolfram Language (Mathematica) , 129 byte

Block[{a=#},Clear@f;s_~f~e_:=If[s==e,1,s~f~e=0;s~f~e=Min[(hMax[#~f~h&/@a@s,Boole[h==s]])/@a@e]];Tr[Max[(e#3~f~e)/@#2]^#2]]&

Provalo online!

Approccio simile alla mia risposta a questa domanda .

La funzione accetta 3 argomenti come input: elenco di adiacenza rappresentato come associazione ( strumento per generare un elenco di adiacenza dall'elenco dei bordi ), posizione degli elfi e posizione di santa.

Si noti che Clear[f]è necessario, poiché l'invio di funzioni deve essere riutilizzabile.

Il codice seguente è un codice non golfato con spiegazione parziale. Altre spiegazioni dopo.

reverseBoole = # != 0 &

(* Or@@{a, b} === reverseBoole[booleOr[Boole[{a, b}]]] *)
booleOr = Max

booleAnd = Min

(* Boole@f[s, e] = Santa can catch Elf ? *)

mainfunc = Block[{adjlist = #},
  Clear[f];
  f[s_, e_] := If[ s == e, f[s, e] = 1,
    f[s, e] = Boole[False];
    f[s, e] = booleAnd[
      (e1  booleOr[
        ( s1  f[s1, e1] ) /@ adjlist[s],
        Boole[e1 == s]
      ]) /@ adjlist[e]
    ]
  ];
  If [ 0 == booleOr[ ( e  f[#3, e] ) /@ #2 ] , 0, Length[#2] ]
]&