चींटियों की क्रमपरिवर्तन

Question

परिचय

मान लीजिए कि आपके पास 0 से लेकर आर -1 तक की संख्या वाला एक शासक है । आप किन्हीं भी दो नंबरों के बीच एक चींटी लगाते हैं, और यह शासक पर गलत तरीके से क्रॉल करना शुरू कर देता है। शासक इतना संकीर्ण है कि चींटी बीच में सभी नंबरों पर चलने के बिना एक स्थिति से दूसरे स्थान पर नहीं चल सकती है। जैसा कि चींटी पहली बार किसी संख्या पर चलती है, आप इसे रिकॉर्ड करते हैं, और यह आपको आर संख्याओं का क्रमचय प्रदान करता है । हम कहते हैं कि एक क्रमपरिवर्तन है antsy अगर यह इस तरह से एक चींटी द्वारा उत्पन्न किया जा सकता है। वैकल्पिक रूप से, एक पर्मुटेशन पी एक एंटेसी है यदि हर एंट्री पी [i] पहले को छोड़कर कुछ पिछली प्रविष्टि से दूरी 1 के भीतर है।

उदाहरण

लंबाई -6 क्रमपरिवर्तन

4, 3, 5, 2, 1, 0

, antsy है, क्योंकि 3 की दूरी 1 के भीतर है 4 , 5 की दूरी 1 के भीतर है 4 , 2 से दूरी 1 के भीतर है 3 , 1 से दूरी 1 के भीतर है 2 , और 0 से दूरी 1 के भीतर है 1 । क्रमपरिवर्तन

3, 2, 5, 4, 1, 0

चींटियां नहीं है, क्योंकि 5 या तो 3 या 2 की दूरी 1 के भीतर नहीं है ; चींटी को 5 से प्राप्त करने के लिए 4 से गुजरना होगा ।

काम

किसी भी उचित प्रारूप में कुछ 1 ≤ r ut 100 के लिए 0 से r-1 तक की संख्याओं के क्रमांकन को देखते हुए , यदि क्रमपरिवर्तन antsy है, तो एक सत्य मान का उत्पादन किया जाता है और यदि नहीं तो एक मिथ्या मूल्य।

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

[0] -> True
[0, 1] -> True
[1, 0] -> True
[0, 1, 2] -> True
[0, 2, 1] -> False
[2, 1, 3, 0] -> True
[3, 1, 0, 2] -> False
[1, 2, 0, 3] -> True
[2, 3, 1, 4, 0] -> True
[2, 3, 0, 4, 1] -> False
[0, 5, 1, 3, 2, 4] -> False
[6, 5, 4, 7, 3, 8, 9, 2, 1, 0] -> True
[4, 3, 5, 6, 7, 2, 9, 1, 0, 8] -> False
[5, 2, 7, 9, 6, 8, 0, 4, 1, 3] -> False
[20, 13, 7, 0, 14, 16, 10, 24, 21, 1, 8, 23, 17, 18, 11, 2, 6, 22, 4, 5, 9, 12, 3, 15, 19] -> False
[34, 36, 99, 94, 77, 93, 31, 90, 21, 88, 30, 66, 92, 83, 42, 5, 86, 11, 15, 78, 40, 48, 22, 29, 95, 64, 97, 43, 14, 33, 69, 49, 50, 35, 74, 46, 26, 51, 75, 87, 23, 85, 41, 98, 82, 79, 59, 56, 37, 96, 45, 17, 32, 91, 62, 20, 4, 9, 2, 18, 27, 60, 63, 25, 61, 76, 1, 55, 16, 8, 6, 38, 54, 47, 73, 67, 53, 57, 7, 72, 84, 39, 52, 58, 0, 89, 12, 68, 70, 24, 80, 3, 44, 13, 28, 10, 71, 65, 81, 19] -> False
[47, 48, 46, 45, 44, 49, 43, 42, 41, 50, 40, 39, 38, 51, 37, 36, 52, 35, 34, 33, 32, 53, 54, 31, 30, 55, 56, 29, 28, 57, 58, 59, 60, 27, 26, 61, 25, 62, 63, 64, 65, 66, 67, 24, 23, 22, 21, 68, 69, 20, 19, 18, 17, 70, 71, 16, 15, 72, 73, 74, 75, 76, 14, 13, 12, 77, 11, 10, 9, 8, 78, 7, 79, 80, 6, 81, 5, 4, 3, 82, 2, 83, 84, 1, 85, 86, 87, 0, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99] -> True

मजेदार तथ्य: r , 1 के लिए , लंबाई r के 2 ^r-1 चींटियों के क्रमपरिवर्तन हैं ।

Comments

यह कई अलग-अलग समाधानों के साथ एक बहुत ही दिलचस्प चुनौती है: मैं अब तक इस्तेमाल की जा रही कम से कम 7 अद्वितीय रणनीतियों की गिनती करता हूं।

— ETHproductions

क्रमपरिवर्तन का संरचित इनपुट रूप विभिन्न प्रकार के दृष्टिकोणों में बहुत योगदान दे रहा है। चींटियों के होने की स्थिति को विभिन्न तरीकों से व्यक्त किया जा सकता है जो सामान्य सूचियों पर असमान हैं।

— xnor

मैं निराश हूं कि अभी तक ANTSI C समाधान नहीं है।

— NoSeatbelts

Answer 1

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

/y+_QQS

इसे ऑनलाइन आज़माएं। (केवल छोटे परीक्षण के मामलों को घातीय रन-टाइम के कारण शामिल किया गया है।) ट्रू के लिए आउटपुट 2, फाल्सी के लिए 0।

/          Count the number of occurences of
      S     the sorted input (implicit Q)
 y          in the order-preserved power set
  +_QQ       of the input prepended by its reverse

दूसरे शब्दों में,

lambda l: subseq(sorted(l), concat(reverse(l), l))

