면책 조항 : 엔터테인먼트 목적 으로이 사이트에 잠시 동안 있었지만 이것이 첫 번째 질문이므로 사소한 오류는 용서하십시오.

배경

숙제를 할 때 선생님은 정말 성 가시고 개별적으로해야 할 모든 문제를 기록합니다 . 따라서 내가해야 할 문제를 복사 하는 데는 영원히 시간이 걸립니다 . 나는 내 인생을 더 편하게 해줄 것이라고 생각했고, 그에게 문제 목록을 덜 차지할 수있는 프로그램을 보내겠다.

페이지 또는 문제 번호 목록을 기록하는 동안 대시를 사용하여 범위를 나타냅니다. 예를 들어 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 % 보너스 (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

답변은 2015 년 12 월 19 일 토요일에 수락됩니다.

GLHF!

LabVIEW, 97 * 0.8 * 0.75 * 0.5 = 29.1 LabVIEW 프리미티브

이것은 성공적인 elemts가 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 바이트

@ kirbyfan64sos 덕분에 9 바이트가 절약되었습니다.

@JosephMalle 및 @cat 덕분에 19 바이트를 절약했습니다.

@ pinkfloydx33 덕분에 11 바이트를 절약했습니다.

#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

자바 스크립트 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)와 함께 질문 (a)의 요구 사항을 충족하지만 단일 페이지에 매달립니다. 중복 (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 online을 테스트 하여 테스트 사례와 비교하여 수행 방법을 확인하고 함수를 복사하여 붙여 넣은 다음이 코드를 사용할 수 있습니다.

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

자바, 252 * 80 % * 75 % * 50 % = 75.6 바이트

나는 방법을 선택하기로 결정했다 (자바에서는 훨씬 더 작음), 여기 골프 버전이 있습니다 :

골프

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

최신 정보:

이제 음수도 처리하여 보너스를 추가 할 수 있습니다.

apt, 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 바이트 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

sh, 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이전 입력 값입니다.