कोई सेटिंग संलग्न नहीं है!


42

पहचान

दीवार में 3 नाखून हैं। आपको स्ट्रिंग का एक टुकड़ा मिला है जो दोनों छोरों के साथ पिक्चर फ्रेम के लिए तय किया गया है। चित्र को लटकाने के लिए, आपने नाखूनों के साथ स्ट्रिंग को उलझा दिया। लेकिन चित्र को जाने देने से पहले: क्या आप यह अनुमान लगा सकते हैं कि क्या छवि गिरने वाली है, बस यह देखने से कि स्ट्रिंग को नाखूनों के चारों ओर कैसे लपेटा जाता है?

पहले उदाहरण में चित्र नहीं गिरेगा। दूसरे उदाहरण में तस्वीर गिरने वाली है।

चुनौती

Nनाखूनों के चारों ओर स्ट्रिंग के मार्ग को देखते हुए , यह निर्धारित करें कि चित्र गिरने वाला है या नहीं। यदि चित्र गिरने वाला हो, और मिथ्या मान हो तो एक सत्य मान लौटाएं ।

विवरण

  • आप मान सकते हैं कि नाखूनों और तस्वीर को नियमित- N+1आंगन में व्यवस्थित किया गया है, नीचे की तस्वीर के साथ।
  • आप मान सकते हैं कि रस्सी में कोई गाँठ नहीं हैं, यानी रस्सी को लगातार दो छोरों में से एक से उखाड़ा जा सकता है।
  • प्रत्येक नाखून वर्णमाला के एक अक्षर के साथ दक्षिणावर्त enumerated है। आप मान सकते हैं कि अधिकांश 26 नाखून (AZ) हैं।
  • एक नाखून के चारों ओर एक घड़ी की कल की चादर को निचले मामले के अक्षर के साथ दर्शाया जाता है, एक काउंटर क्लॉकवाइज लपेट को ऊपरी मामले के अक्षर के साथ चिह्नित किया जाता है।

ऊपर से पहला उदाहरण के रूप में एन्कोड किया जाएगा BcA, दूसरा उदाहरण के रूप में एन्कोड किया गया है CAbBac

इच्छुक पाठक के लिए: यह समस्या यह निर्धारित करने के बराबर है कि क्या निशुल्क समूह का एक तत्व - नाखूनों के सेट द्वारा उत्पन्न - पहचान है या नहीं। इसका मतलब यह है कि बार-बार सब्सट्रिंग को रद्द करना aAया Aaजब तक आप एक निश्चित बिंदु तक नहीं पहुंच जाते, तब तक यह पर्याप्त है । यदि निश्चित बिंदु एक खाली स्ट्रिंग है, तो यह तटस्थ तत्व है, अन्यथा यह नहीं है।

उदाहरण

Picture will fall:
Aa
CAbBac
aBbA
DAacAaCdCaAcBCBbcaAb
ARrQqRrUuVHhvTtYyDdYyEKRrkeUWwua
AKkQqEeVvBESWwseYQqyXBbxVvPpWwTtKkVHLlWwNBbAanYYyyhWwEJZUuNnzjYyBLQqQqlEGgebeEPLlTtZzpUuevZzSsbXSGgsUuLlHhUQquPpHUuFfhTZzIitGgFAaBRrBbbYXxOoDZTDdtzVvXxUudHhOVvoUuXKkxyBEeLlbFfKkHhfVAaQqHAaJjODdoVvhSsZzMZzmPpXNBbnxBbUuSSsUuDRrdNnUusJDIiUuIidCEGgeMmcLlDPOopdTEeQqCAETtNnYyeGUuPEFfSsWwHheAaBbpgCcOHUuhAaCcoEFBbfeaFHhfcCFFffNncGFfgtjMVUuKAakvKkXxLlTMmtmOFfoUuXSsYZzLXxlyxUuRPZzTtprSsWwRrPLlpGgMmKRrDHhdRCcUurYNnKCckykXJjxWwUSsJjKkLlKkuBbBbOoWwWwIiUuPDdBbCcWHBbCFfcDdYBbLlyVvSsWGgEewCchDdYywAaJjEepPpPpQXxZzFfLGXxglNnZzYDdyqCcKWXxwXxQqXTtxkFfBSSAasTFftZzsXGgxSsLlLlbZzAaCCccXVvYyxTIiOoBbFftCVQqDdBbGgAavQqKkDPpKTCctRrkdcvAaQWOowLOolqVMmvZAaHCBbcPphIiRKkrLlzFMOomDIiXJjIixMmdNnMHhmfNTtIiKkSDdTtsVvHhnAaNSVvTUutNnXxsGIiXxPpPHhUupgNnAaAAOoaaIiHJjhVvLlnYyXxQqSsTtKJjkBbNnVvEYCcFfMHGghBbmNnEeJTtjJjWYywyeNWwDIiZYyzOodnMQqmVvCcQqxVvGNnEeNBbngVvUGgYyBbDdVvIiAAaauPpQKDdEekNnVLlvHhGSDIidPZzpsPCcpgQqKkQqNOonLlIiLlJjqPAaPXxTtppYyCPpHhCIicARBbracXxWwXEVUuUuGgZHhzBSsbvGgFfeVvxLlNKknWwBLlIibWOowNnRSsrSEeKAakOosLZzZRrHhzTtTFfUuNnOKkotXxTtla