जहाँ subseqदूसरी सूची में पहली सूची के तत्व क्रम में आसन्न नहीं हैं, यह आउटपुट देता है। subseqPyth में दूसरी सूची के सभी उप-समुच्चय है, जो तत्वों का क्रम रख ले, और पहली सूची की घटनाओं की संख्या की गणना के द्वारा किया जाता है। यह घातीय समय लेता है।

यह काम क्यों करता है? चींटियों के लिए एक क्रमपरिवर्तन के लिए, 0 से n-1 की ओर बढ़ते हुए केवल बाएं से जाना चाहिए, फिर केवल दाएं चलना चाहिए। ऐसा इसलिए है क्योंकि पहले तत्व की तुलना में अधिक तत्वों को बाएं से दाएं की ओर बढ़ना चाहिए, और इससे कम होने वालों को बाएं से दाएं की ओर कम होना चाहिए।

[2, 3, 1, 4, 0]
             ^
       ^     0
 ^     1      
 2  ^        
    3     ^
          4

यदि हम इसकी बाईं ओर उलटी कॉपी लगाकर सूची को मिरर करते हैं, तो यह चलना अब केवल सही है।

[0, 4, 1, 3, 2, 2, 3, 1, 4, 0]
 ^            |             
 0     ^      |             
       1      | ^           
              | 2  ^        
              |    3     ^  
              |          4                                  

इसके विपरीत, इस दर्पण सूची का कोई भी दायाँ भाग मूल सूची के बाएँ-से-दाएँ चलना से मेल खाता है। यह अधिकार केवल 0 से n-1 तक की क्रमबद्ध अनुवर्तीता है। एक चींटियों की सूची में, इस तरह की क्रमबद्धता अद्वितीय है, मूल मूल तत्व की दो आसन्न प्रतियों के बीच एक मनमानी पसंद को छोड़कर।

Comments

आप इसका उपयोग करके 6 बाइट्स तक काट सकते हैं ... बस मजाक कर रहे हैं।

— jwg

एक स्पष्ट रैखिक समय समाधान के साथ एक समस्या के लिए एक घातीय समय दृष्टिकोण का उपयोग करने के बारे में कुछ घृणित है, भले ही यह अच्छी तरह से नीचे गोल्फ।

— डेविड कॉनराड

@ jwg मैं वास्तव में यह विश्वास करता हूँ। यदि सूची संख्या विपरीत क्रम में तर्क लेती है, तो आप दो इनपुटों को जोड़कर 6 बाइट्स प्राप्त कर सकते हैं।

— xnor

ayyyyy, pyth पक्ष की ओर

— मुड़ना

Answer 2

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

(%)=scanl1
f l=zipWith(+)(min%l)[0..]==max%l

जाँच करता है कि क्या चल रही मैक्सिमा और चलने वाली मिनीमा का वेक्टर अंतर [0,1,2,3 ...] है।

l =             [2, 3, 1, 4, 0]

scanl1 max l =  [2, 3, 3, 4, 0]
scanl1 min l =  [2, 2, 1, 1, 0]  
difference =    [0, 1, 2, 3, 4]

जरगब ने 2 बाइट बचाए (%)=scanl1।

Comments

इतना चालाक है! +1

— गेब्रियल बेनामी

