क्या मेरा स्वाइप पैटर्न कानूनी है?


154

अधिकांश एंड्रॉइड स्मार्टफोन उपयोगकर्ता को अपना फोन खोलने के लिए एक स्वाइप पैटर्न का उपयोग करने की अनुमति देते हैं:

आकृति ताला

कुछ पैटर्न वैध हैं, और अन्य असंभव हैं। एक इनपुट स्वाइप पैटर्न को देखते हुए, दिए गए इनपुट पैटर्न के वैध होने या न होने का संकेत देते हुए एक सत्य या मिथ्या लौटाएं।

इनपुट

ग्रिड को 9 के माध्यम से पंक्ति 1 के रूप में चिह्नित किया गया है:

1 2 3   
4 5 6   
7 8 9

इनपुट एक संख्या है जिसमें पहले से आखिरी तक जाने वाले नोड्स शामिल हैं। उदाहरण के लिए, ऊपर स्वाइप पैटर्न 12357 है।

इनपुट एक दशमलव संख्या, स्ट्रिंग या संख्याओं की सूची हो सकती है। इसमें 0 नहीं होगा क्योंकि कोई नोड 0 नहीं है।

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

नियम

  • प्रत्येक नोड शुरू में परिकल्पित के रूप में शुरू होता है और केवल एक बार दौरा किया जा सकता है। कोई भी पैटर्न जो एक बार से अधिक नोड का दौरा करता है वह मिथ्या है।

  • एक सत्य पैटर्न में कम से कम एक स्वाइप होना चाहिए, इसलिए न्यूनतम 2 नोड्स।

  • एक असमान नोड पर सीधे दूसरे के साथ छोड़ना संभव नहीं है। उदाहरण के लिए, 13 मिथ्या है क्योंकि 2 की परिकल्पना और सीधे लाइन में है।

  • केवल विज़िट किए गए नोड पर छोड़ना संभव है। 42631 इसका एक उदाहरण है।

  • लाइनें अन्यथा पार हो सकती हैं। उदाहरण के लिए, 1524 सत्य है।

  • मान लें कि चौड़ाई निरर्थक है और व्यावहारिक मुद्दों (उंगली की मोटाई, आदि) को अनदेखा करें। तो 16 सच्चाई है, भले ही वास्तविकता में इसे हासिल करना थोड़ा कठिन हो।

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

1 -> false     
12 -> true   
13 -> false   
16 -> true  
31 -> false   
33 -> false  
137 -> false   
582 -> true  
519 -> true  
1541 -> false  
12357 -> true    
15782 -> true   
19735 -> false  
42631 -> true   
157842 -> true  
167294385 -> true   
297381645 -> false   
294381675 -> true

यह , इसलिए सबसे कम संख्या में बाइट्स जीतती हैं।




क्या इनपुट सूची गैर-रिक्त होने की गारंटी है?
ज़गरब

@Zgarb हाँ। यह गैर-रिक्त होगा।
स्टेनरी

संबंधित गणित प्रश्न: math.stackexchange.com/questions/205049/…
प्यूरफेरेट

जवाबों:


69

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

संख्या के एक सरणी के रूप में इनपुट लेता है। झूठे मूल्य 0 या NaN हैं । सत्य मान सख्ती से पूर्णांक हैं।

a=>a[p=1]*a.every(n=>a[p=a[n&p&p*n%5<0|~(p-=n)==9&&p/2]&&-n]^=p)

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

कैसे?

प्रस्तावना

दो अंक लंबवत, क्षैतिज रूप से या तिरछे ढंग से विपरीत होते हैं यदि:

  • वे दोनों विषम हैं, एक दूसरे से अलग हैं और 5 से अलग हैं (आकृति 1)
  • या वे दोनों समान हैं और उनकी राशि 10 है (चित्र 2)

    अंकों का विरोध किया

इसके अलावा, दो विपरीत अंकों के बीच खड़ा होने वाला अंक n और p , (n + p) / 2 के बराबर है ।

स्वरूपित स्रोत कोड

a =>
  // force a falsy result if a[1] is undefined
  a[p = 1] *
  // walk through all values n in a[]
  a.every(n =>
    // access either a[-n] or a[undefined]
    a[
      // set p to either -n or undefined
      p =
        // read either a[0] or a[in_between_digit]
        a[
          n & p & p * n % 5 < 0 | ~(p -= n) == 9
          && p / 2
        ]
        && -n
    ]
    // toggle the flag
    ^= p
  )

पिछले अंकों का ध्यान रखना

विज़िट किए गए अंकों के झंडे इनपुट सरणी में नकारात्मक सूचकांकों पर संग्रहीत किए जाते हैं , ताकि वे इसके मूल तत्वों से न टकराएं।

  • यदि p को n पर सेट किया जाता है :

    यदि वर्तमान अंक n पहले से चयनित नहीं था, a[-n] ^= -nतो ध्वज को सेट करेगा और every()लूप को अगले पुनरावृत्ति के साथ जाने देगा। अन्यथा, यह ध्वज को साफ करेगा और लूप को तुरंत विफल होने के लिए मजबूर करेगा।

  • यदि पी अपरिभाषित पर सेट है :

    a[undefined] ^= undefined0 में परिणाम , जो भी पाश विफल करने के लिए मजबूर करता है।

विरोधी अंकों का पता लगाना

निम्न अभिव्यक्ति का उपयोग यह जांचने के लिए किया जाता है कि क्या वर्तमान अंक n और पिछले अंक -p अंकों के विपरीत हैं, जैसा कि प्रस्तावना में परिभाषित किया गया है:

