संख्या में सुरक्षा

22

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

उदाहरण के लिए, 2, 3, 5, 2, 3, 6, 2, 3, 5, 2, 3, 6, ...की लगातार घटनाओं की प्रत्येक जोड़ी: इस संपत्ति है 2जैसे उन दोनों के बीच सबसे दो पूर्णांकों (कम है 2, 3, 5, 2और 2, 3, 6, 2; की लगातार घटनाओं की प्रत्येक जोड़ी 3है उन दोनों के बीच ज्यादा से ज्यादा तीन पूर्णांकों पर, और के लिए एक ही 5और 6।

हालाँकि, 2, 3, 5, 2, 3, 4, 2, 3, 5, 2, 3, 4, ...यह संपत्ति नहीं है: दो लगातार घटनाओं 4, अर्थात् 4, 2, 3, 5, 2, 3, 4, उनके बीच चार से अधिक पूर्णांक हैं।

इनपुट : सकारात्मक पूर्णांकों के आवधिक अनुक्रम का एक उचित प्रतिनिधित्व। उदाहरण के लिए, एक परिमित सूची जैसे कि ऊपर दिए {2, 3, 5, 2, 3, 6}गए पहले अनंत अनुक्रम का प्रतिनिधित्व कर सकती 2, 3, 5, 2, 3, 6, 2, 3, 5, 2, 3, 6, ...है। (उस मामले के लिए, समस्या को परिमित सूचियों के लिए कहा जा सकता है जो अनंत आवधिक सूचियों के बजाय चारों ओर लपेटती हैं।)

आउटपुट : एक सत्य / मिथ्या मूल्य।

सत्य उदाहरण:

{1}
{8, 9}
{2, 3, 4}
{5, 5, 3, 3, 6}
{2, 3, 5, 2, 3, 6}
{6, 7, 3, 5, 3, 7}
{9, 4, 6, 7, 4, 5}
{1, 1, 1, 1, 1, 100, 1}
{1, 9, 1, 8, 1, 7, 1, 11}

झूठे उदाहरण:

{1, 2, 3}
{2, 3, 9, 5}
{3, 5, 4, 4, 6}
{2, 3, 5, 2, 3, 4}
{3, 5, 7, 5, 9, 3, 7}
{5, 6, 7, 8, 9, 10, 11}
{1, 9, 1, 8, 1, 6, 1, 11}

यह कोडगोल्फ है , इसलिए सबसे छोटा कोड जीतता है। सभी भाषाओं में उत्तरों को प्रोत्साहित किया जाता है।

code-golf  array-manipulation  decision-problem 
— ग्रेग मार्टिन
स्रोत
क्या इनपुट सूची में हमेशा कम से कम एक तत्व होता है?
— निम्मी
2
@nimi अन्यथा यह एक अनंत आवधिक अनुक्रम का प्रतिनिधित्व नहीं करेगा।
— मार्टिन एंडर
1
यदि आप thue-morse अनुक्रम लेते हैं और प्रत्येक शब्द में 1 से अधिक कोई निश्चित धनात्मक पूर्णांक जोड़ते हैं, तो आपके पास इस संपत्ति के साथ एक अपरिमेय अनंत क्रम होगा।
— सुपरजेडी २२४

जवाबों:

7

हास्केल, 60 57 56 55 बाइट्स

f(a:b)=b==[]||length(fst$span(/=a)b)<=a&&f b
g x=f$x++x

मान लेता है कि इनपुट सूची में कम से कम एक तत्व है।

प्रयोग उदाहरण: g [1]-> True। इसे ऑनलाइन आज़माएं!

आज्ञा देना aसूची के प्रमुख और bपूंछ हो। परिणाम Trueयदि bखाली है या उस की शुरुआत में तत्वों की संख्या के bबराबर aनहीं है aऔर से अधिक नहीं है और पुनरावर्ती कॉल f bभी Trueहै False। दो बार इनपुट सूची से शुरू करें।

संपादित करें: @Leo ने 3 बाइट्स बचाए। धन्यवाद!

संपादन 2: @ लाईकोनी ने 1 बाइट बचाई। धन्यवाद!

— nimi
स्रोत
स्पान के बजाय टेकवाइल का उपयोग करके आप पैटर्न-मैचिंग से बच सकते हैं और तीन बाइट्स बचा सकते हैं । :)
— लियो
@ लियो: अच्छी पकड़! आमतौर पर उपयोग करने spanसे छोटा होता है takeWhile, इसलिए मैंने इसे बिल्कुल नहीं देखा।
— नीमी
takeWhileकाफी हमेशा के लिए छोटा किया जा सकता fst$spanया fst.span, जो एक और बाइट बचाता है।
— लकोनी
@ लायोनी: बिल्कुल हाँ! धन्यवाद!
— नीमी
लव
— हैस्केल
6

