Problema:

Su tarea es decidir si en una secuencia de números, cada número contiene al menos uno de los dígitos del número que lo precedió.

Por ejemplo, lo siguiente debería devolver la verdad:

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

Lo siguiente debería devolver falsey:

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

Su envío puede ser una función o un programa completo.

Entrada:

La entrada puede ser cualquier tipo razonable de secuencia. Una matriz de números, una matriz de cadenas, una cadena de números delimitada, etc.

Sin embargo, el orden es importante, por lo que cualquier estructura que elija aceptar como entrada obviamente debe tener un orden definido.

La entrada se puede tomar a través del stdin o como argumento.

Puedes asumir:

• todos los números serán enteros no negativos

• la entrada siempre contendrá al menos 2 números

• los números de entrada no comenzarán con un 0

Salida:

La salida será un valor verdadero o falso (como lo define su idioma), que representa si se cumple o no la especificación anterior.

Los valores de verdad / falsey no necesitan ser consistentes entre las pruebas.

Puede enviarse a la salida estándar o devolverse.

Casos de prueba:

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)

Este es el código de golf, por lo que gana el menor número de bytes.

Jalea , 5 4 bytes

f2\Ạ

La entrada es una matriz de cadenas.

Pruébalo en línea!

Cómo funciona

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 bytes

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

Pruébalo en línea!

Imprima un conjunto vacío para Falsey el último elemento paraTrue

Retina , 25 20 bytes

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

^.+$

Pruébalo en línea!

Cada vez que encontramos un dígito que también aparece en el siguiente número, eliminamos el separador entre esos números (junto con los dígitos del número anterior, comenzando por el número compartido, pero eso es irrelevante). La entrada es válida, si todos los separadores se han eliminado en el proceso, lo cual verificamos asegurándonos de que la cadena pueda coincidir como una sola línea.

Brachylog , 9 bytes

{⊇ᵐ=∧?t}ˡ

Pruébalo en línea!

Tenga en cuenta que esto no solo funciona con una lista de enteros, sino también con una lista de cadenas o una lista de listas.

Explicación

{      }ˡ       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 bytes

Guardado un byte gracias a @Neil

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

Toma la entrada como una lista de cadenas.

Fragmento de prueba

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])

* _{( tachado 44 sigue siendo regular 44 )}

05AB1E , 10 bytes

