अस्वीकरण: जबकि मैं थोड़ी देर के लिए मनोरंजन प्रयोजनों के लिए इस साइट पर रहा हूं, यह मेरा पहला प्रश्न है, इसलिए कृपया किसी भी छोटी सी गलती को माफ कर दें।

पृष्ठभूमि

जब हमें होमवर्क सौंपा जाता है, तो मेरा शिक्षक वास्तव में परेशान होता है और वह सभी समस्याएं लिखता है जो हमें व्यक्तिगत रूप से करनी पड़ती हैं। जैसे, मुझे हमेशा के लिए कॉपी करना पड़ता है कि मुझे कौन सी समस्याएँ हैं। मैंने सोचा था कि अपने जीवन को आसान बनाने के लिए, मैं उसे एक ऐसा कार्यक्रम भेजूंगा जो समस्याओं की सूची को कम जगह बना सके।

पृष्ठ या समस्या संख्याओं की सूची लिखते समय, हम किसी श्रेणी को निरूपित करने के लिए डैश का उपयोग करते हैं। उदाहरण के लिए, 19-21बन जाता है 19, 20, 21। यदि बीच में कोई गैप है, तो दो अल्पविराम द्वारा अलग-अलग श्रेणियों का उपयोग किया जाता है: 19-21, 27-31बन जाता है 19, 20, 21, 27, 28, 29, 30, 31।
अभी के बारे में, आप शायद सोच रहे हैं: "यह बहुत तुच्छ लगता है"। वास्तव में, यह पहले से ही यहां और यहां उत्तर दिया गया है ।

हालांकि, वहाँ एक पकड़ है। अगर हमारे पास एक समान लगातार अंकों के साथ सीमा है, तो दोहराया अंकों को छोड़ा जा सकता है। उदाहरण के लिए: 15, 16, 17बन जाता है 15-7, और 107, 108, 109बन जाता है 107-9। एक बोनस के लिए, यदि अंतिम लगातार बराबर अंक 1 से अधिक है और ऊपरी सीमा का अंतिम अंक निम्न के बराबर या उससे कम है, तो निम्नलिखित को छोड़ा जा सकता है (क्षमा करें यदि यह भ्रमित लग रहा है, तो शायद कुछ उदाहरण इसे स्पष्ट कर देंगे) । 109-113बन जाता है 109-3, क्योंकि निचले अंतिम अंक का मतलब है 10 वीं जगह बढ़ना।

चुनौती

आपके कार्यक्रम को इनपुट के माध्यम से पूर्णांक की एक सूची लेनी चाहिए (जो कि आपकी भाषा या एक फ़ंक्शन के लिए मानक है)। आप तय कर सकते हैं कि यह सूची अल्पविराम से अलग है, अंतरिक्ष से अलग है, या एक वास्तविक सूची / सरणी के रूप में।

इस राशन का उपयोग करके उस सूची का प्रतिनिधित्व करने के लिए सबसे छोटा रास्ता (पहले श्रेणियों की संख्या द्वारा क्रमबद्ध, फिर श्रेणियों में शामिल वर्णों का योग) को आउटपुट करें । प्रत्येक धराशायी सीमा एक ही पंक्ति पर होनी चाहिए, लेकिन सीमाओं को अल्पविराम या नईलाइनों से अलग किया जा सकता है (नई रूपरेखा या अल्पविराम की अनुमति दी जाती है)। ये रेंज क्रम में होनी चाहिए।

चूंकि हमारा स्कूल वाई-फाई भयानक है , इसलिए मुझे उसे भेजने के लिए फ़ाइल को जितना संभव हो उतना छोटा करना होगा। सबसे छोटा कोड (बाइट्स में) जीतता है।

बोनस

मेरा शिक्षक सुस्त है, इसलिए कुछ चीजें हैं जो उसे बाहर निकालने में मदद करेंगी। गुणन के माध्यम से एकाधिक बोनस स्टैक, जैसे -10% बोनस (x 90%) और -25% (x 75%) बोनस = 90% * 75% = x 67.5% (-32.5% बोनस)।