पायथन , 57 56 बाइट्स

-1 डेनिस को बाइट धन्यवाद (की जगह i+1:i+v+2के साथ i:i-~vएक साथ iसे 1 की ऑफसेट enumerate)

lambda a:all(v in(a+a)[i:i-~v]for i,v in enumerate(a,1))

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

अनाम समारोह एक सूची ले, aऔर शर्त यह है कि प्रत्येक मान, परीक्षण v, प्रतीत होता है inकी एक संयोजन में अपने अधिकार के लिए प्रासंगिक टुकड़ा aके साथ ही, (a+a)[i:i-~v]है, जहां का 1 आधारित सूचकांक vमें a, i, द्वारा प्रदान की जाती है enumerate(a,1)।

— जोनाथन एलन
स्रोत
1
इसने 8-बाइट जेली उत्तर को प्रेरित किया। :) आप इस तरह से एक बाइट बचा सकते हैं ।
— डेनिस
6

जावास्क्रिप्ट (ईएस 6), 67 65 55 54 51 49 बाइट्स

@BHproductions के लिए 3B धन्यवाद और @Arnauld के लिए 2B धन्यवाद सहेजा गया

a=>!a.some((b,c)=>a.concat(a).indexOf(b,++c)>b+c)

व्याख्या

यह एक फ़ंक्शन को परिभाषित करता है जो aइनपुट के रूप में एक सरणी लेता है । फिर, .someविधि उस सरणी पर पुनरावृत्त करती है, जो प्रत्येक तत्व के लिए एक और फ़ंक्शन निष्पादित करती है।

यह आंतरिक फ़ंक्शन दो तर्क लेता है, bऔर c, वर्तमान मूल्य और इसका सूचकांक। सूचकांक से शुरू होने वाले फ़ंक्शन को वर्तमान मान का सूचकांक मिलता हैc + 1 । फिर यह जांचता है कि क्या यह सूचकांक वर्तमान मूल्य से अधिक है और वर्तमान सूचकांक (एक ही मूल्य के दो घटनाओं के बीच का अंतर इससे अधिक है b)। ध्यान दें कि यह जो हम चाहते हैं उसके ठीक विपरीत देता है।

यदि इनमें से एक रिटर्न मान है true, तो .someफ़ंक्शन भी वापस आ trueजाता है। यदि कोई भी चेक वापस नहीं करता है true, तो.some फ़ंक्शन वापस आ जाता है false। एक बार फिर मूल्य के विपरीत जिसे हम लौटना चाहते हैं, इसलिए यह परिणाम नकारात्मक है और फिर वापस आ गया है।

झसे आज़माओ

यहां सभी परीक्षण मामलों का प्रयास करें: 

let f=
a=>!a.some((b,c)=>a.concat(a).indexOf(b,++c)>b+c)

let truthy = [[1], [8, 9], [2, 3, 4], [5, 5, 3, 3, 6], [2, 3, 5, 2, 3, 6], [6, 7, 3, 5, 3, 7], [9, 4, 6, 7, 4, 5], [1, 1, 1, 1, 1, 100, 1], [1, 9, 1, 8, 1, 7, 1, 11]];
let falsy  = [[1, 2, 3], [2, 3, 9, 5], [3, 5, 4, 4, 6], [2, 3, 5, 2, 3, 4], [3, 5, 7, 5, 9, 3, 7], [5, 6, 7, 8, 9, 10, 11], [1, 9, 1, 8, 1, 6, 1, 11]];

console.log("Truthy test cases:");
for (let test of truthy) {
    console.log(`${test}: ${f(test)}`);
}

console.log("Falsy test cases:");
for (let test of falsy) {
    console.log(`${test}: ${f(test)}`);
}
स्निपेट का विस्तार करें

