Haftungsausschluss: Ich bin zwar schon eine Weile zu Unterhaltungszwecken auf dieser Website, aber dies ist meine erste Frage. Bitte verzeihen Sie kleinere Fehler.

Hintergrund

Mein Lehrer ist sehr nervig, wenn er uns die Hausaufgaben zuweist und schreibt alle Probleme auf, die wir individuell lösen müssen. Als solches brauche ich ewig, um herauszufinden, welche Probleme ich zu lösen habe. Ich dachte, um mein Leben zu erleichtern, würde ich ihm ein Programm schicken, mit dem die Liste der Probleme weniger Platz beanspruchen könnte.

Während wir eine Liste mit Seiten- oder Problemnummern aufschreiben, verwenden wir einen Bindestrich, um einen Bereich zu kennzeichnen. Zum Beispiel 19-21wird 19, 20, 21. Wenn dazwischen eine Lücke besteht, werden zwei durch Kommas getrennte Bereiche verwendet: 19-21, 27-31wird 19, 20, 21, 27, 28, 29, 30, 31.
Im Moment denken Sie wahrscheinlich: "Das scheint ziemlich trivial zu sein". Tatsächlich wurde dies hier und hier bereits beantwortet .

Es gibt jedoch einen Haken. Wenn wir einen Bereich mit gleichen aufeinanderfolgenden Ziffern haben, können die wiederholten Ziffern weggelassen werden. Zum Beispiel: 15, 16, 17wird 15-7und 107, 108, 109wird 107-9. Wenn die letzte aufeinanderfolgende gleiche Ziffer um 1 größer und die letzte Ziffer der oberen Grenze kleiner oder gleich der unteren ist, kann als Bonus das Folgende weggelassen werden (sorry, wenn das verwirrend klang; vielleicht klären es einige Beispiele) . 109-113wird 109-3, da eine niedrigere letzte Ziffer bedeutet, dass der 10er Platz erhöht wird.

Herausforderung

Ihr Programm sollte eine Liste von ganzen Zahlen über die Eingabe erhalten (was auch immer für Ihre Sprache oder eine Funktion Standard ist). Sie können entscheiden, ob diese Liste durch Kommas, Leerzeichen oder als tatsächliche Liste / Array getrennt sein soll.

Geben Sie den kürzesten Weg aus (zuerst sortiert nach Anzahl der Bereiche, dann die Summe der Zeichen in den Bereichen), um diese Liste mit dieser Notation darzustellen. Jeder gestrichelte Bereich muss sich in derselben Zeile befinden, die Bereiche können jedoch durch Kommas oder Zeilenumbrüche getrennt werden (nachfolgende Zeilenumbrüche oder Kommas sind zulässig). Diese Bereiche müssen in Ordnung sein.

Da unser Schul-WLAN schrecklich ist , muss ich die Datei so klein wie möglich machen, um sie ihm zu senden. Der kürzeste Code (in Bytes) gewinnt.

Boni

Mein Lehrer ist schlampig, also gibt es ein paar Dinge, die ihm helfen könnten. Mehrere Boni stapeln sich durch Multiplikation, z. B. ein Bonus von -10% (x 90%) und ein Bonus von -25% (x 75%) = 90% * 75% = x 67,5% (-32,5% Bonus).

• Manchmal bringt er sie in die falsche Reihenfolge (er ist kein Mathematiklehrer). Holen Sie sich einen Bonus von -20%, wenn Ihr Programm Ganzzahlen akzeptiert, die nicht vom kleinsten zum größten sortiert sind.
• Unser Buch ist komisch und in jedem Abschnitt werden die Probleme bei -10 gezählt. Wenn Ihr Programm negative Zahlen akzeptiert, nehmen Sie -25%.
• Akzeptiert es den Bonus einer niedrigeren letzten Ziffer, erhöht sich die Zehnerstelle, z. B. 25-32reduziert sich der Bonus auf 25-2, erhalten Sie einen Bonus von -50%.

Testfälle

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

Eine Antwort wird am Samstag, den 19. Dezember 2015, akzeptiert.

VIEL GLÜCK UND VIEL SPASS!

LabVIEW, 97 * 0,8 * 0,75 * 0,5 = 29,1 LabVIEW-Grundelemente

Dies funktioniert, indem aufwärts gezählt wird, wenn aufeinanderfolgende Elemente 1 voneinander entfernt sind, und dann eine Zeichenfolge aus der Zahl und dem Zahlenmodul 10 erstellt wird, und einige Multiplikationsursachen, bei denen Negative eine Hündin sind.

