बताइये फ्लॉप कैसे हो

Question

कंप्यूटर वैज्ञानिकों के रूप में, आप शायद पॉप और पुश की बुनियादी सूची संचालन से परिचित हैं । ये सरल ऑपरेशन हैं जो तत्वों की एक सूची को संशोधित करते हैं। हालांकि, क्या आपने कभी ऑपरेशन फ्लॉप के बारे में सुना है ? ( फ्लिप- फ्लॉप में )? यह बहुत आसान है। एक संख्या n को देखते हुए , सूची के पहले n तत्वों को उल्टा करें । यहाँ एक उदाहरण है:

>>> a = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> a.flop(4)
[4, 3, 2, 1, 5, 6, 7, 8, 9, 10]

फ्लॉप ऑपरेशन के बारे में अच्छी बात यह है कि आप इसका उपयोग किसी सूची में कुछ अच्छी चीजों को करने के लिए कर सकते हैं, जैसे कि इसे क्रमबद्ध करना । हम फ्लॉप फिल्मों के साथ कुछ ऐसा ही करने जा रहे हैं:

पूर्णांक की एक सूची को देखते हुए, "इसे पास करें"। दूसरे शब्दों में, इसे क्रमबद्ध करें ताकि प्रत्येक डुप्लिकेट तत्व लगातार दिखाई दे।

यह फ्लॉप के साथ किया जा सकता है! उदाहरण के लिए, निम्नलिखित सूची लें:

>>> a = [3, 2, 1, 4, 3, 3, 2]
>>> a.flop(4)
[4, 1, 2, 3, 3, 3, 2]
>>> a.flop(3)
[2, 1, 4, 3, 3, 3, 2]
>>> a.flop(6)
[3, 3, 3, 4, 1, 2, 2]

यह हमें आज की चुनौती की परिभाषा की ओर ले जाता है:

पूर्णांक की एक सूची को देखते हुए, फ्लॉप के किसी भी सेट को आउटपुट करें, जिसके परिणामस्वरूप सूची पड़ोसी होगी।

उदाहरण के रूप में अंतिम सूची का उपयोग करते हुए, आपको आउटपुट देना चाहिए:

4
3
6

क्योंकि सूची को 4 से रोकना, फिर 3 से, फिर 6 से पड़ोसी सूची में परिणाम होगा। ध्यान रखें कि आपको फ्लॉप की सबसे छोटी संभावित सूची को मुद्रित करने की आवश्यकता नहीं है जो पड़ोसी की सूची है। यदि आपने प्रिंट किया था:

4
4
4
3
1
1
6
2
2

इसके बजाय, यह अभी भी एक मान्य आउटपुट होगा। हालाँकि, आप कभी भी सूची की लंबाई से बड़ी संख्या में आउटपुट नहीं कर सकते हैं । ऐसा इसलिए है क्योंकि एक सूची के लिए a = [1, 2, 3], कॉलिंग a.flop(4)बकवास है।

यहाँ कुछ उदाहरण हैं:

#Input:
[2, 6, 0, 3, 1, 5, 5, 0, 5, 1]

#Output
[3, 7, 8, 6, 9]


#Input
[1, 2]

#Output
<any list of integers under 3, including an empty list>


#Input
[2, 6, 0, 2, 1, 4, 5, 1, 3, 2, 1, 5, 6, 4, 4, 1, 4, 6, 6, 0]

#Output
[3, 19, 17, 7, 2, 4, 11, 15, 2, 7, 13, 4, 14, 2]


#Input
[1, 1, 1, 1, 2, 2, 2, -1, 4]

#Output
[]


#Input
[4, 4, 8, 8, 15, 16, 16, 23, 23, 42, 42, 15]

#Output
[12, 7]

ध्यान रखें कि इनमें से प्रत्येक उदाहरण में, दिया गया आउटपुट सिर्फ एक संभावित वैध आउटपुट है। जैसा कि मैंने पहले कहा, फ्लॉप का कोई भी सेट जो पड़ोसियों को दी गई सूची को मान्य आउटपुट है । यदि आप फ़्लॉप की दी गई सूची को सही ढंग से पड़ोसी सूची में रखते हैं, तो सत्यापित करने के लिए आप इस अजगर स्क्रिप्ट का उपयोग कर सकते हैं ।

आप किसी भी उचित प्रारूप में इनपुट और आउटपुट ले सकते हैं। उदाहरण के लिए, फ़ंक्शन तर्क / रिटर्न वैल्यू, STDIN / STDOUT, फ़ाइल पढ़ना / लिखना आदि सभी मान्य हैं। हमेशा की तरह, यह कोड-गोल्फ है , इसलिए सबसे छोटा कार्यक्रम बनाएं जो आप कर सकते हैं, और मज़े करें! :)

