Problema:

Il tuo compito è decidere se in una sequenza di numeri, ogni numero contiene almeno una delle cifre del numero che lo ha preceduto.

Ad esempio, quanto segue dovrebbe restituire la verità:

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

Quanto segue dovrebbe restituire falsey:

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

L'invio può essere una funzione o un programma completo.

Ingresso:

L'input può essere qualsiasi tipo ragionevole di sequenza. Una matrice di numeri, una matrice di stringhe, una stringa delimitata di numeri, ecc.

L'ordine è comunque importante, quindi qualsiasi struttura tu scelga di accettare come input ovviamente deve avere un ordine definito.

L'input può essere preso tramite lo stdin o come argomento.

Puoi presumere:

• tutti i numeri saranno numeri interi non negativi

• l'input conterrà sempre almeno 2 numeri

• i numeri di input non inizieranno con uno 0

Produzione:

L'output sarà un valore di verità o falsità (come definito dalla tua lingua), che indica se la specifica sopra è soddisfatta o meno.

I valori di verità / falsità non devono essere coerenti tra i test.

Può essere inviato allo stdout o restituito.

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

Questo è code-golf, quindi vince il minor numero di byte.

Gelatina , 5 4 byte

f2\Ạ

L'input è una matrice di stringhe.

Provalo online!

Come funziona

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 byte

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

Provalo online!

Stampa un set vuoto per Falsee l'ultimo elemento perTrue

Retina , 25 20 byte

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

^.+$

Provalo online!

Ogni volta che troviamo una cifra che si verifica anche nel numero successivo, rimuoviamo il separatore tra quei numeri (insieme alle cifre nel numero precedente, a partire da quello condiviso, ma questo è irrilevante). L'input è valido, se tutti i separatori sono stati rimossi nel processo, che controlliamo assicurandoci che la stringa possa essere abbinata come una singola riga.

Brachylog , 9 byte

{⊇ᵐ=∧?t}ˡ

Provalo online!

Nota che questo non funziona solo con un elenco di numeri interi, ma anche con un elenco di stringhe o un elenco di elenchi.

Spiegazione

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

Salvataggio di un byte grazie a @Neil

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

Accetta input come un elenco di stringhe.

Test snippet

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

* _{( barrato 44 è ancora regolare 44 )}

05AB1E , 10 byte