n & p & ((p * n) % 5 < 0) | ~(p -= n) == 9

जो इसके बराबर है:

n & p & ((p * n) % 5 < 0) | (p -= n) == -10

नोट: JS में, modulo के परिणाम में लाभांश के समान चिन्ह है।

इसकी व्याख्या इस प्रकार की जा सकती है:

(n is odd AND -p is odd AND (neither -p or n is equal to 5)) OR (n + -p = 10)

इसलिए, यह अभिव्यक्ति 1 यदि रिटर्न केवल और अगर n और -p अंकों का विरोध कर रहे हैं या वे एक ही विषम अंक हैं। क्योंकि एक अंक को दो बार नहीं चुना जा सकता है, इस उत्तरार्द्ध मामले को वैसे भी सही ढंग से ध्यान रखा जाता है।

यदि यह अभिव्यक्ति 1 लौटती है , तो हम [[p / 2] (जहाँ p अब अंकों की नकारात्मक राशि के बराबर है) का परीक्षण करते हैं ताकि यह पता चल सके कि 'पहले के बीच का अंक' गया था या नहीं। अन्यथा, हम एक परीक्षण करते हैं [0] जो सत्य होने की गारंटी है।

पहली पुनरावृत्ति के बारे में

पहला पुनरावृत्ति एक विशेष मामला है, इसमें कोई पिछला अंक नहीं है और हम चाहते हैं कि यह बिना शर्त सफल हो।

हम 1 से पी को इनिशियलाइज़ करके हासिल करते हैं , क्योंकि [1 .. 9] में किसी भी एन के लिए :

  • (1 * n) % 5 नकारात्मक नहीं हो सकता
  • ~(1 - n) 9 के बराबर नहीं हो सकता

मूल उत्तर, 90 बाइट्स

इस पोस्ट से हटा दिया गया है ताकि इसे बहुत अधिक वर्बोज़ न मिले। आप इसे यहाँ देख सकते हैं


-1 बाइट के !!a[1]&साथ बदलकर a[1]&&, क्योंकि कोई भी सत्य मान वापस किया जा सकता है
हरमन एल

@HermanLauenstein धन्यवाद, जो वास्तव में ठीक लगता है। (अब, a[1]*और भी छोटा है।)
अरनौल्ड

1
मैं सख्त रूप से एक सूत्र के बारे में सोचने की कोशिश कर has a node directly in lineरहा था, मुझे नहीं लगा कि यह इतना सरल होगा ...
नील

@ नील इस पोस्ट के संशोधन इतिहास को देखकर, मुझे यकीन है कि आप बता सकते हैं कि मुझे यह महसूस नहीं हुआ कि तुरंत या तो ... :)
Arnauld

लगता है कि आप -1 के ?a[-n]^=1:0साथ बदल &&a[-n]^=1सकते हैं, परीक्षण नहीं कर सकते (मोबाइल पर)
स्टेन स्ट्रम

45

x86 32-बिट मशीन कोड, 62 60 बाइट्स

Hexdump:

33 c0 60 8b f2 33 db 99 80 f9 02 72 2d ad 50 0f
ab c2 72 25 3b c3 77 01 93 2b c3 d1 e8 72 14 68
92 08 0e 02 0f a3 5c 04 ff 5f 73 07 03 d8 0f a3
da 73 06 5b e2 d7 61 40 c3 58 61 c3

यह ecxपहले तत्व में सूची की लंबाई और एक सूचक को प्राप्त करता है edx, और इसमें परिणाम देता है al:

__declspec(naked) bool __fastcall check(int length, const int* list)

8 लाइनें हैं जो बीच में एक नोड समाहित करती हैं:

1 - 3
४ - ६
- ९
1 - 7
2 - 8
3 - 9
1 - 9
3 - 7

मैंने उन्हें बड़े और छोटे संख्या के अंतर के अनुसार समूहीकृत किया।

अंतर 2: 3 लाइनें (1, 4 या 7 से शुरू)
    1 - 3
    ४ - ६
    - ९
अंतर 4: 1 पंक्ति (3 से शुरू)
    3 - 7
अंतर 6: 3 लाइनें (1, 2 या 3 से शुरू)
    1 - 7
    2 - 8
    3 - 9
अंतर 8: 1 पंक्ति (1 से शुरू)
    १ - ९

फिर, मैंने उसे 2-डी लुकअप टेबल में बदल दिया जिसे आधा अंतर और छोटी संख्या द्वारा अनुक्रमित किया गया:

76543210
--------
10010010 - half-difference 1
00001000 - half-difference 2
00001110 - half-difference 3
00000010 - half-difference 4

यह 32 बिट्स का "मैजिक" बिटमैप बनाता है। इसे इंडेक्स करने के लिए, कोड इसे स्टैक में धकेलता है। फिर, यह एक इंडेक्स का उपयोग करके एक बाइट को निकालता है, और उस बाइट से, यह दूसरे इंडेक्स का उपयोग करके एक बिट को निकालता है। यह सब एक निर्देश का उपयोग कर:

bt byte ptr [esp + eax - 1], ebx; // -1 because half-difference is 1-based

यदि बिटमैप इंगित करता है कि बीच में एक नोड है, तो गणना करना आसान है - छोटी संख्या में आधा अंतर जोड़ें।

