Проблема:

Ваша задача состоит в том, чтобы решить, содержит ли каждое число в последовательности чисел хотя бы одну из цифр предшествующего ему числа.

Например, следующее должно вернуть truey:

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

Следующее должно вернуть фальси:

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

Ваше представление может быть функцией или полной программой.

Входные данные:

Ввод может быть любой разумный тип последовательности. Массив чисел, массив строк, разделенная строка чисел и т. Д.

Однако порядок имеет значение, поэтому любая структура, которую вы выбираете в качестве входных данных, очевидно, должна иметь определенный порядок.

Ввод может быть взят через стандартный ввод или в качестве аргумента.

Вы можете предположить:

• все числа будут неотрицательными целыми числами

• вход всегда будет содержать как минимум 2 числа

• ввод цифр не начинается с 0

Выход:

Выводом будет истинное или ошибочное значение (как определено вашим языком), показывающее, соблюдается ли вышеуказанная спецификация или нет.

Значения истина / ложь не должны быть согласованными между тестами.

Он может быть либо выведен на стандартный вывод, либо возвращен.

Тестовые случаи:

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)

Это код-гольф, поэтому выигрывает наименьшее количество байтов.

Желе , 5 4 байта

f2\Ạ

Ввод представляет собой массив строк.

Попробуйте онлайн!

Как это работает

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 байт

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

Попробуйте онлайн!

Вывести пустой набор для Falseи последний элемент дляTrue

Сетчатка , 25 20 байт

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

^.+$

Попробуйте онлайн!

Всякий раз, когда мы находим цифру, которая также встречается в следующем номере, мы удаляем разделитель между этими числами (вместе с цифрами в первом номере, начиная с общего, но это не имеет значения). Ввод действителен, если все разделители были удалены в процессе, который мы проверяем, убедившись, что строка может быть сопоставлена ​​как одна строка.

Брахилог , 9 байт

{⊇ᵐ=∧?t}ˡ

Попробуйте онлайн!

Обратите внимание, что это работает не только со списком целых чисел, но также со списком строк или списком списков.

объяснение

{      }ˡ       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 байта

Сохранено байт благодаря @Neil

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

Принимает ввод в виде списка строк.

Тестовый фрагмент

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

* _{( зачеркнуто 44, по-прежнему регулярно 44 )}

05AB1E , 10 байтов

