19

संख्या के साथ एक सूची को देखते हुए, इस तरह से श्रेणियों का उत्पादन करें:

इनपुट: [0, 5, 0]बन जाएगा [0, 1, 2, 3, 4, 5, 4, 3, 2, 1, 0]।

यह सरणी के माध्यम से एक रेंज मैप कर रहा है, इसलिए हमें सबसे पहले रेंज बनानी होगी [0, 5], जो है [0, 1, 2, 3, 4, 5]। उसके बाद, हम 5रेंज बनाने के लिए उपयोग करते हैं [5, 0]। हमारी पिछली रेंज में लागू, यह हमें देता है:

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

चलो एक दूसरे के बगल में दो समान अंकों के साथ एक परीक्षण मामले का निरीक्षण करते हैं:

[3, 5, 5, 3], ranges:

[3, 5] = 3, 4, 5
[5, 5] = 5 (actually [5, 5] due to overlapping)
[5, 3] = 5, 4, 3

तो यह हमें देगा [3, 4, 5, 5, 4, 3]।

कुछ अन्य परीक्षण मामले:

[1, 9] > [1, 2, 3, 4, 5, 6, 7, 8, 9]
[10, -10] > [10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0, -1, -2, -3, -4, -5, -6, -7, -8, -9, -10]
[3, 0, 0, -3] > [3, 2, 1, 0, 0, -1, -2, -3]
[1, 3, 5, 7, 5, 3, 1, -1, -3] > [1, 2, 3, 4, 5, 6, 7, 6, 5, 4, 3, 2, 1, 0, -1, -2, -3]

इनपुट में हमेशा कम से कम 2 पूर्णांक होंगे।

सबसे छोटा जवाब जीत!

code-golf array-manipulation

— Lamaro
स्रोत

3

सम्बंधित। सम्बंधित।

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

1

इनपुट और आउटपुट किस तरह से संबंधित हैं? वैध इनपुट क्या है?

— दोष

21

05AB1E, 1 बाइट

Ÿ

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

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

यह बिल्ट-इन है।

— डेनिस
स्रोत

18

क्या आपके सिर में सभी एसोलंगों में बिल्ट-इन का एक शब्दकोश है, या क्या है? ;)

— ETHproductions

2

ठीक है, ओसाबी का उपयोग करने के लिए धन्यवाद: पी

— अदनान

7

इसके लिए इसमें बिल्ट-इन भी क्यों है?

— नील

सामान रखने वाले सभी 0byte और 1byte (शायद 2byte) कार्यक्रमों का एक संकलन होना चाहिए।

— कैलक्यूलेटरफलाइन

2

@ नील यह मूल रूप से एक समावेशी रेंज फ़ंक्शन है, यह वास्तव में उतना शानदार नहीं है।

— अदनान

5

जावास्क्रिप्ट, 99 95 93 बाइट्स

4 6 बाइट्स थैंक्स @Neil ।

a=>a.reduce((x,y)=>x.concat(b.map?b=y:[...Array(y<b?b-y:y-b||1)].map(_=>b+=y<b?-1:y>b)),b=[])

f=
a=>a.reduce(
    (x,y)=>
        x.concat(
            b.map?b=y
            :[...Array(y<b?b-y:y-b||1)]
                .map(_=>b+=y<b?-1:y>b)
        )
    ,b=[])


G.addEventListener('click',_=>O.innerHTML=f(JSON.parse(I.value)));

<input id=I value="[3,5,5,3]"><button id=G>Go</button><pre id=O>

स्निपेट का विस्तार करें

— हटा दिया
स्रोत

1

उपयोग करके 3 बाइट्स बचाएं y<b?b-y:y-b||1। उपयोग करके एक और बाइट बचाएं y>b||y-b&&-1।

— नील

@Neil। अच्छे!! धन्यवाद :)

— हटा दिया

1

वास्तव y<b?-1:y>bमें अभी भी बेहतर है।

— नील