विधानसभा स्रोत:

    xor eax, eax;   // prepare to return false
    pushad;         // save all registers
    mov esi, edx;   // esi = pointer to input list
    xor ebx, ebx;   // ebx = previously encountered number = 0
    cdq;            // edx = bitmap of visited numbers = 0

    cmp cl, 2;      // is input list too short?
    jb bad_no_pop;  // bad!

again:
    lodsd;          // read one number
    push eax;

    bts edx, eax;   // check and update the bitmap
    jc bad;         // same number twice? - bad!

    cmp eax, ebx;   // sort two recent numbers (ebx = minimum)
    ja skip1;
    xchg eax, ebx;
skip1:

    // Check whether the line crosses a node
    sub eax, ebx;   // calculate half the difference
    shr eax, 1;
    jc skip_cross;  // odd difference? - no node in the middle

    push 0x020e0892;// push magic bitmap onto stack
    bt byte ptr [esp + eax - 1], ebx; // is there a node in the middle?
    pop edi;
    jnc skip_cross; // no - skip the check

    add ebx, eax;   // calculate the node in the middle
    bt edx, ebx;    // was it visited?
    jnc bad;        // no - bad!

skip_cross:
    pop ebx;
    loop again;

    // The loop was finished normally - return true
    popad;          // restore registers
    inc eax;        // change 0 to 1
    ret;            // return

    // Return false
bad:
    pop eax;        // discard data on stack
bad_no_pop:
    popad;          // restore registers
    ret;            // return

अच्छा! मुझे वास्तव में यह पसंद है bt byte ptr [esp + eax], ebx
अरनौलद

5
विधानसभा समाधान :) आप उपयोग कर सकते हैं देखने के लिए अच्छा cdqके बजाय xor edx, edxके रूप में eaxशून्य है। इसके अलावा, आप उस dec eaxमें गुना कर सकते हैं bt [esp + eax - 1], ebxजो समान लंबाई है लेकिन फिर आपको inc ebxबाद में निकालने की अनुमति देता है । इससे आपको दो बाइट बचानी चाहिए।
जस्टर

विचारों के लिए धन्यवाद! आपने गोल्फर के स्वर्ग में अपना स्थान सुरक्षित कर लिया है, अगर वहाँ एक है :)
अनातोली

5
मुझे लगता है कि हम सभी इस बात से सहमत हो सकते हैं कि गोल्फर्स का स्वर्ग हर किसी के लिए नरक है।
Adonalsium

19

पायथन 2 , 140 131 114 104 99 बाइट्स

-2 के लिए धन्यवाद बाइट्स जोनाथन frech
-5 के लिए धन्यवाद बाइट्स चास ब्राउन

v={0};k=input()
for l,n in zip(k,k[1:])or q:(2**n+~2**l)%21%15%9==5<v-{l+n>>1}==v>q;v|={l};n in v>q

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

स्पष्टीकरण:

# full program, raising a NameError for invalid input
v={0}            # set of visited nodes
k=input()        # load pattern
# iterate through adjacent pairs, if there is no pair, raise a NameError
for l,n in zip(k,k[1:])or q:
  # detect moves skipping over nodes, details below
  (2**n + ~2**l) % 21 % 15 % 9 == 5 < v - {l+n >> 1} == v > q
  v |= {l}       # add the last node to the set of visited nodes
  n in v > q     # if the current node was previously visited, raise a NameError

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

केवल 8 जोड़े नोड्स के बीच में नोड होता है। सूत्र द्वारा नोड्स की एक जोड़ी को एक पूर्णांक के रूप में दर्शाया जा सकता है 2^a-2^b-1। इस संख्या को बार-बार मोडुलो द्वारा छोटा किया जा सकता है:

a  b  2^a-2^b-1  (2^a-2^b-1)%21%15%9
1  3         -7                    5
1  7       -127                    5
1  9       -511                    5
2  8       -253                    5
3  1          5                    5
3  7       -121                    5
3  9       -505                    5
4  6        -49                    5
6  4         47                    5
7  1        125                    5
7  3        119                    5
7  9       -385                    5
8  2        251                    5
9  1        509                    5
9  3        503                    5
9  7        383                    5

(2**n+~2**l)%21%15%9==5पहले जाँचता है कि अगर ऐसी जोड़ी मौजूद है, तो v-{l+n>>1}==vपरीक्षण करता है कि बीच में नोड, जो इसके द्वारा दिया गया है (a+b)/2, अभी तक नहीं आया था और qNameError उठाता है। इन जोड़े के बीच जंजीर तुलना का उपयोग करके, अगली तुलना केवल तब निष्पादित की जाती है जब पिछला वापस आ जाता है True


17

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

-2 चूंकि अब हमें खाली सूची को संभालने की आवश्यकता नहीं है -
-1 से जुड़ने से स्विच j@करने के लिए, समवर्ती करने के लिए, ;और मिस्ड आइटम को नियोजित विधि के लिए बीच में सामना करने की आवश्यकता नहीं है, तिकड़ी की शुरुआत में ठीक है )
-2 से स्विच P¬aSHकरने के लिए oSHके बाद से हम समतल (ठीक दो परिणाम है, के आधे 1है 0.5जो बाहर वैसे भी फ़िल्टर किया जाता है, और कई बराबर परिणाम होने कोई भी विधि कार्यरत पर को प्रभावित किया है)
-1 श्री Xcoder के लिए धन्यवाद (0 अनुक्रमित इनपुट की अनुमति है)

d3ZIỊoSH;µƝFf9Ḷ¤Q⁼