क्या आप परिभाषित करके कुछ बाइट्स बचा सकते हैं (#)=scanl1?

— जर्बद

@Zgarb धन्यवाद, मैं भूल गया कि आप ऐसा कर सकते हैं।

— xnor

Answer 3

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

a=>a.every((v,i)=>a[v]=!i|a[v-1]|a[v+1],a=[])

मैंने सोचा कि स्पष्टीकरण के रूप में इसकी आवश्यकता बहुत आसान है, लेकिन एक चाल है, और बस के मामले में, यहां मेरा पहला संस्करण है, पूर्व-गोल्फ

a => {
  k = []; // I'll put a 1 in this array at position of each value 
          // that I find scanning the input list
  return a.every((v,i) => { // execute for each element v at position i
    // the index i is needed to manage the first iteration
    // return 1/true if ok, 0/false if not valid
    // .every will stop and return false if any iteration return falsy
    k[v] = 1; // mark the current position
    if ( i == 0 )
    {  // the first element is always valid
       return true;
    }
    else
    {
       return k[v-1] == 1 // valid if near a lesser value
              || k[v+1] == 1; // or valid if near a greater value
    }
  })
}

नोट: aइसके बजाय गोल्फ कोड में उपयोग किया जाता है k, क्योंकि मुझे everyकॉल के अंदर मूल सरणी का कोई संदर्भ नहीं चाहिए । इसलिए मैं पैरामीटर का पुन: उपयोग करने वाले वैश्विक नाम स्थान को प्रदूषित करने से बचता हूं

परीक्षा

antsy=
a=>a.every((v,i)=>a[v]=!i|a[v-1]|a[v+1],a=[])

var OkAll=true
;`[0] -> True
[0, 1] -> True
[1, 0] -> True
[0, 1, 2] -> True
[0, 2, 1] -> False
[2, 1, 3, 0] -> True
[3, 1, 0, 2] -> False
[1, 2, 0, 3] -> True
[2, 3, 1, 4, 0] -> True
[2, 3, 0, 4, 1] -> False
[0, 5, 1, 3, 2, 4] -> False
[6, 5, 4, 7, 3, 8, 9, 2, 1, 0] -> True
[4, 3, 5, 6, 7, 2, 9, 1, 0, 8] -> False
[5, 2, 7, 9, 6, 8, 0, 4, 1, 3] -> False
[20, 13, 7, 0, 14, 16, 10, 24, 21, 1, 8, 23, 17, 18, 11, 2, 6, 22, 4, 5, 9, 12, 3, 15, 19] -> False
[34, 36, 99, 94, 77, 93, 31, 90, 21, 88, 30, 66, 92, 83, 42, 5, 86, 11, 15, 78, 40, 48, 22, 29, 95, 64, 97, 43, 14, 33, 69, 49, 50, 35, 74, 46, 26, 51, 75, 87, 23, 85, 41, 98, 82, 79, 59, 56, 37, 96, 45, 17, 32, 91, 62, 20, 4, 9, 2, 18, 27, 60, 63, 25, 61, 76, 1, 55, 16, 8, 6, 38, 54, 47, 73, 67, 53, 57, 7, 72, 84, 39, 52, 58, 0, 89, 12, 68, 70, 24, 80, 3, 44, 13, 28, 10, 71, 65, 81, 19] -> False
[47, 48, 46, 45, 44, 49, 43, 42, 41, 50, 40, 39, 38, 51, 37, 36, 52, 35, 34, 33, 32, 53, 54, 31, 30, 55, 56, 29, 28, 57, 58, 59, 60, 27, 26, 61, 25, 62, 63, 64, 65, 66, 67, 24, 23, 22, 21, 68, 69, 20, 19, 18, 17, 70, 71, 16, 15, 72, 73, 74, 75, 76, 14, 13, 12, 77, 11, 10, 9, 8, 78, 7, 79, 80, 6, 81, 5, 4, 3, 82, 2, 83, 84, 1, 85, 86, 87, 0, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99] -> True`
.split`\n`.forEach(row => {
  var rowElements = row.match(/\w+/g), 
      expected = rowElements.pop()=='True',
      input = rowElements.map(x => +x),
      result = antsy(input),
      ok = result == expected;
  OkAll = OkAll && ok;
  console.log(ok?'OK':'KO', input+' -> '+result)
})
console.log(OkAll ? 'All passed' : 'Failed')

Comments

सच में अच्छा। मैंने पुनरावृत्ति के साथ इस दृष्टिकोण की कोशिश की, लेकिन मैं इसे 65 से नीचे नहीं पा सकता हूं:f=([q,...a],x=[])=>x&&(x[q]=!(x+x)|x[q+1]|x[q-1])&&(a+a?f(a,x):1)

— ETHproductions

यह कैसे काम करता है? क्या आप कुछ उत्परिवर्ती सूची जादू का उपयोग कर रहे हैं?

— जर्ग

@Zgarb स्पष्टीकरण जोड़ा गया

— edc65

Answer 4

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

f=lambda l:l==[]or max(l)-min(l)<len(l)*f(l[:-1])

जाँचता है कि क्या सूची के प्रत्येक उपसर्ग में इसके न्यूनतम और अधिकतम समावेशी के बीच सभी संख्याएँ हैं। यह जाँच करता है कि अधिकतम और न्यूनतम का अंतर इसकी लंबाई से कम है या नहीं।

---

54 बाइट्स:

f=lambda l:1/len(l)or-~l.pop()in[min(l),max(l)+2]*f(l)

जाँचता है कि क्या अंतिम तत्व या तो अन्य तत्वों के न्यूनतम से कम है, या उनके अधिकतम से एक अधिक है। फिर, अंतिम तत्व को हटाता है और पुनरावृत्ति करता है। एकल-तत्व सूची में, आउटपुट True।

यह भी एक मनोरंजक लेकिन लंबी सूची समझ के माध्यम से जाँच की जा सकती है।

lambda l:all(l.pop()in[min(l)-1,max(l)+1]for _ in l[1:])

मैं असमानता का उपयोग करना चाहता हूं min(l)-2<l.pop()<max(l)+2, लेकिन popपहले ऐसा होना चाहिए। त्रुटि कोड के माध्यम से आउटपुट के लिए एक कार्यक्रम का उपयोग करने की संभावना कम होगी।

Answer 5

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

!MatchQ[#,{a__,b_,___}/;Min@Abs[{a}-b]>1]&

उपयोग पैटर्न मिलान कोशिश करते हैं और एक उपसर्ग लगाने के लिए aजिसका अधिकतम अंतर अगले तत्व से bसे अधिक है 1(और का परिणाम negating MatchQ)।

Answer 6

पर्ल, 39 38 35 बाइट्स

के लिए +1 शामिल है -p

STDIN पर अनुक्रम दें:

antsy.pl <<< "2 1 3 0"

antsy.pl:

#!/usr/bin/perl -p
s%\d+%--$a[$&]x"@a"=~/1  /%eg;$_++

Comments

मैं एक कठिन समय इस एक को समझने की कोशिश कर रहा हूँ ... थोड़ा समझाने के लिए देखभाल? धन्यवाद :-) (सिर्फ मुख्य विचार ही पर्याप्त होना चाहिए)

— दादा

Answer 7

MATL , 11 बाइट्स

&-|R1=a4L)A

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

व्याख्या

यह सभी जोड़ीदार पूर्ण अंतरों के मैट्रिक्स की गणना करता है और ऊपरी त्रिकोणीय भाग को रखता है। परिणाम सही है अगर पहले को छोड़कर सभी स्तंभों में कम से कम 1 मूल्य है।

&-     % All pairwise differences
|      % Absolute value
R      % Upper triangular part
1=     % Does each entry equal 1?
a      % Logical "or" along each column
4L)    % Remove first value
A      % Logical "and" of all results

Answer 8

आर, 72 64 60 बाइट्स

v=scan();for(i in seq(v))T=c(T,diff(sort(v[1:i])));all(T==1)

एक क्रमपरिवर्तन एक विस्मयकारी है अगर और केवल अगर इसके सभी बचे हुए उपपरिवर्तन निरंतर हों (जैसे कि छांटने पर अंतर होता है)।

इनपुट लंबाई एक से अधिक करने की गारंटी दी जाती है, तो हम जगह ले सकता है 1:sum(1|v)के साथ seq(v), जो चार बाइट्स बचाता है।

