Problem:

Twoim zadaniem jest zdecydować, czy w sekwencji liczb każda liczba zawiera co najmniej jedną z cyfr liczby, która ją poprzedziła.

Na przykład następujące powinny zwracać prawdę:

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

Falsey powinien zwrócić:

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

Twoje zgłoszenie może być funkcją lub pełnym programem.

Wkład:

Dane wejściowe mogą być dowolnym rozsądnym typem sekwencji. Tablica liczb, tablica ciągów, rozdzielany ciąg liczb itp.

Kolejność ma jednak znaczenie, więc każda struktura, którą zdecydujesz się przyjąć jako dane wejściowe, musi oczywiście mieć określone uporządkowanie.

Dane wejściowe można pobierać za pomocą standardowego wejścia lub argumentu.

Możesz założyć:

• wszystkie liczby będą liczbami całkowitymi nieujemnymi

• wejście zawsze będzie zawierało co najmniej 2 liczby

• numery wejściowe nie zaczynają się od 0

Wydajność:

Dane wyjściowe będą zgodne z prawdą lub falsey (zgodnie z definicją Twojego języka), co oznacza, czy powyższa specyfikacja jest spełniona.

Wartości prawda / falsey nie muszą być spójne między testami.

Może być albo wyprowadzony na standardowe wyjście, albo zwrócony.

Przypadki testowe:

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)

To jest golf golfowy, więc wygrywa najmniejsza liczba bajtów.

Galaretka , 5 4 bajtów

f2\Ạ

Dane wejściowe to tablica ciągów.

Wypróbuj online!

Jak to działa

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 bajtów

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

Wypróbuj online!

Wydrukuj pusty zestaw dla Falsei ostatni element dlaTrue

Siatkówka , 25 20 bajtów

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

^.+$

Wypróbuj online!

Ilekroć znajdziemy cyfrę, która występuje również w następnym numerze, usuwamy separator między tymi liczbami (wraz z cyframi z poprzedniego numeru, zaczynając od wspólnego, ale to nie ma znaczenia). Dane wejściowe są poprawne, jeśli wszystkie separatory zostały w tym procesie usunięte, co sprawdzamy, upewniając się, że łańcuch można dopasować jako jedną linię.

Brachylog , 9 bajtów

{⊇ᵐ=∧?t}ˡ

Wypróbuj online!

Zauważ, że działa to nie tylko z listą liczb całkowitych, ale także z listą ciągów lub listą list.

Wyjaśnienie

{      }ˡ       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 bajtów

Zapisano bajt dzięki @Neil

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

Pobiera dane wejściowe jako listę ciągów znaków.

Testowy fragment kodu

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

* _{( przekreślone 44 jest wciąż zwykłym 44 )}

05AB1E , 10 bajtów

