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

इनपुट

अद्वितीय, सकारात्मक पूर्णांकों की एक अनसुलझी सूची
- जैसे 9 13 3 11 8 4 10 15
इनपुट निम्नलिखित में से किसी एक से लिया जा सकता है:
- stdin
- कमांड-लाइन तर्क
- समारोह तर्क

आउटपुट

एक पंक्ति या आपकी भाषा के निकटतम समान आउटपुट के लिए एक पंक्ति में छपी श्रेणियों या अलग-अलग मूल्यों की एक आदेशित सूची।
- यदि दो या अधिक अनुक्रमिक पूर्णांकों (अनुक्रमिक मान द्वारा, सूची में स्थान के अनुसार नहीं) मौजूद हैं, तो उन्हें एक समावेशी सीमा के रूप में दर्शाया जाएगा - जैसे, 8-11
- अन्य सभी पूर्णांक बस किसी अन्य संकेतन के साथ मुद्रित होते हैं
- एक एकल स्थान आउटपुट का परिसीमन करेगा
इनपुट में मौजूद नंबर आउटपुट में नहीं होना चाहिए, उदाहरण के 3 5 6लिए छोटा नहीं किया जा सकता 3-6क्योंकि 4मौजूद नहीं है

उदाहरण

सफल:

 IN> 9 13 3 11 8 4 10 15 6
OUT> 3-4 6 8-11 13 15

 IN> 11 10 6 9 13 8 3 4 15
OUT> 3-4 6 8-11 13 15

 IN> 5 8 3 2 6 4 7 1
OUT> 1-8

 IN> 5 3 7 1 9
OUT> 1 3 5 7 9

गलत:

 IN> 9 13 3 11 8 4 10 15
OUT> 3-15

रेंज में इनपुट में मूल्य नहीं हैं

 IN> 9 13 3 11 8 4 10 15
OUT> 3 4 8 9 10 11 13 15

सभी अनुक्रमिक मूल्यों को एक सीमा के रूप में दर्शाया जाना चाहिए

 IN> 9 13 3 11 8 4 10 15
OUT> 3-4 8-9 10-11 13 15

विभाजित सीमा, 8-9और 10-11होनी चाहिए8-11

 IN> 9 13 3 11 8 4 10 15
OUT> 8-9 13 10-11 3-4 15

आउटपुट सही तरीके से ऑर्डर नहीं किया गया

नियम

मानक खामियों को अस्वीकार कर दिया जाता है
यदि आपकी भाषा में ऐसा करने का कोई कार्य है तो इसकी अनुमति नहीं है
आप एक पूर्ण कार्यक्रम, या एक फ़ंक्शन लिख सकते हैं
व्हाट्सएप को ट्रेस करने से कोई फर्क नहीं पड़ता

स्कोरिंग

कम से कम बाइट्स जीतता है

code-golf

— कोरी ओगबर्न
स्रोत

1

पहला वाक्य वास्तव में भ्रामक है। मैं यह कहना चाहूंगा कि "अनुक्रमिक पूर्णांकों की सबसे लंबी संभव सीमाओं की सबसे छोटी सूची आउटपुट"। अन्यथा, अच्छी चुनौती!

— नाथन मेरिल

2

मुझे पूरा यकीन है कि हमारे सामने यह चुनौती है, लेकिन मैं सही खोज शब्दों के साथ नहीं आ रहा हूं। किसी को याद है?

— xnor

4

@CoreyOgburn वैसे, किसने आपको PPCG पर पोस्ट करने के लिए प्रेरित किया? हम यह पता लगाने की कोशिश कर रहे हैं कि हमें नए उपयोगकर्ताओं का एक पूरा समूह क्यों मिला है।

— xnor

2

@xnor मैंने महीनों तक साइट पर नज़र रखी है। मैं जिन भाषाओं का उपयोग करता हूं उनमें से कोई भी आम तौर पर जवाब के लिए अच्छे उम्मीदवार हैं और मुझे आज तक पोस्ट करने का सवाल नहीं है।

