I paesi possiedono una serie di territori in un mondo 1D. Ogni paese è identificato in modo univoco da un numero. La proprietà dei territori può essere rappresentata da un elenco come segue:

1 1 2 2 1 3 3 2 4

Definiamo i territori più edgemost di un paese come i due territori più vicini ai bordi. Se l'elenco sopra è stato indicizzato zero, 1i territori più edgemost del paese si verificano in posizione 0e 4.

Un paese ne circonda un altro se l'elenco secondario tra i suoi due territori più edgemost contiene tutti i territori di un altro paese. Nell'esempio sopra, la 2lista secondaria tra i territori più edgemost del paese è:

2 2 1 3 3 2

E vediamo che tutti i territori del paese 3sono tra i territori più edgemostici del paese 2, quindi il paese 2circonda il paese 3.

Un paese con un solo elemento non circonderà mai un altro.

Sfida

Prendi un elenco di numeri interi come input (in qualsiasi formato) e genera un valore di verità se un paese è circondato da un altro e un valore di falsa in caso contrario.

Puoi presumere che l'elenco di input sia non vuoto, contenga solo numeri interi positivi e non "salti" alcun numero: ad esempio, 1 2 1 5sarebbe un input non valido.

Casi test

+----------------------+--------+
|        Input         | Output |
+----------------------+--------+
| 1                    | False  |
| 2 1 3 2              | True   |
| 2 1 2 1 2            | True   |
| 1 2 3 1 2 3          | False  |
| 1 3 1 2 2 3 2 3      | True   |
| 1 2 2 1 3 2 3 3 4    | False  |
| 1 2 3 4 5 6 7 8 9 10 | False  |
+----------------------+--------+

Pyth, 7 byte

n{Q_{_Q

Esegui il codice su casi di test.

n      Check whether the following are not equal:
 {Q     The unique elements in order of first appearance
 _{_Q   The unique elements in order of last appearance
         (done by reversing, taking unique elts, then reversing again)

L'unico modo per evitare i dintorni è che i territori più a sinistra dei paesi siano ordinati nello stesso ordine dei loro territori più a destra. Se due paesi vengono scambiati in questo ordine, uno ha un territorio sia più a sinistra che più a destra dell'altro, e quindi lo circonda.

Per ottenere i paesi unici in ordine di territorio più a sinistra, dedupliciamo semplicemente, che preserva questo ordine. Lo stesso viene fatto per il territorio più a destra invertendo, deduplicando, quindi invertendo di nuovo. Se questi danno risultati diversi, allora un paese è circondato.

Retina , 61 60 byte

Molto più a lungo di quanto vorrei ...

(\b(\d+)\b.* (?!\2 )(\d+) .*\b\2\b)(?!.* \3\b)(?<!\b\3 .*\1)

Stampa il numero di paesi che circondano almeno un altro paese.

Provalo online.

È un'implementazione molto semplice delle specifiche: cerchiamo il modello in A...B...Amodo che Bnon appaia né prima né dopo la partita.

Python, 64 byte

lambda l,S=sorted:S(l,key=l.index)!=S(l,key=l[::-1].index)[::-1]

L'unico modo per evitare i dintorni è che i territori più a sinistra dei paesi siano ordinati nello stesso ordine dei loro territori più a destra. Se due paesi vengono scambiati in questo ordine, uno ha un territorio sia più a sinistra che più a destra dell'altro, e quindi lo circonda.

La funzione verifica che l'ordinamento dei territori per aspetto più a sinistra e aspetto più a destra dia gli stessi risultati. Sfortunatamente, gli elenchi di Python non sono rindexanaloghi a rfind, quindi invertiamo l'elenco, quindi invertiamo l'output ordinato.

Stessa lunghezza (64) con una funzione ausiliaria:

g=lambda l:sorted(l,key=l.index)
lambda l:g(l)[::-1]!=g(l[::-1])

C #, 113 byte

public bool V(int[] n){var u1=n.Distinct();var u2=n.Reverse().Distinct().Reverse();return !u1.SequenceEqual(u2);}

Ungolfed:

public bool ContainsSurroundedCountry(int[] numbers)
{
    int[] uniqueLeftmost = numbers.Distinct().ToArray();
    int[] uniqueRightmost = numbers.Reverse().Distinct().Reverse().ToArray();

    return !uniqueLeftmost.SequenceEqual(uniqueRightmost);
}

Utilizzando un LINQapproccio conciso .

CJam ( 14 13 byte)

{__&\W%_&W%#}

Demo online

Grazie a Martin Büttner per un risparmio di un carattere.

Japt, 12 byte

Uâ ¬¦Uw â ¬w

Provalo online!

Grazie a @xnor per aver capito l'algoritmo. L'array di input viene automaticamente archiviato U, âè uniqify, wè inverso e lo ¦è !=. ¬si unisce con la stringa vuota ( [1,2,3] => "123"); questo è necessario perché la comparazione di JavaScript conta due matrici come non uguali a meno che non siano lo stesso oggetto. Ad esempio (codice JS, non Japt):

var a = [1], b = [1]; alert(a==b); // false
var a = [1], b = a;   alert(a==b); // true

In caso contrario, potremmo rimuovere due byte semplicemente non unendo ciascun array:

Uâ ¦Uw â w

ES6, 76 75 65 64 byte

 a=>(f=r=>a.filter((x,i)=>a.indexOf(x,r&&i+1)==(r|i))+a)()!=f(-1)

Porta semplice delle risposte di @ xnor.

Modifica: 1 byte salvato sostituendolo a.lastIndexOf(x)==icon a.indexOf(x,i+1)<0.

Modifica: salvato 10 byte grazie a @ user81655.

Modifica: 1 byte salvato sostituendolo r||icon r|i.

05AB1E , 4 byte

ÙIÚÊ

Provalo online o verifica tutti i casi di test .

Porto di @xnor risposta Pyth s' .

Spiegazione:

Ù       # Uniquified
 IÚ     # Reversed uniquified on the input again
   Ê    # Check if the two lists are not equal

Java, 281 caratteri

class K{public static void main(String[]a){System.out.println(!k(a[0]).equals(new StringBuffer(k(new StringBuffer(a[0]).reverse().toString())).reverse().toString()));}static String k(String k){for(char i=49;i<58;i++){k=k.replaceFirst(""+i,""+(i-9)).replaceAll(""+i,"");}return k;}}

Python 3, 90 byte

Questa funzione che accetta l'input come un elenco Python. Purtroppo, gli elenchi di Python non supportano direttamente la ricerca dalla fine come fanno le stringhe rindex(), ma vabbè.

def t(c):i,I=c.index,c[::-1].index;return any(i(n)<i(m)and I(n)<I(m)for m in c for n in c)