मेरे सुरंग के सरणियों की जाँच करें

18

कल्पना कीजिए कि आपके पास एक पूर्णांक है, जिनके गैर-नकारात्मक मान उसी सरणी में अन्य पदों के लिए संकेत हैं, केवल यह कि वे मान सुरंगों का प्रतिनिधित्व करते हैं, इसलिए यदि स्थिति A में मान धनात्मक है और स्थिति B की ओर इंगित करता है, तो स्थिति में मान बी को भी सकारात्मक होना चाहिए और सुरंग के दोनों सिरों का प्रतिनिधित्व करने के लिए स्थिति ए की ओर इशारा करना चाहिए। इसलिए:

चुनौती

  • पूर्णांक के एक सरणी को देखते हुए, जांचें कि क्या सरणी प्रतिबंध के साथ एक सुरंग बनाने वाले सरणी के रूप में है और दो अलग-अलग, सत्य और गलत के लिए सुसंगत मूल्यों को वापस करता है।
  • सरणी में मान गैर-सुरंग पदों के लिए शून्य से नीचे, और सुरंग पदों के लिए शून्य या अधिक होगा। यदि आपकी सरणी 1-अनुक्रमित है, तो शून्य मान एक गैर-टनल स्थिति का प्रतिनिधित्व करता है। गैर-सुरंग मानों की जाँच करने की आवश्यकता नहीं है।
  • यदि एक सेल में एक सकारात्मक मूल्य खुद को इंगित करता है, तो यह एक गलत है। यदि A, B, B से C और C से 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  array-manipulation  decision-problem 
— चार्ली
स्रोत
3
हमें किसलिए लौटना चाहिए [0]?
— नागिन
1
एनजीएन के सवाल पर विस्तार करते हुए, स्वयं सुरंगों की अनुमति है? मामले [0,1]और क्या [0,-1,2]देंगे?
— डायलन
1
@dylnan [0,1]उदाहरणों में है। "अगर एक सेल में एक सकारात्मक मूल्य खुद को इंगित करता है, तो वह गलत है"
— ngn
1
सुझाए गए परीक्षण:[2,3,0,1]
— नागिन
1
@JonathanAllan सुरंग मान संभव सरणी स्थिति को इंगित करने वाले मान हैं। यदि आपकी सरणी 0-अनुक्रमित है, तो 0 से नीचे प्रत्येक मान एक सुरंग मान नहीं है। यदि यह 1-अनुक्रमित है तो 1 से नीचे का प्रत्येक मान सुरंग मान नहीं है।
— चार्ली

जवाबों:

8

आर , 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
}
— digEmAll
स्रोत
मैं वास्तव में इस उत्तर के लिए स्पष्टीकरण की सराहना करूंगा। :-)
— चार्ली
3
— @Charlie
5

एपीएल (डायलॉग यूनिकोड) , 19 24 बाइट्स

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

इसे ऑनलाइन आज़माएं!

अनाम लंबोदर उपसर्ग, सत्य के लिए 1 और मिथ्या के लिए 0 लौट रहा है। TIO लिंक में परीक्षण मामलों के लिए आउटपुट का "प्रीटेटिफाइड" संस्करण है।

लगभग bazillion बाइट्स को बचाने के लिए @ngn और @ Adáout को चिल्लाओ।

कुछ परीक्षण मामलों के उत्तर को ठीक करने और इसे एक ट्रेन बनाने के साथ मदद के लिए @ngn के लिए एक अतिरिक्त चिल्लाहट।

अद्यतित उत्तर ⎕IO←0सेटिंग का उपयोग करता है I ndex O रिगिन को 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)
— जे। सल्ल
स्रोत
मुझे लगता है कि यह (1), (3 2 1), (5 4 3 2 1) के लिए काम नहीं करता है।
— nwellnhof
0<→ ×मुझे लगता है कि
— ऊरीएल
4

जावास्क्रिप्ट (ईएस 6), 35 बाइट्स

@ बस्ती के लिए 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()
— Arnauld
स्रोत
अच्छी बात यह है कि मैंने अपने जाप समाधान के पोर्ट को पोस्ट करने से पहले समाधानों की जांच की, जो इसके लगभग समान है। आप के साथ एक बाइट बचा सकते हैं a=>a.every((v,i)=>v<0|v!=i&a[v]==i)।
— झबरा
3

पर्ल 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कारक शून्य या नकारात्मक है, तो सेट { i, a[i] }दो अलग-अलग तत्वों के साथ भी है।

— nwellnhof
स्रोत
3

MATL , 19 18 बाइट्स

-1 लुइस को धन्यवाद

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

इसे ऑनलाइन आज़माएं!, केवल पहले एक के लिए, क्योंकि मैं नहीं जानता कि उन सभी को कैसे करना है!

देता है 0यदि truthy, एक गैर शून्य पूर्णांक अगर falsey, उदा। परीक्षण के मामले के लिए 6 देता है4 ।

कृपया याद रखें कि MATLAB की तरह, MATL 1-अनुक्रमित है इसलिए 1 को परीक्षण मामलों में जोड़ा जाना चाहिए!

इससे पहले एसोलंग में कभी गोल्फ नहीं हुई थी, इसलिए बहुत सलाह मिली!