seq(v)में अगर हालत बर्ताव करता है अलग ढंग से जब इनपुट लंबाई एक की है --- यह अनुक्रम उत्पन्न 1:vकरने के बजाय seq_along(v)। हालांकि, सौभाग्य से, आउटपुट TRUEइस मामले में बदल जाता है , जो वांछित व्यवहार है। वही शून्य-लंबाई इनपुट के लिए भी होता है।

आर में, Tएक पूर्व निर्धारित चर के बराबर है TRUE(लेकिन आर आपको इसे फिर से परिभाषित करने की अनुमति देता है)। TRUEके बराबर भी माना जाता है 1।

मूल समाधान के लिए कुछ उपयोगी सुधार के लिए @Billywob को धन्यवाद।

Comments

इनपुट का उपयोग करके पढ़ने से scanआप दो बाइट बचा सकते हैं। उस मामले में यह forलूप अप्रोच के समान ही बाइट्स की संख्या है : v=scan();c=c();for(i in 1:sum(1|v))c=c(c,diff(sort(v[1:i])));all(c==1)जो आपके वेक्टरकृत दृष्टिकोण से 2 बाइट्स कम होगा।

— बिलीवोब

अच्छा विचार है, और मैं गाली देकर एक बेहतर सोच सकता हूं T। संपादित करेंगे।

— JDL

Answer 9

05AB1E , 7 बाइट्स

Âìæ¹{¢O

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

व्याख्या

अपने शानदार पायथ उत्तर में xnor द्वारा वर्णित प्रक्रिया का उपयोग करता है ।
सत्य उदाहरणों के लिए 2 और झूठे के लिए 0 रिटर्न।

Âì        # prepend a reversed copy of input to input
  æ       # take powerset
   ¹{     # push a sorted copy of input
     ¢    # count occurances of sorted input in powerset
      O   # sum occurances (which for some reason is needed, feels like a bug)

Answer 10

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

ध्यान दें कि @Gabriel Banamy एक छोटे (55 बाइट्स) उत्तर के साथ आया था । लेकिन मुझे लगता है कि यह समाधान अभी भी दिलचस्प है, इसलिए मैं इसे पोस्ट कर रहा हूं।

बाइट्स की संख्या में कोड और -nध्वज के 62 बाइट्स शामिल हैं ।

s/\d+/1x($&+1)/ge;/ 1(1*)\b(?{$.&=$`=~m%\b(11)?$1\b%})^/;say$.

इसे चलाने के लिए:

perl -nE 's/\d+/1x($&+1)/ge;/ 1(1*)\b(?{$.&=$`=~m%\b(11)?$1\b%})^/;say$.' <<< "3 2 5 4 1 0"

लघु स्पष्टीकरण : प्रत्येक संख्या धर्मान्तरित kकी एकल प्रतिनिधित्व करने के लिए k+1(कि +1इसलिए जरूरत है 0रों नजरअंदाज कर नहीं मिलता)। फिर प्रत्येक संख्या के लिए k+1(जैसा कि असमान में व्यक्त किया गया है 1(1*)), हम देखते हैं कि या तो k( $1धारण k) या k+2(जो तब है 11$1) पूर्ववर्ती स्ट्रिंग में मौजूद हैं (द्वारा संदर्भित $-backtick)। यदि नहीं, तो हम $.शून्य पर सेट करते हैं। फिर अंत में हम प्रिंट करते हैं $.जो कि 1यदि हम इसे कभी भी शून्य या शून्य पर सेट नहीं करते हैं।

Answer 11

ब्रेन-फ्लैक 302 264 256 बाइट्स

46 बाइट बचाने के लिए गेहूं जादूगर को धन्यवाद

([]){{}({}<>)<>([])}{}<>(({}))([]){{}({}<>)<>([])}{}<>(({}<>))<>(()){{}(({})<(({})<>[({})]<>(())){((<{}{}>))}{}{{}({}<><{}>)(<>)}{}<>({}<<>(({})<>[({})<>(())]){((<{}{}>))}{}{{}({}<><{}>)(<>)}{}<>>)<>>[({})](<()>)){{}{}(<(())>)}{}}([][()(())]){((<{}{}>))}{}

ढेर के ऊपर सत्य के लिए 1 और झूठी के लिए एक 0 होगा।

सच्चाई: यह ऑनलाइन कोशिश करो!
झूठा: यह ऑनलाइन कोशिश करो!

यह विचार न्यूनतम और अधिकतम संख्या को रखने के लिए है कि चींटी ने स्टैक का दौरा किया है। फिर उन दोनों के लिए प्रत्येक संख्या की तुलना करें और उपयुक्त एक को अपडेट करें। यदि अगली संख्या न्यूनतम 1 से कम या अधिकतम से 1 अधिक नहीं है, तो लूप से बाहर निकलें और झूठी लौटें।

---

संक्षिप्त विवरण:

([])                             # duplicate the bottom element by
{{}({}<>)<>([])}{}<>             # reversing everything onto the other stack 
(({}))([])                       # duplicating the top element
{{}({}<>)<>([])}{}<>             # and reversing everything back

(({}<>))<>                       # copy the top element to the other stack (push twice)
(()){{}                          # push a 1 so the loop starts, and repeat until the top
                                 # two elements are equal
(({})<                           # hold onto the top element to compare later
(({})<>[({})]<>(()))             # push a 0 if diff with the top of the other stack is +1
{{}({}<><{}>)(<>)}{}             # logical not (the previous line pushed a 1 as the second
                                 # element already)
{{}({}<><{}>)<>(<()>)}{}         # replace the top of the other stack with this element if
                                 # the logical not gave us 1
<>({}<<>                         # take the minimum off the other stack temporarily 
(({})<>[({})<>(())])             # push a 0 if diff with the top of the other stack is -1
{((<{}{}>))}{}                   # logical not (the previous line pushed a 1 as the second
                                 # element already)
{{}({}<><{}>)(<>)}{}             # replace the top of the other stack with this element if
                                 # the logical not gave us 1
<>>)<>                           # put the minimum on back on
>)                               # put the element you were comparing back on
[({})](<()>)){{}{}(<(())>)}{}    # push 1 or 0 for not equal to the element we held earlier
                                 # (push the second number back on)
}                                # repeat the loop if the top 2 weren't equal
([][()(())]){((<{}{}>))}{}       # logical not of the height of the stack

Comments

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

— गेहूं जादूगर

@WheatWizard मुझे यकीन है कि कुछ हैं, मेरे पास अभी उन्हें काम करने का समय नहीं है। याद दिलाने के लिए शुक्रिया।

— रिले

मुझे खुशी है कि यह कम से कम आपको समझ में आता है O_O

— गेब्रियल बेलामी

की तुम भी उदाहरणों की जगह ले सकता ([]){({}[()]<({}<>)<>>)}{}से ([]){{}({}<>)<>([])}{}अधिक एक जोड़े को बचाने के लिए बाइट्स

— गेहूं जादूगर

Answer 12

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

;@UŒPċṢ

यह ऑनलाइन की कोशिश करो!

Xnor के जवाब का एक जेली अनुवाद।

पुराने समाधान:

;\Ṣ€IỊȦ
;\Ṣ€IE€P

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

नीचे दिए गए मेरे पायथ उत्तर के समान ही कार्य करता है:

;\          All prefixes (Accumulate (\) over concatenation (;))
  Ṣ€        (Ṣ)ort each (€) prefix
    I       (I)ncrements of each prefix (differences between consecutive elements).  Implicit vectorization.
     E€     Check if all elements are (E)qual (they will be iff the permutation is antsy,
               and all elements will be 1) for each (€) prefix
       P    Is this true for all prefixes?
     ỊȦ     For the other answer, are (Ȧ)ll elements 1 or less (Ị)?

Comments

जैनी के लिए xnor की अन्य विधि का रूपांतरण भी 7 बाइट्स है »\_«\⁼Ṣलेकिन बहुत अधिक कुशल है

— मील

ŒBŒPċṢऔर ;\Ṣ€IỊȦप्रत्येक दृष्टिकोण में एक बाइट को बचाना चाहिए।

— डेनिस

दुर्भाग्य से, पहला काम नहीं करता है क्योंकि मुझे उल्टे इनपुट को बाउंस करने की आवश्यकता होगी, जैसे UŒBŒPċṢकि किसी भी बाइट को नहीं बचाता है। Ị, हालांकि अच्छा है; मुझे लगता है कि यह वास्तव में क्या किया था की तार्किक नहीं उत्पादन करने के लिए कि परमाणु गलत था।

— स्टीवन एच।

मुझे यकीन नहीं है कि आपको इसकी आवश्यकता क्यों होगी U(या @अब मैं इसके बारे में सोचता हूं)। यदि एक सरणी चींटियां है, तो क्या उलटा सरणी है, नहीं?

— डेनिस

जरूरी नहीं: [2, 1, 3, 0]चींटियां हैं, लेकिन [0, 3, 1, 2]नहीं है।

— स्टीवन एच।

Answer 13

CJam ( 21 20 बाइट्स)

{:A,{_)A<$2*)@-#},!}

ऑनलाइन टेस्ट सूट

विच्छेदन

यह उनके हास्केल उत्तर में xnor द्वारा अवलोकन का उपयोग करता है कि पहले nतत्वों के अधिकतम और न्यूनतम के बीच का अंतर होना चाहिए n-1।

{         e# Define a block. Stack: array
  :A,     e#   Store the array in A and get its length
  {       e#   Filter (with implicit , so over the array [0 ... len-1])
    _)A<  e#     Get the first i+1 elements of A (so we iterate over prefixes)
    $2*)  e#     Extract the last element without leaving an empty array if the
          e#     prefix is of length 1 by first duplicating the contents of the
          e#     prefix and then popping the last element
    @-#   e#     Search the prefix for max(prefix)-i, which should be min(prefix)
          e#     giving index 0
  },      e#   So the filter finds values of i for which the prefix of length i+1
          e#   doesn't have max(prefix) - min(prefix) = i
  !       e#   Negate, giving truthy iff there was no i matching the filter
}

