Hãy tưởng tượng bạn có một mảng các số nguyên, có các giá trị không âm là con trỏ tới các vị trí khác trong cùng một mảng, chỉ các giá trị đó đại diện cho các đường hầm, vì vậy nếu giá trị ở vị trí A là dương và trỏ đến vị trí B, thì giá trị ở vị trí B cũng phải dương và chỉ vào vị trí A để thể hiện cả hai đầu của đường hầm. Vì thế:

Thử thách

• Đưa ra một mảng các số nguyên, kiểm tra xem mảng có tuân theo giới hạn là một mảng đường hầm hay không và trả về hai giá trị riêng biệt, mạch lạc cho tính trung thực và falsey.
• Các giá trị trong mảng sẽ ở dưới 0 đối với các vị trí không phải đường hầm và 0 hoặc cao hơn đối với các vị trí đường hầm. Nếu mảng của bạn được lập chỉ mục 1, thì giá trị 0 biểu thị vị trí không đường hầm. Các giá trị không phải là đường hầm không cần phải được kiểm tra.
• Nếu một giá trị dương trong một ô chỉ vào chính nó, thì đó là một con chim ưng. Nếu A chỉ vào B, B đến C và C đến A, đó là một con chim ưng. Nếu một giá trị dương chỉ ra ngoài giới hạn của mảng, đó là một con chim ưng.

Ví dụ

Các ví dụ sau được lập chỉ mục 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)

Đây là môn đánh gôn , vì vậy có thể mã ngắn nhất cho mỗi ngôn ngữ sẽ giành chiến thắng!

R , 47 byte

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

Hãy thử trực tuyến!

Mã không được kiểm soát và giải thích:

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
}

Python 2 , 66 61 60 byte

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

Hãy thử trực tuyến!

APL (Dyalog Unicode) , 19 24 byte

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

Hãy thử trực tuyến!

Tiền tố ẩn danh lambda, trả về 1 cho sự thật và 0 cho giả. Liên kết TIO chứa phiên bản "được chỉnh sửa" của đầu ra cho các trường hợp thử nghiệm.

Hét lên @ngn và @ Adám để tiết kiệm khoảng một triệu byte.

Một tiếng hét thêm cho @ngn để được giúp đỡ sửa câu trả lời cho một số trường hợp thử nghiệm và biến nó thành một chuyến tàu.

Câu trả lời được cập nhật sử dụng ⎕IO←0, đặt I ndex O rigin thành 0.

Làm sao:

×/<∘≢⍨×≠∘⍳∘≢⍨×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)

JavaScript (ES6), 35 byte

Đã lưu 1 byte nhờ @Shaggy

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

Hãy thử trực tuyến!

Đã bình luận

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

Python 2 , 65 byte

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

Hãy thử trực tuyến!

Thạch , 16 byte

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

Hãy thử trực tuyến!

1 chỉ mục.

Perl 6 , 36 byte

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

Hãy thử trực tuyến!

Ý tưởng cơ bản là để kiểm tra xem các bộ { i, a[i], a[a[i]] }chứa chính xác hai yếu tố riêng biệt cho mỗi chỉ số ivới a[i] >= 0. Nếu một phần tử trỏ đến chính nó, tập hợp chỉ chứa một phần tử riêng biệt duy nhất. Nếu đầu kia không quay lại i, tập hợp chứa ba phần tử riêng biệt. Nếu a[i] < 0, xxhệ số bằng 0 hoặc âm, do đó, tập hợp { i, a[i] }cũng có hai phần tử riêng biệt.

MATL , 19 18 byte

-1 Byte nhờ Luis

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

Hãy thử trực tuyến! , chỉ cho người đầu tiên, vì tôi không biết làm thế nào để làm tất cả chúng!

Cung cấp 0nếu trung thực, một số nguyên khác không nếu falsey, ví dụ. cho trường hợp thử nghiệm 6 cho 4.

Xin nhớ rằng giống như MATLAB, MATL được lập chỉ mục 1 vì vậy 1 phải được thêm vào các trường hợp thử nghiệm!

Chưa bao giờ chơi gôn ở Esolang trước đây, vì vậy lời khuyên nhận được rất nhiều!

Giải thích:

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 byte

εèNQyNÊ*y0‹~}P

-1 byte nhờ @Dorian .

Hãy thử trực tuyến hoặc xác minh tất cả các trường hợp thử nghiệm .

Giải trình:

ε               # 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 byte

§JªU¦V«aWgU

Thử nó

Bản gốc (cờ w / o), 14 13 byte

eȧJªX¦Y«aUgX

Hãy thử nó hoặc chạy tất cả các trường hợp thử nghiệm

Python, 112 97 96 86 byte

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

Hãy thử trực tuyến!

Trả về Truehoặc False.

-10 byte nhờ @Rod và @TFeld.

K (ngn / k) , 33 byte

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

Hãy thử trực tuyến!