व्याख्या की:

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
— लुई
स्रोत
क्या मेरा स्पष्टीकरण बहुत बुरा है? मैं पूरी तरह से ओवरबोर्ड जाने के बिना इसे स्पष्ट करना चाहता हूं।
— लूई
3

05AB1E , 16 15 14 बाइट्स

εèNQyNÊ*y0‹~}P

-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)
— केविन क्रूज़सेन
स्रोत
मेरी कोशिश फिल्टर के अलावा एक ही थी। मुझे इस पर सुधार करने का कोई रास्ता नहीं दिख रहा है।
— एमिगा
1
14 बाइट्स । आप के वर्तमान मूल्य को धक्का दे सकते हैंε साथy । तो कोई ज़रूरत नहीं है ©, और प्रत्येक ®ने प्रतिस्थापित कियाy
— डोरियन
@ डोरियन आह, निश्चित रूप से .. यह विरासत में संभव नहीं था जब मैंने यह उत्तर पोस्ट किया था, लेकिन मुझे इसके बारे में तब सोचना चाहिए था जब मैंने आज अपना गोल्फ बनाया था। धन्यवाद! :)
— केविन क्रूज़सेन
2

हास्केल , 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])जहां iएक सूचकांक है। फिर aएक वैध सरणी तभी हर के लिए करता है, तो है (x, y)में uसाथ y >= 0, इस जोड़ी (y, x)के अंतर्गत आता है uके रूप में अच्छी तरह से।

— Delfad0r
स्रोत
2

जावा (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;}

इसे ऑनलाइन आज़माएं!

क्रेडिट

— ओलिवियर ग्रेजायर
स्रोत
हो सकता था 87 बाइट्स अगर यह है कि परेशान करने IndexOutOfBoundsException के लिए नहीं थे। शायद आप इसे आसानी से ठीक करने के लिए कुछ देखते हैं?
— केविन क्रूजेसेन
@ केविनक्रूजसेन मैं देख सकता हूं कि 102 बाइट्स के लिए इसे कैसे ठीक किया जाए । अभी तक कुछ भी कम नहीं है :(
— ओलिवियर ग्रेजायर
1
-3 बाइट्स - rलूप को छोड़ दें और यहाँ
— एलेक्सरजर
1

चारकोल , 22 बाइट्स

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

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। सच्चाई के -लिए आउटपुट और झूठे के लिए कुछ भी नहीं। नोट: खाली सरणी इनपुट करने से चारकोल क्रैश हो जाता है, लेकिन अभी के लिए आप इसके बजाय एक स्थान दर्ज कर सकते हैं, जो पर्याप्त है। स्पष्टीकरण:

  θ                     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
— नील
स्रोत
यह एक बहुत ही चुनौतीपूर्ण चुनौती नहीं लगती ... :-)
— चार्ली
1

पास्कल (एफपीसी) , 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 के लिए।

— AlexRacer
स्रोत
1

साफ , 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
— Οurous
स्रोत
1

पायथ , 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

संपादित करें: एहसास हुआ कि अनुगामी कश्मीर भी अनावश्यक था

— सोक
स्रोत
0

गणितज्ञ, 42 बाइट्स

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

शुद्ध कार्य। इनपुट और रिटर्न Trueया Falseआउटपुट के रूप में संख्याओं की 1-अनुक्रमित सूची लेता है । बस सुरंगों के बाद, यह सुनिश्चित करना कि 0नक्शे में 0कोई भी 1-चक्र मौजूद नहीं है, और सभी चक्र 2-चक्र हैं। (यदि मैं किसी भी किनारे के मामलों में विफल रहता हूं तो मुझे पूरी तरह से यकीन नहीं है, लेकिन यह उदाहरणों के लिए सही परिणाम देता है।)

— LegionMammal978
स्रोत
0

यह उत्तर काम नहीं करता है। यहाँ केवल उदाहरण के लिए।

यह उत्तर सभी (वर्तमान में) पोस्ट किए गए परीक्षण मामलों को पास करता है। हालाँकि, यह अन्य मान्य इनपुट, जैसे कि [1, 2]या पर विफल (त्रुटि उठाता है)[1, 0, 3, 7] ।

यह कैसे पास [1, 0, 3]और फेल हो सकता है [1, 0, 3, 7]? ठीक है, यह सूची के माध्यम से आगे बढ़ता है, जैसे आप उम्मीद करेंगे। जब यह xसूची के एक तत्व को पढ़ता है a, तो यह पहले जांचता है कि क्या xइससे कम है len(a), और तुरंत रिटर्न False, यदि ऐसा है। तो यह सही ढंग से लौटता Falseहै [1, 0, 3], क्योंकि 3इससे कम नहीं हैlen(a) ।

लेकिन यह मानकर कि xउस चेक को पास कर दिया जाता है, कोड फिर कुछ अन्य चेक करने के लिए जाएगा, और एक निश्चित बिंदु पर यह मूल्यांकन करने के लिए होता है a[a[x]]। हम पहले ही गारंटी दे चुके हैं कि मूल्यांकन a[x]करना ठीक होगा ... लेकिन ऐसा नहीं है a[a[x]], जो उदाहरण में a[7]कब xहै । इस बिंदु पर, पायथन लौटने के बजाय, एक उठाता है3[1, 0, 3, 7]IndexErrorFalse ।

पूर्णता के लिए, यहाँ जवाब है।

अजगर 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)।

— mathmandan
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.