चारों ओर से घिरे देश

Question

देश एक 1D दुनिया पर क्षेत्रों की एक श्रृंखला के मालिक हैं। प्रत्येक देश विशिष्ट रूप से एक नंबर से पहचाना जाता है। प्रदेशों के स्वामित्व को निम्नानुसार एक सूची द्वारा दर्शाया जा सकता है:

1 1 2 2 1 3 3 2 4

हम किसी देश के एडग्मोस्ट प्रदेश को दो क्षेत्रों के रूप में परिभाषित करते हैं जो दोनों किनारों के सबसे निकट है। यदि उपरोक्त सूची शून्य अनुक्रमित किया गया था, देश 1के edgemost प्रदेशों स्थिति में पाए जाते हैं 0और 4।

एक देश एक और चारों ओर से घेरता है अगर उसके दो edgemost क्षेत्रों के बीच की सूची में दूसरे देश के सभी क्षेत्र शामिल हैं। उपरोक्त उदाहरण में, देश 2के edgemost क्षेत्रों के बीच की सूची है:

2 2 1 3 3 2

और हम देखते हैं कि देश के सभी क्षेत्र देश 3के edgemost क्षेत्रों के बीच हैं 2, इसलिए देश देश के 2चारों ओर है 3।

केवल एक तत्व वाला देश कभी दूसरे को नहीं घेरेगा।

चुनौती

पूर्णांक की सूची इनपुट के रूप में (किसी भी प्रारूप में) लें और यदि कोई देश किसी दूसरे देश से घिरा हुआ है, और एक मिथ्या मूल्य है , तो सत्य मूल्य का उत्पादन करें ।

आप मान सकते हैं कि इनपुट सूची गैर-रिक्त है, केवल सकारात्मक पूर्णांक हैं, और किसी भी संख्या को 'स्किप' नहीं करता है: उदाहरण के लिए, 1 2 1 5अमान्य इनपुट होगा।

परीक्षण के मामलों

+----------------------+--------+
|        Input         | Output |
+----------------------+--------+
| 1                    | False  |
| 2 1 3 2              | True   |
| 2 1 2 1 2            | True   |
| 1 2 3 1 2 3          | False  |
| 1 3 1 2 2 3 2 3      | True   |
| 1 2 2 1 3 2 3 3 4    | False  |
| 1 2 3 4 5 6 7 8 9 10 | False  |
+----------------------+--------+

Comments

PPCG में आपका स्वागत है! आपके पहले प्रश्न पर बधाई; यह वास्तव में अच्छा लग रहा है!

— मेगो

और देश को घेरने के लिए मुझे अपनी अगली सेना की कितनी सेनाएँ मिलेंगी ?

— ThisSuitIsBlackNot

Answer 1

पायथ, 7 बाइट्स

