Problème:

Votre tâche consiste à décider si dans une séquence de nombres, chaque numéro contient au moins un des chiffres du numéro qui l'a précédé.

Par exemple, ce qui suit devrait retourner véridique:

[1, 12, 203, 0, 30]
             ^   ^ Contains a 0
        ^ Contains a 2
    ^ Contains a 1

Les éléments suivants devraient renvoyer falsey:

[1, 32, 23, 34]
    ^ Doesn't contain a 1, therefore false

Votre soumission peut être une fonction ou un programme complet.

Contribution:

L'entrée peut être n'importe quel type de séquence raisonnable. Un tableau de nombres, un tableau de chaînes, une chaîne de nombres délimitée, etc.

Cependant, l'ordre importe, quelle que soit la structure que vous choisissez d'accepter comme entrée, il doit évidemment avoir un ordre défini.

L'entrée peut être prise via le stdin ou comme argument.

Vous pouvez supposer:

• tous les nombres seront des entiers non négatifs

• l'entrée contiendra toujours au moins 2 chiffres

• les numéros d'entrée ne commenceront pas par un 0

Sortie:

La sortie sera une valeur true ou falsey (telle que définie par votre langue), indiquant si la spécification ci-dessus est remplie ou non.

Les valeurs Truthy / Falsey n'ont pas besoin d'être cohérentes entre les tests.

Il peut être soit sorti vers la sortie standard, soit retourné.

Cas de test:

True cases:
[1, 1, 1, 11, 111, 11, 1]
[12, 23, 34, 45, 56]
[65, 54, 43, 32, 21]
[123, 29, 9, 59, 55, 52, 2017, 2]
[1234567890, 19, 95, 5012, 23]