Comments

मैंने इसे fl (oating बिंदु) op (eration) के रूप में सुना।

— वीजुन झोउ

@ WeijunZhou गणनात्मक संचालन का एक उपाय है, गिनती के संचालन के लिए हार्डवेयर का एक टुकड़ा किया जाता है। en.wikipedia.org/wiki/FLOPS

— iPhoenix

क्या सबमिशन को नियतात्मक होना चाहिए या क्या मैं सरणी को समूहीकृत करने तक छद्म रूप से फ्लॉप कर सकता हूं?

— डेनिस

क्या शून्य फ्लॉप को आउटपुट में प्रदर्शित होने की अनुमति है?

— लैकोनी

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

— पीटर टेलर

Answer 1

हास्केल , 98 71 बाइट्स

h.r
h(x:s)|(a,b)<-span(/=x)s=l b:l s:h(b++r a)
h e=e
r=reverse
l=length

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

व्याख्या

लंबाई की सूची के लिए nयह विधि 2*nफ्लॉप का उत्पादन करती है । यह सूची के अंतिम तत्व को देखकर काम करता है, पहले सूची में उसी तत्व की तलाश करता है और इसे दूसरी से अंतिम स्थिति में फ़्लिप करता है। फिर हटाए गए अंतिम तत्व के साथ सूची पुनरावर्ती "पड़ोसी" है।

सूची के [1,2,3,1,2]लिए एल्गोरिथ्म इस तरह काम करता है:

[1,2,3,1,2]  flip longest prefix that ends in 2: flop 2
[2,1,3,1,2]  bring first element to second to last position: flop n-1 = flop 4
[1,3,1,2,2]  recursively work on n-1 list
[1,3,1,2]    there is no other 2: flop 0
[1,3,1,2]    flop n-1 = flop 3
[1,3,1,2]    recurse
[1,3,1]      flop 1
[1,3,1]      flop 2
[3,1,1]      recurse
[3,1]        flop 0
[3,1]        flop 1
 ...

यह सब मिलकर फ्लॉप [2,4,0,3,1,2,0,1,0,0]और पड़ोस की सूची तैयार करता है [3,1,1,2,2]।

Answer 2

वोल्फ्राम लैंग्वेज (मैथमेटिका) , 71 बाइट्स