n{Q_{_Q

परीक्षण मामलों पर कोड चलाएँ।

n      Check whether the following are not equal:
 {Q     The unique elements in order of first appearance
 _{_Q   The unique elements in order of last appearance
         (done by reversing, taking unique elts, then reversing again)

आस-पास से बचने का एकमात्र तरीका देशों के बाईं ओर के क्षेत्रों को उसी क्रम में क्रमबद्ध किया जाना है, जैसा कि उनका अधिकार क्षेत्र है। यदि इस क्रम में दो देशों की अदला-बदली की जाती है, तो एक क्षेत्र में आगे और पीछे दोनों ओर एक क्षेत्र है, और इसलिए यह चारों ओर से घिरा हुआ है।

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

Answer 2

रेटिना , 61 60 बाइट्स

मैं जितना चाहूंगा उससे बहुत अधिक ...

(\b(\d+)\b.* (?!\2 )(\d+) .*\b\2\b)(?!.* \3\b)(?<!\b\3 .*\1)

उन देशों की संख्या छापता है जो कम से कम एक दूसरे देश को घेरते हैं।

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

यह कल्पना की एक बहुत ही सरल कार्यान्वयन है: हम पैटर्न के लिए देखो A...B...Aऐसा है कि Bन तो पहले या मैच के बाद दिखाई देता है।

Answer 3

पायथन, 64 बाइट्स

lambda l,S=sorted:S(l,key=l.index)!=S(l,key=l[::-1].index)[::-1]

आस-पास से बचने का एकमात्र तरीका देशों के बाईं ओर के क्षेत्रों को उसी क्रम में क्रमबद्ध किया जाना है, जैसा कि उनका अधिकार क्षेत्र है। यदि इस क्रम में दो देशों की अदला-बदली की जाती है, तो एक क्षेत्र में आगे और पीछे दोनों ओर एक क्षेत्र है, और इसलिए यह चारों ओर से घिरा हुआ है।

फ़ंक्शन जाँचता है कि बाईं ओर और सबसे सही उपस्थिति द्वारा प्रदेशों को क्रमबद्ध करना समान परिणाम देता है। दुर्भाग्य से, पायथन सूचियों के rindexअनुरूप नहीं है rfind, इसलिए हम सूची को उल्टा करते हैं, फिर क्रमबद्ध आउटपुट को उल्टा करते हैं।

एक सहायक समारोह के साथ एक ही लंबाई (64):

g=lambda l:sorted(l,key=l.index)
lambda l:g(l)[::-1]!=g(l[::-1])

Answer 4

सी #, 113 बाइट्स

public bool V(int[] n){var u1=n.Distinct();var u2=n.Reverse().Distinct().Reverse();return !u1.SequenceEqual(u2);}

Ungolfed:

public bool ContainsSurroundedCountry(int[] numbers)
{
    int[] uniqueLeftmost = numbers.Distinct().ToArray();
    int[] uniqueRightmost = numbers.Reverse().Distinct().Reverse().ToArray();

    return !uniqueLeftmost.SequenceEqual(uniqueRightmost);
}

संक्षिप्त LINQदृष्टिकोण का उपयोग करना ।

Comments

PPCG में आपका स्वागत है। यह एक बहुत अच्छा ungolfed समाधान है; मुझे अक्सर नए उपयोगकर्ताओं को सूचित करना पड़ता है कि लोग अक्सर अपने कोड के असंगठित (पठनीय, टिप्पणी) संस्करणों को देखना पसंद करते हैं। हालाँकि, आप एक गोल्फ संस्करण शामिल करना भूल गए हैं! कई चालें हैं जिनका आप उपयोग कर सकते हैं, जिसमें 1char चर नाम, व्हॉट्सएप को हटाना और "चर माना जाता है intजब तक कि आप अन्यथा न कहें" quirk। एल्गोरिथ्म और कार्यान्वयन के लिए +1।

— wizzwizz4

आह, मैं देख रहा हूँ। हाँ, मैं इसके लिए नया हूँ। थोड़ा वसा ट्रिम करेंगे और फिर से कोशिश करेंगे। सलाह के लिए धन्यवाद।

— जेसन इवांस

आप एक-वर्ण चर नामों का उपयोग करके दो बाइट्स बचा सकते हैं- वास्तव में, आप चर का उपयोग न करके और केवल एक अभिव्यक्ति बनाकर अधिक बचत कर सकते हैं।

— दरवाज़े

मुझे संदेह है कि आप छोड़ सकते हैं .ToArray()।

— व्लाद

मुझे पता है कि यह लगभग 2.5 साल हो गया है, लेकिन आप इसे 82 बाइट तक नीचे गिरा सकते हैं : using System.Linq;+ n=>!n.Distinct().SequenceEqual(n.Reverse().Distinct().Reverse())(लिनक आयात दुर्भाग्य से अनिवार्य है)। इसे ऑनलाइन आज़माएं। अच्छा जवाब, मेरी तरफ से +1!

— केविन क्रूज़सेन

Answer 5

CJam ( 14 13 बाइट्स)

{__&\W%_&W%#}

ऑनलाइन डेमो

एक-चार बचत के लिए मार्टिन ब्यूटनर को धन्यवाद ।

Answer 6

जाप, 12 बाइट्स

Uâ ¬¦Uw â ¬w

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

एल्गोरिथ्म का पता लगाने के लिए @xnor को धन्यवाद। इनपुट सरणी स्वचालित रूप से संग्रहीत की जाती है U, âuniqify है, wरिवर्स है, और ¦है !=। ¬खाली स्ट्रिंग के साथ जुड़ता है ( [1,2,3] => "123"); यह आवश्यक है क्योंकि जब तक वे समान वस्तु नहीं होते हैं, तब तक जावास्क्रिप्ट का दो खण्डों के बराबर दो सरणियों को गिना जाता है। उदाहरण के लिए (जेएस कोड, जेएपीटी नहीं):

var a = [1], b = [1]; alert(a==b); // false
var a = [1], b = a;   alert(a==b); // true

यदि यह मामला नहीं था, तो हम दो बाइट्स को हटा सकते हैं बस प्रत्येक सरणी में शामिल नहीं हो सकते हैं:

Uâ ¦Uw â w

Comments

जाप की तरह लगता है कि मूल्य समानता को लागू करना चाहते हैं।

— isaacg

Answer 7

ईएस 6, 76 75 65 64 बाइट्स

 a=>(f=r=>a.filter((x,i)=>a.indexOf(x,r&&i+1)==(r|i))+a)()!=f(-1)

@ Xnor के उत्तरों का सीधा पोर्ट।

संपादित करें: 1 बाइट के a.lastIndexOf(x)==iसाथ प्रतिस्थापित करके सहेजा गया a.indexOf(x,i+1)<0।

संपादित करें: @ user81655 के लिए 10 बाइट्स सहेजे गए।

संपादित करें: 1 बाइट के r||iसाथ प्रतिस्थापित करके सहेजा गया r|i।

Comments

एक फ़ंक्शन का उपयोग करके 65 बाइट्स:a=>(f=r=>a.filter((x,i)=>a.indexOf(x,r&&i+1)==(r||i))+a)()!=f(-1)

— user81655

<0 के बजाय ~ का उपयोग करें।

— मामा फन रोल

@ I नहीं, मैं चाहता हूं कि यह -1 हो। ~के रूप में ही है >=0।

— नील

ओह इंतजार मत करो: पी

— मामा फन रोल

@ user81655 क्षमा करें, मैंने किसी कारण से पहले आपकी टिप्पणी पर ध्यान नहीं दिया। ट्रिकी, लेकिन मुझे यह पसंद है!

— नील

Answer 8

05AB1E , 4 बाइट्स

ÙIÚÊ

इसे ऑनलाइन आज़माएं या सभी परीक्षण मामलों को सत्यापित करें ।

पोर्ट ऑफ़ @xnor का पाइथ उत्तर ।

स्पष्टीकरण:

Ù       # Uniquified
 IÚ     # Reversed uniquified on the input again
   Ê    # Check if the two lists are not equal

Answer 9

जावा, 281 वर्ण

class K{public static void main(String[]a){System.out.println(!k(a[0]).equals(new StringBuffer(k(new StringBuffer(a[0]).reverse().toString())).reverse().toString()));}static String k(String k){for(char i=49;i<58;i++){k=k.replaceFirst(""+i,""+(i-9)).replaceAll(""+i,"");}return k;}}

Answer 10

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

यह फ़ंक्शन जो इनपुट को पायथन सूची के रूप में लेता है। अफसोस की बात है कि पायथन की सूची अंत से सीधे खोज का समर्थन नहीं करती है जैसे स्ट्रिंग्स के साथ करते हैं rindex(), लेकिन ओह अच्छी तरह से।

def t(c):i,I=c.index,c[::-1].index;return any(i(n)<i(m)and I(n)<I(m)for m in c for n in c)