5

जावास्क्रिप्ट (स्पाइडरमैन 30+), 81 76 बाइट्स

([n,...a])=>[n,...[for(i of a)for(j of Array(i<n?n-i:i-n||1))n+=i<n?-1:i>n]]

फ़ायरफ़ॉक्स 44 में परीक्षण किया गया। ES6 के भयानक तर्क विनाशकारी क्षमताओं और ES7 की सरणी समझ का उपयोग करता है (जो दुख की बात है ES7 कल्पना से हटा दिया गया है)।

— ETHproductions
स्रोत

पर काम नहीं करता है [3, 0, 0, -3]। मैंने रेंजएयर को ठीक किया और 10 बाइट्स बचाए लेकिन यह अभी भी काम नहीं करता है:([n,...a],z=[n])=>z.concat([for(i of a)for(j of[...Array((r=n<i)?i-n-1:n-i-1),0])i=r?++n:--n])

— नील

क्षमा करें, मेरा मतलब था ([n,...a])=>[n].concat([for(i of a)for(j of[...Array((r=n<i)?i-n:n-i)])i=r?++n:--n])।

— नील

@Neil फिक्स्ड, एक गुच्छा अधिक प्रक्रिया में बंद है

— ETHproductions

4

जावास्क्रिप्ट (ईएस 6) 66 72

एक पुनरावर्ती फ़ंक्शन जो बार-बार संख्याओं के बीच अंतराल को भरने के लिए सरणी के अंदर मूल्यों को जोड़ता है

f=l=>l.some((x,i)=>(z=l[i-1]-x)*z>1&&l.splice(i,0,x+z/2|0))?f(l):l

परीक्षा

f=l=>l.some((x,i)=>(z=l[i-1]-x)*z>1&&l.splice(i,0,x+z/2|0))?f(l):l

console.log=x=>O.textContent+=x+'\n'

;[[1,9],[10,-10],[3,0,0,-3],[1, 3, 5, 7, 5, 3, 1, -1, -3]]
.forEach(t=>console.log(t+' -> ' +f(t)))

<pre id=O></pre>

स्निपेट का विस्तार करें

— edc65
स्रोत

3

सी, 120 + 12 = 132 बाइट्स

i,j,k;f(a,n)int*a;{a[0]--;for(i=0;i<n-1;i++)for(k=0,j=a[i]-a[i+1]?a[i]:a[i]-1;j-a[i+1];)printf("%i ",j+=a[i+1]>j?1:-1);}

उदाहरण कॉल:

f(a,sizeof(a)/4);        // I've added 12 bytes because of ",sizeof(a)/4"

आइडोन पर टेस्ट लाइव ।

— हटा दिया
स्रोत

3

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

lambda n:n[0:1]+sum([range(x,y,2*(y>x)-1)[1:]+[y]for(x,y)in zip(n,n[1:])],[])

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

नील, डेन्करएफ़े, और एरवान के लिए धन्यवाद जो मैंने याद किए सुधारों को इंगित करने के लिए

— मै जाऊं
स्रोत

निश्चित रूप +1से अनावश्यक है?

— नील

क्यों नहीं साथ जाना है lambda n:n[0:1]+sum([range(x,y,[1,-1][y+1<x])[1:]+[y]for(x,y)in zip(n,n[1:])],[])? कुछ बाइट्स बचाता है।

— डेनकर

इसे लिखते समय मैं बहुत थक गया था :) पहले जवाब दें, बाद में सुधार करें।

— मेगो

मुझे लगता है कि आप की जगह ले सकता [1,-1][y+1<x]से 2*(y>x)-1(भी मैं क्यों आप का उपयोग समझ में नहीं आता y<=x बस और नहीं y<x)

— एर्वान

n[0:1]के बराबर है n[:1]।

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

3

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