कानूनी और एक गलत मूल्य ( ) अगर नहीं में [0,8]एक पूर्णांक की सूची ले रहा है 1और एक सत्य मान ( 0) लौटा रहा है ।

इसे ऑनलाइन आज़माएं! या एक परीक्षण-सूट देखें

कैसे?

इनपुट सूची में 0-अनुक्रमित नोड्स के प्रत्येक आसन्न जोड़ी को देखता है। यदि पूर्णांक विभाजन दो में से दो से भिन्न होता है, तो वे ऊपर और नीचे की पंक्तियों पर होते हैं, यदि दो में से तीन द्वारा modulo 2 से भिन्न होता है तो वे बाएं और दाएं कॉलम में होते हैं। दो से विभाजित ऐसी जोड़ियों का योग या तो तीन-नोड-लाइन के 0-अनुक्रमित मध्य-नोड या एक गैर-पूर्णांक मान है - इसलिए इन मूल्यों को पहले 0-अनुक्रमित जोड़ी के सामने डाला जाता है और फिर किसी भी बोगस नोड्स (जैसे 0.5या3.5) को हटा दिया जाता है, सूचियों की परिणामी सूची को समतल कर दिया जाता है और फिर डी-डुप्लिकेट किया जाता है (ऑर्डर-संरक्षित, अद्वितीय प्रविष्टियों को प्राप्त करने के लिए) और अंत में इनपुट की तुलना में - एक कानूनी स्वाइप के लिए यह सब गैर-कानूनी होने के दौरान समाप्त हो जाएगा। लोग गुम मध्य नोड्स और / या डुप्लिकेट नोड्स को हटा देंगे (ध्यान दें कि लंबाई 1 की इनपुट सूची के लिए कोई विशेष आवरण आवश्यक नहीं है क्योंकि इसमें कोई निकटवर्ती जोड़े नहीं हैं):

d3ZIỊoSH;µƝFf9Ḷ¤Q⁼ - left input is a list of integers   e.g. [3,4,7,1,2,8,3]
          µƝ       - perform the chain to the left for adjacent pairs:
                   - e.g. for [a,b] in:   [3,4]         [4,7]         [7,1]         [1,2]         [2,8]         [8,3]
 d3                -   divmod by 3        [[1,0],[1,1]] [[1,1],[2,1]] [[2,1],[0,1]] [[0,1],[0,2]] [[0,2],[2,2]] [[2,2],[1,0]]
   Z               -   transpose          [[1,1],[0,1]] [[1,2],[1,1]] [[2,0],[1,1]] [[0,0],[1,2]] [[0,2],[2,2]] [[2,1],[2,0]]
    I              -   differences        [0,1]         [1,0]         [-2,0]        [0,1]         [2,0]         [-1,-2]
     Ị             -   abs(v)<=1          [1,1]         [1,1]         [0,1]         [1,1]         [0,1]         [1,0]
       S           -   sum (of [a,b])      7            11            8              3            10            11
      o            -   OR (vectorises)    [1,1]         [1,1]         [8,1]         [1,1]         [10,1]        [1,11]
        H          -   halve (vectorises) [0.5,0.5]     [0.5,0.5]     [4,0.5]       [0.5,0.5]     [5,0.5]       [0.5,5.5]
         ;         -   concatenate        [0.5,0.5,3,4] [0.5,0.5,4,7] [4,0.5,7,1]   [0.5,0.5,1,2] [5,0.5,2,8]   [0.5,5.5,8,3]
            F      - flatten              [0.5,0.5,3,4,  0.5,0.5,4,7,  4,0.5,7,1,    0.5,0.5,1,2,  5,0.5,2,8,    0.5,5.5,8,3]
                ¤  - nilad followed by link(s) as a nilad:
              9    -   literal nine
               Ḷ   -   lowered range = [0,1,2,3,4,5,6,7,8]
             f     - filter keep          [        3,4,          4,7,  4,    7,1,            1,2,  5,    2,8,         ,8,3]
                 Q  - deduplicate          [3,4,7,1,2,5,8]
                  ⁼ - equal to the input?  e.g. 0 (here because 5 was introduced AND because 3 was removed from the right)

पिछला तरीका

जेली ,  36  35 बाइट्स

9s3;Z$;“Æ7a‘DZ¤;U$;©0m€2iị®oµƝFQ⁼ȧȦ

इसे ऑनलाइन आज़माएं! या एक परीक्षण-सूट देखें

कैसे?

उपरोक्त के समान लेकिन सभी तीन-नोड-लाइन संभावनाओं का निर्माण करता है और लुक-अप करता है (मिड-नोड के लिए राशि का परीक्षण करने और रोकने के लिए डिमॉड का उपयोग करने के बजाय जाँच करता है)।

सबसे पहले तीन-नोड-लाइनों की सूची का निर्माण:

