문제:

당신의 임무는 일련의 숫자로 모든 숫자가 그 앞에 오는 숫자의 숫자 중 적어도 하나를 포함하는지 여부를 결정하는 것입니다.

예를 들어 다음은 진실을 반환해야합니다.

[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

제출은 기능 또는 전체 프로그램 일 수 있습니다.

입력:

입력은 합리적인 유형의 시퀀스 일 수 있습니다. 숫자 배열, 문자열 배열, 구분 된 숫자 문자열 등

그러나 순서는 중요하므로 입력으로 받아들이도록 선택한 모든 구조에는 명확한 순서가 있어야합니다.

입력은 stdin을 통해 또는 인수로 취할 수 있습니다.

당신은 가정 할 수 있습니다 :

• 모든 숫자는 음이 아닌 정수입니다.

• 입력은 항상 최소 2 개의 숫자를 포함합니다

• 입력 번호는 0으로 시작하지 않습니다

산출:

출력은 위의 사양이 충족되는지 여부를 나타내는 진실 또는 거짓 값입니다 (귀하의 언어로 정의 된대로).

Truthy / falsey 값은 테스트간에 일관성이 없어도됩니다.

stdout으로 출력되거나 리턴 될 수 있습니다.

테스트 사례 :

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.

파이썬 2 , 48 바이트

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

온라인으로 사용해보십시오!

빈 세트 False및 마지막 요소 인쇄True

망막 , 25 20 바이트

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

^.+$

온라인으로 사용해보십시오!

다음 숫자에서도 발생하는 숫자를 찾을 때마다 해당 숫자 사이의 구분 기호를 제거합니다 (이전 숫자의 숫자와 함께 공유 숫자부터 시작하지만 관련이 없습니다). 프로세스에서 모든 구분 기호가 제거 된 경우 입력이 유효하며, 문자열을 단일 행으로 일치시킬 수 있는지 확인합니다.

Brachylog , 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)

자바 스크립트 (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 바이트

Martin Ender 덕분에 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.

하스켈, 51 48 35 바이트

@NickHansen 덕분에 -3 바이트! 나는 그 모나드 연산자로 더 나아질 필요가있다

@Laikoni 및 @nimi 덕분에 -4 및 -9 바이트!

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 바이트

MartinE 덕분에 12 바이트가 절약되었습니다.

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}

출력은 nilfalse이고 "random"정수는 true입니다.

자바 8, 94 90 87 바이트

입력은 숫자를 나타내는 문자열 배열입니다. 두 번째 문자열로 시작하여 이전의 각 문자열에 대해 정규식 비교를 수행하여 해당 문자가 포함되어 있는지 확인합니다 .*[previous string].*.

골프 :

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

언 골프 드 :

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으로 입력조차도 10 진수로 변환 할 때 빈 목록이되지 않으므로에 영향을 미치지 않습니다 Ạ.

파이썬 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이들 인 -eq입력 배열의 길이를 연간. 해당 부울 결과는 파이프 라인에 남아 있으며 출력은 암시 적입니다.

펄 5 , 31 바이트

Martin Ender의 아름다운 대답 의 항구 .

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와 falsy를 들어, 0truthy합니다. 온라인으로
실행 -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

클로저, 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 진실한 값으로 합니다.

언 골프 드 :

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

자바 스크립트 (ES6), 37 바이트

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

줄 바꿈으로 구분 된 숫자의 문자열로 입력을 허용합니다. @ MartinEnder ♦의 탁월한 Retina 답변을 기반으로하지만 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)

로다 , 45 35 바이트

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

온라인으로 사용해보십시오!

이것은 Martin Ender의 Retina 솔루션 포트 인 Perl 5 솔루션과 유사합니다. @Neil 덕분에 -10 바이트

다른 해결책이 있습니다 ( 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

온라인으로 사용해보십시오!

입력은 한 줄에 하나씩 stdin에 있습니다.

출력은 종료 코드에 있습니다. 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. 글로벌 r을 초기화합니다.
2. 입력을 문자열 배열로 변환합니다.
3. 마지막 문자열의 일부 문자가 현재 문자열인지 확인하는 배열을 스캔합니다.
4. 각 결과를 r에 추가합니다.
5. 모든 문자열이 3 단계를 만족하면 1을, 그렇지 않으면 0을 반환합니다.

참고 : 함수 내에서 입력 배열의 시작에 0이 추가되었습니다. 이것은 첫 번째 요소의 비교가 가능하도록 수행되었습니다. 그렇지 않으면 첫 번째 요소의 마지막 문자가 비교를 위해 잡 힙니다. 그러나 현재 검사보다 7 바이트를 추가하는 유형 검사를 수행 할 수 있습니다.