— ल्यूक
स्रोत
बहुत अच्छा, यह वही है जो मैं साथ आया था :-) आप शुरुआत में एक बार दोगुनी सरणी बना सकते हैं और .shift()स्लाइस पर बचाने के लिए उपयोग कर सकते हैं:a=>!a.some(b=>z.indexOf(z.shift())>b,z=a.concat(a))
— ETHproductions
Hehe, महान golfers एक जैसा लगता है; ;-) मैंने शिफ्ट का उपयोग करने के बारे में सोचा, लेकिन मैंने इसका उपयोग नहीं किया, क्योंकि यह लंबे समय तक निकला। हर बार एक बार डबल ऐरे बनाना और हर बार शिफ्ट करना वास्तव में बहुत ही चालाक है। धन्यवाद!
— ल्यूक
चाहेंगे a=>!a.some((n,i)=>a.concat(a).indexOf(n,++i)>n+i)काम करते हैं?
— अरण्युलड
हाँ यह करता है। धन्यवाद!
— ल्यूक
4

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

ṣZL
;çЀ<‘P

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

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

;çЀ<‘P  Main link. Argument: A (array)

;        Concatenate A with itself.
 çD€     For each n in A, call the helper with left arg. A + A and right arg. n.
     ‘   Increment all integers in A.
    <    Perform element-wise comparison of the results to both sides.
      P  Take the product of the resulting Booleans.


ṣZL      Helper link. Left argument: A. Right argument: n

ṣ        Split A at all occurrences of n.
 Z       Zip to transpose rows and columns.
  L      Length; yield the number of rows, which is equal to the number of columns
         of the input to Z.
— डेनिस
स्रोत
3

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

ṙJḣ"‘Œpċ

@ जोनाथनअलन के पाइथन के जवाब से इंस्पायर्ड ।

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

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

ṙJḣ"‘Œpċ  Main link. Argument: A (array)

 J        Yield the indicies of A, i.e., [1, ..., len(A)].
ṙ         Rotate; yield A, rotated 1, ..., and len(A) units rotated to the left.
    ‘     Increment; add 1 to all elements of A.
  ḣ"      Head zipwith; truncate the n-th rotation to length A[n]+1.
     Œp   Take the Cartesian product of all resulting truncated rotations.
       ċ  Count the number of times A appears in the result.
— डेनिस
स्रोत
2

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

a(L,[H|R]):-nth0(X,R,H),H>=X,a(L,R);length(R,N),nth0(X,L,H),H>=N+X,a(L,R).
a(_,[]).


सूची दो बार दर्ज की जानी चाहिए:

a([1,2,3],[1,2,3]).

यदि यह स्वीकार्य नहीं माना जाता है, तो आप विधेय जोड़ सकते हैं

a(L):-a(L,L).

जो अतिरिक्त 14 बाइट जोड़ता है।

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


nb: आप अपने प्रश्नों को '?' से अलग करके एक ही बार में विभिन्न झूठे मामलों के लिए परीक्षण कर सकते हैं। (या) और ',' (और) के साथ अलग-अलग सही मामलों के लिए परीक्षण

यानी, ओपी उदाहरणों का उपयोग करना:

a([1],[1]),
a([8, 9],[8, 9]),
a([2, 3, 4],[2, 3, 4]),
a([5, 5, 3, 3, 6],[5, 5, 3, 3, 6]),
a([2, 3, 5, 2, 3, 6],[2, 3, 5, 2, 3, 6]),
a([6, 7, 3, 5, 3, 7],[6, 7, 3, 5, 3, 7]),
a([9, 4, 6, 7, 4, 5],[9, 4, 6, 7, 4, 5]),
a([1, 1, 1, 1, 1, 100, 1],[1, 1, 1, 1, 1, 100, 1]),
a([1, 9, 1, 8, 1, 7, 1, 11],[1, 9, 1, 8, 1, 7, 1, 11]).

तथा

a([1, 2, 3],[1, 2, 3]);
a([2, 3, 9, 5],[2, 3, 9, 5]);
a([3, 5, 4, 4, 6],[3, 5, 4, 4, 6]);
a([2, 3, 5, 2, 3, 4],[2, 3, 5, 2, 3, 4]);
a([3, 5, 7, 5, 9, 3, 7],[3, 5, 7, 5, 9, 3, 7]);
a([5, 6, 7, 8, 9, 10, 11],[5, 6, 7, 8, 9, 10, 11]);
a([1, 9, 1, 8, 1, 6, 1, 11],[1, 9, 1, 8, 1, 6, 1, 11]).
— Maliafo
स्रोत
2

PHP, 52 बाइट्स

for(;$n=$argv[++$i];$$n=$i)!$$n|$i-$$n<$n+2?:die(1);