Picture will not fall:
A
BcA
ABCD
aBaA
bAaBcbBCBcAaCdCaAcaCAD
ARrQqRrUatuVHhvTYyDdYyEKRrkeUAua
AEEeQqNneHhLlAIiGgaECXxcJjZzeJFfVWwDdKkvYWwyTJjtCXxANIinaXWwxcTWwtUuWwMmTBbVWIiFLlWwZzfwPLlEepvWZzwKkEYEeWXxwySXTtEexRIiNBbnWAaTtQqNnBMSsWwOombwWwPVPpGPpgYyvDdpBbrQqHhUusKRrDAVvadLlWwOZzokGJCXSSssXxxJPpGIigZzjJjLlOoNRrnPpcMZzmjgJjNDEeQqWKkNTtnSswIidCcnYBGgbyJSsjPpIiMmMmMmSNnWVvwZzIQqLXHhxTPptlisOoeTtTtYMmVvPpyKNnMFfmkXxSVvsCGJjXxgXYJPpjWwQIiXxqyDdxFfDdAaRNnJjrctHBbZzhEQqMmeCcRBbrGgAaAaJNnRrYyWwSDdVvsJOojQGgWWwIBbiwRrqJjjWwOoFPMmDdRrQOoqNnRrDPJjpMmdPpGFfVvWUuwgpWCcNnPpwfUXCcZzJjUSsuXxxUuuRGgHhrSQqJjOosMMTtmHhmKkXxDdLlWwjSUuAaMmKYyksZzVvPZzVEeVvvHhZZOozBbzMmZCczYyGgISsiQqpXxMmXxEMmeRrAGgaGgMOGgomZFfDdzSSssBGPpgbTtBbOoRWWwGgLJjlEeGgLDdRrUulNnZzJjJjUKkuXxFfwATtaZzLVvlWwSsMmrBAaELleGBLFflbgHhbIFfiBbPpTWZzwKkKLASsaTJYyjtBbBbWwIiZCcWwzIiZLlUTtuBbYyBbIizTJjtLTtDOOoBbodBbllSsUGgLlAKkauYykUuUNnPpuDFfAaLNVvnVvlHhdMmBAaBbIiVRrGWOoPpwgWXwKkvJjOoTtYCUucVGgYyLlVvFfvRrMmySsDdbtICZzcNnINSOosDQAaXoxRGgKkrqdZznDdXxZzMGgmiJjNnACcMQqmaNnWZzUOuwTVvAJjSsaRrGgSsTtOMmRroVvRrtAVGgvMmaINniDGCcOogRrWwMVvYFfyTtmTtVvOoOIiodRrGgAxaSsGgiJja

3
ऐसा लगता है कि स्ट्रिंग के मार्ग को लिखने के लिए किसी के हाथों को मुक्त करने में, चित्र वैसे भी गिर जाएगा। तब यह चुनौती वास्तव में आसान हो जाती है।
ओकाकोडर