9s3;Z$;“Æ7a‘DZ¤;U$;©0
9s3                   - nine (implicit range) split into threes = [[1,2,3],[4,5,6],[7,8,9]]
     $                - last two links as a monad:
    Z                 -   transpose = [[1,4,7],[2,5,8],[6,7,9]]
   ;                  -   concatenate = [[1,2,3],[4,5,6],[7,8,9],[1,4,7],[2,5,8],[3,6,9]]
              ¤       - nilad followed by link(s) as a nilad:
       “Æ7a‘          -   code-page index list = [13,55,97]
            D         -   decimal (vectorises) = [[1,3],[5,5],[9,7]]
             Z        -   transpose = [[1,5,9],[3,5,7]]
      ;               - concatenate = [[1,2,3],[4,5,6],[7,8,9],[1,4,7],[2,5,8],[3,6,9],[1,5,9],[3,5,7]]
                 $    - last two links as a monad:
                U     -   upend = [[3,2,1],[6,5,4],[9,8,7],[7,4,1],[8,5,2],[9,6,3],[9,5,1],[7,5,3]]
               ;      -   concatenate = [[1,2,3],[4,5,6],[7,8,9],[1,4,7],[2,5,8],[3,6,9],[1,5,9],[3,5,7],[3,2,1],[6,5,4],[9,8,7],[7,4,1],[8,5,2],[9,6,3],[9,5,1],[7,5,3]]
                    0 - literal zero (to cater for non-matches in the main link since ị, index into, is 1-based and modular the 0th index is the rightmost)
                  ;   - concatenate = [[1,2,3],[4,5,6],[7,8,9],[1,4,7],[2,5,8],[3,6,9],[1,5,9],[3,5,7],[3,2,1],[6,5,4],[9,8,7],[7,4,1],[8,5,2],[9,6,3],[9,5,1],[7,5,3],0]
                   ©  - copy the result to the register

अब निर्णय लेना:

...m€2iị®oµƝFQ⁼ȧȦ - left input is a list of integers               e.g. [4,5,8,2,3,9,4]
          µƝ      - perform the chain to the left for adjacent pairs:
                  - i.e. for [a,b] in [[4,5],[5,8],[8,2],[2,3],[3,9],[9,4]]
...               -   perform the code described above = [[1,2,3],[4,5,6],[7,8,9],[1,4,7],[2,5,8],[3,6,9],[1,5,9],[3,5,7],[3,2,1],[6,5,4],[9,8,7],[7,4,1],[8,5,2],[9,6,3],[9,5,1],[7,5,3],0]
   m€2            -   modulo-2 slice €ach = [[1,3],[4,6],[3,9],[1,7],[2,8],[6,9],[1,9],[3,7],[3,1],[6,4],[9,7],[7,1],[8,2],[9,3],[9,1],[7,3],[0]]
      i           -   index of [a,b] in that (or 0 if not there)    e.g. [0,0,13,0,6,0]
        ®         -   recall from register = [[1,2,3],[4,5,6],[7,8,9],[1,4,7],[2,5,8],[3,6,9],[1,5,9],[3,5,7],[3,2,1],[6,5,4],[9,8,7],[7,4,1],[8,5,2],[9,6,3],[9,5,1],[7,5,3],0]
       ị          -   index into (1-based & modular)     e.g. [0,0,[8,5,2],0,[3,6,9],0]
         o        -   OR [a,b]           e.g. [[4,5],[5,8],[8,5,2],[2,3],[3,6,9],[9,4]]
            F     - flatten                          e.g. [4,5,5,8,8,5,2,2,3,3,6,9,9,4]
             Q    - deduplicate                                    e.g. [4,5,8,2,3,6,9]
              ⁼   - equal to the input?                            e.g. 0 (here because 6 was introduced AND because 4 was removed from the right)
                Ȧ - any and all? (0 if input is empty [or contains a falsey value when flattened - no such input], 1 otherwise)
               ȧ  - AND (to force an empty input to evaluate as 1 AND 0 = 0)

जब यूनिकोड वर्णों का एक समूह होता है, तो यह 19 बाइट्स के लिए कैसे निकलता है?
इज़्काता

@ इज़काता जेली अपने स्वयं के कोड-पृष्ठ का उपयोग करती है, जिसे आप हेडर में "बाइट्स" पर क्लिक करके देख सकते हैं। अपने कच्चे बाइट-रूप में यूनिकोड के प्रत्येक अक्षर को आप स्रोत-कोड में देख सकते हैं, केवल एक ही बाइट है।
जोनाथन एलन

15

स्टेक्स , 28 बाइट्स

æ¡_t¿♂≥7▼├öä▒╨½╧£x╪╨┌i╒ë╖¢g•

चलाओ

यह झूठे के लिए 0, और सच के लिए सकारात्मक पूर्णांक पैदा करता है। इसी कार्यक्रम का संबंधित एएससीआई प्रतिनिधित्व है।

cu=x%v*x2BF1379E-%_|+YA=!*yhxi(#+*

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

cu=                                 First: no duplicates
   x%v*                             Second: length of input minus 1
       x2B                          Get all adjacent pairs  
          F                         For each pair, execute the rest
           1379E-%                  a) Any digits that are not 1, 3, 7, 9?
                  _|+Y              Get sum of pair, and store in Y register
                      A=!           b) Sum is not equal to 10?
                         *          c) multiply; logical and: a, b
                          yh        half of y; this will be equal to the
                                        number directly between the current
                                        pair if there is one
                            xi(#    d) has the middle number been observed yet?
                                +   e) plus; logical or: c, d
                                 *  multiply by the accumulated value so far

Yरजिस्टर का चतुर उपयोग ।
वीजुन झोउ

गितुब पर एक और मुद्दा।
वीजुन झोउ

1
मैं संयोग से उस बग को पहले ही तय कर चुका था, लेकिन अभी तक इसे तैनात नहीं किया था। (यह मेरे कार्यक्रम को प्रभावित नहीं करता है)
पुनरावर्ती

1
यह अजीब लग सकता है, लेकिन आप पहले को छोड़ सकते हैं vऔर 1मिथ्या मूल्य के रूप में शामिल कर सकते हैं । 2और ऊपर सत्य हैं।
वीजुन झोउ

