Отказ от ответственности: хотя я уже некоторое время нахожусь на этом сайте в развлекательных целях, это мой первый вопрос, поэтому прошу прощения за любые мелкие ошибки.

Задний план

Назначая нам домашнее задание, мой учитель очень раздражает и записывает все проблемы, которые мы должны решать индивидуально. Таким образом, мне всегда нужно копировать, какие проблемы мне приходится решать. Я думал, чтобы сделать мою жизнь проще, я пошлю ему программу, которая может сделать список проблем занимать меньше места.

При написании списка номеров страниц или проблем мы используем тире для обозначения диапазона. Например, 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

это работает путем подсчета вверх, если число удачных элементов равно 1, а затем создается строка из числа и числа - по модулю 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

Рубин, 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 байт

Эта версия удовлетворяет требованиям вопроса (a) со всеми бонусами (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; 

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  

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

Наконец-то сделано с 3-мя задачами, с оценками до 100 байт: D

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

Вы можете протестировать 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), вот версия для гольфа:

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

Обновить:

Теперь он может обрабатывать и отрицательные числа, добавляя бонус.

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предыдущее входное значение.