Haskell , 48 byte

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

Xác nhận tất cả các thử nghiệm!

Giải trình

Trước tiên hãy viết mã số một chút. Giống f =<< gnhư \x -> f (g x) x, mã tương đương với

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

đó là một chút rõ ràng hơn.

(\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)

Giải pháp này dựa trên một quan sát đơn giản: hãy alà mảng đầu vào và udanh sách các cặp (i, a[i])trong đó ilà một chỉ mục. Sau đó alà một mảng hợp lệ nếu và chỉ nếu với mọi (x, y)năm uvới y >= 0, cặp (y, x)thuộc về ulà tốt.

Java (JDK) , 89 byte

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

Hãy thử trực tuyến!

Tín dụng

• -3 byte nhờ AlexRacer
• -6 byte nhờ trần

than củi , 22 byte

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

Hãy thử trực tuyến! Liên kết là phiên bản dài dòng của mã. Đầu ra -cho sự thật và không có gì cho giả. Lưu ý: Nhập một mảng trống dường như làm hỏng Char than, nhưng bây giờ bạn có thể nhập một khoảng trắng thay vào đó, gần đủ. Giải trình:

  θ                     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

Pascal (FPC) , 165 155 153 byte

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;

Hãy thử trực tuyến!

Thực hiện chức năng lần này vì đầu vào là mảng. Trả về 1cho sự thật và 0cho falsey.

Sạch , 60 byte

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

Hãy thử trực tuyến!

Sạch sẽ , 142 byte

Phiên bản quái vật quá phức tạp:

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

Hãy thử trực tuyến!

Giải thích:

$ 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

Ruby , 44 byte

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

Hãy thử trực tuyến!

Bình thường , 17 16 byte

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

Dùng thử trực tuyến tại đây hoặc xác minh tất cả các trường hợp thử nghiệm cùng một lúc tại đây .

.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

Chỉnh sửa: nhận ra rằng dấu vết k cũng không cần thiết

Groovy , 52 byte

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

Hãy thử trực tuyến!

Perl 5 , 54 byte

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

Hãy thử trực tuyến!

C (gcc) , 95 byte

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

Hãy thử trực tuyến!

Toán học, 42 byte

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

Chức năng thuần túy. Lấy danh sách các số được lập chỉ mục 1 làm đầu vào và trả về Truehoặc Falselàm đầu ra. Chỉ cần đi theo các đường hầm, đảm bảo rằng các 0bản đồ đến 0, không tồn tại 1 chu kỳ và tất cả các chu kỳ là 2 chu kỳ. (Tôi không hoàn toàn chắc chắn nếu điều này thất bại trong bất kỳ trường hợp cạnh nào, nhưng nó cho kết quả chính xác cho các ví dụ.)

Câu trả lời này không hoạt động. Ở đây chỉ nhằm mục đích minh họa.

Câu trả lời này vượt qua tất cả các trường hợp thử nghiệm (hiện tại) được đăng. Tuy nhiên, nó không thành công (gây ra lỗi) trên đầu vào hợp lệ khác, chẳng hạn như [1, 2]hoặc [1, 0, 3, 7].

Làm thế nào nó có thể vượt qua [1, 0, 3]và thất bại [1, 0, 3, 7]? Vâng, nó tiến hành thông qua danh sách, giống như bạn mong đợi. Khi nó đọc một phần tử xcủa danh sách a, đầu tiên nó sẽ kiểm tra xem xcó nhỏ hơn không len(a), và ngay lập tức trả về False, nếu vậy. Vì vậy, nó sẽ trả về một cách chính xác Falsetrên [1, 0, 3], bởi vì 3không phải là ít hơn len(a).

Nhưng giả sử xvượt qua kiểm tra đó, mã sẽ tiếp tục thực hiện một số kiểm tra khác và tại một thời điểm nhất định, nó sẽ xảy ra để đánh giá a[a[x]]. Chúng tôi đã được bảo đảm rằng việc đánh giá a[x]sẽ ổn ... nhưng không a[a[x]], mà quyết tâm a[7]khi xlà 3trong [1, 0, 3, 7]ví dụ. Tại thời điểm này Python tăng một IndexError, thay vì quay trở lại False.

Để đầy đủ, đây là câu trả lời.

Python 2 , 59 byte

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

Hãy thử trực tuyến!

Tôi muốn làm x<len(a)and-1<a[x]..., nhưng tất nhiên len(a)là luôn luôn >-1, vì vậy, ở trên là tương đương. Kiểm tra này là tổng cộng 5 mối quan hệ xích< , >, <, !=, và ==), cộng với một tấm séc riêng biệt -1<xtrong ifđiều kiện.

Python (thuận tiện) ngắn mạch quan hệ như thế này, vì vậy, ví dụ nếu x>=len(a)sau đó kiểm tra trở lại Falsetrước khi nó được a[x](mà nếu không sẽ tăng một IndexError).