ü‚vy`Så1åP

Pruébalo en línea! o como un conjunto de pruebas

Explicación

ü‚          # 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 bytes

Guardado 4 bytes gracias a Martin Ender

l~Afb_1>.&:,:*

Pruébalo en línea!

Explicación

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 Bytes

-3 bytes gracias a @NickHansen! Realmente necesito mejorar con esos operadores de mónada

-4 y -9 bytes gracias a @Laikoni y @nimi respectivamente!

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

Esta versión toma la entrada como un conjunto de cadenas, eliminando la necesidad de showhacerlo, pero por lo que puedo ver, funciona en gran medida de la misma manera que la versión anterior:

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

(Estoy bastante seguro de que puedo enviar una función anónima como esta, pero la arreglaré si es necesario)

Primero, los números se convierten en cadenas. Luego, la magia de la mónada zip=<<tailcrea una función que comprime la lista consigo misma que empareja cada entrada con sus vecinos. Luego allasigna una lambda a cada par que verifica si una cadena contiene caracteres de la otra y finalmente verifica que todos salgan True.

Versión antigua que funciona básicamente de la misma manera:

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

Mathematica 62 47 35 bytes

Con 12 bytes guardados gracias a MartinE.

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

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

Falso

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

Cierto

Rubí, 49 48 bytes

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

La salida es nilpara falso y un entero "aleatorio" para verdadero.

Java 8, 94 90 87 bytes

La entrada es una matriz de cadenas que representan los números. A partir de la segunda cadena, se realiza una comparación de expresión regular con cada cadena anterior para ver si contiene cualquiera de sus personajes: .*[previous string].*.

Golfizado:

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

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

}

Jalea , 6 bytes

Dµf"ḊẠ

Pruébalo en línea!

Explicación

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

Es más obvio intentar usar 2/aquí, pero eso ejecuta una función unaria en todos los segmentos de tamaño 2. "ḊEfectivamente ejecuta una función binaria en todos los pares de elementos adyacentes, lo que significa que podemos usar fdirectamente (en lugar de tener que convertirlo en unario) funcionar como f/). Esto termina dejando el último elemento de la entrada en su lugar, pero afortunadamente ni siquiera una entrada de 0 se convierte en una lista vacía cuando se convierte a decimal, por lo que no tiene ningún efecto en el Ạ.

Python 3 , 48 bytes

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

Pruébalo en línea!

Jalea , 8 bytes

Dœ&L¥2\Ạ

Pruébalo en línea!

¿Cómo?

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 bytes

Código:

üÃõå_

Utiliza la codificación CP-1252 . Pruébalo en línea! o Verifique todos los casos de prueba! .

Explicación:

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

PowerShell , 87 bytes

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

Pruébalo en línea!

No es el más corto en ninguna medida, sino un enfoque ligeramente diferente al que otros usan, y muestra la ingeniosa |?{}funcionalidad.

Esto toma la entrada como una matriz de cadenas $ny luego realiza un bucle desde 1hasta length-1. Usamos Where-Object(the |?{...}) para extraer esos índices que son verdaderos para una condición particular. Puedes pensar en esto como un forbucle combinado con una ifcláusula.

La cláusula aquí es [char[]]$n[($i=$_)-1]|?{$n[$i]-like"*$_*"} . Es decir, tomamos el índice actual $_, lo establecemos $i, lo restamos 1y lo usamos para indexar $n(es decir, obtenemos el elemento anterior en nuestra matriz de entrada). Luego se lanza como una charmatriz y se envía a través de otro Where-Objectprocedimiento.

La cláusula interna $n[$i]-like"*$_*"especifica que la cadena en el índice actual $ies -likeel carácter actual$_ del índice anterior. Por lo tanto, esto generará cualquier carácter que sea común entre los dos elementos de la matriz. Por lo tanto, la cláusula externa solo será verdadera si hay un carácter en común (ya que una matriz vacía es falsey en PowerShell), por lo que el índice solo se seleccionará si hay caracteres en común.

Luego, reunimos todos los índices que coinciden con los criterios, y verificamos que .countestos sean -eqiguales a la longitud de la matriz de entrada. Ese resultado booleano se deja en la tubería y la salida es implícita.

Perl 5 , 31 bytes

Un puerto de la bella de Martin Ender respuesta .

30 bytes de código + -pbandera.

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

Pruébalo en línea!

APL (Dyalog APL) , 9 bytes

∧/×≢¨2∩/⎕

Pruébalo en línea!

∧/ están todos en la lista de

× las señales

≢ de la cuenta de

¨ Cada uno de

2∩/ las intersecciones por pares de

⎕ la entrada?

PHP, 65 68

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

iterar sobre todos los números y eliminar todos los dígitos que aparecieron en el anterior. Cuente con qué frecuencia es igual al número en sí (sin eliminar ningún dígito). Si al menos uno igualara, no tendríamos una coincidencia en uno de los pares.

Se trimcorrigió un error usando insted de strtr. Gracias a @ JörgHülsermann

PHP, 75 bytes

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

toma números de argumentos de línea de comando; sale con 1por falsedad, con 0por verdad.
Ejecutar -ro probarlo en línea .

• comenzar con $b= un número que contiene todos los dígitos
• recorrer los argumentos
  • eliminar todos los dígitos del $bargumento
  • copiar argumento a $b
  • Si no se eliminó ningún dígito, salga con 1
• implícito: salir con 0

PHP, 77 bytes

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

MATL , 14 bytes

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

Pruébalo en línea!

Gracias @LuisMendo por guardar un byte. Explicación:

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 bytes

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

Una función anónima que acepta una secuencia de números. Devoluciones true/ false.

Me gusta como se lee. Definitivamente hay algunas áreas que se pueden mejorar aquí. Mi función que se pasa mapno se puede cambiar fácilmente, por lo que no requiere la macro de la función, lo que significa que toda la función no puede hacer uso de la macro, que probablemente agregó algunos bytes. También sería bueno si pudiera encontrar una mejor manera de desempaquetar los valores en el every?predicado.

(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 bytes

Wow, esto fue un entrenamiento!

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

Este "simplemente" crea una expresión regular utilizando el elemento antiguo, que se muestra 1como un valor verdadero, o nada de otra manera.

Sin 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 bytes

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

Acepta entradas como una cadena de números separados por nueva línea. Basado en la excelente respuesta de Retina de @ MartinEnder ♦, pero haciendo toda la prueba en una sola expresión regular porque es más corto en JavaScript de esa manera.

Pip , 12 10 bytes

$&B@X^_MPg

Toma datos como una serie de argumentos de línea de comandos. La salida es una lista no vacía para la verdad y una lista vacía para falsey. Pruébelo en línea o verifique todos los casos de prueba .

Explicación

         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 bytes

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

Pruébalo en línea!

Esto es similar a la solución Perl 5, que es un puerto de la solución Retina de Martin Ender. -10 bytes gracias a @Neil.

Aquí hay una solución diferente ( 73 72 bytes):

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

Es una función anónima que extrae cadenas de la secuencia y comprueba que las cadenas consecutivas contienen los mismos caracteres. Explicación:

{
    [_/""]|    /* 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 */
}

Posiblemente podría jugar más golf ...

Utilidades Bash + Unix, 71 69 bytes

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

Pruébalo en línea!

La entrada está en stdin, un número por línea.

La salida está en el código de salida: 0 para la verdad, 1 para falsey.

Esto probablemente se puede jugar más al golf.

Para que el código anterior funcione, no puede haber ningún archivo en el directorio actual cuyo nombre sea un solo dígito. Si esto no es aceptable, reemplácelo [\1]en el programa con '[\1]'(a un costo de 2 bytes adicionales).

Ejecución de muestra (el último caso de prueba proporcionado en el desafío):

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

(1 aquí es falsey.)

Cómo funciona:

Lo demostraré en la muestra de ejecución anterior.

El comando sed convierte la entrada en:

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

El comando tr luego convierte esto a la cadena:

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

Esta cadena es un comando de shell para realizar la operación deseada, por lo que canalizo eso en sh y listo.

Q, 57 bytes

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

1. Inicializa r global.
2. Convierte la entrada en una matriz de cadenas.
3. Escanea la matriz y comprueba que algún carácter de la última cadena esté en la cadena actual.
4. Añade cada resultado a r.
5. Devuelve 1 si todas las cadenas satisfacen el paso 3, de lo contrario, devuelve 0.

Nota: 0 agregado al inicio de la matriz de entrada dentro de la función. Esto se hizo para que la comparación del primer elemento se hiciera alistada. De lo contrario, el último carácter del primer elemento se toma para comparar. Sin embargo, podría hacer una verificación de tipo que agregue 7 bytes sobre el recuento actual.