If[(n=Tr[1^#])<1,{},{i=Last@Ordering@#,n,n-1,i-1}~Join~#0[#~Drop~{i}]]&

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

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

लंबाई की एक सरणी को देखते हुए n, 4nफ्लॉप का एक क्रम आउटपुट करता है जो सरणी को बढ़ते क्रम में क्रमबद्ध करता है: विशेष रूप से, एक दूसरे के बगल में डुप्लिकेट तत्वों को लगाते हैं।

विचार यह है कि किसी सरणी को क्रमबद्ध करने के लिए, हम उसके सबसे बड़े तत्व को अंत तक ले जाते हैं, और फिर n-1सरणी के पहले तत्वों को क्रमबद्ध करते हैं । फ्लॉप ऑपरेशन को लागू करने से बचने के लिए, हम सबसे बड़े तत्व को एक तरह से अंत में स्थानांतरित करते हैं जो अन्य तत्वों को परेशान नहीं करता है:

{3, 2, 1, 5, 3, 3, 2}    starting array, with largest element in position 4
{5, 1, 2, 3, 3, 3, 2}    flop 4 to put the largest element at the beginning
{2, 3, 3, 3, 2, 1, 5}    flop 7 to put the largest element at the end
{1, 2, 3, 3, 3, 2, 5}    flop 6 (7-1) to reverse the effect of flop 7 on other elements
{3, 2, 1, 3, 3, 2, 5}    flop 3 (4-1) to reverse the effect of flop 4 on other elements

सामान्य तौर पर, यदि सबसे बड़ा तत्व स्थिति में है i, तो फ्लॉप का क्रम जो इसे अंत तक ले जाता है i, n, n-1, i-1।

Comments

आप सबसे बड़े तत्व को अंत तक ले जा सकते हैं i, n। फिर क्यों करते हैं n-1, i-1? इसके लिए कोई आवश्यकता नहीं है स्थिर प्रकार ।

— पीटर टेलर

@PeterTaylor मुझे नहीं लगता कि उत्तर वास्तव में फ्लॉप प्रदर्शन करता है, बल्कि, यह हर बार सबसे बड़ा तत्व निकालता है, और फ्लॉप के संदर्भ में उस ऑपरेशन के बराबर आउटपुट देता है।

— नील

Answer 3

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

l=input()
while l:k=l.index(max(l));print-~k,len(l),;l=l[:k:-1]+l[:k]

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

Answer 4

जेली , 19 17 बाइट्स

ỤỤạ‘Ḣ
ỤÇÐƤĖµUż’ṚF

सूची बनाता है।

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

Comments

मुझे लगता है कि modulo के ỤŒ¿’Æ!‘ṚĖµUż’ṚFबाद से रिवर्स तरह Œ¿है L!।

— जोनाथन एलन

जो भी कारण के लिए, कि पिछले परीक्षण मामले के लिए काम नहीं करता है, जिसका अर्थ है कि शायद मेरा कोड कुछ अस्पष्ट किनारे के मामले के लिए भी विफल हो जाएगा ...

— डेनिस

और यह वास्तव में इनपुट के लिए विफल है [4, 3, 2, 1, 3]। ओह।

— डेनिस

ओह, बू; कि एक शर्म की बात है।

— जोनाथन एलन

Ụ>Ṫ$ƤSạỤĖµUż’ṚFसहायक लिंक को बदलकर 2 बाइट्स की बचत।

— मील

Answer 5

साफ , 88 बाइट्स

मुझे लगता है कि गार्ड के साथ संभवतः एक छोटा है, लेकिन मैंने अभी तक इसे नहीं पाया है।

import StdEnv
$[h:t]#(a,b)=span((<>)h)t
=map length[b,t]++ $(b++r a)
$e=e
r=reverse

$o r

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

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

Answer 6

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

(a,f=n=>(a=[...a.slice(0, n).reverse(),...a.slice(n)],n),l=a.length,i=0)=>a.reduce(c=>[...c,f(a.indexOf(Math.max(...a.slice(0, l-i)))+1),f(l-i++)],[])

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

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

a=>{f=n=>(a=[...a.slice(0,n).reverse(),...a.slice(n)],n),r=[];for(i=a.length+1;--i>0;)r.push(f(a.indexOf(Math.max(...a.slice(0, i)))+1),f(i));return r}

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

दोनों मूल रूप से शुरुआत के लिए अधिकतम संख्या को फ़्लिप करके सरणी को सॉर्ट करते हैं और फिर इसे शेष सरणी के साथ दोहराते हुए, पीछे की ओर फ़्लिप करते हैं। पहला उपयोग कम करता है, दूसरा एक लूप के लिए उपयोग करता है।

Ungolfed:

array => {
  let flop = n => {
    array = [...array.slice(0, n).reverse(), ...array.slice(n)]; 
    return n;
  }
  let flops = [];
  for (let i = array.length + 1; --i > 0;) 
  {
    let maxIndex = array.indexOf(Math.max(...array.slice(0, i)));
    flops.push(flop(maxIndex + 1), flop(i));
  }
  return flops;
}

Answer 7

पर्ल 5.10 (या अधिक), 66 बाइट्स

5.10 भाषा को स्तर पर लाने के +3लिए -n The use 5.10.0को शामिल किया गया है

#!/usr/bin/perl -n
use 5.10.0;
$'>=$&or$.=s/(\S+) \G(\S+)/$2 $1/*say"$. 2 $."while$.++,/\S+ /g

STDIN पर एक लाइन के रूप में इनपुट के साथ चलाएँ:

flop.pl <<< "1 8 3 -5 6"

सूची को बार-बार किसी भी व्युत्क्रम को खोजकर, सामने वाले को फ्लॉप कर देता है, फिर उलटा फ्लॉप कर देता है और सब कुछ वापस अपनी पुरानी स्थिति में ला देता है।

यह आश्चर्यजनक रूप से इस एक पर एक ही बॉलपार्क में अजगर के रूप में प्राप्त करना मुश्किल था :-)

Answer 8

सी (जीसीसी) , 165 160 बाइट्स

• पांच बाइट बचाने के लिए सीलिंग के लिए धन्यवाद ।

m,j,t;f(A,l)int*A;{for(j=0;j+j<l;A[j]=A[l+~j],A[l+~j++]=t)t=A[j];}F(A,l)int*A;{for(;l;f(A,++m),printf("%d,%d,",m,l),f(A,l--))for(j=m=0;j<l;j++)m=A[j]>A[m]?j:m;}

• इसे ऑनलाइन आज़माएं!
• सत्यापन

Comments

@ceilingcat धन्यवाद।

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