@ लोकोडर आपको बस जल्दी होना है: D
दोष

जवाबों:


11

रेटिना , 21 बाइट्स

+`(.)(?!\1)(?i)\1

^$

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

त्रुटिपूर्ण समाधान की तरह, यह केवल बार-बार निकटवर्ती अपरकेस / लोअरकेस जोड़े को हटाता है और फिर जाँचता है कि परिणाम खाली है या नहीं।

कैसे एक अपरकेस / लोअरकेस जोड़ी से मेल खाता है:

(.)     # Match and capture a letter.
(?!\1)  # Ensure that the next character is not the same, to avoid matching
        # "aa" and "AA".
(?i)    # Turn on case-insensitivity.
\1      # Match the backreference. In .NET, when using case insensitivity,
        # backreferences also get case-insensitive, so this *can* still match
        # iff the cases of the two letters are different.

7

MATLAB, 76 बाइट्स ऑक्टेव, 82 79 77 बाइट्स

यह पहली बार मैंने देखा है जहां MATLAB वास्तव में है हो सकता है कम (एक पूरे बाइट द्वारा) सप्टक से!

MATLAB में नया उत्तर:

c=input('');k='Aa';while k<1e5,k=k+1;c=strrep(c,65+mod(k,64),'');end;~nnz(c)

ऑक्टेव में उत्तर:

c=input('');k='Aa';while k++<1e5,c=strrep(c,['',65+mod(k,64)],'');end;~nnz(c)

सहेजे गए तीन flawr के लिए पांच बाइट्स धन्यवाद। ~nnz(c)से छोटा है isempty(c), और 'Aa'दो बाइट से छोटा है [0,32]

यह ऑक्टेव-संस्करण ऑनलाइन की कोशिश करो!


स्पष्टीकरण:

c=input('')इनपुट के लिए उपयोगकर्ता पूछता है। हम k='Aa'एक चरित्र सरणी के रूप में परिभाषित करते हैं ।

while k++<1e5: एक ओर जहां पाश जहां में दोनों तत्वों kप्रत्येक यात्रा, बढ़ती है, Aa, Bb, Ccऔर इतने पर। लूप तब तक जारी रहेगा जब तक कि सबसे बड़ा तत्व नहीं है 1e5, जो कि अधिकांश तारों के लिए पर्याप्त रूप से उच्च होना चाहिए। इसे 9e9बिना बाइट काउंट बढ़ाए बढ़ाया जा सकता है ।

हम strrepफ़ंक्शन को चरणों में ले जाएंगे , जो बीच से शुरू होगा।

का उपयोग करके mod(k,64)जब हम वर्णमाला के अंत तक पहुँचते हैं (यदि हम कन्वर्ट हम निम्नलिखित मिलेगा kपात्रों को वापस):

ans = Yy
ans = Zz
ans = [{
ans = \|
ans = ]}
ans = ^~
ans = _
ans = `�
ans = aA
ans = bB

जैसा कि आप देख सकते हैं, बीच में कुछ प्रतीक होंगे, लेकिन फिर यह चारों ओर लपेटेगा और फिर से वर्णमाला के साथ शुरू होगा, लेकिन अब निचले मामले के अक्षरों के साथ। यह जांच करने के लिए दोनों एक बहुत ही कम तरीका है Aaऔर aA

['',65+mod(k,64)]mod-कॉल से संख्यात्मक मानों को समेटता है, एक रिक्त स्ट्रिंग के साथ, संख्याओं को वर्णों में परिवर्तित करता है।

strrepस्ट्रिंग से तत्वों को निकालने cऔर इसे वापस करने के लिए उपयोग किया जाता है । यह kस्ट्रिंग की सभी घटनाओं की खोज करेगा और इसे एक खाली स्ट्रिंग के साथ बदल देगा।

1e5पुनरावृत्तियों के बाद हम या तो एक खाली स्ट्रिंग या एक गैर-रिक्त स्ट्रिंग लेंगे। हम जांचते हैं कि क्या cउपयोग करने में कोई तत्व हैं nnz(c)। हम लौटते हैं not(nnz(c)), इस प्रकार 1यदि यह खाली है, और 0यदि पात्र बचे हैंc


6