False cases:
[1, 2, 3, 4, 5, 1, 11] (2 doesn't contain a 1)
[12, 23, 33, 45] (45 doesn't contain a 3)
[98, 87, 76, 11, 12, 23] (11 doesn't contain a 7 or 6)

Il s'agit de code-golf, donc le moins d'octets gagne.

Gelée , 5 4 octets

f2\Ạ

L'entrée est un tableau de chaînes.

Essayez-le en ligne!

Comment ça marche

f2\Ạ  Main link. Argument: A (array of strings)

 2\   Pairwise reduce by:
f       Filter, yielding all chars in the left string that appear in the right one.
   Ạ  All; yield 1 if all strings are non-empty, 0 if not.

Python 2 , 48 octets

lambda x:reduce(lambda a,b:set(a)&set(b)and b,x)

Essayez-le en ligne!

Imprimer un ensemble vide pour Falseet le dernier élément pourTrue

Rétine , 25 20 octets

(.).*¶(?=.*\1)

^.+$

Essayez-le en ligne!

Chaque fois que nous trouvons un chiffre qui se produit également dans le numéro suivant, nous supprimons le séparateur entre ces chiffres (ainsi que les chiffres de l'ancien numéro, à partir du numéro partagé, mais ce n'est pas pertinent). L'entrée est valide, si tous les séparateurs ont été supprimés dans le processus, ce que nous vérifions en nous assurant que la chaîne peut correspondre à une seule ligne.

Brachylog , 9 octets

{⊇ᵐ=∧?t}ˡ

Essayez-le en ligne!

Notez que cela fonctionne non seulement avec une liste d'entiers, mais aussi avec une liste de chaînes ou une liste de listes.

Explication

{      }ˡ       Left fold on the input:
 ⊇ᵐ=              It is possible to find a number which is a subset of both input numbers
    ∧             (and)
     ?t           The output is the second number (to continue the fold)

JavaScript (ES6), 47 44 ^_* 43 octets

Un octet enregistré grâce à @Neil

x=>x.every(y=>y.match(`[${p}]`,p=y),p=1/19)

Prend l'entrée comme une liste de chaînes.

Extrait de test

let f =
x=>x.every(y=>y.match(`[${p}]`,p=y),p=1/19)

let g = x => console.log("f([%s]): %s", x.join(", "), f(x.map(String)))

g([1, 1, 1, 11, 111, 11, 1])
g([12, 23, 34, 45, 56])
g([65, 54, 43, 32, 21])
g([123, 29, 9, 59, 55, 52, 2017, 2])
g([123456789, 19, 95, 5012, 23])

g([1, 2, 3, 4, 5, 1, 11])
g([12, 23, 33, 45])
g([98, 87, 76, 11, 12, 23])

* _{( barré 44 est toujours régulier 44 )}

05AB1E , 10 octets

ü‚vy`Så1åP

Essayez-le en ligne! ou comme suite de tests

Explication

ü‚          # map pairing over each pair in input
  v         # for each pair
   y`       # push as 2 separate elements on stack
     Så     # check each digit in 2nd number for membership in first
       1å   # check if any 1 exists in the resulting list
         P  # product of stack

CJam , 18 15 14 octets

4 octets enregistrés grâce à Martin Ender

l~Afb_1>.&:,:*

Essayez-le en ligne!

Explication

l~              e# Read and eval the input
  Afb           e# Convert each number to a list of digits
     _          e# Duplicate the array
      1>        e# Slice it after the first element
        .&      e# Vectorized set intersection; take the set intersection of corresponding 
                e#  elements of the two arrays
          :,    e# Get the length of each intersection
            :*  e# Take the product of the whole array. 
                e#  Will be 0 if any intersection was empty.

Haskell, 51 48 35 octets

-3 octets grâce à @NickHansen! J'ai vraiment besoin de m'améliorer avec ces opérateurs de monade

-4 et -9 octets grâce à @Laikoni et @nimi respectivement!

and.(zipWith(any.flip elem)=<<tail)

Cette version prend l'entrée comme un tableau de chaînes, éliminant le besoin de show, mais pour autant que je puisse voir, cela fonctionne en grande partie de la même manière que l'ancienne version:

all(\(x,y)->any(`elem`x)y).(zip=<<tail).map show

(Je suis assez certain que je suis autorisé à soumettre une fonction anonyme comme celle-ci, mais je la corrigerai si nécessaire)

Les nombres sont d'abord convertis en chaînes. Ensuite, la magie de la monade zip=<<tailcrée une fonction qui zippe la liste avec elle-même, qui associe chaque entrée à son ou ses voisins. Ensuite, allmappe un lambda à chaque paire qui vérifie si une chaîne contient des caractères de l'autre et enfin vérifie qu'ils sortent tous True.

Ancienne version qui fonctionne essentiellement de la même manière:

f a=and$zipWith(\b->any(`elem`show b).show)a$tail a

Mathematica 62 47 35 octets

Avec 12 octets enregistrés grâce à MartinE.

FreeQ[#⋂#2&@@@Partition[#,2,1],{}]&

FreeQ[#⋂#2&@@@Partition[#,2,1],{}]&[{{1},{1,2},{2,0,3},{0},{3,1}}]

Faux

FreeQ[#⋂#2&@@@Partition[#,2,1],{}]&[{{1},{1,2},{2,0,3},{0},{3,0}}]

Vrai

Rubis, 49 48 octets

->x{x.each_cons(2){|z|x&&=z*' '=~/(.).* .*\1/};x}

La sortie est nilpour false et un entier "aléatoire" pour true.

Java 8, 94 90 87 octets

L'entrée est un tableau de chaînes représentant les nombres. A partir de la deuxième chaîne, il effectue une comparaison d'expression régulière contre chaque chaîne précédente pour voir si elle contient l' un de ses personnages: .*[previous string].*.

Golfé:

a->{int r=1,i=0;while(++i<a.length)r*=a[i].matches(".*["+a[i-1]+"].*")?1:0;return r>0;}

Non golfé:

public class NumberChainingPredicate {

  public static void main(String[] args) {
    System.out.println("Expect true:");
    for (String[] input : new String[][] { { "1", "1", "1", "11", "111", "11", "1" }, { "12", "23", "34", "45", "56" },
        { "65", "54", "43", "32", "21" }, { "123", "29", "9", "59", "55", "52", "2017", "2" },
        { "1234567890", "19", "95", "5012", "23" } }) {
      System.out.println(java.util.Arrays.toString(input) + " = " + exec(f(), input));
    }

    System.out.println();
    System.out.println("Expect false:");
    for (String[] input : new String[][] { { "1", "2", "3", "4", "5", "1", "11" }, { "12", "23", "33", "45" },
        { "98", "87", "76", "11", "12", "23" } }) {
      System.out.println(java.util.Arrays.toString(input) + " = " + exec(f(), input));
    }
  }

  private static java.util.function.Function<String[], Boolean> f() {
    return a -> {
      int r = 1, i = 0;
      while (++i < a.length) {
        r *= a[i].matches(".*[" + a[i - 1] + "].*") ? 1 : 0;
      }
      return r > 0;
    };
  }

  private static boolean exec(java.util.function.Function<String[], Boolean> function, String[] input) {
    return function.apply(input);
  }

}

Gelée , 6 octets

Dµf"ḊẠ

Essayez-le en ligne!

Explication

Dµf"ḊẠ
Dµ        Treat the first (i.e. only) input as a list of decimal digits
   "      For each pair of corresponding elements in {the input digits} and
    Ḋ     {the input digits} with the first element removed
  f       take all elements common to both sides
     Ạ    then return true if the result has no empty lists, false otherwise

Il est plus évident d'essayer d'utiliser 2/ici, mais cela exécute une fonction unaire sur toutes les tranches de taille 2. "Ḋexécute efficacement une fonction binaire sur toutes les paires d'éléments adjacents, ce qui signifie que nous pouvons utiliser fdirectement (plutôt que d'avoir besoin de le convertir en unaire fonctionner comme f/). Cela finit par laisser le dernier élément de l'entrée en place, mais heureusement, même une entrée de 0 ne devient pas une liste vide lorsqu'elle est convertie en décimal, donc cela n'a aucun effet sur le Ạ.

Python 3 , 48 octets

f=lambda x:x==x[:1]or{*x[0]}&{*x[1]}and f(x[1:])

Essayez-le en ligne!

Gelée , 8 octets

Dœ&L¥2\Ạ

Essayez-le en ligne!

Comment?

Dœ&L¥2\Ạ - Main link: the list of integers            e.g. [3, 13, 351, 73, 82]
D        - convert all the integers to decimal lists       [[3],[1,3],[3,5,1],[7,3],[8,2]]
     2\  - 2-slice cumulative reduce with:
    ¥    -     last two links as a dyad:
 œ&      -         multiset intersection                   [[3],[1,3],[3],[]]
         -         length                                  [1,2,1,0]
       Ạ - all truthy?                                     0

05AB1E , 5 octets

Code:

üÃõå_

Utilise l' encodage CP-1252 . Essayez-le en ligne! ou Vérifiez tous les cas de test! .

Explication:

üà         # Intersection on each pair
  õå       # Check if the empty string exists
    _      # Boolean negate

PowerShell , 87 octets

param($n)(1..($a=$n.length-1)|?{[char[]]$n[($i=$_)-1]|?{$n[$i]-like"*$_*"}}).count-eq$a

Essayez-le en ligne!

Pas le plus court du tout, mais une approche légèrement différente de celle utilisée par d'autres, et montre la |?{}fonctionnalité astucieuse .

Cela prend l'entrée sous la forme d'un tableau de chaînes $n, puis effectue une boucle du 1haut vers le length-1. Nous utilisons Where-Object(le |?{...}) pour extraire les indices qui sont véridiques pour une condition particulière. Vous pouvez penser à cela comme une forboucle de combinaison avec une ifclause.

La clause ici est [char[]]$n[($i=$_)-1]|?{$n[$i]-like"*$_*"}. Autrement dit, nous prenons l'index en cours $_, le définissant sur $i, et soustrayant 1, et en l'utilisant pour indexer $n(c'est-à-dire que nous obtenons donc l'élément précédent dans notre tableau d'entrée). Celui-ci est ensuite charconverti en tableau et envoyé via une autre Where-Objectprocédure.

La clause interne $n[$i]-like"*$_*"spécifie que la chaîne de l'index actuel $iest -likele caractère actuel $_de l'index précédent. Cela produira donc tous les caractères communs aux deux éléments du tableau. Ainsi, la clause externe ne sera véridique que s'il y a un caractère en commun (puisqu'un tableau vide est falsey dans PowerShell), et donc l'index ne sera sélectionné que s'il y a des caractères en commun.

Ensuite, nous rassemblons tous les indices qui correspondent aux critères et vérifions que .countceux-ci correspondent -eqà la longueur du tableau d'entrée. Ce résultat booléen est laissé sur le pipeline et la sortie est implicite.

Perl 5 , 31 octets

Un port de la belle réponse de Martin Ender .

30 octets de code + -pindicateur.

s/(\S)\S* (?=\S*\1)//g;$_=!/ /

Essayez-le en ligne!

APL (Dyalog APL) , 9 octets

∧/×≢¨2∩/⎕

Essayez-le en ligne!

∧/ sont tous ceux dans la liste des

× les panneaux

≢ du décompte de

¨ chacun des

2∩/ les intersections par paire de

⎕ l'entrée?

PHP, 65 68

for(;null!==$a=$argv[++$i+1];)$r+=$a==strtr($a,$argv[$i],_);echo!$r;

parcourir tous les nombres et supprimer tous les chiffres apparus dans le précédent. Comptez la fréquence à laquelle il est égal au nombre lui-même (aucun chiffre supprimé). Si au moins un égal, nous n'avions pas de match dans l'une des paires.

Correction d'une erreur en utilisant triminsted of strtr. Merci à @ JörgHülsermann

PHP, 75 octets

for($b=3**39;--$argc;)preg_replace("#[$b]#","",$b=$argv[$argc])<$b?:die(1);

prend les nombres des arguments de la ligne de commande; sort avec 1pour faux, avec 0pour vrai.
Exécutez-le -rou testez-le en ligne .

• commencer par $b= un nombre contenant tous les chiffres
• parcourir les arguments
  • supprimer tous les chiffres de $bl'argument
  • copier l'argument dans $b
  • si aucun chiffre n'a été supprimé, quittez avec 1
• implicite: quitter avec 0

PHP, 77 octets

for($i=$t=1;++$i<$argc;)$t*=preg_match("#[{$argv[$i-1]}]#",$argv[$i]);echo$t;

MATL , 14 octets

1&)"V@VX&nv@]x

Essayez-le en ligne!

Merci @LuisMendo d'avoir enregistré un octet. Explication:

1&)            % 'Pop' the first item from the input and push it on the stack.
   "       ]   % Main 'for' loop, to loop over the rest of the input.
    V            % Stringify previous (or first) iten from the input.
     @V          % Push current number, convert to string
       X&        % Intersect with stringified number already on the stack.
         nv      % Count the size of the intersection, and add it to the existing list of sizes.
           @     % Push the current number again for the intersection in the next loop. 
             x % Remove the number pushed by the last loop.
               % Else the program would end with the result on the second instead of the first position in the stack

Clojure, 71 octets

(fn[n](every?(fn[[q w]](some q w))(partition 2 1(map #(set(str %))n))))

Une fonction anonyme qui accepte une séquence de nombres. Renvoie true/ false.

J'aime sa lecture. Il y a certainement quelques domaines qui peuvent être améliorés ici. Ma fonction passée à mapne peut pas être facilement modifiée de sorte qu'elle ne nécessite pas la macro de fonction, ce qui signifie que la fonction entière ne peut pas utiliser la macro, qui a probablement ajouté quelques octets. Ce serait également bien si je pouvais trouver une meilleure façon de décompresser les valeurs dans le every?prédicat.

(defn number-chain? [nums]
  (let [; Turn each number into a set of characters
        set-nums (map #(set (str %)) nums)

        ; Partition the sets into lists of neighbors
        ; [1 2 3 4] -> [[1 2] [2 3] [3 4]]
        partitioned (partition 2 1 set-nums)]

    ; Does every second neighbor contain some element of the first?
    (every?
      (fn [[l1 l2]]
        (some l1 l2))
      partitioned)))

SimpleTemplate, 124 octets

Wow, c'était un entraînement!

{@eachargv asA keyK}{@ifK}{@setR"/[",O,"]/"}{@calljoin intoR"",R}{@ifA is notmatchesR}{@return}{@/}{@/}{@setO A}{@/}{@echo1}

Cela fait "simplement" un regex en utilisant l'ancien élément, montrant 1comme une valeur véridique, ou rien d'autre.

Non golfé:

{@each argv as number key K}
    {@if K}
        {@set regex "/[", old, "]/"}
        {@call join into regex "", regex}
        {@if number is not matches regex}
            {@return false}
        {@/}
    {@/}
    {@set old number}
{@/}
{@echo 1}

JavaScript (ES6), 37 octets

s=>/^(.*(.).*\n(?=.*\2))+.+$/.test(s)

Accepte l'entrée comme une chaîne de nombres séparés par des sauts de ligne. Basé sur l'excellente réponse Retina de @ MartinEnder ♦, mais faisant tout le test en une seule expression rationnelle, car il est plus court en JavaScript de cette façon.

Pip , 12 10 octets

$&B@X^_MPg

Prend l'entrée comme une série d'arguments de ligne de commande. La sortie est une liste non vide pour véridique et une liste vide pour falsey. Essayez-le en ligne ou vérifiez tous les cas de test .

Explication

         g  List of all cmdline args
       MP   Map this function to consecutive pairs of items from that list:
     ^_      Split 1st item of pair into list of characters
    X        Convert to regex that matches any of those characters
  B@         Find all matches in 2nd item of pair
$&          Fold on logical AND--truthy if all items are truthy, falsey if one is falsey
            Print (implicit)

Röda , 45 35 octets

{[_=~`(\S*(\S)\S* (?=\S*\2))+\S+`]}

Essayez-le en ligne!

Ceci est similaire à la solution Perl 5, qui est un port de la solution Retina de Martin Ender. -10 octets grâce à @Neil.

Voici une solution différente ( 73 72 octets):

{[_/""]|{|x|{x|[0]()unless[not(_ in y)]else[1]}if tryPeek y}_|sum|[_=0]}

Il s'agit d'une fonction anonyme qui extrait les chaînes du flux et vérifie que les chaînes consécutives contiennent les mêmes caractères. Explication:

{
    [_/""]|    /* split strings -> creates arrays of characters */
    {|x|       /* begin for loop over character arrays */
        {      /* begin if tryPeek(y) -> peeks the second item from the stream */
               /* x and y are now two consecutive character arrays */
            x| /* push characters in x to the stream */
            [0]()unless[not(_ in y)]else[1] /* pushes 0 to the stream */
                                            /* if y contains the character */
                                            /* in the stream, otherwise 1 */
        }if tryPeek y
    }_|        /* end for loop */
    sum|       /* sum all numbers in the stream */
    [_=0]      /* return true if the sum is zero */
}

Il pourrait éventuellement être joué au golf plus ...

Utilitaires Bash + Unix, 71 69 octets

sed "s/\(.*\)/<<<\1 \&\&grepx[\1]/;1s/.*g/g/;\$s/ .*//"|tr 'x
' \ |sh

Essayez-le en ligne!

L'entrée se fait sur stdin, un nombre par ligne.

La sortie est dans le code de sortie: 0 pour véridique, 1 pour falsey.

Cela peut probablement être joué plus.

Pour que le code ci-dessus fonctionne, il ne doit pas y avoir de fichier dans le répertoire courant dont le nom est un seul chiffre. Si ce n'est pas acceptable, remplacez-le [\1]dans le programme par '[\1]'(au coût de 2 octets supplémentaires).

Exemple d'exécution (le dernier cas de test fourni dans le défi):

$ echo '98
> 87
> 76
> 11
> 12
> 23' | ./digittest > /dev/null; echo $?
1

(1 ici est falsey.)

Comment ça marche:

Je vais démontrer sur l'exemple ci-dessus.

La commande sed convertit l'entrée en:

grepx[98]
<<<87 &&grepx[87]
<<<76 &&grepx[76]
<<<11 &&grepx[11]
<<<12 &&grepx[12]
<<<23

La commande tr convertit ensuite ceci en chaîne:

grep [98] <<<87 &&grep [87] <<<76 &&grep [76] <<<11 &&grep [11] <<<12 &&grep [12] <<<23

Cette chaîne est une commande shell pour effectuer l'opération souhaitée, donc je la redirige vers sh et j'ai terminé.

Q, 57 octets

{r::();({r,::any(last x)in y;x,enlist y}\)($)0,x;all 1_r}

1. Initialise le r global.
2. Convertit l'entrée en tableau de chaînes.
3. Analyse le tableau en vérifiant que certains caractères de la dernière chaîne se trouvent dans la chaîne actuelle.
4. Ajoute chaque résultat à r.
5. Renvoie 1 si toutes les chaînes satisfont l'étape 3, sinon renvoie 0.

Remarque: 0 ajouté au début du tableau d'entrée dans la fonction. Cela a été fait de façon à ce que la comparaison du premier élément se fasse en enrôlé. Sinon, le dernier caractère du premier élément est saisi pour comparaison. Pourrait cependant faire une vérification de type qui ajoute 7 octets sur le nombre actuel.