कमांड लाइन तर्कों से अनुक्रम लेता है; 1सच्चाई के लिए, झूठे के लिए कोड के साथ बाहर निकलता है 0।
के साथ भागो -nr।

  • $nतर्कों के माध्यम से पाश :
    • अगर कोई पिछली घटना नहीं थी या यह हाल ही में पर्याप्त था
      , तो कुछ भी न करें, और कोड के साथ बाहर निकलें1
    • पिछली चर$$n ( चर चर ) में याद रखें
  • कोड के साथ बाहर निकलें 0(निहित)
— टाइटस
स्रोत
पागल आपके चर नाम अमान्य हैं, लेकिन मुझे यह पसंद है।
— जार्ग हुल्सरमैन
2

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

$
,$`
M!&`\b(1+),.*?\b\1\b
+%`(^1*)1,1+
$1
M`1,
^0

अल्पविराम से अलग-अलग संख्याओं की एक सूची के रूप में इनपुट।

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

व्याख्या

$
,$`

इनपुट को डुप्लिकेट करें ताकि हम उन चरणों की जांच कर सकें जो अंत के आसपास लपेटते हैं।

M!&`\b(1+),.*?\b\1\b

दो समान मूल्यों के बीच प्रत्येक (सबसे छोटा) सेक्शन का मिलान करें और वापस लौटें, जैसे 11,111,1,11।

+%`(^1*)1,1+
$1

बार-बार पहले नंबर से एक अंक निकालें, इसके बाद एक पूरी संख्या के साथ। यदि अंतराल काफी छोटा है तो यह पहले नंबर को पूरी तरह से हटा देगा। अन्यथा, कम से कम एक अंक रहेगा।

M`1,

गणना करें कि 1,सभी लाइनों में कितनी बार दिखाई देता है। यदि यह कहीं भी दिखाई देता है, तो एक कदम बहुत चौड़ा था।

^0

0(केवल केवल 0) के साथ शुरू होने वाली संख्या से मिलान करने का प्रयास करें । यह प्रभावी रूप से आउटपुट का तार्किक निषेध है।

— मार्टिन एंडर
स्रोत
2

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

a=>![...a,...a].some((n,i)=>a[-n]-(a[-n]=i)<~n)

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

हम aप्रत्येक पूर्णांक की अंतिम सामना की स्थिति को संग्रहीत करने के लिए इनपुट सरणी का पुनः उपयोग करते हैं a। हम -nइस स्थिति को संग्रहीत करने के लिए कुंजी का उपयोग करते हैं ताकि यह मूल सूचकांकों के साथ हस्तक्षेप न करे a।

जब a[-n]मौजूद होता है, तो वास्तविक परीक्षण होता है। जब a[-n]अस्तित्व में नहीं होता है, तो अभिव्यक्ति a[-n] - (a[-n] = i)बराबर होती है undefined - i == NaNऔर तुलना ~nहमेशा गलत होती है, जो अपेक्षित परिणाम है।

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

कोड स्निपेट दिखाएं

— Arnauld
स्रोत
2

रेटिना ,  41 39 बाइट्स

2 बाइट्स ने मार्टिन एंडर को धन्यवाद दिया, जिसने मुझे एसओ पर अपने शानदार गाइड के साथ संतुलन साधने वाले समूहों से परिचित कराया

$
,$`,
((1)+,)(?=(?<-2>1+,)*(\1|$))

^$

इनपुट एक अल्पविराम से अलग की गई संख्याओं की सूची है। आउटपुट 0झूठे और 1सच्चे के लिए है।

इसे ऑनलाइन आज़माएं! (टेस्ट सूट जो स्वचालित रूप से दशमलव से परिवर्तित होता है)

मैंने हाल ही में समूहों को संतुलित करने के बारे में सीखा है, इसलिए मैं उन्हें एक कोशिश देना चाहता था। वे उपयोग करने के लिए सबसे आसान उपकरण नहीं हैं, लेकिन यकीन है कि वे शक्तिशाली हैं।

व्याख्या

$
,$`,

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

((1)+,)(?=(?<-2>1+,)*(\1|$))

यहां चीजें दिलचस्प हैं। यह एक प्रतिस्थापन चरण है, हम पहली पंक्ति द्वारा मिलान की गई प्रत्येक चीज़ को दूसरी पंक्ति से प्रतिस्थापित करते हैं, इस मामले में हम उन सभी नंबरों को हटाने के लिए देख रहे हैं nजो n+1अन्य विभिन्न नंबरों के बाद नहीं हैं ।