10

जावास्क्रिप्ट, 112 बाइट्स

x=>/^(?!.*(.).*\1|[^5]*(19|28|37|46|91|82|73|64)|[^2]*(13|31)|[^8]*(79|97)|[^4]*(17|71)|[^6]*(39|93))../.test(x)

हो सकता है कि कुछ रेगेक्स आधारित भाषा अधिक छोटी होनी चाहिए। लेकिन मुझे नहीं पता।

नील के लिए धन्यवाद, 3 बाइट्स )(?!को |बचाने के लिए बदलें ।


@ WeijunZhou मैं 213 के लिए सच हो गया, क्या गलत है?
tsh

कुछ भी गलत नहीं है, इसके लिए खेद है।
वीजुन झोउ

अब जब से ओपी ने स्पष्ट किया है, के लिए विफल रहता है 144
वीजुन झोउ

1
@ WeijunZhou को तय किया जाना चाहिए; 2 और बाइट्स ...
tsh

यदि आप सोच रहे थे, तो रेटिना 0.8.2 पोर्ट 98 बाइट्स में काम करने लगता है।
नील

6

रेटिना 0.8.2 , 98 बाइट्स

टीश के जवाब से प्रभावित । मैंने इसके विपरीत होने की कोशिश की, इसके विपरीत अमान्य स्वाइपों का मिलान किया, फिर एंटी-ग्रीपिंग किया।

A`(.).*\1|^([^5]*(19|28|37|46|91|82|73|64)|[^2]*(13|31)|[^8]*(79|97)|[^4]*(17|71)|[^6]*(39|93)|.$)

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


6

भूसी , 25 20 बाइट्स

S=öufΛ¦1ΣẊ§Jzo½+em‰3

0-आधारित अनुक्रमण के साथ पूर्णांकों की सूची लेता है। रिटर्न 0 या 1. इसे ऑनलाइन आज़माएं!

व्याख्या

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

S=öufΛ¦1ΣẊ§Jzo½+em‰3  Implicit input, say [0,4,6,7,1]
                 m‰3  Divmod each by 3: L = [[0,0],[1,1],[2,0],[2,1],[0,1]]
         Ẋ§Jzo½+e     This part inserts the middle node between adjacent nodes.
         Ẋ            Do this for each adjacent pair, e.g. [1,1],[2,0]:
          §           Apply two functions and combine results with third.
            zo½+      First function:
            z         Zip with
               +      addition,
             o½       then halve: N = [3/2,1/2]
                e     Second function: pair: P = [[1,1],[2,0]]
           J          Combining function: join P with N: [[1,1],[3/2,1/2],[2,0]]
                      Result is a list of such triples.
        Σ             Concatenate: [[0,0],[1/2,1/2],[1,1],[1,1],[3/2,1/2],...,[0,1]]
    f                 Keep only those pairs
     Λ                both of whose elements
      ¦1              are divisible by 1, i.e. are integers: [[0,0],[1,1],[1,1],,...,[0,1]]
   u                  Remove duplicates: [[0,0],[1,1],[2,0],[2,1],[0,1]]
S=ö                   Is the result equal to L? Implicitly print 1 or 0.

3

सी ++, 267 256 बाइट्स

#define R)return 0
#define H(a,q)if(d==q&&n==a&&!m[a]R;
int v(int s[],int l){if(l<2 R;int m[10]{},i=1,p=s[0],d,n;for(;i<l;++i){m[p]=1;if(m[s[i]]R;d=(d=p-s[i])<0?-d:d;if(d%2<1){n=(p+s[i])/2;H(5,4)H(5,8)H(2,2)H(5,2)H(8,2)H(4,6)H(5,6)H(6,6)}p=s[i];}return 1;}

यह जांचने के लिए कि क्या पैटर्न एक असमान नोड पर नहीं छोड़ता है, यह कई चीजें करता है:

  1. गणना करें कि वर्तमान नोड और अंतिम नोड के बीच संख्यात्मक अंतर dकहां dहै।
  2. यदि dयह अजीब है, तो जांच करने की कोई आवश्यकता नहीं है, यह एक नोड पर नहीं छोड़ सकता है।
  3. यदि dके बराबर 4या है 8, तो छलांग नोड्स के बीच है 1-9या 3-7, इसलिए नोड की जांच करें5
  4. यदि d2 है, और मध्य नोड ( (last_node + current_node)/2) या तो 2,5 या 8 है, तो मध्य नोड की जांच करें
  5. यदि d6 है, तो पहले की तरह ही जांच करें 4, लेकिन 5या6

पैरामीटर एक हैं int[]और यह तत्व गणना है। यह intएक boolप्रकार के रूप में व्याख्या की जा सकती है


!(d%2)=> d%2<1काम करना चाहिए।
ज़ाचार्इ


मैंने एक नई तरकीब सीखी: int s[]=> int*s। मुझे लगता है कि मैं काम करूंगा।
13

2

पर्ल, 135 बाइट्स (134 + -n)

@a{split//}=1;(@{[/./g]}==keys%a&&/../)||die();for$c(qw/132 465 798 174 285 396 195 375/){$c=~/(.)(.)(.)/;/^[^$3]*($1$2|$2$1)/&&die()}

थोड़ा ungolfed संस्करण

@a{split//} = 1;
(@{[/./g]} == keys %a && /../) || die();
for $c (qw/132 465 798 174 285 396 195 375/) {
  $c=~/(.)(.)(.)/;
  /^[^$3]*($1$2|$2$1)/&&die()
}

निर्गम कोड के माध्यम से आउटपुट। 0सत्य है, कोई अन्य मूल्य मिथ्या है। मेटा सर्वसम्मति के अनुसार , विफलता के मामले में STDERR आउटपुट की अनदेखी की जाती है।

संभवत: सभी संभावनाओं को सूचीबद्ध करने की तुलना में "ओवर नॉट जंप" नियम की जांच करने का एक तेज़ तरीका है।


2

MATL , 42 41 39 बाइट्स

9:IeXKi"Ky@=&fJ*+XK+y&fJ*+Em~zw0@(]z8<v

यह पैदा करता है

  • एक गैर-खाली कॉलम वेक्टर जिसमें केवल सत्य-आउटपुट के रूप में गैर-शून्य संख्या होती है ; या
  • एक गैर-खाली कॉलम वेक्टर जिसमें कम से कम एक शून्य होता है, जो झूठा होता है।

यहाँ आप पढ़ सकते हैं कि ये आउटपुट क्रमशः सत्य और मिथ्या क्यों हैं। इसे ऑनलाइन आज़माएं!

या सभी परीक्षण मामलों को सत्यापित करें , पाद लेख के साथ जिसमें सत्यता / झूठ के लिए मानक परीक्षण शामिल है ।


2

स्टैक्स , 73 72 66 65 बाइट्स CP437

ÉWyƒ▬ºJOTƒw-H┌↓&ⁿç↨¼<ü6π║¢S○j⌂zXΣE7≈╩╕╤ö±÷C6▒☼■iP-↑⌐¥]╩q|+zΦ4Φ·¥Ω

79 बाइट्स अनपैक किए जाने पर,

d4{cAs-5F132396978714EEL3/{xs:IBc0<A*++cEd:-1=sccHs|M=s{U>m|A**mEx%2<xu%x%=!L|+

भागो और डिबग ऑनलाइन!

या बैच टेस्ट चलाएं , जहां meXएक हेडर है ताकि स्टैक्स मल्टीलाइन इनपुट को प्रोसेस कर सके।

Hash.Outputs के लिए सख्ती से धनात्मक संख्या (वास्तव में विफल रहा है परीक्षण की संख्या) का उपयोग किए बिना कार्यान्वयन falsy मामलों और 0के लिए truthy वाले।

व्याख्या

dइनपुट स्टैक को साफ करता है। इनपुट xवैसे भी परिवर्तनशील है।

4{cAs-5F मध्य-नोड सूची का पहला भाग उत्पन्न करता है।

132396978714EE मध्य-नोड सूची के दूसरे भाग को हार्डकोड करता है।

L3/मुख्य स्टैक में सभी तत्वों को इकट्ठा करता है और प्रत्येक 3 तत्वों वाले भागों में विभाजित करता है, परिणाम सरणी है a, जो कि सभी अमान्य 3-नोड समूहों का सरणी है।

{xs:IBc0<A*++cEd:-1=sccHs|M=s{U>m|A**mEप्रत्येक अमान्य नोड सूची के लिए, निम्नलिखित जाँच करें। चेक परिणामों के परिणाम andएड का उपयोग कर रहे हैं **। चूंकि 8 अमान्य नोड सूचियां हैं, इसलिए इस कोड का परिणाम 8 तत्वों की एक सरणी होगा। Eमुख्य सरणी पर अंतिम अपने व्यक्तिगत तत्वों के लिए सरणी भेजता है।

xs:I इनपुट सरणी में नोड सूची तत्वों के सूचकांक प्राप्त करें।

Bc0<A*++यदि "मध्य नोड" (जैसे 5नोड सेट में 1,5,9) का सूचकांक है -1(जिसका अर्थ है कि यह इनपुट सरणी में मौजूद नहीं है), तो सूचकांक को बदल दें 9

cEd:-1=परीक्षण करें कि क्या दो "टर्मिनल नोड्स" (जैसे 1,5नोड सेट में 1,5,9) इनपुट सरणी में आसन्न हैं।

sccHs|M= परीक्षण करें कि क्या "मध्य नोड" का रूपांतरित सूचकांक दो "टर्मिनल नोड्स" से बड़ा है, जिसमें दो मामले शामिल हैं: "मध्य नोड" गायब है, या "मध्य नोड" दो "टर्मिनल नोड्स" के बाद आता है

s{U>m|Aपरीक्षण करता है कि क्या "अंत नोड्स" के दोनों अनुक्रम गैर-संवेदी हैं। (यानी वे दोनों इनपुट में दिखाई देते हैं)।

दो अतिरिक्त परीक्षण किए जाते हैं,

x%2< जाँचता है कि इनपुट सरणी एक सिंगलटन है या नहीं।

xu%x%=! परीक्षण कि क्या दो बार दौरा किया गया है कि नोड्स हैं।

मुख्य स्टैक पर 10 परीक्षा परिणाम हैं (प्रत्येक अमान्य नोड सूची के लिए एक, प्लस दो अतिरिक्त परीक्षण)।

L|+10 तत्वों को इकट्ठा करता है और उन्हें जोड़ता है। |aयह भी इस्तेमाल किया जा सकता था जो बस यह जाँचता है कि सरणी पर कोई सत्य तत्व हैं या नहीं।

निहित उत्पादन।


2

जावा, 375 355 बाइट्स

-20 बाइट्स Zacharý को धन्यवाद

int v(int s[]){int[]m=new int[10];int i=1,p=s[0],d,n,l=s.length;if(l<2)return 0;for(;i<l;++i){m[p]=1;if(m[s[i]]!=0)return 0;d=(d=p-s[i])<0?-d:d;if(d%2==0){n=(p+s[i])/2;if((d==4||d==8)&&n==5&&m[5]==0)return 0;if(d==2&&(n==2&&m[2]==0||n==5&&m[5]==0||n==8&&m[8]==0))return 0;if(d==6&&(n==4&&m[4]==0||n==5&&m[5]==0||n==6&&m[6]==0))return 0;}p=s[i];}return 1;}

यह इस उत्तर का एक बंदरगाह है और यह समान सिद्धांतों पर काम करता है


ओह। आप जावा में एवररिंग कर रहे हैं।
Zacharý

int v(int s[]){int[]m=new int[10];int i=1,p=s[0],d,n,l=s.length;if(l<2)return 0;for(;i<l;++i){m[p]=1;if(m[s[i]]!=0)return 0;d=(d=p-s[i])<0?-d:d;if(d%2==0){n=(p+s[i])/2;if((d==4||d==8)&&n==5&&m[5]==0)return 0;if((d==2)&&(n==2&&m[2]==0||n==5&&m[5]==0||n==8&&m[8]==0))return 0;if(d==6&&(n==4&&m[4]==0||n==5&&m[5]==0||n==6&&m[6]==0))return 0;}p=s[i];}return 1;}काम करना चाहिए (संचालन का क्रम)
Zacharý

आप (d==2)बस बदल सकते हैं d==2, मैंने पहले ही अनदेखी कर दी थी।
जकार्इ

d%2==0=>d%2<1
ज़ाचारि

0

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

q{@U9.nm+mc|g1aZksd2-MC.DR3d_dC,t

परीक्षण सूट।

0-आधारित अनुक्रमण का उपयोग करता है।

व्याख्या

q {@ U9.nm + mc | g1aZksd2-MC.DR3d_dC, t - पूर्ण कार्यक्रम। इनपुट: एसटीडीआईएन से एक सूची एल।

                               , t -> प्रथम तत्व के बिना L के साथ P जोड़ी।
                              सी -> स्थानांतरण।
       m -> जोड़े की सूची पर नक्शा (2-तत्व सूची):
        + mc | g1aZksd2-MC.DR3d -> मैप किए जाने वाले फ़ंक्शन (चर: d):
                         R d -> d के प्रत्येक तत्व के लिए ...
                       .D 3 -> ... 3 से उसका divmod लें।
                      C -> ट्रान्सपोज करें।
                    -M -> घटाव द्वारा प्रत्येक को कम करें।
         m -> प्रत्येक अंतर के लिए (चर: k):
            g1aZl -> Is | k | ≤ 1?
           | sd -> यदि वह मिथ्या है, तो उसे d के योग से बदलें।
          c 2 -> 2 से भाग दें।
        + _d -> मैपिंग के परिणाम के लिए d के रिवर्स को जोड़ दें।
     .n -> समतल।
  @ U9 -> चौराहे को (Take 0 [0; 9)) के साथ ले जाएं।
 {>> डेडुप्लिकेट।
q -> और जांचें कि क्या परिणाम एल के बराबर है।

34 बाइट्स के लिए वैकल्पिक दृष्टिकोण :

q{sI#I#+Fm+,hdcR2+MCd]edCtBK.DR3QK

0

जाप , 35 बाइट्स

eUä@[(Xu3 aYu3)¥1ªX+Y ÷2XY]Ãc f9o)â

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

थोड़ा ungolfed और यह कैसे काम करता है

eUä@[(Xu3 aYu3)¥1ªX+Y ÷2XY]Ãc f9o)â

Implicit beginning U(input) and some arbitrary sequence conversions

UeUä@[(Xu3 aYu3)==1||X+Y ÷2XY]} c f9o)â

  Uä             Convert the input array into length-2 subsections and map...
    @[ ... ]}      function of X,Y which returns an array of...
      Xu3 aYu3==1||X+Y ÷2          (abs(X%3 - Y%3)==1||X+Y)/2,
                         XY        X, Y
  c              Flatten the result of mapping
    f9o          Intersect with range(9)
        â        Take unique elements, preserving order
Ue             Is the result the same as original array?

संभावित जंप के निर्धारण में कुछ अंतर के साथ इस जेली समाधान से विचार को चित्रित किया :

  • जेली उत्तर divmod का उपयोग करता है यह देखने के लिए कि क्या किसी जोड़े के लगाए जाने पर 2 का अंतर है /3या नहीं %3
  • यह उत्तर केवल उपयोग करता है %3और जाँचता है कि क्या अंतर 0 या 2 है। यदि अंतर 0 है, तो दो सेल लंबवत रूप से संरेखित हैं, और गैर-जंप अभी भी की संपत्ति साझा करते हैं (X+Y)%2 != 0

0

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

ओवस के जवाब के आधार पर लेकिन 2 बाइट्स छोटी और कम गूढ़ होती हैं। बस अनुक्रम को 2d निर्देशांक और परीक्षण समता में परिवर्तित करता है। 0-8 इंडेक्स मानता है।

v={9}
s=input()
for n,l in zip(s[1:]or q,s):n/3+l/3&1|n%3+l%3&1or n+l>>1in v or q;v|={l};n in v>q

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

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