---

वैकल्पिक दृष्टिकोण (20 बाइट्स भी)

{_{a+_)f-:z1&,*}*^!}

ऑनलाइन टेस्ट सूट

यह सीधे जांचता है कि पहले के बाद प्रत्येक तत्व पिछले तत्व से दूरी 1 पर है। चूंकि इनपुट एक क्रमपरिवर्तन है और इसलिए मानों को दोहराता नहीं है, यह एक पर्याप्त परीक्षण है। 1-बाइट बचाने के लिए मार्टिन को धन्यवाद।

विच्छेदन

{_{a+_)f-:z1&,*}*^!}

{         e# Declare a block. Stack: array
  _       e#   Work with a copy of the array
  {       e#   Fold...
    a+    e#     Add to the accumulator.
    _)f-  e#     Dup, pop last, map subtraction to get distance of this element from
          e#     each of the previous ones
    :z1&, e#     Check whether the absolute values include 1
    *     e#     If not, replace the accumulator with an empty array
  }*
  ^!      e#   Test whether the accumulator is equal to the original array
          e#   Note that this can't just be = because if the array is of length 1
          e#   the accumulator will be 0 rather than [0]
}

Comments

मुझे लगता है कि यह एक बचाता है? {_{a+_)f-:z1&,*}*^!}

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

@MartinEnder, बहुत अच्छा। उत्सुकता से आपने पोस्ट किया कि जैसे मैं एक ही बाइट की गिनती के साथ पूरी तरह से अलग दृष्टिकोण पोस्ट कर रहा था।