— कोरी ओगबर्न

1

@xnor: यह माल्टीसेन के होमवर्क सूची के समान है लेकिन समान नहीं है।

— एलेक्स ए।

9

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

N=sorted(map(int,raw_input().split(' ')));print(''.join((''if n+1in N else'-'+`n`)if n-1in N else' '+`n`for n in N)[1:])

यदि इनपुट एक फ़ंक्शन तर्क के रूप में एक सूची हो सकती है (धन्यवाद mbomb007 और सशर्त के लिए xnor)

93 90 81 बाइट्स

def f(N):print''.join((' '+`n`,`-n`*-~-(n+1in N))[n-1in N]for n in sorted(N))[1:]

(77 बाइट्स यदि प्रमुख व्हाट्सएप स्वीकार्य है - अंतिम ड्रॉप करें [1:])

— रूथ फ्रैंकलिन
स्रोत

आप कुछ बाइट्स को बचाने के str(n)लिए बदल सकते हैं `n`, अगर आप पायथन 2 में स्विच करते हैं

— mbomb007

तुम भी एक समारोह है कि उपयोग करने के बजाय इनपुट के रूप में एक सूची लेता है बना सकते हैं raw_input(), और आप बदल सकते हैं '-'+`n`करने के लिए `-n`। और जब से आप अब पायथन 2 का उपयोग कर रहे हैं, आप कोष्ठक को हटा सकते हैं print।

— mbomb007

टुकड़ा द्वारा स्ट्रिंग टुकड़ा उत्पन्न करना चतुर है। बाइट की बचत के लिए, यह आमतौर पर सूची चयन या अंकगणित द्वारा सशर्त करने के लिए कम है, जैसे def f(N):print''.join([' '+`n`,`-n`*(n+1 not in N)][n-1 in N]for n in sorted(N))[1:](जिसे आगे बढ़ाया जा सकता है)।

— xnor

आप set(N)इसके बजाय उपयोग करने में सक्षम हो सकते हैं sorted(N); यह सही ढंग से cPython का उपयोग करते समय सबसे छोटे से सबसे कम चलना होगा, लेकिन सभी कार्यान्वयन के लिए काम करने की गारंटी नहीं है, इसलिए यह वैध है या नहीं, इसके बारे में कुछ सवाल है।

— केसाब

6

जावास्क्रिप्ट (ईएस 6): 171 154 140 137 बाइट्स

सुझावों के लिए धन्यवाद edc65 और vihan1086! ~~[...n]बहुत अच्छा है,~~ लेकिन यह इन मामलों में बहु अंकों की संख्या के कारण काम नहीं करता है।

f=n=>{s=e=o='';n.split` `.map(Number).sort((a,b)=>a-b).map(v=>{s=s||v;if(e&&v>e+1){o+=`${s<e?s+'-'+e:s} `;s=v}e=v});return o+(s<e?s+'-'+e:e)}

ईएस 5 संस्करण, 198 184 183 174 बाइट्स

f=function(n){s=e=o='';n.split(' ').map(Number).sort(function(a,b){return a-b}).map(function(v){s=s||v;if(e&&v>e+1){o+=(s<e?s+'-'+e:s)+' ';s=v}e=v});return o+(s<e?s+'-'+e:e)}

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

f = function (n) {
    s = e = 0, o = '';
    n.split(' ').map(Number).sort(function (a, b) {
        return a - b
    }).map(function (v) {
        s = s || v;
        if (e && v > e + 1) {
            o += (s < e ? s + '-' + e : s) + ' ';
            s = v
        }
        e = v
    });
    return o + (s < e ? s + '-' + e : e)
}