ü‚vy`Så1åP

Попробуйте онлайн! или как тестовый набор

объяснение

ü‚          # 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 байтов

Сохранено 4 байта благодаря Мартину Эндеру

l~Afb_1>.&:,:*

Попробуйте онлайн!

объяснение

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 байт

-3 байта благодаря @NickHansen! Мне действительно нужно поправиться с этими операторами монады

-4 и -9 байтов благодаря @Laikoni и @nimi соответственно!

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

Эта версия принимает входные данные в виде массива строк, что устраняет необходимость в них show, но, насколько я вижу, оно работает в основном так же, как и в старой версии:

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

(Я вполне уверен, что мне разрешено отправлять анонимную функцию, подобную этой, но я исправлю ее при необходимости)

Сначала числа конвертируются в строки. Затем магия монад zip=<<tailсоздает функцию, которая объединяет список с самим собой, который связывает каждую запись со своими соседями. Затем allсопоставляет лямбду с каждой парой, которая проверяет, содержит ли одна строка символы из другой, и, наконец, проверяет, все ли они вышли True.

Старая версия, которая работает в основном так же:

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

Mathematica 62 47 35 байт

С сохранением 12 байтов благодаря MartinE.

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

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

Ложь

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

Правда

Рубин, 49 48 байтов

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

Вывод nilдля false и «случайное» целое для true.

Ява 8, 94 90 87 байт

Ввод - это массив строк, представляющих числа. Начиная со второй строки, он выполняет сравнение регулярных выражений с каждой предыдущей строкой, чтобы увидеть, содержит ли он какой-либо из своих символов:.*[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);
  }

}

Желе , 6 байт

Dµf"ḊẠ

Попробуйте онлайн!

объяснение

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

Это наиболее очевидно, чтобы попытаться использовать 2/здесь, но он запускает унарную функцию на всех срезах размера 2. "Ḋэффективно запускает двоичную функцию на всех парах смежных элементов, что означает, что мы можем использовать fнапрямую (вместо того, чтобы преобразовывать ее в унарный функционировать как f/). Это в конечном итоге оставляет последний элемент ввода на месте, но, к счастью, даже ввод 0 не становится пустым списком при преобразовании в десятичную, поэтому он не влияет на Ạ.

Python 3 , 48 байт

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

Попробуйте онлайн!

Желе , 8 байт

Dœ&L¥2\Ạ

Попробуйте онлайн!

Как?

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 байтов

Код:

üÃõå_

Использует кодировку CP-1252 . Попробуйте онлайн! или проверьте все контрольные примеры! ,

Объяснение:

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

PowerShell , 87 байт

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

Попробуйте онлайн!

Не самый короткий по какой-либо мере, но немного иной подход, чем другие, который демонстрирует отличную |?{}функциональность.

Это принимает входные данные в виде массива строк $n, а затем циклически переходит от 1до length-1. Мы используем Where-Object( |?{...}), чтобы вытащить те индексы, которые соответствуют действительности для конкретного условия. Вы можете думать об этом как о комбинированной forпетле сif предложением.

Пункт здесь есть [char[]]$n[($i=$_)-1]|?{$n[$i]-like"*$_*"}. То есть мы берем текущий индекс $_, устанавливаем его $iи вычитаем 1, и используем его для индексации $n(т.е. мы получаем предыдущий элемент в нашем входном массиве). Затем он приводится как char-array и отправляется через другую Where-Objectпроцедуру.

Внутреннее предложение $n[$i]-like"*$_*"указывает, что строка в текущем индексе $iявляется -likeтекущим символом$_ из предыдущего индекса. Поэтому будут выведены любые символы, которые являются общими для двух элементов массива. Таким образом, внешнее предложение будет правдивым только в том случае, если есть общий символ (поскольку в PowerShell пустой массив ложный), и поэтому индекс будет выбран только при наличии общих символов.

Затем, мы собираем все индексы , которые соответствуют критериям, и убедитесь , что .countих является -eqUAL длиной входного массива. Этот логический результат остается в конвейере, а вывод неявным.

Perl 5 , 31 байт

Порт Мартина Эндера красивый ответ .

30 байт кода + -pфлаг.

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

Попробуйте онлайн!

APL (Dyalog APL) , 9 байтов

∧/×≢¨2∩/⎕

Попробуйте онлайн!

∧/ все в списке

× знаки

≢ из подсчета

¨ каждый из

2∩/ парные пересечения

⎕ вход?

PHP, 65 68

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

переберите все числа и удалите все цифры, которые появились в предыдущем. Посчитайте, как часто оно совпадает с самим числом (без удаления цифры). Если хотя бы один из них равнялся, у нас не было совпадений в одной из пар.

Исправлена ​​ошибка с использованием triminsted of strtr. Благодаря @ JörgHülsermann

PHP, 75 байт

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

принимает числа из аргументов командной строки; 1выходить с ложью, с 0правдой.
Запустите -rили протестируйте его онлайн .

• начать с $b= число, содержащее все цифры
• цикл через аргументы
  • убрать все цифры $bиз аргумента
  • скопировать аргумент в $b
  • если ни одна цифра не была удалена, выйдите с 1
• неявный: выход с 0

PHP, 77 байт

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

MATL , 14 байтов

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

Попробуйте онлайн!

Спасибо @LuisMendo за сохранение байта. Объяснение:

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 байт

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

Анонимная функция, которая принимает последовательность чисел. Возвращает true/ false.

Мне нравится, как это читается. Здесь определенно есть несколько областей, которые можно улучшить. Моя функция передаетсяmap не может быть легко изменена, так что для нее не требуется макрос функции, что означает, что вся функция не может использовать макрос, который, вероятно, добавил несколько байтов. Также было бы хорошо, если бы я мог найти лучший способ распаковки значений в every?предикате.

(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 байта

Вау, это была тренировка!

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

Это «просто» делает регулярное выражение, используя старый элемент, показывая 1 как истинное значение, или ничего другого.

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 байт

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

Принимает ввод как строку разделенных новой строкой чисел. Основано на превосходном ответе Retina @ MartinEnder, но выполняет весь тест в одном регулярном выражении, потому что в этом случае он короче в JavaScript.

зернышко , 12 10 байт

$&B@X^_MPg

Принимает ввод как последовательность аргументов командной строки. Вывод - непустой список для правды и пустой список для фалси.Попробуйте онлайн или проверьте все контрольные примеры .

объяснение

         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 байт

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

Попробуйте онлайн!

Это похоже на решение Perl 5, которое является портом решения Retina от Martin Ender. -10 байт благодаря @Neil.

Вот другое решение ( 73 72 байта):

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

Это анонимная функция, которая извлекает строки из потока и проверяет, что последовательные строки содержат одинаковые символы. Объяснение:

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

Это может быть в гольф больше ...

Утилиты Bash + Unix, 71 69 байт

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

Попробуйте онлайн!

Ввод на стандартный ввод, один номер в строке.

Выход находится в коде выхода: 0 для правды, 1 для фальси.

Это, вероятно, может быть в гольф больше.

Чтобы приведенный выше код работал, в текущем каталоге не может быть ни одного файла, имя которого состоит из одной цифры. Если это не приемлемо, замените [\1]в программе'[\1]' (стоимостью 2 дополнительных байта).

Пробный прогон (последний тестовый пример, представленный в задании):

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

(1 вот фальси.)

Как это работает:

Я продемонстрирую на примере выше.

Команда sed преобразует ввод в:

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

Команда tr затем преобразует это в строку:

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

Эта строка является командой оболочки для выполнения желаемой операции, поэтому я передаю ее в sh и все готово.

Q, 57 байт

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

1. Инициализирует глобальный р.
2. Преобразует ввод в массив строк.
3. Сканирует массив, проверяя, находится ли какой-либо символ в последней строке в текущей строке.
4. Добавляет каждый результат к r.
5. Возвращает 1, если все строки удовлетворяют шагу 3, иначе возвращает 0.

Примечание: 0 добавляется к началу входного массива внутри функции. Это было сделано для того, чтобы сравнение по первому элементу было сделано зачислено. В противном случае последний символ первого элемента будет выбран для сравнения. Однако можно выполнить проверку типа, которая добавляет 7 байтов к текущему количеству.