— पीटर टेलर

Answer 14

जावा, 100 98 79 75 बाइट्स

a->{int n=a[0],m=n-1;for(int i:a)n-=i==m+1?m-m++:i==n-1?1:n+1;return n==0;}

पूर्व में:

a->{int m,n;m=n=a[0];--m;for(int i:a)if(i==m+1)m=i;else if(i==n-1)n=i;else return 0>1;return 1>0;}

की जगह 3 बाइट्स सहेजा trueऔर falseसाथ 1>0और 0>1।

पीटर टेलर के उत्कृष्ट सुझावों के लिए 23 बाइट्स का धन्यवाद!

Ungolfed:

a -> {
    int n = a[0], m = n - 1;
    for (int i : a)
        n -= i == m + 1? m - m++ : i == n - 1? 1 : n + 1;
    return n == 0;
}

के रूप में अब तक देखा उच्चतम और निम्नतम मूल्यों पर नज़र रखें mऔर n; केवल एक नया मान स्वीकार करें अगर यह है m + 1या n - 1अगले उच्च या निम्न मान है; उच्च मूल्य को इनिशियलाइज़ करें, mपहले तत्व की तुलना में एक कम पर ताकि यह लूप के चारों ओर पहली बार "मेल" करेगा। नोट: यह एक रैखिक-समय, ऑनलाइन एल्गोरिथ्म है। यह कई अन्य समाधानों के विपरीत, वर्तमान, उच्चतम-अब तक, और निम्नतम-अभी तक मूल्यों के लिए केवल तीन शब्दों की स्मृति की आवश्यकता है।

यदि अगला मान श्रेणी के उच्च और निम्न दोनों छोरों को याद करता है, तो सबसे कम-अब तक का मान सेट है -1और फिर निम्न अंत कभी भी आगे नहीं बढ़ सकता है और शून्य तक नहीं पहुंच सकता है। हम तब जाँच करते हैं कि निम्न मान nशून्य तक पहुँच गया है या नहीं।

(दुर्भाग्य से यह कम कुशल है क्योंकि हमें हमेशा पहले गलत नंबर के बाद बाहर निकलने के बजाय पूरे अनुक्रम को देखना पड़ता है , लेकिन 23-बाइट बचत (!) के साथ बहस करना कठिन होता है जब अन्य समाधान ओ (n ^ 2) का उपयोग कर रहे होते हैं। ) और घातांक समय दृष्टिकोण।)

उपयोग:

import java.util.function.Predicate;

public class Antsy {
    public static void main(String[] args) {
        int[] values = { 6, 5, 4, 7, 3, 8, 9, 2, 1, 0 };
        System.out.println(test(values,
            a -> {
                int n = a[0], m = n - 1;
                for (int i : a)
                    n -= i == m + 1? m - m++ : i == n - 1? 1 : n + 1;
                return n == 0;
            }
        ));
    }

    public static boolean test(int[] values, Predicate<int[]> pred) {
        return pred.test(values);
    }
}

नोट: यह जावा 8 लैम्ब्डा का लाभ उठाए बिना भी लिखा जा सकता है:

जावा 7, 89 बाइट्स

boolean c(int[]a){int n=a[0],m=n-1;for(int i:a)n-=i==m+1?m-m++:i==n-1?1:n+1;return n==0;}

Comments

विशेष मामले की अच्छी हैंडलिंग। int m,n;m=n=a[0];--m;हो सकता है int n=a[0],m=n-1;, और महंगा है returnऔर (या कुछ इसी तरह के elseसाथ कम किया जा सकता है i==m+1?m++:n=(i==n-1)?i:-1;return n==0;- मैंने यह परीक्षण नहीं किया है)।

— पीटर टेलर

@PeterTaylor शानदार! दुर्भाग्य से, जावा अनुमति नहीं दी जाएगी जैसे कोई साइड इफेक्ट m++या m+=1वहाँ, मैं इतना अभी भी एक की जरूरत है ifऔर एक elseहै, और यह पहले बुरा मूल्य पर कम सर्किटिंग के पहलू खो देता है, लेकिन यह एक बड़ा सुधार है। धन्यवाद!

— डेविड कॉनरैड

यह एक जटिल अभिव्यक्ति में दुष्प्रभावों की अनुमति देगा। यह एक कथन के रूप में एक सामान्य अभिव्यक्ति का उपयोग नहीं कर सकता है। सबसे खराब स्थिति में आपको एक डमी वैरिएबल बनाने jऔर परिणाम को असाइन करने की आवश्यकता होती है, लेकिन संदेह है कि इसे करने का एक बेहतर तरीका होगा।

— पीटर टेलर

@PeterTaylor खैर, मैंने इस पर कुछ बदलावों की कोशिश की, जिसमें इसे एक डमी वैरिएबल को सौंपना भी शामिल है g, और मुझे यह काम करने के लिए नहीं मिला। (मैं जावा 9-ईआर + 138 का उपयोग कर रहा हूं, शायद यह जावा 8 और जावा 9 के बीच अंतर है?) मैं कल फिर से कोशिश कर सकता हूं।

— डेविड कॉनरैड

समझ गया। n-=i==m+1?m-m++:i==n-1?1:n+1;

— पीटर टेलर

Answer 15

पायथ ( कांटा ), 13 बाइट्स

!sstMM.+MSM._

पायथ के इस कांटे के लिए नो ट्राई इट ऑनलाइन लिंक। कांटा में .+डेल्टास फ़ंक्शन शामिल है , जो मानक पाइथ लाइब्रेरी का हिस्सा नहीं है।

स्पष्टीकरण:

           ._  For each of the prefixes:
         SM    Sort it
      .+M      Get deltas (differences between consecutive elements), which for antsy
                 permutations would all be 1s
   tMM         Decrement each of the elements (all 0s for antsy permutations)
 ss            Sum all the results from the above together, 0 for antsy and >0 for non-antsy
