बहुत सारे जासूस!

Question

आप दुश्मन के जासूसों के व्यापक नेटवर्क से लड़ रहे हैं । आप जानते हैं कि प्रत्येक जासूस की कम से कम एक (कभी-कभी कई) नकली पहचान होती है, जिसका वे उपयोग करना पसंद करते हैं। आप वास्तव में जानना चाहेंगे कि आप वास्तव में कितने जासूसों के साथ काम कर रहे हैं।

सौभाग्य से, आपके काउंटर-इंटेलिजेंस एजेंट अपना काम कर रहे हैं और कभी-कभी यह पता लगा सकते हैं कि दो नकली पहचान वास्तव में एक ही दुश्मन जासूस द्वारा नियंत्रित की जाती हैं।

यानी:

• आपके एजेंटों को हमेशा नहीं पता होता है कि दो नकली पहचान के पीछे एक ही जासूस है, हालांकि
• यदि कोई एजेंट आपको बताता है कि दो नकली पहचान एक ही जासूस द्वारा नियंत्रित की जाती हैं, तो आप भरोसा करते हैं कि वे सही हैं।

एजेंट संदेश

एजेंट आपको गुप्त संदेश भेजते हैं जो आपको बताते हैं कि उनके पीछे कौन सी पहचान है। एक उदाहरण:

आपके पास सौदा करने के लिए 2 एजेंट और 5 नकली पहचान हैं ।

पहला एजेंट आपको एक संदेश भेजता है:

Red Red Blue Orange Orange

इसका मतलब है कि उन्हें लगता है कि 3 जासूस हैं:

• पहला वाला (रेड) पहचान 1 और 2 को नियंत्रित करता है
• दूसरा वाला (नीला) पहचान 3 को नियंत्रित करता है
• तीसरा एक (ऑरेंज) पहचान 4 और 5 को नियंत्रित करता है

दूसरा एजेंट आपको एक संदेश भेजता है:

cat dog dog bird fly

इसका मतलब है कि उन्हें लगता है कि 4 जासूस हैं:

• पहले वाला (बिल्ली) पहचान 1 को नियंत्रित करता है
• दूसरा वाला (कुत्ता) पहचान 2 और 3 को नियंत्रित करता है
• तीसरा एक (पक्षी) पहचान को नियंत्रित करता है 4
• चौथा एक (मक्खी) पहचान को नियंत्रित करता है 5

हमारे द्वारा देखे गए विज्ञान को संकलित करना:

Identities:   id1    id2    id3    id4    id5 
Agent 1:    |--same-spy--|       |--same-spy--|
Agent 2:           |--same-spy--|
Conclusion: |-----same-spy------||--same-spy--|

इसका मतलब है कि ज्यादातर 2 जासूस हैं ।

टिप्पणियाँ

एक ही जासूस के स्वामित्व वाली पहचान लगातार नहीं होती है, जैसे एक संदेश:

dog cat dog

यह सही है।

इसके अलावा, एक ही शब्द का इस्तेमाल दो अलग-अलग एजेंटों द्वारा किया जा सकता है - इसका मतलब कुछ भी नहीं है, यह सिर्फ एक संयोग है, उदाहरण के लिए:

Agent 1: Steam Water Ice
Agent 2: Ice Ice Baby

बर्फ का उपयोग दोनों एजेंटों द्वारा किया जाता है - Iceपहले एजेंट Iceद्वारा उपयोग दूसरे एजेंट द्वारा उपयोग की जाने वाली दो घटनाओं से असंबंधित है ।

चुनौती

अपने सभी एजेंटों की बुद्धि संकलित करें और पता लगाएं कि वास्तव में कितने दुश्मन हैं। (अधिक सटीक होने के लिए, सबसे ऊपरी ऊपरी सीमा प्राप्त करें, जो आपके पास सीमित जानकारी है।)

बाइट्स में सबसे छोटा कोड जीतता है।

इनपुट और आउटपुट युक्ति

इनपुट n लाइनों की एक सूची है, जो एजेंटों के n संदेशों का प्रतिनिधित्व करती है। प्रत्येक पंक्ति में k- अलग-अलग टोकन होते हैं, सभी लाइनों के लिए एक ही k होता है। टोकन अल्फ़ान्यूमेरिक हैं, मनमानी लंबाई। मामला मायने रखता है।