ü‚vy`Så1åP

Wypróbuj online! lub jako pakiet testowy

Wyjaśnienie

ü‚          # 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 bajtów

Zaoszczędzono 4 bajty dzięki Martinowi Enderowi

l~Afb_1>.&:,:*

Wypróbuj online!

Wyjaśnienie

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 bajtów

-3 bajty dzięki @NickHansen! Naprawdę muszę być lepszy z tymi operatorami monad

-4 i -9 bajtów dzięki odpowiednio @Laikoni i @nimi!

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

Ta wersja przyjmuje dane wejściowe jako tablicę ciągów, co eliminuje potrzebę show, ale, o ile widzę, działa w dużej mierze w ten sam sposób, co starsza wersja:

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

(Jestem pewien, że mogę przesłać taką anonimową funkcję, ale naprawię ją, jeśli to konieczne)

Najpierw liczby są konwertowane na ciągi. Następnie magia monady zip=<<tailtworzy funkcję, która zamyka listę samą sobą, która paruje każdą pozycję z sąsiadami. Następnie allodwzorowuje lambda na każdą parę, która sprawdza, czy jeden ciąg znaków zawiera znaki z drugiej, i na koniec sprawdza, czy wszystkie wychodzą True.

Stara wersja, która działa w zasadzie w ten sam sposób:

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

Mathematica 62 47 35 bajtów

Z 12 bajtami zaoszczędzonymi dzięki MartinE.

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

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

Fałszywe

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

Prawdziwe

Rubinowy, 49 48 bajtów

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

Dane wyjściowe są nildla false, a „losowa” liczba całkowita dla true.

Java 8, 94 90 87 bajtów

Dane wejściowe to tablica ciągów znaków reprezentujących liczby. Począwszy od drugiego łańcucha, wykonuje regularne porównania ekspresji wobec każdego poprzedniego łańcucha aby sprawdzić, czy zawiera ona żadnej z jej znaków: .*[previous string].*.

Gra w golfa:

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

Nie golfowany:

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

}

Galaretka , 6 bajtów

Dµf"ḊẠ

Wypróbuj online!

Wyjaśnienie

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

Najbardziej oczywista jest próba użycia 2/tutaj, ale ta uruchamia jednoargumentową funkcję na wszystkich plasterkach wielkości 2. "Ḋskutecznie uruchamia funkcję binarną na wszystkich parach sąsiednich elementów, co oznacza, że ​​możemy użyć fbezpośrednio (zamiast konieczności konwertowania jej na jednoargumentową funkcja jako f/). To kończy się pozostawieniem ostatniego elementu wejścia na miejscu, ale na szczęście nawet wejście 0 nie staje się pustą listą po konwersji na dziesiętne, więc nie ma to wpływu na Ạ.

Python 3 , 48 bajtów

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

Wypróbuj online!

Galaretka , 8 bajtów

Dœ&L¥2\Ạ

Wypróbuj online!

W jaki sposób?

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 bajtów

Kod:

üÃõå_

Wykorzystuje kodowanie CP-1252 . Wypróbuj online! lub Zweryfikuj wszystkie przypadki testowe! .

Wyjaśnienie:

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

PowerShell , 87 bajtów

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

Wypróbuj online!

Nie najkrótszy pod żadnym względem, ale nieco inne podejście niż inni, i pokazuje sprytną |?{}funkcjonalność.

To pobiera dane wejściowe jako tablicę ciągów znaków $n, a następnie zapętla od 1do length-1. Używamy Where-Object( |?{...}), aby wyciągać te wskaźniki, które są prawdziwe dla określonego warunku. Możesz myśleć o tym jak o forpętli kombinowanej z ifklauzulą.

Klauzula jest tutaj [char[]]$n[($i=$_)-1]|?{$n[$i]-like"*$_*"}. Oznacza to, że bierzemy bieżący indeks $_, ustawiamy go $ii odejmujemy 1, i używamy go do indeksowania $n(tj. Tak, aby uzyskać poprzedni element w naszej tablicy wejściowej). Jest to następnie rzutowane jako chartablica i wysyłane przez inną Where-Objectprocedurę.

Klauzula wewnętrzna $n[$i]-like"*$_*"określa, że ​​ciąg przy bieżącym indeksie $ijest -likebieżącym znakiem $_z poprzedniego indeksu. W ten sposób wyprowadzone zostaną wszystkie znaki, które są wspólne między dwoma elementami tablicy. Zatem klauzula zewnętrzna będzie prawdziwa tylko wtedy, gdy występuje wspólny znak (ponieważ pusta tablica w programie PowerShell ma falsey), a zatem indeks zostanie wybrany tylko wtedy, gdy występują wspólne znaki.

Następnie zbieramy wszystkie wskaźniki, które pasują do kryteriów, i sprawdzamy, czy .countsą one odpowiednie -eqdo długości tablicy wejściowej. Ten wynik logiczny jest pozostawiany w potoku, a dane wyjściowe są niejawne.

Perl 5 , 31 bajtów

Port pięknej odpowiedzi Martina Endera .

30 bajtów kodu + -pflaga.

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

Wypróbuj online!

APL (Dyalog APL) , 9 bajtów

∧/×≢¨2∩/⎕

Wypróbuj online!

∧/ są wszystkie na liście

× znaki

≢ zestawienia

¨ każdy z

2∩/ pary skrzyżowań

⎕ wkład?

PHP, 65 68

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

iteruj po wszystkich liczbach i usuń wszystkie cyfry, które pojawiły się w poprzednim. Policz, jak często równa się samej liczbie (bez cyfr usuwanych). Jeśli przynajmniej jeden był równy, nie mieliśmy meczu w jednej z par.

Naprawiono błąd przy użyciu triminsted strtr. Dzięki @ JörgHülsermann

PHP, 75 bajtów

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

pobiera liczby z argumentów wiersza poleceń; wychodzi z 1falsy, z 0prawdy.
Uruchom go -rlub przetestuj online .

• zacznij od $b= liczba zawierająca wszystkie cyfry
• zapętlaj argumenty
  • usuń wszystkie cyfry $bz argumentu
  • skopiuj argument do $b
  • jeśli cyfra nie została usunięta, wyjdź za pomocą 1
• niejawne: wyjście z 0

PHP, 77 bajtów

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

MATL , 14 bajtów

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

Wypróbuj online!

Dzięki @LuisMendo za uratowanie bajtu. Wyjaśnienie:

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 bajtów

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

Anonimowa funkcja, która akceptuje ciąg liczb. Zwraca true/ false.

Lubię, jak to czyta. Jest zdecydowanie kilka obszarów, które można poprawić tutaj. Przekazanej funkcji mapnie można łatwo zmienić, aby nie wymagała makra funkcji, co oznacza, że ​​cała funkcja nie może korzystać z makra, które prawdopodobnie dodało niektóre bajty. Byłoby również miło, gdybym mógł wymyślić lepszy sposób rozpakowywania wartości w every?predykacie.

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

Wow, to był trening!

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

To „po prostu” dokonuje wyrażenia regularnego, używając starego elementu, pokazując 1jako prawdziwą wartość lub nic innego.

Nie golfowany:

{@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 bajtów

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

Akceptuje wprowadzanie jako ciąg liczb oddzielonych znakiem nowej linii. Na podstawie doskonałej odpowiedzi Retina @ MartinEndera, ale wykonuję cały test w jednym wyrażeniu regularnym, ponieważ w ten sposób jest krótszy w JavaScript.

Pip , 12 10 bajtów

$&B@X^_MPg

Pobiera dane wejściowe jako ciąg argumentów wiersza polecenia. Dane wyjściowe to niepusta lista dla prawdy i pusta lista dla falsey. Wypróbuj online lub sprawdź wszystkie przypadki testowe .

Wyjaśnienie

         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 bajtów

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

Wypróbuj online!

Jest to podobne do rozwiązania Perl 5, które jest portem rozwiązania Retina autorstwa Martina Endera. -10 bajtów dzięki @Neil.

Oto inne rozwiązanie ( 73 72 bajty):

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

Jest to anonimowa funkcja, która pobiera ciągi ze strumienia i sprawdza, czy kolejne ciągi zawierają te same znaki. Wyjaśnienie:

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

Mogłoby być golfa więcej ...

Narzędzia Bash + Unix, 71 69 bajtów

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

Wypróbuj online!

Wejście jest ustawione na standardowe, jedna liczba na linię.

Dane wyjściowe znajdują się w kodzie wyjścia: 0 dla prawdy, 1 dla falsey.

To może być bardziej golfa.

Aby powyższy kod działał, w bieżącym katalogu nie może być żadnego pliku o nazwie jednocyfrowej. Jeśli nie jest to dopuszczalne, zamień [\1]w programie na '[\1]'(koszt 2 dodatkowych bajtów).

Uruchomienie próbne (ostatni przypadek testowy podany w wyzwaniu):

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

(1 tutaj to falsey.)

Jak to działa:

Pokażę na przykładowym przebiegu powyżej.

Polecenie sed przekształca dane wejściowe w:

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

Polecenie tr przekształca to w ciąg:

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

Ten ciąg jest poleceniem powłoki do wykonania żądanej operacji, więc potokuję to do sh i gotowe.

Q, 57 bajtów

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

1. Inicjuje globalne r.
2. Konwertuje dane wejściowe na tablicę ciągów.
3. Skanuje tablicę sprawdzając, czy jakiś znak w ostatnim ciągu znajduje się w bieżącym ciągu.
4. Dołącza każdy wynik do r.
5. Zwraca 1, jeśli wszystkie ciągi spełniają krok 3, w przeciwnym razie zwraca 0.

Uwaga: 0 dołączane na początku tablicy wejściowej w ramach funkcji. Dokonano tego, aby porównanie pierwszego elementu zostało zarejestrowane. W przeciwnym razie ostatni znak pierwszego elementu zostanie porównany. Mógłby jednak sprawdzić typ, który dodaje 7 bajtów ponad bieżącą liczbę.