// Demonstration
document.body.innerHTML = f('1 2');
document.body.innerHTML += '<p>' + f('9 13 3 11 8 4 10 15 6');
document.body.innerHTML += '<p>' + f('11 10 6 9 13 8 3 4 15');
document.body.innerHTML += '<p>' + f('5 8 3 2 6 4 7 1');
document.body.innerHTML += '<p>' + f('5 3 7 1 9');

Expand snippet

— rink.attendant.6
स्रोत

कोई कोष्ठक के साथ n.plplit मेरे लिए पूरी तरह से नया है! लेकिन [...n]बेहतर है

— edc65

@ edc65 धन्यवाद, इस तरह स्ट्रिंग को खोलना कभी नहीं सोचा था।

— २०

इस codegolf.stackexchange.com/questions/37624/…

— edc65

... लेकिन ... क्या यह किसी भी उदाहरण के साथ काम करता है? मल्टीडिजिट संख्याएं हैं, इसलिए आपको "" (रिक्त स्थान) पर विभाजन नहीं चाहिए "" (रिक्त स्ट्रिंग)। मैंने शायद आपको गलत टिप दी

— edc65

@ edc65 मुझे लगा कि कुछ अलग दिख रहा है, तब मुझे एहसास हुआ कि परीक्षण के मामले विफल रहे। फिर भी कुछ नया सीखना अच्छा है

— rink.attenders.6

4

रूबी, 86 84 बाइट्स

s=->*a{puts a.sort.slice_when{|i,j|i+1!=j}.map{|e|e.size<2?e:[e[0],e[-1]]*"-"}*" "}

# demo
s[9, 13, 3, 11, 8, 4, 10, 15, 6]
# => 3-4 6 8-11 13 15

इस के लिए डॉक्स में एक उदाहरण से एक से थोड़ा golfed संस्करण है slice_when ।

— steenslag
स्रोत

4

सीजेएम, 35 बाइट्स