!              Logical negation.

Comments

यह देखकर मुझे पाइथ में विलय करने के लिए आश्वस्त करता है।

— isaacg

Answer 16

पर्ल, 66 54 +1 = 55 बाइट्स

के लिए +1 बाइट -n।

s/\d+/$.&=!@a||1~~[map{abs$_-$&}@a];push@a,$&/eg;say$.

स्पष्टीकरण:

s/\d+/$.&=!@a||1~~[map{abs$_-$&}@a];push@a,$&/eg;say$.
#input is automatically read into $_.
#regex automatically is performed on $_.
s/   /                                       /eg;
    #Substitution regex.
    #/g means to keep searching after the first match
    #/e evaluates the replacement as code instead of regex.
  \d+  #Match of at least 1 digit.  Match automatically gets stored in $&
      $.&=  #$. is initially 1.  This basically says $. = $. & (code)
           !@a  #Since @a is uninitialized, this returns !0, or 1
                #We don't want to check anything for the first match
              || #logical or
                1~~
                   #~~ is the smartmatch operator.  When RHS is scalar and LHS is array reference,
                   #it returns 1 iff RHS is equal to at least one value in de-referenced LHS.
                   [map{abs$_-$&}@a];
                       #Return an array reference to the array calculated by |$_ - $&|
                       #where $_ iterates over @a.  Remember $& is the stored digit capture.
                                     push@a,$& #pushes $& at the end of @a.
                                                 say$. #output the result

प्रिंट 0 अगर झूठ है, तो 1 अगर सच है।

-11 बाइट्स @ दादा को धन्यवाद

Comments

वह वास्तव में अच्छा है। आप इसे 55 बाइट तक नीचे कर सकते हैं, हालांकि perl -nE 's/\d+/$.&=!@a||1~~[map{abs$_-$&}@a];push@a,$&/eg;say$.': -nइसके बजाय <>=~आप /rसंशोधक से छुटकारा पा सकते हैं । का उपयोग \d+और उसके बाद $&के बजाय (\d+)और $1। !@aके बजाय 0>$#a। $.&=के बजाय $.&&=। push@a,$&इसके बजाय@a=(@a,$&)

— दादा

किसी कारण से, मेरा सिस्टम मुझे बताता है कि नई फ़ाइल 55 बाइट्स लंबी है, जो स्पष्ट रूप से गलत है, क्योंकि यह केवल 54 अक्षर है, इसलिए ???

— गेब्रियल बेनामी

हम्म कि अजीब बात है। (और मुझे नहीं पता कि यह कहां से आता है)। लेकिन मुझे पूरा यकीन है कि यह केवल 54 है (पीपीसीजी-डिज़ाइन स्क्रिप्ट मुझे 54 बताती है, और मेरा बाइटकाउंट ऐप मुझे 54 असवेल बताता है)।

— दादा

क्या यह संभव है कि बाइट काउंट फ़ाइल के अंत में अनावश्यक न्यूलाइन होने के कारण बाहर था?

— ट्राइकोप्लेक्स

Answer 17

ब्रेनफक, 60 बाइट्स

,+[>+>+<<-]
,+
[
  [>->->+<<<-]
  >-
  [
    +>+
    [
      <<<
    ]
  ]
  >[>]
  <[<+<+>>-]
  <<<,+
]
>.

क्रमपरिवर्तन को बाइटर्स के रूप में दिया गया है जिसमें कोई विभाजक नहीं है और कोई समाप्ति न्यूलाइन नहीं है। चूंकि \x00इनपुट में होता है, यह कार्यान्वयन के लिए डिज़ाइन किया गया है EOF = -1। आउटपुट \x00झूठे और \x01सच्चे के लिए है।

का क्रमपरिवर्तन हैं \x01अप करने के लिए chr(r)अनुमति दी है, तो हम के सभी उदाहरणों की जगह ले सकता ,+के साथ ,एक साथ 57 के स्कोर के लिए EOF = 0कार्यान्वयन।

इसे ऑनलाइन आज़माएं (57-बाइट संस्करण): इनपुट को बाइट को छोड़कर किसी भी सन्निहित सीमा के क्रमपरिवर्तन के रूप में दिया जा सकता है \x00, और आउटपुट \x00गलत और सही सीमा के न्यूनतम के लिए होगा।

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

मुख्य लूप की शुरुआत में सामान्य कामकाजी स्थान का मेमोरी लेआउट है

c a b 0 0

जहां cवर्तमान चरित्र है, aन्यूनतम है, और bअधिकतम है। (60-बाइट संस्करण के लिए, सब कुछ 1 के ऑफसेट के साथ संभाला जाता है ,+।)

Answer 18

ब्रेकीलॉग , 22 बाइट्स

