음수가 아닌 값이 같은 배열의 다른 위치에 대한 포인터이고 그 값만 터널을 나타내는 정수 배열이 있다고 가정합니다. 따라서 위치 A의 값이 양수이고 위치 B를 가리키는 경우 위치의 값 B는 또한 양수 여야하며 터널의 양쪽 끝을 나타내려면 위치 A를 가리켜 야합니다. 그래서:

도전

• 정수 배열이 제공되면 배열이 터널링 배열 인 제한 사항을 준수하는지 확인하고 진실성과 거짓에 대해 두 개의 고유하고 일관된 값을 반환합니다.
• 어레이의 값은 비 터널 위치의 경우 0 미만이고 터널 위치의 경우 0 이상입니다. 배열이 1 인덱싱 된 경우 0 값은 비 터널 위치를 나타냅니다. 비 터널 값은 확인할 필요가 없습니다.
• 셀의 양수 값이 그 자체를 가리키면 이는 잘못된 것입니다. A가 B를 가리키고, B를 C로, C를 A로 A를 가리키는 경우에는 잘못된 것입니다. 양의 값이 배열의 한계를 초과하면 잘못된 것입니다.

예

다음 예제는 인덱스가 0입니다.

[-1, -1, -1, 6, -1, -1, 3, -1, -1]  Truthy (position 3 points to position 6 and vice versa)
[1, 0]                              Truthy (position 0 points to position 1 and vice versa)
[0, 1]                              Falsey (positions 0 and 1 point to themselves)
[4, 2, 1, -1, 0, -1]                Truthy
[2, 3, 0, 1]                        Truthy
[1, 2, 0]                           Falsey (no circular tunnels allowed)
[-1, 2, -1]                         Falsey (tunnel without end)
[]                                  Truthy (no tunnels, that's OK)
[-1, -2, -3]                        Truthy (no tunnels, that's OK)
[1, 0, 3]                           Falsey (tunnel goes beyond limits)
[1]                                 Falsey (tunnel goes beyond limits)
[1, 0, 3, 7]                        Falsey (tunnel goes beyond limits)

이것은 code-golf 이므로 각 언어마다 가장 짧은 코드가 이길 수 있습니다!

R , 47 바이트

function(v,a=v[v>0],b=sort(a))all(v[a]==b&a!=b)

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

풀린 코드 및 설명 :

f=
function(v){          # v vector of tunnel indexes (1-based) or values <= 0

  a = v[v>0]          # get the tunnel positions

  b = sort(a)         # sort the tunnel positions ascending

  c1 = v[a]==b        # get the values of 'v' at positions 'a'
                      # and check if they're equal to the sorted positions 'b'
                      # (element-wise, returns a vector of TRUE/FALSE)

  c2 = a != b         # check if positions 'a' are different from sorted positions 'b' 
                      # (to exclude tunnels pointing to themselves, element-wise,
                      #  returns a vector of TRUE/FALSE)

  all(c1 & c2)        # if all logical conditions 'c1' and 'c2' are TRUE then
                      # returns TRUE otherwise FALSE
}

파이썬 2 , 66 61 60 바이트

lambda l:all(len(l)>v!=i==l[v]for i,v in enumerate(l)if-1<v)

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

APL (Dyalog Unicode) , 19 24 바이트

×/<∘≢⍨×≠∘⍳∘≢⍨×0∘>∨⊢=⊢⍳⍳⍨

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

익명 람다를 접두사로 사용하면 진실로 1을, 거짓으로 0을 반환합니다. TIO 링크에는 테스트 사례에 대한 "고급화 된"버전의 출력이 포함됩니다.

대략적으로 bazillion 바이트를 절약하기 위해 @ngn 및 @ Adám을 외칩니다.

일부 테스트 사례에 대한 답변을 수정하고 기차를 만드는 데 도움이되는 @ngn에 대한 추가 외침.

업데이트 된 답변 은를 사용 ⎕IO←0하여 I ndex O rigin을 0으로 설정합니다 .

어떻게:

×/<∘≢⍨×≠∘⍳∘≢⍨×0∘>∨⊢=⊢⍳⍳⍨ ⍝ Prefix lambda, argument ⍵ → 4 2 1 ¯1 0 ¯1.
                       ⍳⍨ ⍝ Index of (⍳) ⍵ in ⍵. ⍵⍳⍵ → 0 1 2 3 4 3
                     ⊢⍳   ⍝ Index of that in ⍵ (returns the vector length if not found). 
                          ⍝ ⍵⍳⍵⍳⍵ → 4 2 1 6 0 6
                  ⊢=      ⍝ Compare that with ⍵. ⍵=⍵⍳⍵⍳⍵ → 1 1 1 0 1 0
                          ⍝ This checks if positive indices tunnel back and forth correctly.
                 ∨        ⍝ Logical OR with
              0∘>         ⍝ 0>⍵ → 0 0 0 1 0 1∨1 1 1 0 1 0 → 1 1 1 1 1 1
                          ⍝ Removes the zeroes generated by negative indices
             ×            ⍝ Multiply that vector with
            ⍨             ⍝ (using ⍵ as both arguments)
         ⍳∘≢              ⍝ Generate the range [0..length(⍵)-1]
       ≠∘                 ⍝ And do ⍵≠range; this checks if any          
                          ⍝ element in ⍵ is tunneling to itself.
                          ⍝ ⍵≠⍳≢⍵ → 4 2 1 ¯1 0 ¯1≠0 1 2 3 4 5 → 1 1 1 1 1 1  
      ×                   ⍝ Multiply that vector with
     ⍨                    ⍝ (using ⍵ as both arguments)
  <∘≢                     ⍝ ⍵ < length(⍵) → 4 2 1 ¯1 0 ¯1 < 6 → 1 1 1 1 1 1
                          ⍝ This checks if any index is out of bounds
×/                        ⍝ Finally, multiply and reduce.
                          ⍝ ×/1 1 1 1 1 1 → 1 (truthy)

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

@Shaggy 덕분에 1 바이트 절약

a=>a.every((v,i)=>v<0|v!=i&a[v]==i)

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

댓글

a =>                // a[] = input array
  a.every((v, i) => // for each value v at position i in a[]:
    v < 0 |         //   force the test to succeed if v is negative (non-tunnel position)
    v != i &        //   make sure that this cell is not pointing to itself
    a[v] == i       //   check the other end of the tunnel
  )                 // end of every()

파이썬 2 , 65 바이트

lambda l:all(l[v:]>[]and v!=i==l[v]or v<0for i,v in enumerate(l))

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

젤리 , 16 바이트

ị=JanJ$>L<$o<1$Ạ

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

1- 색인.

펄 6 , 36 바이트

{!.grep:{2-set $++,$^v,.[$v]xx$v+1}}

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

기본 아이디어는 집합 { i, a[i], a[a[i]] }이 각 색인에 대해 정확히 두 개의 고유 한 요소를 포함 하는지 여부를 확인하는 것 i입니다 a[i] >= 0. 요소가 자체를 가리키는 경우, 세트에는 하나의 고유 한 요소 만 포함됩니다. 다른 쪽 끝이를 가리 키지 않으면 i세트에는 세 개의 고유 한 요소가 포함됩니다. 경우 a[i] < 0의 xx계수는 0 또는 음수이므로 집합은 { i, a[i] }두 가지 요소도.

MATL , 19 18 바이트

Luis 덕분에 -1 바이트

n:G=GGG0>f))7M-|hs