कभी-कभी वह उन्हें गलत क्रम में रखता है (वह गणित शिक्षक नहीं है)। यदि आपका प्रोग्राम पूर्णांकों को स्वीकार कर सकता है तो -20% बोनस लें, जो कम से कम सबसे बड़े क्रमबद्ध न हों।
हमारी पुस्तक अजीब है, और प्रत्येक अनुभाग -10 पर समस्याओं को गिनना शुरू कर देता है। यदि आपका कार्यक्रम नकारात्मक संख्याओं को स्वीकार कर सकता है, तो -25% लें।
यदि यह 10 के स्थान पर निचले अंतिम अंक के बोनस को स्वीकार करता है, जैसे कि 25-32कम करना 25-2, -50% बोनस लेना।

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

In:  1, 2, 3, 4, 5
Out: 1-5

In:  3, 4, 5, 9, 10, 11, 12
Out: 3-5, 9-12

In:  149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160
Out: 149-60

In: 1 2 3 4
Out: 1-4


For bonuses:

In: 109, 110, 111, 112, 113
Out: 109-3

In:  19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29
Out: 19-9

In: -3, -2, -1, 0, 1, 2
Out: -3-2

In: -3, -2, -1
Out: -3--1

एक उत्तर शनिवार, 19 दिसंबर 2015 को स्वीकार किया जाएगा।

GLHF!

code-golf string number

— Cyoce
स्रोत

तीसरे परीक्षण मामले में आउटपुट क्यों नहीं है 1-4 9-2?

— एलेक्स ए।

एक प्रोग्राम के लिए आउटपुट क्या होना चाहिए जो (ए) करता है और (बी) 50% बोनस नहीं लेता है, के लिए 149 150 151 152 153 154 155 156 157 178 159 160?

— lirtosiast

3

मैं शपथ ले सकता था कि इस तरह से एक और सवाल है, लेकिन मैं इसे नहीं ढूँढ सकता ...

— mbomb007

5

मुझे लगता है कि यह संबंधित प्रश्न है जिसके बारे में हर कोई सोच रहा है। हालांकि एक सूची में बदल जाता है।

— डेनिस

1

एक और बात - पाठ का कहना है कि रेंज के अंतिम पृष्ठ के लिए पेनुलेटेट अंक को काट दिया जाना चाहिए यदि यह प्रारंभ पृष्ठ की तुलना में कम है, लेकिन परीक्षण के मामले का कहना है 19-9, जैसा कि पाठ का तात्पर्य 19,20,...,29नहीं 19-29है। तो कौन सा सही है?

— zocky

5

LabVIEW, 97 * 0.8 * 0.75 * 0.5 = 29.1 LabVIEW प्रिमिटिव

यह ऊपर की ओर गिनती करके काम करता है यदि सक्सेसिव एलिमेंट्स 1 अलग हैं और फिर संख्या और संख्या से एक स्ट्रिंग बनाते हैं - मोडुलो 10 की गणना करें और कुछ गुणन कारण नकारात्मक एक कुतिया हैं।

Gif 8,9,10,11और आउटपुट का इनपुट दिखाता है 8-1। इनपुट -5,-4,-3,1,3,4,5 -5--3,1,3-5के लिए बाहर आता है।

— Eumel
स्रोत

1

वास्तव में, इसे लूप के लिए प्रत्येक के रूप में गिना जा रहा है / जबकि लूप / यदि / जो भी 1 आदिम है वह उचित नहीं है क्योंकि जेएस जैसी भाषाओं में, वे 1 से अधिक बाइट

— गिनते हैं

@ ev3commander कुछ भी निष्पक्ष है अगर यह एक शांत एनिमेटेड आरेख के साथ आता है!

— साइयो

यही कारण है कि आदिम में बाइट्स नहीं है। इसके अलावा बहुत सारे वायरिंग चल रहे हैं, इसलिए लूप्स एक्टौल्ली कम से कम 2 या 3 हैं और शिफ्ट रजिस्टर + इनिशियलाइज़ेशन के लिए एक और 3।

— यूमेल

1

मानक गोल्फ नियमों से आपको लगता है कि इसकी सिर्फ बोरिंग कर सकते हैं,

— Eumel

2

@ ev3commander दरअसल, अगर भाषा चुनौती से नई है तो आपको प्रतिस्पर्धात्मक कारणों से इसका उपयोग करने की अनुमति नहीं है।

— अदनान

14

सी ++ 11, 451 * 80% * 75% * 50% = 135.3 बाइट्स

सहेजे गए 9 बाइट @ kirbyfan64sos के लिए धन्यवाद।