आउटपुट एक एकल संख्या होनी चाहिए, जो आपके एजेंटों की बुद्धि के आधार पर, अलग-अलग जासूसों की संख्या का प्रतिनिधित्व करती है।

उदाहरण

उदाहरण 1

इनपुट:

Angel Devil Angel Joker Thief Thief
Ra Ra Ras Pu Ti N
say sea c c see cee

आउटपुट:

2

उदाहरण 2

इनपुट:

Blossom Bubbles Buttercup
Ed Edd Eddy

आउटपुट:

3

उदाहरण 3

इनपुट:

Botswana Botswana Botswana
Left Middle Right

आउटपुट:

1

उदाहरण 4

इनपुट:

Black White
White Black

आउटपुट:

2

उदाहरण 5

इनपुट:

Foo Bar Foo
Foo Bar Bar

आउटपुट:

1

उदाहरण 6

इनपुट:

A B C D
A A C D
A B C C
A B B D

आउटपुट:

1

उदाहरण 7

इनपुट:

A B A C

आउटपुट:

3

उदाहरण 8

इनपुट:

A
B
C

आउटपुट:

1

उदाहरण 9

इनपुट:

X

आउटपुट:

1

Comments

क्या हम प्रत्येक पंक्ति को शब्दों के एक सरणी के रूप में ले सकते हैं?

— अरनुलद

@HenryHenrinson इनपुट को सख्त बनाने वाली एकमात्र चीज़ इनपुट प्रारूप को बदलने के लिए कोड की शुरुआत में एक छोटा ब्लर है। यह वास्तव में चुनौती के लिए कुछ भी नहीं जोड़ता है

— f .nɪt Julk

मुझे लगता है कि इस तरह के कोड गोल्फ को और अधिक अवसर देगा :)

— हेनरी हेनरिंस

सख्त I / O प्रारूप वास्तव में हतोत्साहित होते हैं क्योंकि वे चुनौती के मूल से अलग होते हैं। उदाहरण के लिए, यह सुनिश्चित करना कि इनपुट अंतरिक्ष से अलग किए गए शब्दों की लाइनों के रूप में है, आवश्यक नहीं है, क्योंकि कोई भी प्रत्येक पंक्ति को शब्दों की एक सूची के रूप में प्रस्तुत कर सकता है (जिसे अरनॉल्ड ने कहा था), और केवल यही चीज इस नियम को चुनौती में जोड़ती है लाइनों को विभाजित करने की आवश्यकता है, ऐसा कुछ जो जरूरी नहीं कि चुनौती का एक हिस्सा है।

— आउटगोल्फर

यह शीर्षक आपके औसत टीम किले 2 गेम की तरह लगता है!

— Tvde1

Answer 1

स्लेजहैमर 0.5.1 , 16 15 बाइट्स

⡡⠥⡀⡾⠥⢢⠍⣽⡷⣩⣅⡷⣡⢒⠅

इस वुल्फराम भाषा समारोह में व्याख्या (अंतिम &निहित है):