온라인으로 사용해보십시오! , 나는 그들 모두를 수행하는 방법을 모르기 때문에 첫 번째에만!

0예를 들어, true이면 0이 아닌 정수를 제공합니다 . 테스트 케이스 6 준다 4.

MATLAB과 마찬가지로 MATL도 1- 인덱싱되므로 테스트 사례에 1을 추가해야합니다!

전에는 Esolang에서 골프를 타 본 적이 없으므로 조언을 크게 받았습니다!

설명 :

n:G=GGG0>f))7M-|hs
                        Implicit - input array
n                       Number of values in array
 :                      Make array 1:n
  G                     Push input
   =                    Equality
n:G=                    Makes non-zero array if any of the tunnels lead to themselves
    GGG                 Push input 3x
       0                Push literal 0
        >               Greater than
      G0>               Makes array of ones where input > 0
         f              Find - returns indeces of non-zero values
                        Implicit - copy this matrix to clipboard
          )             Indeces - returns array of positive integers in order from input
           )            Ditto - Note, implicit non-zero any above maximum
            7M          Paste from clipboard
              -         Subtract
    GGG0>f))7M-         Makes array of zeros if only two-ended tunnels evident
               |        Absolute value (otherwise eg. [3,4,2,1] -> '0')
                h       Horizontal concat (ie. joins check for self tunnels and wrong tunnels)
                 s      Sum; = 0 if truthy, integer otherwise                 

05AB1E , 16 15 14 바이트

εèNQyNÊ*y0‹~}P

@Dorian 덕분에 -1 바이트 .