19 बाइट्स @JosephMalle और @cat की बदौलत सहेजे गए।

सहेजे गए 11 बाइट्स @ pinkfloydx33 की बदौलत।

#include<vector>
#include<cmath>
#include<algorithm>
#include<string>
#define T string
#define P append
using namespace std;T f(vector<int>v){sort(v.begin(),v.end());T r=to_T(v[0]);int b=1;int m=v[0];for(int i=1;i<=v.size();i++){if(i!=v.size()&&v[i]==v[i-1]+1){if(!b){m=v[i-1];}b=1;}else{if(b){T s=to_T(v[i-1]);r.P("-").P(s.substr(s.size()-(v[i-1]-m==1?1:log10(v[i-1]-m)),s.size()));}if(i!=v.size()){r.P(", ").P(to_T(v[i]));}b=0;}}return r;}

यह सभी बोनस के लिए योग्य है।

नमूना पैरामीटर परीक्षण और परिणाम:

In:  [1, 2, 3, 4, 5]
Out: 1-5

In:  [3, 4, 5, 9, 10, 11, 12]
Out: 3-5, 9-12

In:  [149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160]
Out: 149-60

In:  [1, 2, 3, 4]
Out: 1-4

In:  [109, 110, 111, 112, 113]
Out: 109-3

In:  [19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29]
Out: 19-9

— TheCoffeeCup
स्रोत

के intबजाय का उपयोग क्यों नहीं unsigned int? 9 बाइट बचाता है।

— kirbyfan64sos

@ kirbyfan64sos धन्यवाद, ध्यान नहीं दिया।

— द कॉफ़ी कॉप

+1 हमेशा C ++ देखना पसंद करता है। मैं इसका परीक्षण नहीं कर सकता, लेकिन मुझे नहीं लगता कि आपको iostream की जरूरत है

— sudo rm -rf slash

मुझे नहीं लगता कि आपको iostream की जरूरत है, लेकिन gccदिया:

a.cpp: In function ‘std::string f(std::vector<int>)’: a.cpp:8:83: error: ‘to_string’ was not declared in this scope

— बिल्ली

@cat सुनिश्चित करें कि यह पर्याप्त अपडेट है कि यह C ++ 11 मानक का समर्थन करता है। 4.3-ईश के साथ अच्छा होना चाहिए -std=c++11; > = 5.0 पर यह डिफ़ॉल्ट रूप से है (वास्तव में यह है -std=gnu11, लेकिन काफी करीब है)।

— Mego

8

रूबी, 120 118 * 0.8 * 0.75 * 0.5 = 35.4 बाइट्स

इनपुट के रूप में कमांड-लाइन तर्क देता है (कॉमा ठीक हैं); मानक उत्पादन के लिए प्रति पंक्ति एक सीमा प्रिंट करता है।