मिंकोलंग 0.15 , 30 बाइट्स

od4&x,N.I1=$6&d3~c-$~48*=,2&xx

यहाँ यह कोशिश करो!

व्याख्या

od                            Take character from input and duplicate it
  4&                          If top of stack is truthy, jump 4 spaces
    x                         Dump top of stack
     ,                        NOT top of stack
      N.                      Output as number and stop

    I1=                       1 if stack has 1 element, 0 otherwise
       $6&                    If top of stack is truthy, jump 16 spaces (to the beginning)
          d3~c                Duplicate top two items of stack, in reversed order
              -               Subtract
               $~             Absolute value
                 48*          Push 32
                    =,        0 if top two items are equal, 1 otherwise
                      2&xx    If top of stack is truthy, dump two elements from top

बाहरी लूप की आवश्यकता को समाप्त करने के लिए मिंकोलंग के टॉरोइडल प्रकृति का लाभ उठाया गया है। यहां सामान्य विचार यह जांचने के लिए है कि क्या स्टैक के शीर्ष दो तत्व 32 यूनिट अलग हैं (मतलब वे एक अपरकेस / लोअरकेस जोड़ी हैं), और यदि वे हैं, तो दोनों को बंद कर दें। चूंकि यह "रीयलटाइम" में किया गया है, इसलिए बोलने के लिए, जोड़े के घोंसले को ठीक से संभाला जाता है।


5

हास्केल, 62 बाइट्स

a%l|b:t<-l,abs(a-b)==32=t|1>0=a:l
f=null.foldr((%).fromEnum)[]

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

क्रेडिट करने के लिए flawrabs और के लिए Laikoni fromEnumमानचित्र

सहायक फ़ंक्शन %पहले से ही सरलीकृत स्ट्रिंग लेता है l, और aपरिणाम को सरल करने से पहले प्रतीक को प्रस्तुत करता है। यदि lव्युत्क्रम वर्ण से शुरू होता है a, तो वे रद्द कर देते हैं। अन्यथा, aबस पूर्वनिर्मित है। ध्यान दें कि इस स्तर पर और सरलीकरण की आवश्यकता नहीं है।

मुख्य कार्य fprepends और प्रत्येक चरित्र को बदले में सरल करता है a foldr। फिर, यह जांचता है कि परिणाम खाली है या नहीं।

यह जांचने के लिए कि क्या दो वर्ण विपरीत मामले हैं और इसलिए रद्द करना चाहिए, देखें कि क्या उनके ASCII मान 32 से भिन्न हैं। प्रत्येक तत्व को fromEnumपारित होने से पहले संसाधित किया जाता है %


अच्छा! और स्पष्टीकरण के लिए धन्यवाद, मैं हर बार नई चीजें सीख रहा हूं!
दोष

4

05AB1E , 17 बाइट्स

DvADu‚øDíìvyK}}õQ

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

व्याख्या

Dv                 # input number of times do:
  A                # push lowercase alphabet
   Du              # push uppercase alphabet
     ‚ø            # zip the alphabets together (['aA', ..., 'zZ'])
       Díì         # prepend a copy with each element reversed ('Aa' ...)
          v        # for each pair in the resulting list
           yK      # remove it from the accumulated string (starts as input)
             }}    # end loops
               õQ  # check result for equality to empty string

4

हास्केल , 98 97 85 81 बाइट्स

यह सिर्फ एक भोली कार्यान्वयन है जो बार-बार आसन्न पत्रों को रद्द करने की कोशिश करता है जब तक कि अधिक परिवर्तन नहीं होता है, और फिर उसी से परिणाम निर्धारित करता है।

धन्यवाद -nimi -12 बाइट्स के लिए और @xnor अन्य -4 बाइट्स के लिए!

o=fromEnum
r(a:b:l)|abs(o a-o b)==32=l|1>0=a:r(b:l)
r x=x
f=null.until((==)=<<r)r

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


f=null.until(\a->r a==a)r.map fromEnumदो बाइट्स बचाना चाहिए।
लैकोनी

मुझे लगता है कि (\a->r a==a)हो सकता है ((==)=<<r)
22