Length[ConnectedComponents[RelationGraph[Inner[Equal, ##1, Or] &,
    Transpose[StringSplit @ #1]]]] &

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

Transpose[StringSplit @ #1]: इनपुट सूची में प्रत्येक स्ट्रिंग को विभाजित करें, और कॉलम लें (जासूसी पहचान)

RelationGraph[Inner[Equal, ##1, Or] &, ...]: उस ग्राफ़ का निर्माण करें जहां दो कोने एक किनारे साझा करते हैं यदि कम से कम एक स्थिति बराबर है (यदि उन्हें एक ही जासूस के रूप में वर्गीकृत किया जाता है जो किसी अन्य अनुकूल स्थान पर है)

Length[ConnectedComponents[...]]: जुड़े घटकों की संख्या जासूसों की संभावित संख्या पर ऊपरी बाध्य है।

Answer 2

जावास्क्रिप्ट (Node.js) ,  155 150 142  141 बाइट्स

a=>new Set((a=a.map(s=>s.split` `))[0].map((_,x)=>a.flat(m=1<<x).map(o=_=>a.map((b,y)=>b.map((w,i)=>m>>i&1|o[w+=y]?o[w]=m|=1<<i:0)))|m)).size

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

कैसे?

$x$$m$$x$

+---------+-------+-------+-------+-------+-------+-------+
| x       |   0   |   1   |   2   |   3   |   4   |   5   |
+---------+-------+-------+-------+-------+-------+-------+
| 2**x    |   1   |   2   |   4   |   8   |  16   |  32   |
+---------+-------+-------+-------+-------+-------+-------+
| words   | Angel | Devil | Angel | Joker | Thief | Thief |
|         | Ra    | Ra    | Ras   | Pu    | Ti    | N     |
|         | say   | sea   | c     | c     | see   | cee   |
+---------+-------+-------+-------+-------+-------+-------+
| bitmask |  15   |  15   |  15   |  15   |  48   |  48   |
+---------+-------+-------+-------+-------+-------+-------+

टिप्पणी की गई

a =>                      // a[] = input
new Set(                  // we eventually convert the generated array into a set
  (a = a.map(s =>         // we first need to convert each line into
    s.split` `            // an array of words (*sigh*)
  ))                      //
  [0].map((_, x) =>       // for each word at position x in the first line:
    a.flat(m = 1 << x)    //   initialize a bitmask m with the x-th bit set and build an
                          //   array containing as many entries (N) as there are words in
                          //   the whole matrix
    .map(o =              //   the object o is used to store words
         _ =>             //   repeat N times to ensure that all relations are found:
      a.map((b, y) =>     //     for each line b[] at position y in a[]:
        b.map((w, i) =>   //       for each word w at position i in b[]:
          m >> i & 1 |    //         if the i-th bit is set in m (the relation already
                          //         exists)
          o[w += y] ?     //         or w + y is set in o (a relation exists in this line):
            o[w] =        //           set o[w + y] (the value doesn't matter as long as
                          //           it's non-zero)
              m |= 1 << i //           set the i-th bit in m
          :               //         else:
            0             //           do nothing
        )                 //       end of map() over the words
      )                   //     end of map() over the lines
    ) | m                 //   end of map() over all flatten entries; yield m
  )                       // end of map() over x
).size                    // return the size of the corresponding set

Comments

तो ... व्यवहार में, यह एक 32 या 64 पहचान की सीमा होगी?

— विलेक्स-

@ विलक्स- मुझे लगता है कि वह बिगआईंट पर स्विच कर सकता है, हालांकि यह निश्चित रूप से बाइट्स का खर्च होगा।

— नील

Answer 3

जेली , 19 बाइट्स

ḲiⱮ`)ZŒc€ẎyⱮ@ƒƊÐLQL

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

इनपुट को अंतरिक्ष से अलग लाइनों (उस के लिए पाद लेख) की सूची के रूप में लेता है।

नोट: ḲŒQ)PSकाम नहीं करता है।

Answer 4

पायथन 3 , 132 162 154 139 135 बाइट्स

def f(a):r=[*zip(*[map(b.index,b)for b in map(str.split,a)])];return sum(i==min(min(u)for u in r if min(w)in u)for i,w in enumerate(r))

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

यह गुच्छों की पहचान करने वाले एक ग्राफ एल्गोरिथ्म का एक बहुत कॉम्पैक्ट कार्यान्वयन है।

1. प्रत्येक एजेंट के लिए, हम प्रोफाइल और उनके उपनाम का एक नक्शा बनाते हैं, जो उपस्थिति का सबसे कम सूचकांक है [map(b.index,b)for b in map(str.split,a)]:। Ie [0,1,2,1,2]तीन जासूसों की पहचान करता है, जहां पहली प्रोफ़ाइल एक की है, दूसरी और चौथी की एक दूसरे से और तीसरी और पांचवीं से आखिरी की है। समूह सूचकांक समूह में पहली प्रोफ़ाइल का सूचकांक भी है।

2. इस मैट्रिक्स को ट्रांसपोज़ करके ( [*zip(*m...)]), हमें प्रत्येक प्रोफ़ाइल के लिए एक समूह सदस्यता मिलती है। यह एक निर्देशित, एसाइक्लिक ग्राफ बनाता है, क्योंकि समूह सूचकांक प्रोफ़ाइल सूचकांकों का एक सबसेट होते हैं, और सभी किनारे कम या बराबर सूचकांकों की ओर जाते हैं। उसी जासूसी से संबंधित प्रोफाइल अब अन्य प्रोफाइल के बिना कनेक्शन के साथ एक क्लस्टर बनाती है। हमारे पास अभी भी डुप्लिकेट पथ हैं, क्योंकि प्रोफ़ाइल इंडेक्स कई समूहों के इंडेक्स से जुड़े हैं।

3. निम्नलिखित छोरों के साथ, हम ग्राफ को एक समतल जंगल में कम से कम करते हैं, जहां सभी प्रोफाइल सीधे उनके पेड़ में सबसे निचले सूचकांक से जुड़े होते हैं, अर्थात मूल: min(min(u)for u in r if min(w)in u)

4. अंत में, जंगल में जड़ों की संख्या लौटाएं, यानी खुद से जुड़े सूचकांक return sum(i==...):।

Comments

क्या इंडेंटेशन जरूरी है? यह तब से युग है जब मैंने अजगर का उपयोग किया था, लेकिन मुझे याद है कि आप ऑन्लाइनर बना सकते हैं।

— मार्क गार्डनर

आप कर सकते हैं, लेकिन अगर आप छोरों के लिए नेस्टेड का उपयोग नहीं करते हैं। TIO खुद के लिए;)

— चल जमैका

Answer 5

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

≔⪪Ｓ θＷＳ«≔⪪ι ιＦＬιＵＭθ⎇⁼λ§θκ§θ⌕ι§ικλ»ＩＬΦθ⁼κ⌕θι

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। संभवतः एक बोझिल इनपुट प्रारूप का उपयोग करके कुछ बाइट्स बचा सकता है। स्पष्टीकरण:

≔⪪Ｓ θ

पहले एजेंट की सूची इनपुट करें।

ＷＳ«

शेष एजेंटों के लिए दोहराएँ।

≔⪪ι ι

उनकी सूची इनपुट करें।

ＦＬι

प्रत्येक तत्व सूचकांक पर लूप।

ＵＭθ⎇⁼λ§θκ§θ⌕ι§ικλ»

इस एजेंट की सूची में पहले तत्व को उसी पहचान के साथ खोजें और पहले एजेंट की सूची को अपडेट करके दिखाएं कि वे समान पहचान हैं।

ＩＬΦθ⁼κ⌕θι

शेष विशिष्ट पहचानों की संख्या की गणना करें।

Answer 6

जेली , 25 15 बाइट्स

ḲĠ)ẎfƇFQɗⱮQ$ÐLL

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

स्पेस-अलग-अलग एजेंट के दावों की एक सूची लेने और अलग-अलग जासूसों की संख्या के सबसे ऊपरी ऊपरी हिस्से को वापस करने के लिए एक विवादास्पद लिंक।

व्याख्या

  )              | For each list:
Ḳ                | - Split at spaces
 Ġ               | - Group indices of equal items
   Ẏ             | Tighten lists, so we have a single list of grouped indices
           $ÐL   | Repeat the following until no change:
        ʋⱮQ      | - Do the following as a dyad, mapping through each element of the uniquified list as the right argument
    fƇ           |   - Keep only those list members with one or more items matching the right argument
      F          |   - Flatten
       Q         |   - Uniquify
              L  | Finally take the length of the resultant list

पिछले संस्करणों के साथ मुद्दों की पहचान करने के लिए @Arnauld और @JonathanAllan और एक बाइट को बचाने के लिए @JonathanAllan को धन्यवाद! यदि सूची की सूची की अनुमति देने के लिए इनपुट युक्ति को शिथिल किया गया, तो इससे एक बाइट बच जाएगी।

Comments

मुझे लगता है कि वास्तव में यह छंटनी अनावश्यक हो सकती है, क्योंकि समूहों में सूचकांकों Ġको क्रमबद्ध किया गया है और चपटा, डी-डुप्लिकेट किया हुआ फ़िल्टर परिणाम है, fƇFQहमेशा, बार-बार आवेदन के बाद, क्रमबद्ध क्रम में इन के साथ समाप्त 'a a b b c', 'a b a b cहोगा (जैसे एक अंतिम नहीं मिलेगा [3,4,1,2], हालांकि यह रास्ते में दिखाई देगा)। तो ḲĠ)ẎfƇFQɗⱮQ$ÐLL15 के लिए अच्छा हो सकता है?

— जोनाथन एलन

@JonathanAllan अच्छा स्थान। मेरे पास एक नाटक है (और सोचें कि यह कैसे काम करता है) और सोचें कि आप सही हैं।

— निक केनेडी

Answer 7

जावास्क्रिप्ट (Node.js) , 120 बाइट्स

a=>a.map(l=>(s=l.split` `).map((w,i)=>r[o(i)]=o(s.indexOf(w)),o=i=>r[i]-i?o(r[i]):i),r=[])|r.map(g=(v,i)=>t+=v==i,t=0)|t

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

a=>a.map(l=>(                  // for each line
  (s=l.split` `).map((w,i)=>(  // for each words in line
    r[o(i)]=o(s.indexOf(w)),   // join(current index, first occurrence index)
  )),                          //   without updating nodes in path
  o=i=>r[i]-i?o(r[i]):i,       // a function to find root of some node
  r=[]                         // initial disjoint-set
))|
r.map(g=(v,i)=>t+=v==i,t=0)|   // count roots of tree
t                              // output

Answer 8

भूसी , 12 बाइट्स

LωomΣknṁoηkw

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

व्याख्या

यह विचार जासूसों के सभी समूहों की एक सूची बनाने के लिए है जो एक ही व्यक्ति के रूप में जाने जाते हैं, फिर एक निश्चित बिंदु तक पहुंचने तक समूहों को क्रमिक रूप से मर्ज करते हैं। आउटपुट शेष समूहों की संख्या है जिन्हें विलय नहीं किया जा सकता है।

LωomΣknṁoηkw  Implicit input: list of strings, say ["a bc a","b g g"]
       ṁ      Map and concatenate:
           w   Split at spaces: "a bc a" becomes ["a","bc","a"]
         ηk    Group indices by equality of elements: [[1,3],[2]]
              Result: [[1,3],[2],[1],[2,3]]
 ω            Iterate until result doesn't change:
     k         Group greedily by
      n        (non-emptiness of) intersection: [[[1,3],[1]],[[2],[2,3]]]
   mΣ          Concatenate each part: [[1,3,1],[2,2,3]]
              Result: [[1,3,1,2,2,3]]
L             Length: 1

Answer 9

पायथन 3 ,191 182 बाइट्स

धन्यवाद पुनरावर्ती

e=enumerate
def f(a):
	r=[list(map(b.index,b))for b in map(str.split,a)]
	for z in r:
		for i,v in e(z):
			for x in(i>v)*r:x[(i,x[i])[x[i]<i]]=z[v]
	return sum(i==v for i,v in e(z))

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

Comments

-9 बाइट्स: tio.run/…

— पुनरावर्ती

Answer 10

रूबी , 123 117 बाइट्स

एक समान विचार का उपयोग करता है Movatica के पायथन 3 समाधान लेकिन प्रत्येक "ट्री" के लिए सबसे कम जासूस सूचकांक की गणना थोड़े अलग तरीके से करता है (पिछले सामना किए गए प्रोफाइल का ट्रैक रखकर, यदि यह मौजूद है, तो एक ओवरलैप ढूंढकर और उन्हें मिलाकर)

-6 बाइट्स @ जीबी से।

->a,*b{a.map{|s|e=s.split;e.map{|i|e.index i}}.transpose.map{|e|b<<(b.find{|i|i-e!=i}||[])+e}
b.map(&:min).uniq.size}

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

व्याख्या

->a,*b{                                             # Start lambda with input a, b=[]
       x=
         a.map{|s|                             }    # For each agent's report
                  e=s.split;                        # Split the words
                            e.map{|i|e.index i}     # Get spy number for each

   .transpose                                       # Transpose to get group membership
             .map{|e|                            }  # For each profile
                        (b.find{|i|i-e!=i}||[])     # Find a profile in b that overlaps
                                                    #  If one is not found, use []
                                               +e   # Add the profile onto the found one
                     b<<                            # Insert this modified profile into b

b.map(&:min)                                        # Get minimum of each modded profile
            .uniq                                   # Deduplicate
                 .size                              # Size of array
}                                                   # Implicit return

Comments

पॉपिंग और जिपिंग के बजाय, आप सिर्फ ट्रांसपोज़ कर सकते हैं।

— GB

113 बाइट्स

— जीबी

@GB सिर के लिए धन्यवाद; मैं पॉप-जिप या शिफ्ट-जिप का उपयोग हमेशा के लिए सरणियों को स्थानांतरित करने के लिए कर रहा हूं! साथ ही, आपके उपयोग की चाल s.split.map{|i|s.index i}अच्छी है, लेकिन यह इनपुट की लंबाई के आधार पर किनारे के मामले बना सकता है। यह इनपुट 3 नहीं, बल्कि 2 लौटना चाहिए

— वैल्यू इंक

Answer 11

पायथन 2 , 229 221 बाइट्स

e=enumerate
def f(s):
 v=[];u=sum([(lambda a:[{i for i,x in e(a)if x==k}for k in set(a)])(a.split())for a in s.split('\n')],v)
 while u:
	x=u.pop()
	for i,y in e(u):
	 if x&y:u.pop(i);u+=[x|y];break
	else:v+=[x]
 return v

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

8 बाइट्स विल्केबेन को ।

Comments

चूंकि gकेवल एक बार उपयोग किया जाता है, क्या आप इसे इनलाइन परिभाषित नहीं कर सकते? मुझे लगता है कि अगर यह संभव है कि अजगर में भूल जाते हैं, लेकिन मुझे लगता है कि यह याद है।

— स्टीफन

221 बाइट्स

— विल्केन

Answer 12

क्लीन , 137 बाइट्स

import StdEnv,Text,Data.List
q=length
$l=q(iter(q l)(map flatten o groupBy isAnyMember)(transpose[[(s,n)\\s<-split" "z]\\z<-l&n<-[1..]]))

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

एजेंटों द्वारा उपयोग किए जाने वाले तारों को जोड़ते हैं, लाइन-संख्या के साथ एजेंटों को समानता को रोकने के लिए दिखाई देते हैं, फिर बार-बार जांचते हैं कि क्या किसी पद के लिए कोई वाक्यांश ओवरलैप करता है और परिणामी सेट की संख्या को गिनता है।

Answer 13

PHP , 271 बाइट्स

यह किसी भी पहचान के साथ काम नहीं करेगा क्योंकि मैं पहचान के साथ "जासूसी नंबर" को स्टोर करता हूं। मुझे नहीं लगता कि हालांकि इसे ठीक करना मुश्किल नहीं होगा।

$a=$argv;array_shift($a);if(count($a)==1)array_push($a,...$a);foreach($a as&$b)$b=explode(" ",$b);$c=array_map(null,...$a);foreach($c as&$d)foreach($d as$k=>$e){if(!$d[s])$d[s]=++$s;foreach($c as&$f)if($f[$k]==$e)$f[s]=$d[s];}echo count(array_unique(array_column($c,s)));

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

व्याख्या

अपने आप को यह लिखने में उलझन में है लेकिन यह सभी परीक्षण मामलों के लिए काम करता है!

$a=$argv;					//shorten the arguments variable
array_shift($a);				//removes the script name from the arguments variable
if(count($a)==1)array_push($a,...$a);		//the code needs at least 2 messages to run so if only 1 message duplicate it. "..." passes the stuff in the array rather than the array itself?
foreach($a as&$b)$b=explode(" ",$b);		//turns each string message into an array
$c=array_map(null,...$a);			//if you give array_map "null" for the callabck then it zips the arrays, turning a m by n 2D array into a n by m 2D array. this changes it from the messages being grouped to the identities being grouped
foreach($c as&$d)				//loop over the groups of identities
	foreach($d as$k=>$e)			//loop over the names the agents gave the identity and keep track of the key
	{
		if(!$d[s])$d[s]=++$s;		//if this identity doesn't have a "spy number" give it the next one
		foreach($c as&$f)		//loop over the groups of identities again
			if($f[$k]==$e)		//check if the agents gave any other identities this name 
				$f[s]=$d[s];	//if they did then give those the same "spy number"
	}
echo count(array_unique(array_column($c,s)));	//use array_column to get the "spy number" of each identity, remove duplicates using array_unique and then count the size of the array giving the upper limit of spies

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