:@[fb:{oLtT,Lh:T:efL}a

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

व्याख्या

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

:@[fb                       Take all but the first prefixes of the Input
     :{             }a      This predicate is true for all those prefixes
       oLtT,                Sort the prefix, call it L, its last element is T
            Lh:T            The list [First element of L, T]
                :efL        Find all integers between the First element of L and T. It must
                              result in L

Comments

पहली से आखिरी तक की सीमा एक दृष्टिकोण है जो मुझे सीजेएम में हुई थी। अन्य प्रकार, जोड़ीदार अंतर थे, वे सभी की जाँच करें 1। मुझे नहीं पता कि ब्रेजलॉग में कितना आसान है।

— पीटर टेलर

@PeterTaylor दुर्भाग्य से लगातार जोड़े (या सीधे जोड़ीदार अंतरों की गणना) करने का कोई छोटा तरीका नहीं है (अभी के लिए)।

— 8

Answer 19

बैच, 133 बाइट्स

@set/au=%1,l=%1-1,a=0
@for %%n in (%*)do @call:l %%n
@exit/b%a%
:l
@if %1==%u% (set/au+=1)else if %1==%l% (set/al-=1)else set a=1

कमांड-लाइन तर्कों के रूप में इनपुट लेता है। सफलता के लिए त्रुटि स्तर 0 के साथ बाहर, विफलता के लिए 1।

Answer 20

जे, 14 बाइट्स

/:~-:>./\-<./\

यह @ xnor की विधि पर आधारित है ।

व्याख्या

/:~-:>./\-<./\  Input: array P
        \       For each prefix of P
     >./          Reduce using the maximum
          <./\  Get the minimum of each prefix of p
         -      Subtract between each
   -:           Test if it matches
/:~               P sorted

Answer 21

जावा, 170 बाइट्स

boolean f(int[]a){int l=a.length,i=0,b=0,e=l-1;int[]x=new int[l];for(;i<l;i++)x[i]=i;for(i--;i>0;i--)if(a[i]==x[b])b++;else if(a[i]==x[e])e--;else return 0>1;return 1>0;}

ऐरे xमें ऑर्डर में 0 से अधिकतम संख्या तक मान है (पायथन यहां बहुत बेहतर होगा ...)। लूप सबसे कम ( x[b]) या उच्चतम ( x[e]) संख्या का मिलान करने की कोशिश कर रहा है, जो अभी तक सामने नहीं आया है; यदि ऐसा होता है, तो उस चरण में संख्या तक पहुंचा जा सकता है।

यहां टेस्ट कोड ।

Answer 22

मैथेमेटिका, 47 बाइट्स

मार्टिन एंडर के समाधान (आश्चर्य चकित!) की तुलना में थोड़ा लंबा है। लेकिन यह मेरे अधिक अपठनीय प्रयासों में से एक है, इसलिए यह अच्छा है: डी

#=={}||{Max@#,Min@#}~MemberQ~Last@#&&#0@Most@#&

स्पष्टीकरण:

#=={}                         empty lists are antsy (function halts with True)
 ||                            or
{Max@#,Min@#}~MemberQ~Last@#  lists where the last number is largest or smallest
                              are possibly antsy (else function halts with False)
 &&                            and
#0@Most@#&                    recursively call this function after dropping the
                              last element of the list

Answer 23

जावा 7, 170 169 बाइट्स

import java.util.*;Object c(int[]a){List l=new ArrayList();l.add(a[0]);for(int i:a){if(l.indexOf(i)<0&l.indexOf(i-1)<0&l.indexOf(i+1)<0)return 0>1;l.add(i);}return 1>0;}

Ungolfed और परीक्षण कोड:

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

import java.util.*;
class M{
  static Object c(int[] a){
    List l = new ArrayList();
    l.add(a[0]);
    for(int i : a){
      if(l.indexOf(i) < 0 & l.indexOf(i-1) < 0 & l.indexOf(i+1) < 0){
        return 0>1; //false
      }
      l.add(i);
    }
    return 1>0; //true
  }

  public static void main(String[] a){
    System.out.println(c(new int[]{ 0 }));
    System.out.println(c(new int[]{ 0, 1 }));
    System.out.println(c(new int[]{ 1, 0 }));
    System.out.println(c(new int[]{ 0, 1, 2 }));
    System.out.println(c(new int[]{ 0, 2, 1 }));
    System.out.println(c(new int[]{ 2, 1, 3, 0 }));
    System.out.println(c(new int[]{ 3, 1, 0, 2 }));
    System.out.println(c(new int[]{ 1, 2, 0, 3 }));
    System.out.println(c(new int[]{ 2, 3, 1, 4, 0 }));
    System.out.println(c(new int[]{ 0, 5, 1, 3, 2, 4 }));
    System.out.println(c(new int[]{ 6, 5, 4, 7, 3, 8, 9, 2, 1, 0 }));
    System.out.println(c(new int[]{ 4, 3, 5, 6, 7, 2, 9, 1, 0, 8 }));
    System.out.println(c(new int[]{ 5, 2, 7, 9, 6, 8, 0, 4, 1, 3 }));
    System.out.println(c(new int[]{ 20, 13, 7, 0, 14, 16, 10, 24, 21, 1, 8, 23, 17, 18, 11, 2, 6, 22, 4, 5, 9, 12, 3, 15, 19 }));
    System.out.println(c(new int[]{ 34, 36, 99, 94, 77, 93, 31, 90, 21, 88, 30, 66, 92, 83, 42, 5, 86, 11, 15, 78, 40, 48, 22, 29, 95, 64, 97, 43, 14, 33, 69, 49, 50, 35, 74, 46, 26, 51, 75, 87, 23, 85, 41, 98, 82, 79, 59, 56, 37, 96, 45, 17, 32, 91, 62, 20, 4, 9, 2, 18, 27, 60, 63, 25, 61, 76, 1, 55, 16, 8, 6, 38, 54, 47, 73, 67, 53, 57, 7, 72, 84, 39, 52, 58, 0, 89, 12, 68, 70, 24, 80, 3, 44, 13, 28, 10, 71, 65, 81, 19 }));
    System.out.println(c(new int[]{ 47, 48, 46, 45, 44, 49, 43, 42, 41, 50, 40, 39, 38, 51, 37, 36, 52, 35, 34, 33, 32, 53, 54, 31, 30, 55, 56, 29, 28, 57, 58, 59, 60, 27, 26, 61, 25, 62, 63, 64, 65, 66, 67, 24, 23, 22, 21, 68, 69, 20, 19, 18, 17, 70, 71, 16, 15, 72, 73, 74, 75, 76, 14, 13, 12, 77, 11, 10, 9, 8, 78, 7, 79, 80, 6, 81, 5, 4, 3, 82, 2, 83, 84, 1, 85, 86, 87, 0, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99 }));
  }
}

आउटपुट:

true
true
true
true
false
true
false
true
true
false
true
false
false
false
false
true