Das GIF zeigt eine Eingabe von 8,9,10,11und Ausgaben 8-1. Zur Eingabe -5,-4,-3,1,3,4,5 -5--3,1,3-5kommt raus.

C ++ 11, 451 × 80% × 75% × 50% = 135,3 Byte

9 Bytes dank @ kirbyfan64sos gespeichert.

19 Bytes dank @JosephMalle und @cat eingespart.

11 Bytes dank @ pinkfloydx33 gespart.

#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;}

Dies qualifiziert sich für alle Boni.

Beispielparametertest und Ergebnis:

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 Bytes

Übernimmt Befehlszeilenargumente als Eingabe (Kommas sind in Ordnung); druckt einen Bereich pro Zeile zur Standardausgabe.

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}

Mit Leerzeichen / Kommentaren:

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
}

Testfälle

$ 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

Funktionen, die von Testfällen nicht abgedeckt werden

Ungeordnete Eingabe- und Einzelelementbereiche:

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

Negative Bereiche (die größere Zahl kann damit nicht abgekürzt werden):

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

Abkürzung für eine beliebige Anzahl von Ziffern (gewöhnliche Bash-Erweiterung, die hier für die Eingabe verwendet wird):

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

Javascript ES6, 229 * 80% * 75% * 50% = 68,7 Byte

Testeingang

Ich verwende folgende Testdaten:

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
];

Grundlegend: 229 Bytes

Diese Version erfüllt die Anforderungen der Frage (a) mit allen Boni (c, d, e), hängt aber an einzelnen Seiten. Es kann auch Duplikate verarbeiten (f). Negative Seiten können bis zu -10.000 Seiten verarbeitet werden, was sich bei (großen) Geschwindigkeitsverlusten leicht erhöhen lässt.

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

(Die Ausgabe oben zeigt der Kürze halber Leerzeichen anstelle von tatsächlichen Zeilenumbrüchen.)

Einzelseiten: 233 Bytes

Diese etwas längere Version erfüllt zusätzlich (e) und zeigt einzelne Seiten als einen Bereich mit gleichen unteren und oberen Grenzen an

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 Bytes * 0,8 * 0,75 * 0,5 = 106,5

Dies erfüllt alle Boni. Es hat mich fast 100 zusätzliche Bytes gekostet, damit alles gut funktioniert. Diese Funktion lässt führende Ziffern nur dann aus, wenn die Lücke die Einerstelle nicht überschreitet. Zum Beispiel 9 10 11Ausgänge, 9-1aber 9 10 11 12 .. 20 21Ausgänge9-21 .

Wenn GAP ein bisschen weniger ausführlich gewesen wäre, hätte ich das ziemlich kurz bekommen können (hätte auch viele Bytes gespart, wenn ich nicht die exakte Syntax befolgt hätte.) Ich werde wahrscheinlich versuchen, dies morgen ein bisschen härter zu spielen. Testfälle siehe unten.

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;

Beachten Sie, dass in der GAP-Syntax [a..b]entspricht [a,a+1,...,b]. Ich glaube, dass diese Testfälle zeigen, dass dieses Programm alle Anforderungen erfüllt. Wenn etwas nicht stimmt, lass es mich wissen.

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 Bytes

Endlich mit den 3 Herausforderungen fertig, Scores unter 100 Bytes: D

Golf gespielt

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

Sie können lua online testen , um zu sehen, wie es sich gegen die Testfälle verhält. Kopieren Sie die Funktion, und fügen Sie den folgenden Code ein:

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 Byte

Ich habe mich für eine Methode entschieden (ist in Java viel kleiner), hier ist die Golfversion:

Golf gespielt

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()):"";}

Und hier ist die lesbare Version:

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()) : "";
}

Im Test sind dies die Ergebnisse:

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()):"";}
}

Ausgabe:

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

Aktualisieren:

Jetzt können auch negative Zahlen verarbeitet werden, was den Bonus erhöht.

Japt, 127 Bytes * 80% * 75% * 50% = 38,1

Wow, das war eine echte Herausforderung, alle Boni einzuschließen. Es könnte wahrscheinlich kürzer gemacht werden.

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

Probieren Sie es online!

Wie es funktioniert

Die Erklärung ist sehr grob; Zögern Sie nicht, Fragen zu stellen.

/*    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 Bytes × 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=", ")

Mit neuen Zeilen eingerückt:

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=", ")

Testfälle:

> 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

Es funktioniert für den -50% Bonus:

> 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

Es akzeptiert unsortierte Eingaben:

> 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

Es akzeptiert negative Zahlen:

> 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}'

Shell-Skript

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}'

Dabei sist der Beginn der aktuellen Sequenz und oder vorherige Eingabewert.