c=(b=(a=$*.map(&:to_i).sort).map &:succ)-a
puts (a-b).map{|m|(m<n=c.shift-1)?"#{m}-#{m<0?n:n%10**"#{n-m-1}".size}":m}

व्हॉट्सएप / टिप्पणियों के साथ:

c=(
  b=(
    # a is the sorted input
    a=$*.map(&:to_i).sort
  # b is the set of successors of elements of a
  ).map &:succ
# c=b-a is the set of not-quite-least upper bounds of our ranges
)-a

# a-b is the set of greatest lower bounds of our ranges
puts (a-b).map {|m|
  # for each range [m,n], if there are multiple elements
  (m < n = c.shift-1) ?
    # yield the range, abbreviating n appropriately if positive
    "#{m}-#{m<0 ? n : n % 10 ** "#{n-m-1}".size}" :
    # in the one-element case, just yield that
    m
}

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

$ ruby homework.rb 1, 2, 3, 4, 5
1-5

$ ruby homework.rb 3, 4, 5, 9, 10, 11, 12
3-5
9-2

$ ruby homework.rb 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160
149-60

$ ruby homework.rb 1 2 3 4
1-4

$ ruby homework.rb 109, 110, 111, 112, 113
109-3

$ ruby homework.rb 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29
19-9

परीक्षण मामलों द्वारा कवर नहीं की गई विशेषताएँ

अनियंत्रित इनपुट और एकल-तत्व श्रेणियाँ:

$ ruby homework.rb 2 17 19 22 0 1 8 20 18
0-2
8
17-0
22

नकारात्मक सीमाएँ (इनसे बड़ी संख्या को संक्षिप्त करना संभव नहीं):

$ ruby homework.rb -17 -18 -19 -20 -21
-21--17

अंकों की मनमानी संख्या की संक्षिप्त अभिव्यक्ति (इनपुट के लिए उपयोग किया जाने वाला साधारण बैश विस्तार):

$ ruby homework.rb {1234567..1235467} 2345999 2346000 2346001
1234567-467
2345999-1

— ezrast
स्रोत

मेरा मानना है कि आप की जगह ले सकता ((n=c.shift-1)>m)साथm<n=c.shift-1

— Cyoce

5

जावास्क्रिप्ट ईएस 6, 229 * 80% * 75% * 50% = 68.7 बाइट्स

टेस्ट इनपुट

मैं निम्नलिखित परीक्षण डेटा का उपयोग कर रहा हूं:

var A1=[
  5,6,7,            // => 5-7     # (a) group pages 
  2,3,              // => 2-3,5-7 # (b) must be properly sorted
  -9,-8,-7,         // => -10--8  # (c) allow negative numbers
  29,30,31,32,      // => 29-2    # (d) lower last digit implies increasing the 10s place
  9,10,11,12,       // => 9-11    # NOT 9-2
  36,37,38,39,40,41,42,43,44,45,46,47, 
                    // => 36-47   # NOT 36-7
  99,100,101,102,   // => 99-102  # NOT 99-2
  109,110,111,112,  // => 109-2   # NOT 109-12
],
// more tests, not specified in the question
A2=[
  120,124,       // => 120,124 # (e) handle single pages
],
A3=[
  135,136,135    // => 135-6   # (f) handle duplicates
];

बेसिक: 229 बाइट्स

यह संस्करण सभी बोनस (सी, डी, ई) के साथ प्रश्न (ए) की आवश्यकताओं को पूरा करता है, लेकिन एकल पृष्ठों पर लटका हुआ है। यह डुप्लिकेट (एफ) को भी संभाल सकता है। यह -10,000 से नीचे के नकारात्मक पृष्ठों को संभालता है, जिसे आसानी से (बड़े) गति के नुकसान के साथ बढ़ाया जा सकता है।

F=(a)=>{var R=[],i=NaN,l,u;a.map(x=>R[1e4+x]=x);R.concat('').map(x=>(i!=i&&(l=x,u=l-1),i=0,u=(x+="")-u-1?l=console.log(l+'-'+(u>0?(l.length-u.length||(z=>{for(;l[i]==u[i];i++);})(),u.length-i-2||u-l>9||i++,u.slice(i)):u))||x:x))}
F(A1.concat(A3)) --> -9--7 2-3 5-7 9-12 29-2 36-47 99-102 109-2 135-136

(उपरोक्त उत्पादन संक्षिप्तता के लिए वास्तविक newlines के बजाय रिक्त स्थान दिखाता है)

एकल पृष्ठ: 233 बाइट्स

यह थोड़ा लंबा संस्करण अतिरिक्त रूप से संतुष्ट करता है (ई) और एक पेज को समान निचली और ऊपरी सीमाओं के साथ एक सीमा के रूप में प्रदर्शित करता है

G=(a)=>{var R=[],i=NaN,l,u;a.map(x=>R[1e4+x]=x);R.concat('').map(x=>(i!=i&&(l=x,u=l-1),i=0,u=(x+="")-u-1?l=console.log(l+'-'+(u-l&u>0?(l.length-u.length||(z=>{for(;l[i]==u[i];i++);})(),u.length-i-2||u-l>9||i++,u.slice(i)):u))||x:x))}
G(A1.concat(A2,A3)) --> -9--7 2-3 5-7 9-12 29-2 36-47 99-102 109-2 120-120 124-124

— zocky
स्रोत

@Cyoce - क्या आप ES6- सक्षम जावास्क्रिप्ट इंजन का उपयोग कर रहे हैं?

— जोकी

ओह, हम्म, मेरे पास एक बग है, यह वास्तव में 36-47 को सही ढंग से नहीं संभालता है। उचित प्रक्रिया क्या है? क्या मैं इसे हटा सकता हूं और इसे ठीक कर दूंगा, या इसे ठीक करने की कोशिश करूंगा (अभी मेरे पास समय नहीं हो सकता है), या क्या?

— जोकी

हम्म, यह सिर्फ मेरे क्रोम में काम करता है। क्या देता है?

— जोकी

और ज़ोकी, जब आप कर सकते हैं तो इसे ठीक करें। यह तब तक मान्य नहीं होगा जब तक कि इसे ठीक नहीं किया जाता है, और तब तक इसे स्वीकार नहीं किया जा सकता है (यह मानते हुए कि आपका सबसे कम बाइट है)।

— साइओस

आइए हम इस चर्चा को चैट में जारी रखते हैं ।

— साइओस

3

जीएपी , 355 बाइट्स * 0.8 * 0.75 * 0.5 = 106.5

यह सभी बोनस को संतुष्ट करता है। यह सब कुछ अच्छी तरह से काम करने के लिए मुझे लगभग 100 अतिरिक्त बाइट्स की लागत। यह फ़ंक्शन केवल अग्रणी अंकों को छोड़ देता है यदि अंतराल एक बार वाले स्थान को ओवरफ्लो नहीं करता है। उदाहरण के लिए 9 10 11आउटपुट 9-1लेकिन 9 10 11 12 .. 20 21आउटपुट9-21 ।

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

g:=function(l)local n;if not l=[] then Sort(l);n:=1;while not l=[] do;if not IsSubset(l,[l[1]..l[1]+n]) then if not n=1 then if n-1>10-l[1] mod 10 and n-1<11 then Print(l[1],"-",(l[1]+n-1) mod 10);else Print(l[1],"-",l[1]+n-1);fi;else Print(l[1]);fi;Print(", ");SubtractSet(l,[l[1]..l[1]+n-1]);g(l);fi;n:=n+1;od;fi;Print("\b\b  ");end;

ungolfed:

g:=function(l)
    local n;
    if not l=[] then
        Sort(l);
        n:=1;
        while not l=[] do;
            if not IsSubset(l,[l[1]..l[1]+n]) then
                if not n=1 then
                    if n-1>10-l[1] mod 10 and n-1<11 then
                        Print(l[1],"-",(l[1]+n-1) mod 10);
                    else
                        Print(l[1],"-",l[1]+n-1);
                    fi;
                else
                    Print(l[1]);
                fi;
                Print(", ");
                SubtractSet(l,[l[1]..l[1]+n-1]);
                g(l);
            fi;
            n:=n+1;
        od; 
    fi;
    Print("\b\b  ");
end;

ध्यान दें कि GAP सिंटैक्स में, [a..b]के बराबर है [a,a+1,...,b]। मेरा मानना है कि ये परीक्षण मामले प्रदर्शित करते हैं कि यह कार्यक्रम सभी आवश्यकताओं को पूरा करता है। अगर कुछ गलत है, तो मुझे बताएं।

gap> h([1..5]);
1-5  
gap> h([3,4,5,9,10,11,12]);
3-5, 9-2  
gap> h([149..160]);
149-160  
gap> h([109..113]);
109-3  
gap> h([19..29]);
19-9  

gap> h([-1,-2,-3,-7,-20000,9,10,110101,110102]);
-20000, -7, -3--1, 9-10, 110101-110102  

gap> h([10101,10102,10103,10,11,12,13,14,15,16,234,999,1000,1001,1002]);
10-16, 234, 999-2, 10101-10103

— लियाम
स्रोत

3

लुआ, 322 * 80% * 75% * 50% = 96.6 बाइट्स

अंत में 3 चुनौतियों के साथ किया गया, 100 बाइट्स के तहत स्कोर: डी

golfed

function f(l)table.sort(l)l[#l+1]=-13 a=l[1]t,s=a,"" for _,v in next,l do if v-t>1 or t-v>1 then s,p,r=s..a.."-",""..t,""..a r:gsub("%d",function(c)p=r:find(c)~=r:len()and p:gsub("^(-?)"..c,"%1")or p r=r:gsub("^"..c,"")end)p=t-a<10 and t%10<a%10 and p:gsub("^(%d)","")or p s,a,t=s..p..",",v,v else t=v end end return s end

Ungolfed

function f(l)
    table.sort(l)
    l[#l+1]=-13 
    a=l[1] 
    t,s=a,"" 
    for _,v in next,l 
    do
        if v-t>1 or t-v>1
        then
            s,p,r=s..a.."-",""..t,""..a
            r:gsub("%d",function(c)
                p=r:find(c)~=#r and p:gsub("^(-?)"..c,"%1")or p
                r=r:gsub("^"..c,"")
            end)
            p=t-a<10 and t%10<a%10 and p:gsub("^(%d)","")or p
            s=s..p..","
            a,t=v,v
        else
            t=v
        end
    end
return s
end

आप लुआ का ऑनलाइन परीक्षण कर सकते हैं , यह देखने के लिए कि यह परीक्षण के मामलों के खिलाफ कैसा प्रदर्शन करता है, फ़ंक्शन को कॉपी करें, इस कोड के बाद:

a={1,2,3,4,5}
b={3,4,5,9,10,11,12,13,14,15,16,17,18,19,20,21}
c={149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160}
d={-7,8,5,-6,-5,6,7}
print(f(a))
print(f(b))
print(f(c))
print(f(d))

— Katenkyo
स्रोत

यदि {9..21} दर्ज किया गया है तो विफल होने लगता है। आउटपुट 9-1।

— लियाम

@ICHHHHAT फिक्स्ड, इसे इंगित करने के लिए धन्यवाद :)

— काटनेंको

2

जावा, 252 * 80% * 75% * 50% = 75.6 बाइट्स

मैंने एक विधि के लिए जाने का फैसला किया है (जावा में बहुत छोटा है), यहाँ गोल्फ का संस्करण है:

golfed

int p,c,s;String m(int[]a){p=s=c=0;c--;String o="";Arrays.sort(a);for(int n:a){if(s==0)o+=s=n;else if(n-p==1)c++;else{o+=t()+", "+(s=n);c=-1;}p=n;}return o+t();}String t(){return c>=0?"-"+(""+p).substring((""+Math.abs(p)).length()-(""+c).length()):"";}

और यहाँ पठनीय संस्करण है:

int p, c, s;

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

String t() {
    return c >= 0 ? "-" + ("" + p).substring(("" + Math.abs(p)).length() - ("" + c).length()) : "";
}

जब परीक्षण किया जाता है तो ये परिणाम हैं:

import java.util.Arrays;
public class A {
    public static void main(String...s) {
        A a = new A();
        System.out.println(a.m(new int[] {1, 2, 3, 4, 5}));
        System.out.println(a.m(new int[] {3, 4, 5, 9, 10, 11, 12}));
        System.out.println(a.m(new int[] {149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160}));
        System.out.println(a.m(new int[] {109, 110, 111, 112, 113}));
        System.out.println(a.m(new int[] {19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29}));
        System.out.println(a.m(new int[] {1,10,11,16}));
        System.out.println(a.m(new int[] {-3,-2,-1,0,1,2,3}));
        System.out.println(a.m(new int[] {-3,-2,-1}));
    }

    int p,c,s;String m(int[]a){p=s=c=0;c--;String o="";Arrays.sort(a);for(int n:a){if(s==0)o+=s=n;else if(n-p==1)c++;else{o+=t()+", "+(s=n);c=-1;}p=n;}return o+t();}String t(){return c>=0?"-"+(""+p).substring((""+Math.abs(p)).length()-(""+c).length()):"";}
}

आउटपुट:

1-5
3-5, 9-2
149-60
109-3
19-9
1, 10-1, 16
-3-3
-3--1

अद्यतन करें:

यह अब बोनस के साथ नकारात्मक संख्याओं को भी संभाल सकता है।

— रॉय वैन रिजन
स्रोत

मेरे पास कोई जावा विशेषज्ञ हूँ, लेकिन आप इसे बदल कर छोटा कर सकता p=s=c=0;c--;करने के लिए p=s=0;c=-1;?

— साइयो

मैं कोई जावा विशेषज्ञ नहीं हूं, लेकिन क्या आप रिटर्न c> = 0 को बदलकर इसे छोटा कर सकते हैं? "bla": "" c <0 वापस करने के लिए? "": "bla"?

— Stephan Schinkel

आप c=~(p=s=0)शैली बिंदुओं के लिए भी कर सकते हैं ।

— साइयो

2

जाप, 127 बाइट्स * 80% * 75% * 50% = 38.1

वाह, कि सभी बोनस को शामिल करने के लिए एक चुनौती की एक बिल्ली थी। यह शायद कम किया जा सकता है।

D=[]N=Nn-;DpNr@Y-1¥Xg1 ?[Xg Y]:DpX ©[YY]}D;Ds1 £[BC]=Xms;B¥C?B:B+'-+CsBg ¦'-©Cl ¥Bl ©C¬r@B¯Z ¥C¯Z ªC-B§ApCl -Z ©ÂBsX <ÂCsX ?Z:X

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

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

स्पष्टीकरण बहुत मोटा है; आपके पास कोई भी प्रश्न पूछने में संकोच न करें।

/*    Setting up basic variables    */
                      // Implicit: A = 10, N = list of input numbers.
D=[],N=Nn-;           // D = empty array, N = N sorted by subtraction.

/*    Finding ranges of page numbers    */    
Dp                    // Push into D the result of
NrXYZ{                // reducing each previous value X and item Y in N by this function,
}[];                  // starting with an empty array:
 Y-1==Xg1 ?           //  If Y is 1 more than the second item of X,
 [Xg Y]:              //   return [X[0], Y].
 DpX &&[YY]           //  Otherwise, push X into D and return [Y, Y].

/*    Formatting result    */
Ds1 mXYZ{             // Take the first item off of D and map each item X by this function:
 [BC]=Xms;            //  Set B and C to the first to items in X as strings.
 B==C?B               //  If B is the same as C, return B.
 :B+'-+Cs             //  Otherwise, return B + a hyphen + C.slice(
  Bg !='-&&           //   If B[0] is not a hyphen (B is not negative), AND
  Cl ==Bl &&          //   B and C are the same length,

  /*    Cutting off unnecessary digits    */
  Cq r                //    then C split into digits, reduced with
  rXYZ{               //    each previous value X, item Y, and index Z mapped by this function:
   Bs0,Z ==Cs0,Z ||   //     If B.slice(0,Z) equals C.slice(0,Z), OR
   C-B<=ApCl -Z       //     C - B <= 10 to the power of (C.length - Z);
   &&~~BsX <~~CsX     //     AND B.slice(X) is a smaller number than C.slice(X),
   ?Z:X               //     then Z; otherwise, X.
                      //   Otherwise, 0.

— ETHproductions
स्रोत

1

आर, 167 बाइट्स x 80% x 75% x 50% -> 50.1

s=sort(scan(se=","));r=c();while(length(s)){w=s==1:length(s)+s[1]-1;x=s[w];s=s[!w];z=tail(x,1);r=c(r,paste0(x[1],"-",ifelse(z-x[1]<=10,z%%10,z%%100)))};cat(r,sep=", ")

नई लाइनों के साथ प्रस्तुत:

s=sort(scan(se=","))
r=c()
while(length(s)){
w=s==1:length(s)+s[1]-1
x=s[w]
s=s[!w]
z=tail(x,1)
r=c(r, paste0(x[1],"-", ifelse(z-x[1]<=10, 
                               z%%10,
                               z%%100)))}
cat(r,sep=", ")

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

> s=sort(scan(se=","));r=c();while(length(s)){w=s==1:length(s)+s[1]-1;x=s[w];s=s[!w];r=c(r,paste0(x[1],"-",ifelse(tail(x,1)-x[1]<=10,tail(x,1)%%10,tail(x,1)%%100)))};cat(r,sep=", ")
1: 3, 4, 5, 9, 10, 11, 12
8: 
Read 7 items
3-5, 9-2
> s=sort(scan(se=","));r=c();while(length(s)){w=s==1:length(s)+s[1]-1;x=s[w];s=s[!w];r=c(r,paste0(x[1],"-",ifelse(tail(x,1)-x[1]<=10,tail(x,1)%%10,tail(x,1)%%100)))};cat(r,sep=", ")
1: 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160
13: 
Read 12 items
149-60

यह -50% बोनस के लिए काम करता है:

> s=sort(scan(se=","));r=c();while(length(s)){w=s==1:length(s)+s[1]-1;x=s[w];s=s[!w];r=c(r,paste0(x[1],"-",ifelse(tail(x,1)-x[1]<=10,tail(x,1)%%10,tail(x,1)%%100)))};cat(r,sep=", ")
1: 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29
12: 
Read 11 items
19-9
> s=sort(scan(se=","));r=c();while(length(s)){w=s==1:length(s)+s[1]-1;x=s[w];s=s[!w];r=c(r,paste0(x[1],"-",ifelse(tail(x,1)-x[1]<=10,tail(x,1)%%10,tail(x,1)%%100)))};cat(r,sep=", ")
1: 109, 110, 111, 112, 113
6: 
Read 5 items
109-3

यह बिना इनपुट के स्वीकार करता है:

> s=sort(scan(se=","));r=c();while(length(s)){w=s==1:length(s)+s[1]-1;x=s[w];s=s[!w];r=c(r,paste0(x[1],"-",ifelse(tail(x,1)-x[1]<=10,tail(x,1)%%10,tail(x,1)%%100)))};cat(r,sep=", ")
1: 114, 109, 110, 111, 112, 113
7: 
Read 6 items
109-4

यह नकारात्मक संख्याओं को स्वीकार करता है:

> s=sort(scan(se=","));r=c();while(length(s)){w=s==1:length(s)+s[1]-1;x=s[w];s=s[!w];r=c(r,paste0(x[1],"-",ifelse(tail(x,1)-x[1]<=10,tail(x,1)%%10,tail(x,1)%%100)))};cat(r,sep=", ")
1: -1,0,1,2
4: 
Read 3 items
-1-2

— plannapus
स्रोत

0

श, 135 * .8 * .75 * .5 = 40.5

tr , \\n|sort -n|awk -vORS="" '$1-o>1||!c{print p c$1;s=$1}{o=$1;c=", ";p=""}o>s{p="-"substr(o,length(o)-length(o-s-1)+1)}END{print p}'

शेल स्क्रिप्ट

tr , \\n|           # comma separated -> newline separated
sort -n|            # sort
awk -vORS=""        # suppress automatic newlines in output

awk script

# on step > 1 or first run, end the current sequence and start a new one.
# on first run, p and c are empty strings.
$1-o>1||!c
    {print p c$1;s=$1}

# old = current, c = ", " except for first run, clear end string.
    {o=$1;c=", ";p=""}

# if the sequence is not a single number, its end is denoted by "-o".
# print only the last n digits of o.
o>s
    {p="-"substr(o,length(o)-length(o-s-1)+1)}

# end the current sequence without starting a new one.
END
    {print p}'

जहां sवर्तमान अनुक्रम की शुरुआत oहै और पिछले इनपुट मूल्य है।

— रेनर पी।
स्रोत

मुझे यह पसंद है, लेकिन वर्तमान में इसे -25% बोनस नहीं मिलता है। पदार्थ () शून्य से संकेत और महत्वपूर्ण अंक काट रहा है।

— ezrast

@ezrast यह वास्तव में -50% बोनस के संदर्भ में सही व्यवहार है: -31, -30, -29, -2810 के स्थान से इसमें वृद्धि -3होती है -2और इसलिए इसे संघनित किया जाएगा -31-8। मैं यह बनाता है अस्पष्टता भी देखते हैं, लेकिन यह है कि क्या के लिए कहा जाता है।

— रेनर पी।

इन पेज नंबरों को गाढ़ा करें!

पृष्ठभूमि

चुनौती

बोनस

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

LabVIEW, 97 * 0.8 * 0.75 * 0.5 = 29.1 LabVIEW प्रिमिटिव

सी ++ 11, 451 * 80% * 75% * 50% = 135.3 बाइट्स

रूबी, 120 118 * 0.8 * 0.75 * 0.5 = 35.4 बाइट्स

जावास्क्रिप्ट ईएस 6, 229 * 80% * 75% * 50% = 68.7 बाइट्स

टेस्ट इनपुट

बेसिक: 229 बाइट्स

एकल पृष्ठ: 233 बाइट्स

जीएपी , 355 बाइट्स * 0.8 * 0.75 * 0.5 = 106.5

लुआ, 322 * 80% * 75% * 50% = 96.6 बाइट्स

golfed

Ungolfed

जावा, 252 * 80% * 75% * 50% = 75.6 बाइट्स

golfed

अद्यतन करें:

जाप, 127 बाइट्स * 80% * 75% * 50% = 38.1

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

आर, 167 बाइट्स x 80% x 75% x 50% -> 50.1

श, 135 * .8 * .75 * .5 = 40.5