Відмова: хоча я вже небагато часу побував на цьому веб-сайті для розважальних цілей, це моє перше питання, тому прошу пробачити будь-які незначні помилки.

Фон

Призначаючи нам домашні завдання, мій вчитель справді дратує і виписує всі проблеми, які ми маємо робити окремо. Таким чином, мені потрібно назавжди копіювати проблеми, які мені доводиться робити. Я думав полегшити своє життя, я надішлю йому програму, яка могла б переліку проблем займати менше місця.

Записуючи список номерів сторінок або проблем, ми використовуємо тире для позначення діапазону. Наприклад, 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-х.

Виклик

Ваша програма повинна приймати список цілих чисел за допомогою введення даних (що є стандартним для вашої мови чи функції). Ви можете вирішити, чи цей список розділений комами, пробілом чи фактичним списком / масивом.

Виведіть найкоротший шлях (спочатку відсортований за кількістю діапазонів, потім сума символів, включених до діапазонів), щоб представити цей список, використовуючи це позначення. Кожен штриховий діапазон повинен бути на одному рядку, але діапазони можуть бути розділені комами або новими рядками (дозволені наступні рядки чи коми). Ці діапазони повинні бути в порядку.

Оскільки наш шкільний Wi-Fi жахливий , я мушу зробити файл якомога меншим, щоб надіслати його йому. Виграє найкоротший код (у байтах).

Бонуси

Мій вчитель неохайний, тому є кілька речей, які допоможуть йому вийти. Кілька бонусів укладаються шляхом множення, наприклад, бонус -10% (х 90%) та -25% (х 75%) бонус = 90% * 75% = х 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!

LabVIEW, 97 * 0,8 * 0,75 * 0,5 = 29,1 LabVIEW Примітиви

це працює, підраховуючи вгору, якщо послідовні елементи розташовані на відстані один від одного, а потім створює рядок з числа і числа - модуль підрахунку 10, а деяке множення викликає негативи сука.

Gif демонструє вхід 8,9,10,11та вихід 8-1. Для введення -5,-4,-3,1,3,4,5 -5--3,1,3-5виходить.

C ++ 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

Ruby, 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

Скорочення довільних чисел цифр (звичайне розширення bash, що використовується для введення тут):

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

Javascript ES6, 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 байт

Ця версія задовольняє вимогам питання (а) з усіма бонусами (c, d, e), але висить на одних сторінках. Він також може обробляти дублікати (f). Він обробляє негативні сторінки до -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

(Вихідний результат показує пробіли замість фактичних нових рядків для стислості)

Одиничні сторінки: 233 байти

Ця трохи довша версія додатково задовольняє (e) та відображає окремі сторінки у вигляді діапазону з рівними нижньою та верхньою межами

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

GAP , 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; 

неозорений:

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  

Луа, 322 * 80% * 75% * 50% = 96,6 байт

Нарешті зроблено з 3-ма завданнями, Оцінками під 100 байт: D

Гольф

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

Безумовно

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

Ви можете протестувати lua в Інтернеті , щоб побачити, як він працює проти тестових випадків, скопіюйте вставку функції з наступним цим кодом:

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))

Java, 252 * 80% * 75% * 50% = 75,6 байт

Я вирішив скористатися методом (набагато меншим у Java), ось версія для гольфу:

Гольф

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

Оновлення:

Тепер він може також обробляти негативні числа, додаючи до бонусу.

Japt, 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.

R, 167 байт х 80% х 75% х 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

ш, 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

# 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попереднє вхідне значення.