Les pays possèdent une série de territoires dans un monde 1D. Chaque pays est identifié de manière unique par un numéro. La propriété des territoires peut être représentée par une liste comme suit:

1 1 2 2 1 3 3 2 4

Nous définissons les territoires les plus en pointe d'un pays comme les deux territoires les plus proches de l'un ou l'autre bord. Si la liste ci-dessus était indexée à zéro, les territoires 1les plus avancés du pays apparaissent à la position 0et 4.

Un pays en entoure un autre si la sous-liste entre ses deux territoires les plus avancés contient tous les territoires d'un autre pays. Dans l'exemple ci-dessus, la sous-liste entre les territoires 2les plus en pointe du pays est la suivante:

2 2 1 3 3 2

Et nous voyons que tous les territoires de pays se 3situent entre les territoires les plus avancés du pays 2, de sorte que le pays 2entoure le pays 3.

Un pays avec un seul élément n'en entourera jamais un autre.

Défi

Prenez une liste d’entiers comme entrée (dans n’importe quel format) et générez une valeur de vérité si un pays est entouré par un autre, et une valeur de faux sinon.

Vous pouvez supposer que la liste d'entrée est non vide, qu'elle ne contient que des entiers positifs et qu'elle ne "saute" aucun nombre: par exemple, 1 2 1 5une entrée invalide.

Cas de 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 octets

n{Q_{_Q

Exécutez le code sur les cas de 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)

La seule façon d'éviter les environs est de trier les territoires les plus à gauche des pays dans le même ordre que leurs territoires les plus à droite. Si deux pays sont échangés dans cet ordre, l’un a un territoire plus à gauche et plus à droite que l’autre, et l’entoure ainsi.

Pour obtenir les pays uniques dans l'ordre du territoire le plus à gauche, nous dédupliquons simplement, ce qui préserve cet ordre. La même chose est faite pour le territoire le plus à droite en inversant, en dédupliquant, puis en inversant à nouveau. Si ceux-ci donnent des résultats différents, alors un pays est entouré.

Retina , 61 60 octets

Beaucoup plus long que je voudrais ...

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

Imprime le nombre de pays qui entourent au moins un autre pays.

Essayez-le en ligne.

C'est une implémentation très simple de la spécification: nous recherchons le motif A...B...Aqui Bn'apparaît ni avant ni après le match.

Python, 64 octets

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

La seule façon d'éviter les environs est de trier les territoires les plus à gauche des pays dans le même ordre que leurs territoires les plus à droite. Si deux pays sont échangés dans cet ordre, l’un a un territoire plus à gauche et plus à droite que l’autre, et l’entoure ainsi.

La fonction vérifie que le tri des territoires en fonction de l'apparence la plus à gauche et de l'extrême droite donne les mêmes résultats. Malheureusement, les listes Python n'ont pas d' rindexanalogue rfind, aussi nous inversons la liste, puis la sortie triée.

Même longueur (64) avec une fonction auxiliaire:

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

C #, 113 octets

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);
}

Utiliser une LINQapproche concise .

CJam ( 14 à 13 octets)

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

Démo en ligne

Merci à Martin Büttner pour l’économie d’un caractère.

Japt, 12 octets

Uâ ¬¦Uw â ¬w

Essayez-le en ligne!

Merci à @xnor d’avoir découvert l’algorithme. Le tableau d'entrée est automatiquement stocké dans U, âest uniqify, west inversé et l' ¦est !=. ¬se joint à la chaîne vide ( [1,2,3] => "123"); cela est nécessaire car la comparaison de JavaScript compte deux tableaux comme non égaux, à moins qu'il ne s'agisse du même objet. Par exemple (code JS, pas Japt):

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

Si ce n'était pas le cas, nous pourrions supprimer deux octets en ne rejoignant tout simplement pas chaque tableau:

Uâ ¦Uw â w

ES6, 76 75 65 64 octets

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

Portage direct des réponses de @ xnor.

Edit: Sauvegardé 1 octet en remplaçant a.lastIndexOf(x)==ipar a.indexOf(x,i+1)<0.

Edit: 10 octets sauvegardés grâce à @ user81655.

Edit: Sauvegardé 1 octet en remplaçant r||ipar r|i.

05AB1E , 4 octets

ÙIÚÊ

Essayez-le en ligne ou vérifiez tous les cas de test .

Port de @xnor réponse Pyth de .

Explication:

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

Java, 281 caractères

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 octets

Cette fonction prend l’entrée sous forme de liste Python. Malheureusement, les listes Python ne prennent pas directement en charge la recherche à partir de la fin rindex(), contrairement aux chaînes , mais bon.

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)