शहर में दो नए शेरिफ हैं - DJMcMego जोड़े की पहचान करना!

Question

हमारे पास शहर में कुछ नए शेरिफ मॉडरेटर्स हैं , Mego और DJMcMayhem । हमें उनके नए पदों के लिए उन्हें उचित रूप से सम्मानित करने के लिए एक चुनौती की आवश्यकता है, इसलिए हम वहां जाते हैं।

यहाँ कुछ ऐसा है जिसने उनके प्रोफाइल पर मंडराते समय मेरा ध्यान खींचा है - उनके यूजर आईडी और । यदि आप अंक-वार घटाव का प्रदर्शन करते हैं, तो आप कुछ रोमांचक (निश्चित रूप से, पूर्ण अंतर लेते हुए) नोटिस करेंगे:$31716$$45941$

3|1|7|1|6
4|5|9|4|1
-+-+-+-+- (-)
1|4|2|3|5

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

हम एक पूर्णांक के सकारात्मक पूर्णांक एक जोड़ी को डीजेएमसीएमगो युग्म कहेंगे यदि अंक-वार पूर्ण अंतर लगातार पूर्णांक हैं, आरोही क्रम में सॉर्ट किया गया है, लेकिन वास्तव में उनमें से एक ऐसा नहीं है जहां यह है। यही है, अंक-वार घटाव के परिणाम के ठीक एक अंक को किसी अन्य स्थिति में स्थानांतरित करना संभव है , जैसे कि पूर्णांक में केवल निरंतर अंक होते हैं, आरोही क्रम में क्रमबद्ध।$(a, b)$

ऊपर हमारे उदाहरण में, जोड़ी एक डीजेएमकेगो जोड़ी है, क्योंकि यदि को और बीच ले जाया जाता है , तो परिणाम , जो मानदंडों को पूरा करता है। ध्यान दें कि परिणामी संख्या के अंकों को पर शुरू करने की आवश्यकता नहीं है , उन्हें बस निरंतर होना चाहिए। जब कोई इस बारे में अनिश्चित होता है कि उन्हें क्या निर्णय लेना चाहिए, तो वे हमेशा चीजों को छाँटने के लिए दूसरे की मदद पर भरोसा कर सकते हैं।4 3 5 12345 $(31716, 45941)$$4$$3$$5$$12345$$1$

आपका कार्य एक सत्य / मिथ्या मूल्य का उत्पादन करना है जो इस बात पर निर्भर करता है कि इनपुट के रूप में दिए गए धनात्मक पूर्णांक की एक जोड़ी एक DJMcMego जोड़ी है।

• आपको गारंटी दी जाती है कि और के अंक समान होंगे, हमेशा कम से कम 4।$a$$b$

• आप पूर्णांकों को किसी भी उचित प्रारूप में ले सकते हैं (यानी देशी पूर्णांक, तार, अंकों की सूची, आदि)

• आप किसी भी प्रोग्रामिंग भाषा में प्रतिस्पर्धा कर सकते हैं और इनपुट ले सकते हैं और किसी भी मानक विधि के माध्यम से आउटपुट प्रदान कर सकते हैं , जबकि ध्यान दें कि इन खामियों को डिफ़ॉल्ट रूप से मना किया गया है। यह कोड-गोल्फ है , इसलिए हर भाषा के लिए सबसे छोटा सबमिशन (बाइट्स में) जीतता है।

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

a, b -> Output

31716, 45941 -> Truthy
12354, 11111 -> Truthy
56798, 22222 -> Truthy
23564, 11111 -> Truthy
1759,  2435  -> Truthy
12345, 11111 -> Falsy
3333,  2101  -> Falsy
22354, 22222 -> Falsy
31717, 45941 -> Falsy
14325, 11111 -> Falsy
89789, 78865 -> Falsy
14954, 61713 -> Falsy
25631, 11114 -> Falsy

या, किसी अन्य प्रारूप में ।

Comments

क्या हम गैर- DJMcMego जोड़ियों के लिए सत्य का उत्पादन कर सकते हैं और DJMcMego जोड़े के लिए मिथ्या हो सकते हैं? क्या सत्य / झूठे मूल्यों के अनुरूप होने की आवश्यकता है?

— डायलन

@Blacksilver मुझे लगता है कि मैं कर दिया है इसे करने के लिए उसे पीटा पी:

— DJMcMayhem

@ Mr.Xcoder "डिफ़ॉल्ट रूप से सत्य / झूठे मूल्यों की अदला-बदली की अनुमति है" क्या यह वास्तव में एक बात है?

— मार्टिन एंडर

@ Mr.Xcoder निश्चित रूप से, कई चुनौतियां इसे अनुमति देती हैं, लेकिन "यह डिफ़ॉल्ट रूप से अनुमत है" यह कहते हुए मुझे लगता है कि कहीं न कहीं एक मेटा पोस्ट है।

— मार्टिन एंडर

शायद 25631, 11114उदाहरण के रूप में जोड़ें । मतभेद हैं 14523जो वर्तमान कार्यक्रमों में से कई को भ्रमित करते हैं

— टन इंजील

Answer 1

05AB1E , 18 बाइट्स