온라인으로 시도 하거나 모든 테스트 사례를 확인하십시오 .

설명:

ε               # Map each value `y` of the (implicit) input-list to:
 è              #   If the current value indexed into the (implicit) input-list
  NQ            #   is equal to the index
       *        #   And
    yNÊ         #   If the current value is not equal to the current index
           ~    #  Or if:
        y0‹     #   The current value is negative
            }P  # After the map: check if everything is truthy
                # (after which the result is output implicitly)

Japt -e , 11 바이트

§JªU¦V«aWgU

시도 해봐

원본 (플래그없이), 14 13 바이트

eȧJªX¦Y«aUgX

사용해 보거나 모든 테스트 사례를 실행하십시오.

파이썬, 112 97 96 86 바이트

f=lambda l:sum(i==l[i]or len(l)<=l[i]or 0<=l[i]and i!=l[l[i]]for i in range(len(l)))<1

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

반환 True또는 False.

@Rod 및 @TFeld 덕분에 -10 바이트

K (ngn / k) , 33 바이트

{*/(x<0)|(x<#x)&(~x=!#x)&x=x?x?x}

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

하스켈 , 48 바이트

(all=<< \u(x,y)->y<0||x/=y&&elem(y,x)u).zip[0..]

모든 테스트 케이스를 확인하십시오!

설명

먼저 코드를 조금 풀자. 대로 f =<< g와 동일한 \x -> f (g x) x코드가 동등

(\u->all(\(x,y)->y<0||x/=y&&elem(y,x)u)u).zip[0..]

조금 더 명확합니다.

(\u ->                                  -- given u, return
    all (\(x, y) ->                     -- whether for all elements (x, y) of u
            y < 0 ||                    -- either y < 0, or
            x /= y && elem (y, x) u     -- (x /= y) and ((y, x) is in u)
        )
    u
) . zip [0..]                           -- given the array a (implicitly via point-free style),
                                        -- return the array augmented with indices (it's the u above)

이 용액 간단한 관찰에 기초한다 :하자 a입력 배열되고 u쌍 목록 인덱스이다. 이어서 만을위한 경우 모든 경우에 유효한 배열 에서 와 , 한 쌍 속하는 도.(i, a[i])ia(x, y)uy >= 0(y, x)u

자바 (JDK) , 89 바이트

a->{int l=a.length,i=l;for(;i-->0;)i=a[i]<1||a[i]<l&&a[i]!=i&a[a[i]]==i?i:-2;return-2<i;}

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

크레딧

• AlexRacer 덕분에 -3 바이트
• ceilingcat 덕분에 -6 바이트

숯 , 22 바이트

¬Φθ∨⁼ικ¬∨‹ι⁰∧‹ιＬθ⁼κ§θι

온라인으로 사용해보십시오! 링크는 자세한 버전의 코드입니다. 출력 -falsy에 대한 truthy와 아무것도. 참고 : 빈 배열을 입력하면 Charcoal이 충돌하는 것처럼 보이지만, 지금은 거의 비슷한 공간을 입력 할 수 있습니다. 설명:

  θ                     Input array
 Φ                      Filter elements
     ι                  Current value
    ⁼                   Equals
      κ                 Current index
   ∨                    Or
       ¬                Not
          ι             Current value
         ‹ ⁰            Is less than zero
        ∨               Or
              ι         Current value
             ‹          Is less than
               Ｌ        Length of
                θ       Input array
            ∧           And
                  κ     Current index
                 ⁼      Equals
                   §θι  Indexed value
¬                       Logical Not (i.e. is result empty)
                        Implicitly print

파스칼 (FPC) , 165 (155) 153 바이트

function f(a:array of int32):byte;var i:int32;begin f:=1;for i:=0to length(a)-1do if a[i]>-1then if(a[i]=i)or(a[i]>length(a))or(a[a[i]]<>i)then f:=0;end;

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

이번에는 입력이 배열이기 때문에 기능했습니다. 반환 1truthy 및 0falsey합니다.

클린 , 60 바이트

import StdEnv
@l=and[v<0||l%(v,v)==[i]&&v<>i\\v<-l&i<-[0..]]

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

클린 , 142 바이트

과도하게 복잡한 몬스터 버전 :

import StdEnv,Data.List,Data.Maybe
$l=and[?i(mapMaybe((!?)l)j)j\\i<-l&j<-map((!?)l)l|i>=0]with?a(Just(Just c))(Just b)=a==c&&b<>c;?_ _ _=False

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

설명 :

$ l                           // function $ of `l` is
 = and [                      // true when all elements are true
  ?                           // apply ? to
   i                          // the element `i` of `l`
   (mapMaybe                  // and the result of attempting to
    ((!?)l)                   // try gettting an element from `l`
    j)                        // at the potentially invalid index `j`
   j                          // and `j` itself, which may not exist
  \\ i <- l                   // for every element `i` in `l`
  & j <- map                  // and every potential `j` in
    ((!?)l)                   // `l` trying to be indexed by
    l                         // every element in `l`
  | i >= 0                    // where `i` is greater than zero
 ]
with
 ? a (Just (Just c)) (Just b) // function ? when all the arguments exist
  = a==c && b<>c              // `a` equals `c` and not `b`
  ;
 ? _ _ _ = False              // for all other arguments, ? is false

루비 , 44 바이트

->a{a.all?{|x|x<0||(w=a[x])&&x!=w&&a[w]==x}}

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

Pyth , 17 16 바이트

.A.e|>0b&nbkq@Qb

여기 에서 온라인으로 시도 하거나 모든 테스트 사례를 한 번에 확인 하십시오 .

.A.e|>0b&nbkq@QbkQ   Implicit: Q=eval(input())
                     Trailing k, Q inferred
  .e             Q   Map the input with b=element, k=index, using:
     >0b               0>b
    |                  OR (
         nbk           b != k
        &              AND
            q@Qbk      Q[b] == k)
.A                   Check if all elements are truthy

편집 : 후행 k도 불필요하다는 것을 깨달았습니다.

그루비 , 52 바이트

{o=!(i=0);it.each{e->o&=e<0||(it[e]==i&&i-e);i++};o}

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

펄 5 , 54 바이트

{$i=-1;!grep$_>=0*$i++&&($_==$i||$i!=($_[$_]//-1)),@_}

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

C (gcc) , 95 바이트

i(_,o,O,Q,I)int*_;{for(I=O=0;O<o;O++)_[O]<0||(Q=_[O[_]],I|=_[O]>=o|Q<0|Q>=o|O[_]==O|Q!=O);Q=I;}

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

수학, 42 바이트

#=={}||(a=0@@#)[[#]]=!=a&&a[[#]][[#]]===a&

순수한 기능. 1 인덱싱 된 숫자 목록을 입력 및 반환 True또는 False출력 으로 취합니다 . 그냥 보장, 터널을 다음 0지도가 0더 1 사이클이 존재하지 않으며, 모든 사이클은 2 회입니다. (이것이 어떤 경우에도 실패하는지는 확실하지 않지만 예제에 대한 올바른 결과를 제공합니다.)

이 답변은 효과가 없습니다. 여기는 설명 목적으로 만 사용됩니다.

이 답변은 (현재) 게시 된 모든 테스트 사례를 통과합니다. 그러나, 이러한 다른 유효한 입력에 (오류 제기)가 실패 [1, 2]또는 [1, 0, 3, 7].

어떻게 통과 [1, 0, 3]하고 실패 할 수 [1, 0, 3, 7]있습니까? 글쎄, 그것은 예상대로 목록을 진행합니다. x리스트 의 요소 를 읽으면 a먼저 x보다 작은 지 여부 를 확인한 다음 len(a)즉시를 반환합니다 False. 보다 작기 때문에 False에 올바르게 반환 됩니다 .[1, 0, 3]3len(a)

그러나 x그 검사 를 통과 한다고 가정하면 코드는 다른 검사를 수행하고 특정 시점에서 평가 a[a[x]]합니다. 우리는 이미 평가하는 것을 보장 한 a[x]하지 확인 될 것입니다 ...하지만 a[a[x]]로 확인하는 a[7]경우 x입니다 3에서 [1, 0, 3, 7]예. 이 시점에서 파이썬은 IndexError반환하지 않고을 발생 False시킵니다.

완전 함을 위해 여기에 답이 있습니다.

파이썬 2 , 59 바이트

lambda a:all(x<len(a)>-1<a[x]!=x==a[a[x]]for x in a if-1<x)

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

나는하고 싶었지만 x<len(a)and-1<a[x]...물론 len(a)항상 >-1이므로 위의 내용은 같습니다. 이 검사는 5 개 연쇄 관계의 합계이다 ( <, >, <, !=, 및 ==), 플러스 별도 체크 -1<x의 if상태.

파이썬은 (단순하게) 이와 같은 연쇄 관계를 단락 x>=len(a)시킵니다. 예를 들어 검사가 False도착하기 전에 반환 되면 a[x](그렇지 않으면을 발생 IndexError시킵니다).