l~${__0=f-ee::=0+0#/((oW>Wf*S+oe_}h

CJam दुभाषिया में इसे ऑनलाइन आज़माएं ।

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

l~$     e# Read a line from STDIN, evaluate it and sort the result.
{       e# Do:
  _     e#   Push a copy of the array.
  _0=f- e#   Subtract the first element from all array elements.
  ee    e#   Enumerate the differences: [0 1 4] -> [[0 0] [1 1] [2 4]]
  ::=   e#   Vectorized quality: [i j] -> (i == j)
  0+    e#   Append a zero.
  0#    e#   Push the first index of 0.
  /     e#   Split the array into chunks of that size.
  (     e#   Shift out the first chunk.
  (o    e#   Print its first element.
  W>    e#   Discard all remaining elements (if any) except the last.
  Wf*   e#   Multiply all elements of the remainder by -1.
  S+o   e#   Append a space and print.
  e_    e#   Flatten the rest of the array.
}h      e# Repeat while the array is non-empty.

— डेनिस
स्रोत

4

रूबी, 70 बाइट्स

इस तरह की समस्याएं मुझे उपयुक्त तरीकों के लिए रूबी एपीआई की जांच करने के लिए प्रेरित करती हैं, और आज मैंने एक नई खोज की: और Array#slice_when, रूबी v2.2 में नई शुरुआत की और इस सटीक स्थिति के लिए उपयुक्त प्रतीत होता है :)

f=->a{puts a.sort.slice_when{|i,j|j-i>1}.map{|x|x.minmax.uniq*?-}*' '}

सरणी को छांटने और उचित रूप से रखने के बाद, यह प्रत्येक उप-सरणी लेता है और उच्चतम और निम्नतम तत्व से एक स्ट्रिंग बनाता है, और फिर इस पूरे सरणी को एक स्ट्रिंग में जोड़ता है।

उदाहरण:

f.call [9,13,3,11,8,4,10,15,6] प्रिंट 3-4 6 8-11 13 15

— daniero
स्रोत

4

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

b(Z,C,[D|E]):-Z=[A|B],(A=:=D+1,(B=[],put(45),print(A);b(B,C,[A,D|E]));(E=[],tab(1),print(A);writef('-%t %t',[D,A])),b(B,A,[A]));!.
a(A):-sort(A,B),b(B,_,[-1]).

बहुत बुरा है लेकिन फिर प्रोलॉग एक भयानक गोल्फ भाषा है

उदाहरण: a([9,13,3,11,8,4,10,15,6]).आउटपुट3-4 6 8-11 13 15

— Fatalize
स्रोत

3

CJam, 38 33 बाइट्स

@Dennis द्वारा सुझाए गए विचारों और कोड अंशों का उपयोग करते हुए नया संस्करण:

l~$_,,.-e`{~T+\_T+:T;(_2$+W*Q?S}/

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

इनपुट प्रारूप वर्ग कोष्ठक में CJam सरणी है।

यहां मूल विचार यह है कि मैं पहले सॉर्ट किए गए इनपुट अनुक्रम से एक मोनोटोनिक अनुक्रम घटाता हूं:

3  4  8  9 10 11 13 15
0  1  2  3  4  5  6  7  (-)
----------------------
3  3  6  6  6  6  7  8

इस अंतर में, समान अंतराल के भाग वाले मानों का मान समान होता है। CJam RLE ऑपरेटर को इस अंतर पर लागू करना सीधे अंतराल की गणना करता है।

घटाए गए अनुक्रमिक मानों को आउटपुट के दौरान वापस जोड़ने की आवश्यकता होती है। मैं पूरी तरह से खुश नहीं हूं कि मेरे कोड में यह कैसे किया गया है। मुझे संदेह है कि मैं कुछ बाइट्स को सौंपने के अधिक सुरुचिपूर्ण तरीके से बचा सकता हूं।

अंतराल के उत्पादन को उत्पन्न करने के लिए, यह डेनिस के अंतिम मूल्य के लिए एक नकारात्मक संख्या उत्पन्न करने के विचार का उपयोग करता है, जो उत्पादन का ख्याल रखता है - , और तर्क को भी सरल करता है क्योंकि अंतराल के आकार के आधार पर केवल एक मूल्य को जोड़ने / छोड़े जाने की आवश्यकता होती है ।

स्पष्टीकरण:

l~    Get input.
$     Sort it.
_,,   Create monotonic sequence of same length.
.-    Calculate vector difference between the two.
e`    Calculate RLE of difference vector.
{     Loop over entries in RLE.
  ~     Unpack the RLE entry, now have length/value on stack.
  T+    Add position to get original value for start of interval.
  \     Bring length of interval to top of stack.
  _T+:T;  Add length of interval to variable T, which tracks position.
  (     Decrement interval length.
  _     Copy it, we need it once for calculating end value, once for ternary if condition.
  2$    Copy interval start value to top...
  +     ... and add interval length - 1 to get end value.
  W*    Negate end value.
  Q?    Output end value if interval length was > 1, empty string otherwise.
  S     Add a space.
}%    End loop.

— रेटो कोराडी
स्रोत

कि RLE का एक चतुर उपयोग है! मेरे जवाब से रेंज हैंडलिंग और इनपुट प्रारूप को उधार लेकर, आप 34 बाइट्स तक प्राप्त कर सकते हैं:l~$_,,.-e`{~T+\_T+:T;,f+(\W>Wf*S}/

— डेनिस

जब मैंने मूल रूप से आपके समाधान को देखा था, तो मैं एक तरह से हैरान था कि आपको -कोड में दिखाए बिना आउटपुट में कैसे मिला , और बिना किसी शर्त के। अब मैं इसे प्राप्त करता हूं: यह अंतिम मूल्य को नकारात्मक संख्या में बदलने से आता है! मैं कभी इसके साथ नहीं आया, इसलिए मुझे इसे कॉपी करने के बारे में बुरा लगेगा। मैं अगली बार इससे सीखने की कोशिश करूँगा! :)

— रेटो कोरदी

काफी उचित। कैसे के बारे में l~$_,,.-e{~ T + _T +: T? (_ 2 $ + W * Q? S} / `हालांकि? यह अपने कोड के समान बहुत अधिक है और केवल 33 बाइट्स का वजन है।

— डेनिस

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

— रेटो कोराडी

2

कॉफीस्क्रिप्ट, 178 161 बाइट्स

मेरे जावास्क्रिप्ट जवाब की तरह। मुझे यह पता लगाने की आवश्यकता है कि क्या समझ का उपयोग करने से परिणाम कम हो जाएंगे।

f=(n)->s=e=o='';n.split(' ').map(Number).sort((a,b)->a-b).map((v)->s=s||v;(o+=s+(if s<e then'-'+e else'')+' ';s=v)if(e&&v>e+1);e=v);o+(if s<e then s+'-'else'')+e

मूल:

f=(n)->o='';s=e=0;n.split(' ').map(Number).sort((a,b)->a-b).forEach((v,i)->if!i then s=v else(o+=s+(if s<e then'-'+e else'')+' ';s=v)if(v!=e+1);e=v);o+(if s<e then s+'-'else'')+e

— rink.attendant.6
स्रोत

1

पायथन 2, 126 122 121 बाइट्स

मुझे पता है कि यह छोटा हो सकता है, बस यह नहीं पता कि कहां .. फॉर्म में इनपुट की आवश्यकता है [#, #, #, #, ..., #]।

l=sorted(input());s=`l[0]`;c=0;x=1
while x<len(l):y,z=l[x],l[x-1];s+=(('-'+`z`)*c+' '+`y`)*(y-z>1);c=(y-z<2);x+=1
print s

— Kade
स्रोत

आप execअक्सर साथ समाधान खोजने लगते हैं ।

— mbomb007

@ mbomb007 आप xnor के बारे में सोच रहे होंगे :) और मुझे लगता है कि इस स्थिति में लूपिंग समान लंबाई हो सकती है, यहां तक कि छोटी भी (इसके साथ अभी तक पर्याप्त रूप से नहीं खेला है)।

— काडे

1

आप को बदलने के लिए सक्षम होना चाहिए while x<len(l)के साथ while l[x:]कुछ बाइट्स बचाने के लिए।

— मैथमंडन

1

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

void f(int[]a){java.util.Arrays.sort(a);for(int b=a.length,c=b-1,i=0,j=a[0],l=j;++i<b;){if(a[i]!=++j||i==c){System.out.print((l+1==j?l+(i==c?" "+a[c]:""):l+"-"+(i==c?j:j-1))+" ");l=j=a[i];}}}

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

— टीएनटी
स्रोत

1

जावा, 171 162 बाइट्स

String s(int[] n){Arrays.sort(n);int p=0,b=0;String r="",d="";for(int c:n){if(c==++p)b=1;else{if(b==1){r+="-"+--p+d+c;p=c;b=0;}else{r+=d+c;p=c;}d=" ";}}return r;}

एक अंतर सरणी के रूप में इनपुट लेता है, आउटपुट को एक अलग-अलग स्ट्रिंग सूची के रूप में देता है

— vijrox
स्रोत

मानों की सूची से लेकर सीमाएं निर्धारित करें

इनपुट

आउटपुट

उदाहरण

नियम

स्कोरिंग

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

93 90 81 बाइट्स

जावास्क्रिप्ट (ईएस 6): 171 154 140 137 बाइट्स

ईएस 5 संस्करण, 198 184 183 174 बाइट्स

रूबी, 86 84 बाइट्स

सीजेएम, 35 बाइट्स

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

रूबी, 70 बाइट्स

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

CJam, 38 33 बाइट्स

कॉफीस्क्रिप्ट, 178 161 बाइट्स

पायथन 2, 126 122 121 बाइट्स

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

जावा, 171 162 बाइट्स