ü‚vy`Så1åP

Provalo online! o come una suite di test

Spiegazione

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

Risparmiato 4 byte grazie a Martin Ender

l~Afb_1>.&:,:*

Provalo online!

Spiegazione

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 byte

-3 byte grazie a @NickHansen! Ho davvero bisogno di stare meglio con quegli operatori di monade

-4 e -9 byte grazie rispettivamente a @Laikoni e @nimi!

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

Questa versione prende l'input come una matrice di stringhe, eliminando la necessità di show, ma per quanto posso vedere funziona in gran parte allo stesso modo della versione precedente:

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

(Sono abbastanza certo di poter inviare una funzione anonima come questa, ma la riparerò se necessario)

Innanzitutto i numeri vengono convertiti in stringhe. Quindi la magia della monade zip=<<tailcrea una funzione che comprime la lista con se stessa e che accoppia ogni voce con i suoi vicini. Quindi allassocia un lambda a ciascuna coppia che controlla se una stringa contiene caratteri dall'altra e infine verifica che escano tutti True.

Vecchia versione che funziona sostanzialmente allo stesso modo:

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

Mathematica 62 47 35 byte

Con 12 byte salvati grazie 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}}]

Vero

Rubino, 49 48 byte

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

L'output è nilper false e un numero intero "casuale" per true.

Java 8, 94 90 87 byte

L'input è una matrice di stringhe che rappresentano i numeri. A partire dalla seconda corda, si esegue un confronto espressione regolare contro ogni stringa precedente per vedere se contiene uno qualsiasi dei suoi personaggi: .*[previous string].*.

golfed:

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

Ungolfed:

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

}

Gelatina , 6 byte

Dµf"ḊẠ

Provalo online!

Spiegazione

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

È più ovvio provare a usare 2/qui, ma che esegue una funzione unaria su tutte le sezioni di dimensione 2. "Ḋesegue effettivamente una funzione binaria su tutte le coppie di elementi adiacenti, il che significa che possiamo usare fdirettamente (piuttosto che doverlo convertire in unario funzione come f/). Questo finisce per lasciare in posizione l'ultimo elemento dell'input, ma per fortuna nemmeno un input di 0 diventa un elenco vuoto quando convertito in decimale, quindi non ha alcun effetto su Ạ.

Python 3 , 48 byte

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

Provalo online!

Gelatina , 8 byte

Dœ&L¥2\Ạ

Provalo online!

Come?

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 byte

Codice:

üÃõå_

Utilizza la codifica CP-1252 . Provalo online! o Verifica tutti i casi di test! .

Spiegazione:

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

PowerShell , 87 byte

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

Provalo online!

Non il più breve di qualsiasi misura, ma un approccio leggermente diverso rispetto ad altri, e mostra il nifty |?{} funzionalità .

Questo prende l'input come una matrice di stringhe in $n, quindi 1passa da fino a length-1. Usiamo Where-Object(il |?{...}) per estrarre quegli indici che sono veritieri per una particolare condizione. Puoi pensarlo come una combinazionefor ciclo con una ifclausola.

La clausola qui è [char[]]$n[($i=$_)-1]|?{$n[$i]-like"*$_*"}. Cioè, stiamo prendendo l'indice corrente $_, impostandolo $ie sottraendo 1e usandolo per indicizzare $n(cioè, quindi otteniamo l'elemento precedente nel nostro array di input). Questo viene quindi lanciato come achar array e inviato attraverso un'altra Where-Objectprocedura.

La clausola interna $n[$i]-like"*$_*"specifica che la stringa nell'indice corrente $iè-like il carattere corrente $_dall'indice precedente. Ciò genererà quindi tutti i caratteri che sono in comune tra i due elementi dell'array. Pertanto, la clausola esterna sarà vera solo se c'è un carattere in comune (poiché una matrice vuota è falsa in PowerShell), e quindi l'indice sarà selezionato solo se ci sono caratteri in comune.

Quindi, raccogliamo tutti gli indici che soddisfano i criteri e verifichiamo che gli .countstessi siano -eqidentici alla lunghezza dell'array di input. Tale risultato booleano viene lasciato sulla pipeline e l'output è implicito.

Perl 5 , 31 byte

Un porto della bella risposta di Martin Ender .

30 byte di codice + -pflag.

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

Provalo online!

APL (Dyalog APL) , 9 byte

∧/×≢¨2∩/⎕

Provalo online!

∧/ sono tutti quelli nell'elenco

× i segni

≢ del conteggio di

¨ ciascuna di

2∩/ le intersezioni di coppia di

⎕ l'ingresso?

PHP, 65 68

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

scorrere su tutti i numeri e rimuovere tutte le cifre visualizzate nel precedente. Conta la frequenza con cui è uguale al numero stesso (nessuna cifra rimossa). Se almeno uno eguagliava non avremmo avuto una corrispondenza in una delle coppie.

Risolto un errore usando triminsted of strtr. Grazie a @ JörgHülsermann

PHP, 75 byte

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

prende i numeri dagli argomenti della riga di comando; esce con 1per falsy, con 0per verità.
Esegui -ro prova online .

• inizia con $b= un numero contenente tutte le cifre
• scorrere tra gli argomenti
  • rimuove tutte le cifre di $bdall'argomento
  • copia argomento in $b
  • se nessuna cifra è stata rimossa, uscire con 1
• implicito: esci con 0

PHP, 77 byte

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

MATL , 14 byte

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

Provalo online!

Grazie @LuisMendo per aver salvato un byte. Spiegazione:

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 byte

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

Una funzione anonima che accetta una sequenza di numeri. Restituisce true/ false.

Mi piace come si legge. Ci sono sicuramente alcune aree che possono essere migliorate qui. La mia funzione che viene passata mapnon può essere facilmente modificata in modo da non richiedere la macro di funzione, il che significa che l'intera funzione non può utilizzare la macro, che probabilmente ha aggiunto alcuni byte. Sarebbe anche bello se potessi trovare un modo migliore per decomprimere i valori nel every?predicato.

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

Wow, questo è stato un allenamento!

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

Questo "semplicemente" crea una regex usando il vecchio elemento, mostrando 1come un valore di verità, o niente altro.

Ungolfed:

{@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 byte

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

Accetta input come una stringa di numeri separati da una nuova riga. Basato sull'eccellente risposta Retina di @ MartinEnder, ma esegue l'intero test in un'unica regexp perché in questo modo è più breve in JavaScript.

Pip , 12 10 byte

$&B@X^_MPg

Accetta input come una serie di argomenti della riga di comando. L'output è un elenco non vuoto per la verità e un elenco vuoto per la falsità. Provalo online o verifica tutti i casi di test .

Spiegazione

         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 byte

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

Provalo online!

Questo è simile alla soluzione Perl 5, che è una porta della soluzione Retina di Martin Ender. -10 byte grazie a @Neil.

Ecco una soluzione diversa ( 73 72 byte):

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

È una funzione anonima che estrae le stringhe dallo stream e verifica che le stringhe consecutive contengano gli stessi caratteri. Spiegazione:

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

Potrebbe essere possibile giocare a golf di più ...

Utilità Bash + Unix, 71 69 byte

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

Provalo online!

L'input è su stdin, un numero per riga.

L'output è nel codice di uscita: 0 per verità, 1 per falsità.

Questo probabilmente può essere giocato a golf di più.

Perché il codice sopra funzioni, non ci può essere alcun file nella directory corrente il cui nome sia una singola cifra. Se ciò non è accettabile, sostituirlo[\1] con il programma'[\1]' (al costo di 2 byte aggiuntivi).

Esempio di esecuzione (l'ultimo caso di test fornito nella sfida):

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

(1 qui è falso.)

Come funziona:

Dimostrerò sull'esempio precedente.

Il comando sed converte l'input in:

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

Il comando tr quindi converte questo nella stringa:

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

Questa stringa è un comando shell per eseguire l'operazione desiderata, quindi la installo in sh e ho finito.

Q, 57 byte

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

1. Inizializza globale r.
2. Converte l'input nella matrice di stringhe.
3. Esegue la scansione dell'array verificando che alcuni caratteri nell'ultima stringa siano nella stringa corrente.
4. Aggiunge ogni risultato a r.
5. Restituisce 1 se tutte le stringhe soddisfano il passaggio 3, altrimenti restituisce 0.

Nota: 0 aggiunto per l'avvio dell'array di input all'interno della funzione. Questo è stato fatto in modo che il confronto del primo elemento fosse fatto arruolato. Altrimenti, l'ultimo carattere del primo elemento viene preso per il confronto. Potrebbe comunque essere eseguito un controllo del tipo che aggiunge 7 byte rispetto al conteggio corrente.