αDæIg<ùʒD{Q}gĀ*{¥P

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

Comments

आपको संभवतः एक नोट जोड़ना चाहिए 1जो 05AB1E में एकमात्र सत्य संख्या है; श्री Xcoder ने मुझे इस तथ्य के बारे में सूचित नहीं किया था, मैंने इस समाधान की वैधता पर सवाल उठाया होगा। क्या आप एक स्पष्टीकरण जोड़ सकते हैं, साथ ही, जब आपके पास समय हो?

— झबरा

@ शैगी आप इस बीच में मेरे समाधान की व्याख्या पर एक नज़र डाल सकते हैं: यह एनिग्मा की तरह कुशल नहीं है, लेकिन हम ज्यादातर समान कार्यों का उपयोग कर रहे हैं।

— कलडो

@ शागिर्द: जब मैंने इसे पोस्ट किया, तो स्पष्टीकरण जोड़ने का समय नहीं था, लेकिन अब यह हो गया है :)

— एमिगा

यह नए परीक्षण मामले, 14325, 11111 ( झूठा ) के लिए विफल रहता है ।

— डेनिस

@ डेनिस: धन्यवाद, अभी के लिए तय किया जाना चाहिए (बहुत सारे बाइट्स की कीमत पर)। इसके लिए बाद में प्रयास करना होगा।

— एमिग्ना

Answer 2

C (gcc) , 259 258 254 253 250 248 233 बाइट्स

• एक बाइट गोल्फ को परेशान करने के लिए स्टेन स्ट्रम का धन्यवाद ।
• कुछ चर आरंभीकरणों को जोड़कर चार बाइट्स सहेजे गए।
• गोल्फ से एक बाइट सहेजा for(...;l++)b*=B[l]==-~B[l-1];करने के लिए for(...;b*=B[l]==-~B[~-l++]);(सबसे अधिक संभावना है, अपरिभाषित व्यवहार पर निर्भर की आवश्यकता के रूप में यह पहले का मूल्यांकन B[l]के बाद -~B[~-l++])।
• सहेजे गए तीन से पांच बाइट्स।
• छत के लिए धन्यवाद पंद्रह बाइट्स बचाता है ।

j,k,l,L,r,b;f(char*A,char*B){for(j=r=0;A[L=j];)A[j++]=-~abs(A[j]-B[j]);for(j=0;j-L;j++)for(k=~0;L-++k;r|=!b)if(j-k){strcpy(B,A);for(l=j;A[l];B[~-l]=B[++l]);for(l=L;l-k;B[-~l]=B[--l]);B[k]=A[j];for(l=b=0;B[++l];b|=B[l]+~B[~-l]);}A=r;}

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

स्पष्टीकरण (248 बाइट संस्करण)

j,k,l,L,r,b;                            // global variables
f(char*A,char*B){                       // function takes two strings
 for(j=r=0;A[j];L=j)                    // loop through A, compute array length L
  A[j++]=-~abs(A[j]-B[j]);              // set every entry in A to the absolute
                                        // difference of A and B at that position
                                        /* Test out all possible movements of        *
                                         * characters and see if any one             *
                                         * results in a sorted list => DJMcMego pair */
 for(j=0;j-L;j++)                       // loop through array
  for(k=~0;L-++k;r|=!b)                 // loop through array
   if(j-k){                             // j is not equal to k
    for(l=0;A[l];B[l++]=A[l]);          // copy A to B
    for(l=j;A[l];B[~-l]=B[++l]);        // shift part of B
    for(l=L;l-k;B[-~l]=B[--l]);         // shift part of B
    B[k]=A[j];                          // insert character at correct position
    for(l=b=0;B[++l];b|=B[l]+~B[~-l]);} // test if B is sorted
 A=r;}                                  // return if there was a DJMcMego pair found

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

Comments

छोरों के लिए जो केवल 1 बार चलते हैं, आप j=041 वें चार के रूप में छोड़ सकते हैं

— स्टेन स्ट्रम

@StanStrum मैं काफी निश्चित हूं कि आप jउस मूल्य पर भरोसा करते हैं 0जो जरूरी नहीं कि कई कॉल के बाद हो। एक फ़ंक्शन, हालांकि, मनमाने ढंग से अक्सर कॉल करने योग्य होना चाहिए और अभी भी चुनौती को हल करना चाहिए ( प्रासंगिक मेटा पोस्ट )।

— जोनाथन फ्रीच

@StanStrum, हालांकि, आप jलूप से पहले शून्य को परिभाषित कर सकते हैं और इस तरह एक बाइट बचा सकते हैं।

— जोनाथन फ्रीच