1
दूसरी पंक्ति में, मुझे लगता है कि आप बदल सकते हैं =r lकरने के लिए lविचार किया जा रहा है कि यह केवल रन प्रति एक प्रतिस्थापन बनाने के लिए पर्याप्त होता है।
xnor

धन्यवाद! मैं दूसरे संकेत को समझता हूं, लेकिन मुझे पता नहीं है कि इसके साथ क्या हो रहा है =<<, ऐसा लगता है जैसे जादू XD
त्रुटी

1
@flawr इस टिप को देखें । की =<<तरह है, >>=लेकिन बदली हुई दलीलों के साथ। अभिव्यक्ति अक्सर अर्थ के रूप में सामने आती ((==)=<<r)है "के तहत अपरिवर्तनीय है r"।
xnor

3

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

""==StringDelete[""|##&@@#<>#2&~MapThread~{Join[a=Alphabet[],A=ToUpperCase@a],A~Join~a}]~FixedPoint~#&

बेनाम इनपुट और लौटने के रूप में एक अक्षरात्मक स्ट्रिंग लेने समारोह Trueया False

कार्यान्वयन का दिल एक फ़ंक्शन बना रहा है जो किसी भी रद्द करने वाली जोड़ी, जैसे "Pp"या "gG", एक स्ट्रिंग से हटाता है । अभिव्यक्ति {Join[a=Alphabet[],A=ToUpperCase@a],A~Join~a}वर्णों की सूचियों की एक क्रमबद्ध जोड़ी, पहली सूची {"a","b",...,"Z"}और दूसरी होने का उत्पादन करती है {"A","B",...,"z"}। फिर #<>#2&~MapThread~एक सूची तैयार करता है, जहां इन दो सूचियों के संबंधित तत्वों को समेट दिया गया है, अर्थात् {"aA","bB",...,"Zz"}। मजेदार अभिव्यक्ति ""|##&@@तब (तर्क अनुक्रम के जादू के माध्यम से ##) विकल्पों की एक सूची तैयार करती है "" | "aA" | "bB" | ... | "Zz"; अंत में, StringDelete[...]एक फ़ंक्शन है जो स्ट्रिंग में से किसी भी विकल्प की किसी भी घटना को हटा देता है।

अब यह बार-बार उस फ़ंक्शन को इनपुट स्ट्रिंग में लागू करने के लिए पर्याप्त है, जब तक कि परिणाम नहीं बदलता है, जिसे पूरा किया जाता है ~FixedPoint~#, और फिर परीक्षण करें कि क्या परिणाम के साथ खाली स्ट्रिंग है ""==


3

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

f=(s,t=s.replace(/(.)\1+/gi,s=>s.replace(/(.)(?!\1)./,'')))=>s==t?!s:f(t)

.NET के विपरीत, जावास्क्रिप्ट में मैच के बीच में केस सेंसिटिविटी को बंद करने का कोई तरीका नहीं है, इसलिए इसके बजाय हमें बार-बार पत्र केस के सभी सब्सट्रेटिंग को असंवेदनशील तरीके से ढूंढना है, और फिर किसी भी बेमेल जोड़ी को आसन्न वर्णों को हटाना है, जो इस बिंदु तक होना चाहिए एक ऊपरी / लोअरकेस जोड़ी।


3

पर्ल, 28 बाइट्स

1 while s/.(??{$&^' '})//;$_

स्पष्टीकरण:

पर्ल एक मानक नियमित अभिव्यक्ति के अंदर एक गतिशील रूप से उत्पन्न नियमित अभिव्यक्ति को शामिल करने की अनुमति देता है।

.कुछ भी मेल खाता है।

(??{उत्पन्न regex की शुरुआत है।

$&चर पूरे मिलान किया स्ट्रिंग अब तक, जो इस मामले में अभी जो कुछ भी है शामिल होंगे .मिलान नहीं हुआ।

^ऑपरेटर ऑपरेंड के मूल्यों के आधार पर, या तो संख्यात्मक XOR या स्ट्रिंग XOR करता है। इस मामले में, यह स्ट्रिंग एक्सआर होगा।

' 'सिर्फ एक एक अंतरिक्ष, जो आसानी से ascii (या यूनिकोड!) 32. का मूल्य है एक अंतरिक्ष रेंज az या AZ में एक चार के साथ XOR-एड है जब युक्त स्ट्रिंग है, यह मामला या शिकंजा कम करने के लिए ऊपरी से बदल जाएगा विपरीत।

})उत्पन्न regex का अंत है।

1 while s/whatever// बार-बार एक पैटर्न खोजेगा और उसे खाली स्ट्रिंग से बदल देगा।

$_डिफ़ॉल्ट चर है। जब आप किसी अन्य चर को निर्दिष्ट नहीं करते हैं तो यह चर वह आनंद और रोमांचक चीज है। यहाँ मैं इसका इस्तेमाल एक सत्य या मिथ्या मूल्य को वापस करने के लिए कर रहा हूँ, क्योंकि एक शून्य लंबाई स्ट्रिंग झूठी है, और एक गैर-लंबाई लंबाई स्ट्रिंग जो समान नहीं है "0"वह सच है। मैं यह भी मान रहा हूं कि इनपुट स्ट्रिंग को मूल रूप से इसमें रखा गया था।

इसे यहाँ आज़माएँ


तकनीकी रूप से, यह इसके विपरीत देता है कि चुनौती क्या मांगती है (आप झूठे और इसके विपरीत होने पर सच्चाई लौटाते हैं)। इसे ठीक करने के लिए, बस !फाइनल से पहले जोड़ें $_। अगर इसे इस तरह से रखना आपके साथ ठीक है, तो आप ध्वज के s/.(??{$&^' '})//&&redoलिए +1 बाइट को बदलकर 4 बाइट बचा सकते हैं -p। यह आपके पास अभी जिस तरह से है उसमें काम नहीं करेगा क्योंकि { code }यह वास्तव में एक लूप नहीं है (इस प्रकार &&redoकाम नहीं करेगा), लेकिन -pइसे एक whileलूप के अंदर रखता है ।
गैब्रिएल बेनामी

के ' 'साथ बदलकर आप एक और बाइट भी बचा सकते हैं $"इस पर एक नज़र डालें कि कोड क्या दिखता है।
गेब्रियल बेनामी

2

प्रोलोग (एसडब्ल्यूआई) , 151 बाइट्स

f(S):-S="";string_code(I,S,X),string_code(J,S,Y),J is I+1,32is abs(X-Y),B is J+1,sub_string(S,0,I,_,T),sub_string(S,B,_,0,U),string_concat(T,U,V),f(V).

लंबे समय तक झूठे मामलों को चलाने के कारण लंबे समय तक ले जाता है।

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

Ungolfed

f(S):-                       The string S corresponds to a falling picture if:
  S="";                      S is the empty string, or...
  string_code(I,S,X),        X is the character code at some index I
  string_code(J,S,Y),        Y is the character code at some index J
  J is I+1,                  J is I+1
  32 is abs(X-Y),            X and Y differ by 32 (difference between lower/upper case)
  B is J+1,                  ...
  sub_string(S,0,I,_,T),     ...
  sub_string(S,B,_,0,U),     ...
  string_concat(T,U,V),      ...
  f(V).                      The concatenation of the substrings before and after 
                             the letters X and Y corresponds to a falling picture.

1

MATL , 20 बाइट्स

t"[]yd|32=fX<tQh(]n~

इसे ऑनलाइन आज़माएं! या सभी परीक्षण मामलों को सत्यापित करें (इसमें कुछ समय लगता है)।

व्याख्या

t       % Input string implicitly. Duplicate
"       % Do as many times as input size
  []    %   Push empty array
  y     %   Duplicate current string onto the top
  d|    %   Absolute consecutive differences
  32=   %   Convert to true if 32, false otherwise
  fX<   %   Index of first occurrence of true, or empty of all false
  tQ    %   Duplicate, add 1. This gives the next index, or empty
  h     %   Concatenate. Gives the two consecutive indices of letters
        %   to be removed, or empty
  (     %   Assign an empty array to those positions, i.e. delete them
]       % End
n~      % Number of elements, negate

1

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

(ToCharacterCode@#//.{x___,y_,z_,w___}/;Abs[y-z]==32:>{x,w})=={}&


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