ऐसा करने के लिए, हम पहले 1समूह में प्रत्येक को कैप्चर करते हुए (इस मामले में समूह संख्या 2 को कैप्चर करते हुए) नंबर से मेल खाते हैं । फिर एक सकारात्मक नज़र के साथ, एक शून्य-चौड़ाई के दावे के लिए, हम बार-बार एक संतुलन समूह में मिलान करने का प्रयास करते हैं -2, जो कि समूह द्वारा किए गए कैप्चर की संख्या 2, अल्पविराम के बाद की संख्या से अधिक सफल नहीं होगा । संख्याओं के इस क्रम के बाद, हम संतुष्ट होते हैं यदि हम या तो पहले नंबर पर पहुँचते हैं या पंक्ति के अंत में।

नोट: यदि यह पूर्ण संख्या के साथ मैच खोजने का प्रबंधन नहीं करता है, तो यह अभिव्यक्ति किसी संख्या के अंतिम भाग से मेल खा सकती है। यह कोई समस्या नहीं है, क्योंकि तब संख्या का पहला भाग स्ट्रिंग में रहेगा और हम जानेंगे कि प्रतिस्थापन पूरी तरह से सफल नहीं हुआ।

^$

अंत में, परिणाम सत्य होना चाहिए अगर हमने सूची से सभी नंबरों को पूरी तरह से हटा दिया है। हम खाली स्ट्रिंग का मिलान करने और पाए गए मैचों की संख्या वापस करने का प्रयास करते हैं।

— सिंह
स्रोत
1
अच्छा काम! :) की कोई जरूरत नहीं है \b। इसे हटाने से आवारा मैचों का कारण होगा लेकिन वे पूरी संख्या को हटाने में विफल रहेंगे, इसलिए आप किसी भी तरह एक खाली स्ट्रिंग के साथ समाप्त नहीं होंगे।
— मार्टिन एंडर
@MartinEnder आप निश्चित रूप से सही हैं, धन्यवाद :)
— Leo
1

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

ẋ2ĠṢI_2<"QȦ

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

ẋ2ĠṢI_2<"QȦ  Main link. Argument: A (array)

ẋ2           Repeat A twice to account for wrap-around.
  Ġ          Group all indices of A + A by their respective values, sorting the
             index groups by the associated values.
   Ṣ         Sort the groups lexicographically, i.e., by first appearance in A.
    I        Increments; compute the forward differences of adjacent indices in
             each of the groups.
     _2      Subtract 2 from the differences.
         Q   Unique; yield A, deduplicated.
       <"    Compare all differences in the index group corresponding to the n-th
             unique value in A with the n-th unqiue value in A.
          Ȧ  All; yield 1 if and only if none of the comparisons returned 0.
— डेनिस
स्रोत
1

रोड़ा , 50 बाइट्स

f a{seq 0,#a-1|[indexOf(a[_],a[_1+1:]..a)<=a[_1]]}

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

आखिरकार! मैं कर दिया है इंतजार कर के लिए इस चुनौती ...

यह एक ऐसा फ़ंक्शन है जो एक सत्य या एक मिथ्या मूल्य लौटाता है। यह एक तर्क लेता है, सरणी।

यह सूचकांक की प्रत्येक धारा के लिए जाँच करता है और प्रत्येक सूचकांक के लिए जाँच करता है _1कि वर्तमान सूचकांक और अगले सूचकांक की दूरी a[_1]इससे अधिक नहीं है a[_1]।

— fergusq
स्रोत
कैसे _1काम करता है ?
— Kritii Lithos
@KritiiLithos यह पसंद है _, लेकिन पहले खींचे गए मूल्य को संदर्भित करता है। यदि मैंने कई _एस का उपयोग किया होता, तो प्रत्येक ने एक अलग मान निकाला होता। उदाहरण के लिए, [1, 2, 3] | print(_, _, _)प्रिंट 123, लेकिन [1,2,3] | print(_, _1, _1)प्रिंट 111 222 333(अलग-अलग लाइनों पर)।
— फर्ग्यूसक
0

05AB1E , 13 बाइट्स

Dì©v®¦©yky›_P

इसे ऑनलाइन आज़माएं! या टेस्ट सूट के रूप में

व्याख्या

Dì             # duplicate input and prepend the copy to the original
  ©            # store a copy in the register
   v           # for each element in the list
    ®          # push the list from register
     ¦©        # remove the first element and store a copy in the register
       yk      # get the index of the current element in the list
         y›_   # check if it's less than or equal to the current element
            P  # product of stack
— Emigna
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.