आप के साथ एक बाइट दाढ़ी कर सकते हैं f(char*A,char*B){-> f(A,B)char*A,*B;{।

— लैंबडाबेटा

@LambdaBeta वे दो स्निपेट समान लंबाई के हैं।

— जोनाथन फ्रीच

Answer 3

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

इनपुटिंग सिंटैक्स में अंकों के दो सरणियों के रूप में इनपुट लेता है (a)(b)। एक बूलियन देता है।

a=>b=>a.some((_,i)=>a.some((_,j)=>i-j&&!(A=a.map((v,i)=>Math.abs(v-b[i]))).some(v=>v-A[~k--]-1,A.splice(i,0,A.splice(j,1)[k=0]))))

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

Answer 4

एसडब्ल्यूआई-प्रोलॉग, 157 बाइट्स

बहुत कम नहीं है, लेकिन समस्या विशेष रूप से घोषणात्मक विधेय, चर बंधन और पुनरावृत्ति के लिए अच्छी तरह से अनुकूल लग रही थी, अर्थात, प्रोपल :)

n(T,Y):-s(T,Q,I,J),s(Y,W,I,J),m(Q,W).
s(T,Q,I,J):-nth0(I,T,X,R),nth0(J,Q,X,R),I\=J.
m([A,B|T],[C,D|Y]):-1 is abs(B-D)-abs(A-C),m([B|T],[D|Y]).
m([_],[_]).

के साथ कॉल करें, जैसे, n([3,1,7,1,6],[4,5,9,4,1]).

स्पष्टीकरण: दोनों सूचियों में एक तत्व को एक नई स्थिति में ले जाएं (SWI- प्रोलॉग nth0बिल्ट-इन का उपयोग करके ) और जांचें कि क्या नई सूचियों का अंतर लगातार है।

s(T,Q,I,J)    % switch (yet unbounded) index I and J in list T, store in Q
s(Y,W,I,J)    % switch (now bounded) I and J in list Y
m(Q,W)        % check new lists
s(T,Q,I,J) :- nth0(I,T,X,R) % X (unbounded) is the I-th (unbounded) element 
                            % of list T with rest R (=prefix+postfix) 
nth0(J,Q,X,R) % the same X is the J-th element in list Q with the same rest R
I\=J          % I and J are unequal
m([A,B|T],[C,D|Y]) :-  % consider first two elements of both lists
1 is abs(B-D)-abs(A-C) % check if differences are consecutive                          
m([B|T],[D|Y])         % recursion starting with the second element
m([_],[_]).            % stop recursion at last element in the list

Answer 5

जे , 27 बाइट्स

−8 बाइट्स FrownyFrog के लिए धन्यवाद

1"0(-:(2-/\|\:|),1#.2>/\|)-

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

प्रारंभिक समाधान:

जे , 35 बाइट्स

[:((1=[:*/2-/\\:~)*1=1#.0<2-/\])|@-

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

व्याख्या

इनपुट के रूप में अंकों की सूची लेता है

|@- सूचियों के अंकों के बीच पूर्ण अंतर पाता है

1=1#.0<2-/\]जाँच करता है कि क्या केवल एक अंक अपनी जगह से बाहर है। पहले मैं आसन्न अंकों के सभी जोड़े के बीच अंतर पाता हूं और यह देखने के लिए जांच करता हूं कि क्या उनमें से केवल एक सकारात्मक है।

* निम्नलिखित परीक्षण के साथ उपरोक्त परीक्षा (1 या 0) से परिणाम गुणा करें:

1=[:*/2-/\\:~क्या सभी अंक लगातार हैं? मैं सूची को नीचे क्रमबद्ध करता हूं, आसन्न अंकों के सभी जोड़ों के लिए अंतर लेता हूं, उन्हें गुणा करता हूं और जांचता हूं कि क्या यह 1 के बराबर है

Comments

के लिए विफल 25634 11111(कई अन्य प्रस्तुतियाँ के रूप में)

— टन हास्पेल

@ टन हास्पेल - हां, आप सही हैं। मैं देखता हूँ कि ti इसे कैसे ठीक करते हैं।

— गैलेन इवानोव

मैं इसे ठीक नहीं किया, सिर्फ गोल्फ।

— FrownyFrog

@FrownyFrog धन्यवाद! मैं इस समस्या को भूल गया हूं।

— गैलेन इवानोव

Answer 6

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

ạµṢ_JEċ@Œ¿-Ƥ%L

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

यह काम किस प्रकार करता है

ạµṢ_JEċ@Œ¿-Ƥ%L  Main link. Arguments: A, B (digit arrays)

ạ               Take the elementwise absolute difference. Call the result R.
 µ              New chain. Argument: R
  Ṣ             Sort R.
    J           Indices; yield [1, ..., len(R)].
   _            Take the elementwise difference.
     E          Test if all differences are equal.
                The result is 1 if R consists of consecutive digits, 0 otherwise.
          -Ƥ    For all outfixes of R, generated by dropping one of its elements:
        Œ¿        Get its permutation index (1 if sorted, higher if not).
      ċ@        Count the number of times the Boolean from the left appears in the
                array to the right. If the Boolean is 1, the count represents the
                number of ways a single digit can be deleted to yield a sorted
                array. The count has to be positive for a DJMcMego pair, but less
                than the length of R, since R may not be sorted.
            %L  Take the result modulo len(R), mapping len(R) to 0.

Answer 7

जाप , 18 बाइट्स

यह बहस करते हुए कि मुझे यह पोस्ट करना चाहिए या नहीं, कुछ घंटों के लिए। कल देर रात इसके साथ आया, लेकिन इसे ठीक से परीक्षण करने का समय नहीं था ( और मुझे लगा कि यह बहुत लंबा हो सकता है!)। ओलिवर ने तब से एक समान समाधान पोस्ट किया है (जो कि, जब यह मूल रूप से पोस्ट किया गया था, तो अमान्य है) यदि वह, या समुदाय, यह महसूस करता है कि यह भी समान है, तो मैं खुशी से इसे हटा दूंगा।

2 अंकों सरणियों, आउटपुट के रूप में इनपुट लेता है 0के लिए trueया के लिए किसी अन्य नंबर false।

íaV
ä> x*Un än × É

इसे आज़माएँ या सभी परीक्षण मामलों की जाँच करें

---

व्याख्या

                   :Implicit input of digit arrays U and V               :[3,1,7,1,6],[4,5,9,4,1]
í V                :Interleave V with U                                  :[[3,4],[1,5],[7,9],[1,4],[6,1]]
 a                 :Get the absolute difference of each pair             :[1,4,2,3,5]
\n                 :Assign that new array to variable U
ä>                 :Is each element greater than the next?               :[false,true,false,false]
     Un            :Sort U                                               :[1,2,3,4,5]
        än         :Get the deltas                                       :[1,1,1,1]
           ×       :Reduce by multiplication                             :1
    *              :Multiply each element in the boolean array by that   :[0,1,0,0]
   x               :Reduce by addition                                   :1
             É     :Subtract 1                                           :0

और, कुछ और परीक्षण मामलों पर उस प्रक्रिया से गुजरने के लिए:

---------------------------------------------------------------
| U   | [2,3,5,6,4] | [1,2,3,4,5] | [3,1,7,1,7] | [1,4,9,5,4] |
| V   | [1,1,1,1,1] | [1,1,1,1,1] | [4,5,9,4,1] | [6,1,7,1,3] |
|-----|-------------|-------------|-------------|-------------|
| íaV | [1,2,4,5,3] | [0,1,2,3,4] | [1,4,2,3,6] | [5,3,2,4,1] |
|-----|-------------|-------------|-------------|-------------|
| ä>  | [F,F,F,T]   | [F,F,F,F]   | [F,T,F,F]   | [T,T,F,T]   |
|-----|-------------|-------------|-------------|-------------|
| Un  | [1,2,3,4,5] | [0,1,2,3,4] | [1,2,3,4,6] | [1,2,3,4,5] |
| än  | [1,1,1,1]   | [1,1,1,1]   | [1,1,1,2]   | [1,1,1,1]   |
| ×   | 1           | 1           | 2           | 1           |
|-----|-------------|-------------|-------------|-------------|
| *   | [0,0,0,1]   | [0,0,0,0]   | [0,2,0,0]   | [1,1,0,1]   |
| x   | 1           | 0           | 2           | 3           |
| É   | 0           | -1          | 1           | 2           |
---------------------------------------------------------------

Comments

के लिए विफल 25634 11111(के रूप में कई अन्य प्रस्तुतियाँ)

— 16

Answer 8

पर्ल, 121 118 बाइट्स

($a,$b)=map[split//],@ARGV;
$s+=$l>$_,$l=$_ for@c=map abs($$a[$i]-$$b[$i++]),@$a;
@c=sort@c;
say$s==1&&$c[-1]-$c[0]==$#$a

बैश में टेस्ट:

function golf {
   perl -E'($a,$b)=map[split//],@ARGV;$s+=$l>$_,$l=$_ for@c=map abs($$a[$i]-$$b[$i++]),@$a;@c=sort@c;say$s==1&&$c[-1]-$c[0]==$#$a' $1 $2
}
golf 31716 45941       #says 1, true
golf 12354 11111       #says 1, true
golf 56798 22222       #says 1, true
golf 46798 22222       #says nothing, false
golf 22354 22222       #says nothing, false
golf 1759 2435         #says 1, true
golf 12345 11111       #says nothing, false
golf 89789 78865       #says nothing, false
golf 14954 61713       #says nothing, false

Comments

के लिए विफल 25634 11111(के रूप में कई अन्य प्रस्तुतियाँ)

— टन हास्पेल

Answer 9

जावा 8 , 245 227 223 194 188 बाइट्स

~ 29 बाइट बचाने के लिए केविन का धन्यवाद

एक और 6 बाइट्स के लिए फिर से केविन का धन्यवाद

 z->{int l=z.length/2,c[]=new int[l],i=0,j=0;for(;i<l;)c[i]=Math.abs(z[i]-z[i+++l]);java.util.Arrays.sort(z=c.clone());for(i=0;i<l-1;j+=z[i]-z[i-1]!=1?1:0)j+=c[i]-c[++i]>0?1:0;return j==1;}

उसी पैटर्न का अनुसरण करते हुए गैलेन अपने जे उत्तर के लिए आया था।

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

Comments

आप इस तरह की कुछ और चीजों को गोल्फ कर सकते हैं ( 194 बाइट्स ): z->{int l=z.length/2,c[]=new int[l],i=0,j=0,d[];for(;i<l;)c[i]=Math.abs(z[i]-z[i+++l]);java.util.Arrays.sort(d=c.clone());for(i=0;i<l-1;j+=d[i+1]-d[i++]!=1?1:0)j+=c[i]-c[i+1]>0?1:0;return j==1;}मैंने संयुक्त intऔर int[]शुरुआत में; l=z.length/2एक बार इस्तेमाल किया और l4 बार के बजाय पुन: उपयोग ; बदल if(...)j++करने के लिए j+=...?1:0तो वे छोरों के अंदर रखा जा सकता है और कोष्ठक और दूसरा सेमी-कोलन हटाया जा सकता है; हटा दिया i++और ++सीधे iलूप में आखिरी पर करते हैं ; आदि

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

188 बाइट्स : z->{int l=z.length/2,c[]=new int[l],i=0,j=0;for(;i<l;)c[i]=Math.abs(z[i]-z[i+++l]);java.util.Arrays.sort(z=c.clone());for(i=0;i<l-1;j+=z[i]-z[i-1]!=1?1:0)j+=c[i]-c[++i]>0?1:0;return j==1;}। d[]उस इनपुट को हटा दिया और पुन: उपयोग किया, जिसकी zअब आपको आवश्यकता नहीं है; बदली j+=c[i]-c[i+1]?1:0;और j+=d[i+1]-d[i++]!=1?1:0, j+=c[i]-c[++i]?1:0;और j+=z[i]-z[i-1]?1:0। हालांकि मुझ से +1। अच्छा जवाब! :)

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

धन्यवाद @ केविन, हर बार आपने टिप्पणी की थी कि मैंने केवल एक या दो तरीकों में से एक पाया है जो आपने पहले ही इसे नीचे कर दिया था: पी आप मुझसे बहुत तेज़ हैं! मदद के लिए बहुत बहुत धन्यवाद!

— विकासशील 6

हेहे :) यह सब अनुभव के साथ आता है, मुझे लगता है। मैं पहले से ही जावा में लगभग दो साल से गोल्फ खेल रहा हूं। जितना अधिक आप इसे करते हैं, आप इस तरह की चीजों को आसानी से देखते हैं। और यहां तक ​​कि मेरे जवाबों को ओलिवियरग्रेयर, नेवे, और कुछ अन्य लोगों द्वारा हर समय के रूप में अच्छी तरह से नीचे दिया गया है। ओह, आप शायद उन्हें पहले ही देख चुके हैं, लेकिन जावा में गोल्फिंग के लिए टिप्स और <सभी भाषाओं में गोल्फिंग के लिए टिप्स> के माध्यम से पढ़ने के लिए बहुत दिलचस्प हैं।

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

के लिए विफल रहता है 25634 11111(कई अन्य प्रस्तुतियाँ के रूप में)

— टन हास्पेल

Answer 10

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

+`(.)(.*¶)(.)(.*)
$2$4;$1,$3
\d
*
(_*),\1
_
L$w`(;_+\b)(.*)(;_+\b)
$%`$2$3$1$%"$3$1$2$'
m`(^;_+|\1_)+$

इसे ऑनलाइन आज़माएं! लिंक में परीक्षण मामले शामिल हैं। एक आरोही क्रम को प्राप्त करने के लिए अंकों की संख्या को स्थानांतरित किया जा सकता है, जो कि सीधे स्वैप के लिए 2 है क्योंकि या तो अंक को उस मामले में दूसरे से आगे ले जाया जा सकता है। स्पष्टीकरण:

+`(.)(.*¶)(.)(.*)
$2$4;$1,$3

अंकों को जोड़ो।

\d
*

यूनीरी में बदलें।

(_*),\1
_

अंतर लें, लेकिन फिर 1 जोड़ें क्योंकि रेटिना में शून्य के साथ काम करना कठिन ™ है।

L$w`(;_+\b)(.*)(;_+\b)
$%`$2$3$1$%"$3$1$2$'

वास्तव में एक अंक ले जाकर प्राप्त अंकों के सभी अनुक्रमों को सूचीबद्ध करें।

m`(^;_+|\1_)+$

लगातार अंकों के लिए जाँच करें।

Answer 11

पर्ल 5 ; -एफ 87 84 83 बाइट्स

पुरानी शैली की गिनती: 86 बाइट्स (के +3लिए -F)

वह एसटीडीआईएन पर 2 पंक्तियों के रूप में नंबर देता है, एक अनुवर्ती नई रेखा के बिना अंतिम पंक्ति।

सच के लिए 2 बार तक अंतर स्ट्रिंग प्रिंट करता है, झूठे के लिए कुछ भी नहीं

लंबी A0123456789स्ट्रिंग वास्तव में कष्टप्रद है।

#!/usr/bin/perl -F
$_=<>;s%.%abs$&-$F[pos]%eg;s%%"'$`$''=~s:|:A0123456789=~/\$`$&\$'/>//&&say:reg"%eeg

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

अगर यह 79मान्य है, तो मुझे यह पता है:

$_=<>;s%.%abs$&-$F[pos]%eg;s,,$a=$&;"$`$'"=~s:|:A0123456789=~/$`$a$'/%//:reg,eg

यह एक मान्य जोड़ी के लिए क्रैश होता है, इसलिए आपको एक गैर शून्य निकास कोड मिलता है। यह कुछ भी नहीं करता है अगर एक जोड़ी नहीं है और निकास कोड के साथ बाहर निकलता है। 0. मुझे पता है कि निकास कोड के माध्यम से परिणाम वापस करने की अनुमति है, लेकिन क्या वे ठीक से सत्य और झूठे हैं या वास्तव में उलट हैं (शेल के 0लिए सही है)?

Answer 12

रूबी , 124 113 99 95 बाइट्स

->l,b,d=-1{m=l.map!{|i|(i-b[d+=1]).abs}.sort;l.any?{|*i|m-i==l-i}&&m!=l&&/#{m*''}/=~[*0..9]*''}

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

Comments

के लिए विफल 25634 11111(कई अन्य प्रस्तुतियाँ के रूप में)

— टन हास्पेल

@ टोनहोस्ट ने इसे तय किया, धन्यवाद

— असोन तुहिद

बहुत बढ़िया पलटाव। एक +1:-)

— टन होज़ल

Answer 13

पाइट , 20 18 बाइट्स

ą←ą-ÅĐʁ>Ʃ1=⇹ş₋Π1=∧

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

व्याख्या:

       Implicitly get the first number
ą      Convert to list of digits
←      Get the second number
ą      Convert to list of digits
-Å     Take the absolute value of the differences of the lists element-wise
Đ      Duplicate the list of differences
ʁ>     Reduce by greater than
Ʃ1=    Is the sum of that array equal to 1
⇹      Swap the top two items on the stack
ş      Sort the top of the stack ascending
₋      Reduce by subtraction (from the right)
Π1=    Is the product of the array equal to 1
∧      bitwise-AND (in this case, also logical AND) the top two items on the stack
       Implicit print

Comments

के लिए विफल 25634 11111(के रूप में कई अन्य प्रस्तुतियाँ)

— टन हास्पेल

Answer 14

++ , 105 बाइट्स जोड़ें

D,w,@~,Ñ_€|BSVcGbU1b]2b]+º=
D,k,@,BPB*
L,BcB_€|B]dBkbUBSVcGbU£>sVcGB]VBKB#BKBcB_0º>b]GBK{w}b]++b*1=BK{k}*

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

एक लंबो फ़ंक्शन को परिभाषित करता है जो इनपुट के रूप में अंकों की दो सूची लेता है। डीजेएमसीएमगो जोड़े के लिए 24 ^{1 से} विभाज्य एक सकारात्मक पूर्णांक आउटपुट , 0 अन्यथा।

_{1: यदि यह बहुत अधिक प्रतिबंधात्मक है, तो यह डीजेएमसीएमगो जोड़े के लिए एक सकारात्मक पूर्णांक भी आउटपुट करता है, और अन्यथा 0}

यह काम किस प्रकार करता है

यहां हम यह निर्धारित करने के लिए 4 जांच करते हैं कि क्या इनपुट वैध है। कोड के वे भाग जो उन जाँचों को करते हैं

BcB_€|B]dBkbUBSVcGbU£>sVcGB]V

यहां, हम पूर्ण अंकों के अंतर की सूची लेते हैं, फिर ओवरलैपिंग जोड़े की संख्या की गणना करते हैं जो अवरोही क्रम में क्रमबद्ध होते हैं। प्रत्येक DJMcMego जोड़ी 1 का परिणाम तैयार करती है , लेकिन वे इस पहलू में अद्वितीय नहीं हैं। हम बाद में बाइट्स को बचाने के लिए इनपुट के निरपेक्ष अंकों के अंतर को भी संग्रहीत करते हैं। इस सरणी को A के रूप में संदर्भित किया जाएगा ।

BKB#BKBcB_0º>b]

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

D,w,@~,Ñ_€|BSVcGbU1b]2b]+º=
GBK{w}b]

तीसरा, हम जांचते हैं कि क्या जोड़ी [1, 2] ए के आगे के वेतन वृद्धि में निहित है । यह जाँचता है कि, A की कम से कम एक स्थिति में , यह क्रमबद्ध है, जो DJMcMego जोड़े के लिए एक मापदंड है।

D,k,@,BPB*
BK{k}

हमारी अंतिम जाँच के रूप में, हम दावा करते हैं कि A का दूसरा तत्व कभी 0 नहीं है । एक जोड़ी, X और Y के लिए , एक DJMcMego जोड़ी होने के लिए, हम मान सकते हैं कि उनका A हमेशा विशिष्ट है, क्योंकि इसमें डुप्लिकेट के साथ एक सरणी दूसरे के साथ एक मान को स्वैप करके लगातार नहीं बनाया जा सकता है।

अंत में, हम जाँचते हैं कि इनमें से पहले तीन परीक्षण 1 लौट आए , और चौथे ने एक मान x लौटाया जैसे x। 0

कोड के माध्यम से कदम के लिए एक कदम इस प्रकार है

D,w,		; Define a function w;
		;   This takes an array of integers
		;   Returns whether the pair [1, 2] appears in the absolute forward differences
		;
	@	; Take one argument
	~,	; Splat that argument to the stack
		;   Example argument:		[1 4 2 3 5]
		;
	Ñ_	; Increments;		STACK = [3 -2 1 2]
	€|	; Magnitudes;		STACK = [3 2 1 2]
	BSVcGbU	; Overlapping pairs;	STACK = [[3 2] [2 1] [1 2]]
	1b]2b]+	; Push [1 2];		STACK = [[3 2] [2 1] [1 2] [1 2]]
	º=	; Any equal [1 2];	STACK = [1]

; ============= ;

D,k,		; Define a function k;
		;   This function takes an array of integers
		;   Returns whether the second element is 0;
		;
	@,	; Take one argument and push to the stack
		;   Example argument:		[[1 4 2 3 5]]
		;
	BP	; Behead;		STACK = [[4 2 3 5]] 
	B*	; Product;		STACK = [120]
		;
		; In DJMcMego pairs, A may begin with a 0
		; For example, 12354 and 11111, so we need to remove the first element
		; Taking the product yields 0 if any element is 0
		; However, in order to be a DJMcMego pair, two digits at the same index
		;   cannot be the same, otherwise their digit-wise difference will be 0

; ============= ;

L,		; Define a lambda function
		;
		; This lambda function takes two arrays of digits as input
		; Returns an integer to determine if those digits represent a DJMcMego pair
		;
		; A lambda function is shorter to define than a normal function
		; However, when called inside functions with the ] command,
		;   they consume the entire stack as arguments, meaning that using functions
		;   allows us to preserve important values
		;
		; Example arguments:		[[3 1 7 1 6] [4 5 9 4 1]]
		;
		; First check:
		;
	BcB_	; Digit differences;	STACK = [-1 -4 -2 -3 5]
	€|	; Magnitudes;		STACK = [1 4 2 3 5]
	B]dBkbU	; Save a copy, A	STACK = [1 4 2 3 5]			A: [1 4 2 3 5]
	BSVcGbU	; Overlapping pairs;	STACK = [[1 4] [4 2] [2 3] [3 5]]
	£>	; Sorted descendingly?	STACK = [0 1 0 0]
	sVcG	; How many?		STACK = [1]
	B]V	; Save a copy;		STACK = []				Register: [1]
		;
		; Second check:
		;
	BK	; Retrieve A;		STACK = [[1 4 2 3 5]]
	B#	; Sort;			STACK = [[1 2 3 4 5]]
	BK	; Retrieve A;		STACK = [[1 2 3 4 5] [1 4 2 3 5]]
	BcB_	; Element differences;	STACK = [0 -2 1 1 0]
	0º>b]	; Any negatives;	STACk = [[1]]
		;
		; Third and fourth checks:
		;
	G	; Retrieve register;	STACK = [[1] [1]]
	BK	; Retreive A;		STACK = [[1] [1] [1 4 2 3 5]]
	{w}b]	; Run w;		STACK = [[1] [1] [1]]
	++	; Concatenate;		STACK = [[1 1 1]]
	b*1=	; Product = 1;		STACK = [1]
	BK{k}	; Run k;		STACK = [1 120]
	*	; Multiply;		STACK = [120]

		; To force output as 1 and 0 values,
		;   append a ? to the end, to output the sign (forces boolean conversion)

Answer 15

आर , 110 106 84 बाइट्स

function(x,y,z=abs(x-y),w=z-min(z)+1)adist(p(1:max(w)),p(w),c("s"=9))==2
p=intToUtf8

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

@JayCe एक हास्यास्पद 22 बाइट बचाने के साथ!

यहाँ वर्कहॉर्स है adist, जो दो तारों के बीच एक "सामान्यीकृत लेवेन्सहाइट संपादित दूरी" देता है। डिफ़ॉल्ट रूप से दूरी एक स्ट्रिंग को दूसरे में बदलने के लिए आवश्यक सम्मिलन, विलोपन और प्रतिस्थापन की न्यूनतम संख्या की गणना है। लेकिन adistआप चीजों को कैसे पसंद करते हैं, इसकी अनुमति देता है - इसलिए मैंने 1 के बजाय 9 को दूरी में जोड़ने के लिए प्रत्येक प्रतिस्थापन का भार उठाया है। यह प्रभावी रूप से एल्गोरिथ्म को केवल सम्मिलन और विलोपन के लिए देखने के लिए मजबूर करता है।

यह कोड पूर्णांकों के वैक्टर को स्वीकार करता है, पूर्ण तत्व-भिन्न अंतरों की गणना करता है और परिणाम को 1 पर शुरू करने के लिए अनुवाद करता है w।

फिर कस्टम वेटेड लेवेंसहाइट दूरी को wएक स्ट्रिंग और स्ट्रिंग बनाने के लिए एक साथ चिपकाया जाता है "1234..."(वास्तव में utf-8 "\001\002\003\004..."लेकिन adistपरवाह नहीं है।) वर्णों की समान संख्या के साथ w।

स्ट्रिंग का एकमात्र तरीका ठीक एक अंक का स्थान हो सकता है यदि आप एक विलोपन और एक प्रविष्टि करते हैं, तो 2 की दूरी दे।

Comments

यह नए परीक्षण मामले, 14325, 11111 ( झूठा ) के लिए विफल रहता है ।

— डेनिस

मुझे लगता है कि paste0बस हो सकता pasteहै के बाद से केवल एक ही इनपुट।

— ग्यूसेप

p=intToUtf8 ?

— JayCe

मुझे लगा कि मेरे पास एक गोल्फ की जगह w=z-min(z)+1)adist(p(1:max(w))है w=z-min(z))adist(p(0:max(w))लेकिन यह काम नहीं कर रहा intToUtf8(\000)है क्योंकि NULL है।

— JayCe

यह एक दिलचस्प समाधान है जो अधिक अपवित्रों का हकदार है .... मुझे लगता है कि कोडगॉल्फ में अपवोट्स की भविष्यवाणी AI के लिए अगला सीम है :)

— JayCe

Answer 16

जावास्क्रिप्ट, 137 136 135 134 132 123 बाइट्स

वाक्य रचना, आउटपुट currying में अंकों की दो सरणियों के रूप में इनपुट लेता है 0के लिए trueऔर के लिए किसी अन्य नंबर false।

a=>b=>(c=a.map((x,y)=>(x-=b[y])<0?-x:x)).map(x=>t+=x>c[++j]&(d=[...c].sort()).slice(i=0,-1).every(x=>d[++i]-x&1),t=j=0)|t^1

---

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

f=
a=>b=>(c=a.map((x,y)=>(x-=b[y])<0?-x:x)).map(x=>t+=x>c[++j]&(d=[...c].sort()).slice(i=0,-1).every(x=>d[++i]-x&1),t=j=0)|t^1
o.innerText=`${l=`-`.repeat(21)}\n|   #1  |   #2  | f |${m=`\n|${`|`.padStart(8,`-`).repeat(2)}---|\n`}${[[31716,45941],[12354,11111],[56798,22222],[23564,11111],[1759,2435],[12345,11111],[3333,2101],[22354,22222],[31717,45941],[89789,78865],[14954,61713]].map(([x,y])=>`| ${JSON.stringify(x).padEnd(6)}| ${JSON.stringify(y).padEnd(6)}| ${f([...``+x])([...``+y])} |`).join(m)}\n`+l

<pre id=o></pre>

Comments

[...u].sort(y=0)अमान्य जावास्क्रिप्ट है, सॉर्ट के लिए तर्क एक फ़ंक्शन होना चाहिए

— edc65

@ edc65, वह लंबे समय से बाहर संपादित किया गया है। अमान्य के रूप में यह हो सकता है, हालांकि, यह काम किया! ;)

— झबरा

" 25634 11111(के रूप में कई अन्य प्रस्तुतियाँ) के लिए विफल रहता है " - टन हास्पेल

— असोन तुहिद

Answer 17

पायथन 2 , 116 119 106 बाइट्स

धन्यवाद श्री Xcoder 116->84कट के लिए, लेकिन मैंने पाया कि मैं "लगातार संख्या" मानदंड से चूक गया हूं, इसलिए इस उद्देश्य के लिए 26 बाइट्स जोड़े जाते हैं :(

उसके बाद, -1 और धन्यवाद श्री Xcoder, और -13 धन्यवाद ovs

def m(a,b):l=[abs(x-y)for x,y in zip(a,b)];print sum(e>f for e,f in zip(l,l[1:]))==1==len(l)-max(l)+min(l)

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

यह एक नीचे की 25634 - 11111समस्या को हल करता है लेकिन दोहरी लंबाई ( 211 206 145 142B) के साथ ... गोल्फिंग ...

def m(a,b):l=[abs(x-y)for x,y in zip(a,b)];r=[l[i]-i-min(l)for i in range(len(l))];print(sum(r)==0)&(len([x for x in r if abs(x)>1])<2)&any(r)

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

और नए मध्यस्थों को बधाई :)

व्याख्या:

l=[abs(x-y)for x,y in zip(a,b)]

अंकों के निरपेक्ष अंतर की सूची तैयार करता है।

r=[l[i]-i-min(l)for i in range(len(l))]

उचित स्थिति से ऑफसेट की गणना करता है।

sum(r)==0

यदि अनुक्रम निरंतर नहीं है, तो ऑफसेट राशि "आमतौर पर" नहीं होगी 0. लेकिन भले ही यह 0 के बराबर हो, अगले वाले उन्हें बाहर ब्लॉक कर देंगे।

len([x for x in r if abs(x)>1])<2

केवल 0 या 1 आइटम में 1 से अधिक पूर्ण ऑफसेट होगा (गलत स्थिति वाला, और 0 मामले में ऐसा है 1,2,3,5,4)

any(r)

संख्या को सही स्थिति में होने पर मामले को रोक देता है

Comments

यह m([3,3,3,3],[2,1,0,1])(रिटर्न True) Tio

— असोन तुहिद

@AsoneTuhid मैंने उनके गोल्फ के आधार पर समस्या का समाधान किया है क्योंकि जब मैंने जवाब प्रस्तुत किया था और उन्होंने मेरे जवाब को भूल गए तो मैं इस मामले को भूल गया।

— शायरु असकोतो

के लिए 25634 11111

— असफल

@ टोनहॉश ओह, यह मुश्किल है। मैं इसे ठीक करने के तरीकों के बारे में सोच रहा हूं, लेकिन ऐसा लगता है कि यह जवाब के लिए बाइट्स का एक बहुत कुछ जोड़ देगा

— Shieru Asakoto

Answer 18

हास्केल , 182 163 162 132 बाइट्स

(#)=zipWith(-)
a&b|s<-abs<$>a#b=or[all(==1)$tail a#a|(x,h:y)<-p s,(q,r)<-p$x++y,a<-[q++h:r],a/=s]
p l=[splitAt k l|k<-[0..length l]]

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

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