+3 के लिए -p(कोड में $'इतना स्थान होता है और -गिनती भी शामिल है)

STDIN पर संख्याओं की सूची दें:

fluctuating.pl <<< "3 5 5 3"

fluctuating.pl:

#!/usr/bin/perl -p
($n=$&+($'<=>$&))-$'&&s/\G/$n / while/\S+ /g

अस्थायी चर और इन सभी कोष्ठक suboptimal लगता है ...

— टन हास्पेल
स्रोत

ऐसा लगता है कि आपने गलत उत्तर पोस्ट किया है: यह काम नहीं कर रहा है और $' आपने जो उल्लेख किया है वह कोड में नहीं है ...

— दादा

@ दादा: हाँ, फिर से तय के बजाय कोड का एक पुराना अप्रयुक्त संस्करण चिपकाया गया। धन्यवाद और तय

— टोन हास्पेल

2

हास्केल, 63 55 बाइट्स

g(a:b:r)=[a|a==b]++[a..b-1]++[a,a-1..b+1]++g(b:r)
g x=x

प्रयोग उदाहरण: g [3,5,5,3]-> [3,4,5,5,4,3]।

यह एक संबंधित चुनौती के लिए मेरे जवाब का एक संशोधन है । फिर, मुख्य कार्य सूची को ऊपर से नीचे और नीचे से (जहां एक सूची खाली होगी) और पुनरावर्ती कॉल करने के लिए किया जाता है। उस मामले को संभालने के लिए जहां दोनों सूचियां खाली हैं, हम प्रस्तुत करते हैं जो मूल्यांकन करता है कि क्या और अन्यथा।ab-1ab+1a==b[a|a==b][a]a==b[]

— nimi
स्रोत

2

आर, 86 82 75 बाइट्स

function(x)rep((y<-rle(unlist(Map(seq,head(x,-1),x[-1]))))$v,pmax(1,y$l-1))

रेप न करने का उपयोग करके 4 बाइट्स को बचाया गया। पिन (कोड गोल्फ प्रदर्शन नहीं!) 1 आंशिक रूप से निर्मित मिलान का उपयोग करके एक और 7 बाइट्स का उपयोग करते हुए बचाया $(और 1 पंक्ति में फ़ंक्शन परिभाषा को ध्वस्त कर रहा है।

— mnel
स्रोत

मुझे लगता है कि (y=...)इसके बजाय (y<-...)भी मान्य है, और एक बाइट कम है।

— ग्यूसेप

2

रूबी, 116 82 बाइट्स

->n{o,*m=n;o=[o];m.zip(n).map{|t,u|o+=[[u],[*u+1..t],[*t..u-1].reverse][t<=>u]};o}

मेरा पहला गोल्फ।

संपादित करें: बहुत बढ़िया सुझाव के लिए धन्यवाद।

— emagdne
स्रोत

चर को निर्दिष्ट करने की आवश्यकता नहीं है, अनाम खरीद पर्याप्त है; औपचारिक पैरामीटर के आसपास कोष्ठक लगाने की कोई आवश्यकता नहीं है; सरणी का पहला तत्व बाहर निकालना समानांतर असाइनमेंट और स्पैट से छोटा है; mapकोड ब्लॉक को कई मापदंडों के रूप में लिया जा सकता है ->n{o,*m=n;o=[o];m.zip(n).map{|t,u|o+=u==t ?[u]:(u<t ?[*u+1..t]:[*t..u-1].reverse)};o}:। अन्यथा अच्छा पहला गोल्फ।

— मैनावर्क

स्पेसशिप ऑपरेटर द्वारा 3 एलिमेंट एरे से पिक करना 2 टर्नरी ऑपरेटरों से कम है [[u],[*u+1..t],[*t..u-1].reverse][t<=>u]:।

— मैनावर्क

2

जाप , 12 बाइट्स

सहेजे गए 16 बाइट्स @ETHproductions की बदौलत !

ä!õ ËsE©DÊ>1

इसे ऑनलाइन टेस्ट करें

— ओलिवर
स्रोत

1

पर्ल 6, 94 बाइट्स

मैं अभी इस बात से सुपर खुश नहीं हूँ, मैं शायद बाद में एक और शॉट लूंगा

{reduce {|@^a[0..*-2],|@^b},map {@_[0]!= @_[1]??(@_[0]...@_[1])!!(@_[0],@_[1])},.rotor(2=>-1)}

— हॉटकी
स्रोत

1

PHP 5.4, 86 बाइट्स

यह एक सम्मिलित फ़ाइल के रूप में उपयोग करने के लिए है, जो परिणाम देता है।

मान को कमांडलाइन पैरामीटर के रूप में पारित किया जाता है।

<?for($i=1;$i<$argc-1;$R=array_merge($R?:[],range($argv[$i++],$argv[$i++])));return$R;

बिल्कुल सुंदर या कुछ भी नहीं, लेकिन काम करता है।

— इस्माइल मिगुएल
स्रोत

1

पायथन 3 , 76 बाइट्स

पायथन जवाब में पहला प्रयास। मूल विचार अनुक्रम में जोड़े की बार-बार पहचान करना है जहां अंतर एक कदम से बड़ा है और सही दिशा में अनुक्रम को पूरा करने के लिए एक (और केवल एक) अतिरिक्त तत्व सम्मिलित करता है। तब तक दोहराएं जब तक कि लगातार तत्वों के बीच का अंतर +1 और -1 के बीच न हो।

d=diff
while any(d(x)**2>1):i=argmax(d(x)**2);x[:i+1]+=[x[i]+sign(d(x)[i])]

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

— NofP
स्रोत

0

लूआ, 156 बाइट्स

एक फ़ंक्शन जो पैरामीटर में एक सरणी लेता है और विस्तारित सरणी वापस करता है।

function f(t)r={}for i=2,#t
do x,y=t[i-1],t[i]r[#r+1]=x==y and x or nil
z=x>y and-1or 1
x=x==r[#r]and x+z or x
for j=x,y,z
do r[#r+1]=j end end
return r end

अपुष्ट और स्पष्टीकरण

function f(t)
  r={}                        -- Initialise an empty array
  for i=2,#t                  -- Iterate over the parameter array
  do
    x,y=t[i-1],t[i]           -- x and y are shorter names than t[i-1]
    r[#r+1]=                  -- when there's a range like [5,5]
      x==y and x or nil       -- put this number once in the array
    z=x>y and-1or 1         -- determine the step value
    x= x==r[#r]               -- prevent repeating the last value of r
          and x+z or x        -- by incrementing/decrementing x
    for j=x,y,z               -- iterate from t[i-1] to t[i] by step z (-1 or 1)
    do
      r[#r+1]=j               -- put j into the array r
    end
  end
  return r                    -- return the extended array
end

उपयोग में आसानी के लिए, आप निम्न फ़ंक्शन का उपयोग करके दिए गए सरणी को प्रिंट कर सकते हैं f()।

function printArray(t)
  print("["..table.concat(t,",").."]")
end

इस सबमिशन का परीक्षण करते समय, आप इसे कॉल कर सकते हैं:

printArray(f( {0,5,0,3,4,4,7,3,-3} ))
> [0,1,2,3,4,5,4,3,2,1,0,1,2,3,4,4,5,6,7,6,5,4,3,2,1,0,-1,-2,-3]

— Katenkyo
स्रोत

0

मथकड, 62 "बाइट्स"

जैसा कि Mathcad एक 2D "व्हाइटबोर्ड" और विशेष ऑपरेटर (जैसे, समन ऑपरेटर, इंटीग्रल ऑपरेटर) का उपयोग करता है, और XML प्रारूप में बचाता है, एक वास्तविक वर्कशीट में कई सौ (या अधिक) वर्ण हो सकते हैं। कोड गोल्फ के प्रयोजनों के लिए, मैंने उन पात्रों या ऑपरेटरों की संख्या होने के लिए एक मैथेकड "बाइट काउंट" लिया है जिसे उपयोगकर्ता को वर्कशीट बनाने के लिए दर्ज करना होगा।

फ़ंक्शन की परिभाषा को सीधे प्रोग्राम में परिवर्तित करना, और एक एकल वर्ण नाम के साथ वैरिएबल लेस्ट की जगह, कुल 62 "बाइट्स" देता है। फ़ंक्शन के साथ, पूर्ण नाम के बजाय किसी एकल वर्ण का उपयोग करते हुए, यह परिभाषा के लिए 65 "बाइट्स" तक बढ़ जाता है और प्रत्येक कॉल के लिए एक और 4 "बाइट्स" होता है (यह मानते हुए कि सूची का निर्माण स्वयं समग्र बाइट में शामिल नहीं है गिनती (Mathcad की अंतर्निहित तालिकाओं का उपयोग करके सूची को इनपुट करने का एक और तरीका है)।

— स्टुअर्ट ब्रुफ़
स्रोत

0

PHP, 144 बाइट्स

function f($r){$m=[];for($i=0;++$i<count($r);){$d=array_pop($m);$n=$r[$i];$p=$r[$i-1];$m=array_merge($m,$p==$n?[$p,$n]:range($p,$n));}return$m;}

एक्स्प्लोडेड वीयू

function f($r) {
  $m = [];
  for ($i=0; ++$i < count($r); ) {
    $d = array_pop($m);
    $n = $r[$i];
    $p = $r[$i-1];
    $m = array_merge($m, $p==$n ? [$p,$n]
                                : range($p,$n));
  }
  return $m;
}

इनपुट / फ़ंक्शन कॉल

f([ bound1, bound2, bound3, ... ]);

उत्पादन

[int, int, int, int, ...]

यह गन्दा और चंकी है, और मैं इसे बाद में अनुकूलित करने का प्रयास करूँगा। यह range()आसन्न मूल्य जोड़े की प्रत्येक जोड़ी से बनाता है , फिर उन्हें एक साथ सिलाई करता है ( popपिछले संचयी के अंत के बाद Array)।

— ricdesi
स्रोत

0

पर्ल 6, 21

.join $ _ के लिए छोटा है

say EVAL .join: "..."

परीक्षण (रकुडो)

perl6 -MMONKEY-SEE-NO-EVAL -e'say EVAL @*ARGS.join: "..."' 1 3 5 7 5 3 1 -1 -3

उत्पादन

(1 2 3 4 5 6 7 6 5 4 3 2 1 0 -1 -2 -3)

— Demayl
स्रोत

0

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

,r⁼?2\Ṗ;¥/

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

— आउटग्रॉफर को एरिक करें
स्रोत

-1

आर , 74 बाइट्स

एक और आर समाधान

function(x){b=x[1];z=c();for(a in x[-1]){z=c(z,c(b:(a-sign(a-b))));b=a};z}

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

— NofP
स्रोत

यह काफी काम नहीं करता क्योंकि अंतिम मूल्य गायब लगता है ...

— Giuseppe

उतार-चढ़ाव वाली पर्वतमाला

05AB1E, 1 बाइट

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

जावास्क्रिप्ट, 99 95 93 बाइट्स

जावास्क्रिप्ट (स्पाइडरमैन 30+), 81 76 बाइट्स

जावास्क्रिप्ट (ईएस 6) 66 72

सी, 120 + 12 = 132 बाइट्स

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

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

हास्केल, 63 55 बाइट्स

आर, 86 82 75 बाइट्स

रूबी, 116 82 बाइट्स

जाप , 12 बाइट्स

पर्ल 6, 94 बाइट्स

PHP 5.4, 86 बाइट्स

पायथन 3 , 76 बाइट्स

लूआ, 156 बाइट्स

अपुष्ट और स्पष्टीकरण

मथकड, 62 "बाइट्स"

PHP, 144 बाइट्स

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

आर , 74 बाइट्स