Sie erhalten eine Liste mit 2 Tupeln positiver Ganzzahlen in der folgenden Form:

a1 b1, a2 b2, ..., an bn

Mit anderen Worten, die 2-Tupel sind durch Kommas getrennt, und die ganzen Zahlen in jedem Tupel sind durch Leerzeichen getrennt. Alle aZahlen sind in streng aufsteigender Reihenfolge, ebenso die bs. Ihr Ziel ist es, "die Lücken zu füllen". Damit ist folgendes gemeint:

• Wenn a _i +1 == a _{i + 1 ist} , tu nichts.
• Wenn sonst ein _i + 1 <a _{i + 1} , werden Sie Tupel in die Sequenz einfügen wie folgt: a _i b _i , a _i + 1 b _{i + 1} , ein _i 2 b _{i + 1} , ..., a _{i + 1} -1 b _{i + 1} , a _{i + 1} b _{i + 1} .

Mit anderen Worten, wenn es eine "Lücke" im a _{i gibt} , werden Sie mehr in die Liste einfügen, wobei das eingefügte bs b _{i + 1} (das Ende der Lücke) ist.

Beispiel :

Eingang: 6 125, 7 170, 10 185

Ausgabe: 6 125, 7 170, 8 185, 9 185, 10 185

Bewertung : Die Bewertung der Übermittlung ist die Anzahl der Bytes, die zum Erstellen eines Programms erforderlich sind, um bei Angabe einer Zeichenfolge wie oben beschrieben die "gefüllte" Liste der Tupel im gleichen Format auszugeben.

Die niedrigste Punktzahl gewinnt!

Pyth, 31 30 Bytes

Jsrz7Pjds,R+ehfghTdcJ2\,}hJePJ

1 Byte dank Jakube.

Auf der hohen Ebene wird für jede Zahl im Bereich der a die Liste nach a gefiltert, die größer als diese Zahl ist, und dann wird das b aus dem ersten solchen Tupel als b verwendet.

Demonstration.

CJam, 42 41 39 38 Bytes

q~,]:T(\-2=),>{IST2/z~\{I<!}#=,',S}fI&

Probieren Sie es online im CJam-Interpreter aus .

Python 2, 192 180 171 Bytes

Leider dauert es eine Menge Bytes, um die Eingabe zu analysieren und die Ausgabe zu formatieren. Vielen Dank auch an Sp3000, der mein Gehirn in Gang gebracht hat :)

n=[map(int,x.split())for x in input().split(',')]
for i in range(len(n)-1):j=0;exec'print n[i][0]+j,`n[i+(j>0)][1]`+",",;j+=1;'*(n[i+1][0]-n[i][0])
print n[-1][0],n[-1][1]

Python 3.5.0b1 +, 123 Bytes

L=map(eval,(input()+",").split())
o=""
while L:
 *L,a,b=L;x=a-1
 while[x,b,*L][-2]<a:o=", %d %d"%(a,*b)+o;a-=1
print(o[2:])

Das Parsen der Eingabe war ein Schmerz, also habe ich sie einfach ignoriert und so analysiert, wie sie ist. Das bedeutet, dass

6 125, 7 170, 10 185

wird analysiert als

[6, (125,), 7, (170,), 10, (185,)]

daher der Splat in der String-Formatierung.

JavaScript ( ES6 ), 97 103

Da ich den Wortlaut der Frage schwer zu verstehen fand, stützte ich meine Arbeit auf das Beispiel.

Erster Versuch, es könnte einen kürzeren Weg mit nur 1 Teilung geben. Scannen der Eingabezeichenfolge in einem einzigen Durchgang mit Ersetzen.

f=l=>
  l.replace(/\d+/g,b=>{
    for(i=p||a-1;a&&i++<a;p=a)o+=`, ${i} `+b;
    a=a?0:b
  },p=a=o='')
&&o.slice(2)

// TEST

out=x=>O.innerHTML+=x+'\n'

test=v=>out(v+'\n->'+f(v))

test('6 125, 7 170, 10 185')

<pre id=O></pre>
<input id=I><button onclick='test(I.value)'>-></button>

.

Haskell, 152 Bytes

p(x,y)=", "++show x++' ':show y
(a:b:c)%x|a<x=c%x|0<1=(x,b)
g a=p.(a%)=<<[0+head a..last$init a]
main=interact$drop 2.g.(map(read.fst).lex=<<).words

Wie es funktioniert

p ist eine einfache Hilfsfunktion zur Formatierung von Zeichenfolgen:

>>> p (6, 125)
", 6 125"

(%) ist eine "Suchfunktion" zum Ausfüllen von Lücken:

>>> let nums = [6, 125, 7, 135, 10, 185]
>>> nums % 8
(8,185)

[head a..last$init a]ist der Bereich der zu verwendenden Zahlen: von der ersten analysierten Ganzzahl bis zur vorletzten analysierten Ganzzahl. ( 0+Dies hilft dem Typprüfer zu schließen, dass das gesamte Programm mit NumWerten umgeht; ansonsten readweiß er nicht, was zu analysieren ist.) Dann concatMap(oder =<<) haben wir (oder ) unsere vorherigen Funktionen über den Bereich, um eine große Zeichenfolge zu erhalten. Das gmacht:

>>> g nums
", 6 125, 7 135, 8 185, 9 185, 10 185"

Endlich gibt es main. Es hat die Form interact$s, also ist alles, was uns wichtig ist, die Funktion s :: String -> String, die stdin in stdout verwandelt .

Um die Eingabe zu lesen, teilen wir uns zunächst in Wörter auf:

>>> (words) "6 125, 7 170, 10 185"
["6","125,","7","170,","10","185"]

Dann haben wir concatMapdie Funktion map(read.fst).lexüber diese Liste. Für ein Wort bedeutet dies:

>>> (map(read.fst).lex) "125," :: [Int]
[125]

Für eine Liste von Wörtern erhalten Sie concat [[6], [125], [7], ...] == [6, 125, 7...]also die Liste, an die wir übergeben möchten g. Schließlich gibt uns dropdie Führung ", "aus der Saite g.

CJam, 34 Bytes

ri_[_q~,]:,2/::fe&:.e|+ee>Sf*", "*

Ich habe mit Dennis 'Antwort angefangen , aber schließlich wird es nichts mehr wie das Original.

Probieren Sie es online aus.

Perl, 67 Bytes

(66 Zeichen Code + 1 Zeichen Befehlszeilenoption)

s/(\b\d+ \d+)(?=, (?!(??{$k=$1+1}) ).+( \d+))/"$1, ".$k.$2/e&&redo

Ausführungsbeispiel:

perl -pe 's/(\b\d+ \d+)(?=, (?!(??{$k=$1+1}) ).+( \d+))/"$1, ".$k.$2/e&&redo' <<< "6 125, 7 170, 10 185"

Erläuterung: Der allgemeine Ansatz besteht darin, einen regulären Ausdruck zu erstellen, der in der Lage ist, auf das nächste Token zu schauen, um festzustellen, ob er um eins zunimmt (regulärer Ausdruck ist bei der Arithmetik Unsinn, daher fügen wir eine Perl-Ausführung hinzu, um die Addition durchzuführen, und suchen danach). Ist dies nicht der Fall, ersetzen wir diese Übereinstimmung durch den Originaltext sowie das neue Token durch den erhöhten Index. Wir wiederholen dies dann mehrmals am Eingang, bis es sich nicht mehr ändert.

Für die folgende Erklärung ist ein 'Abschnitt' der durch Kommas getrennte Wert, und die 'Token' sind die durch Leerzeichen getrennten Werte innerhalb dieses Werts.

 s/     
   (\b\d+ \d+)             # Matches the first two numbers in a section
   (?=,                 # Look ahead to the next section
     (?!(??{$k=$1+1}) ) # Make sure the first token in the next section is not increased by one, store this value in $k. Happily, although our $1 contains TWO space separated numbers, it increases the first number and ignores the second - strange behaviour in Perl.
     .+                 # Ignore the actual value of first token of the next section (i.e. the index)
     ( \d+)             # Create a backreference on the second (i.e. the value)
   )   
 /                      # Start the replacement string...
   "$1, "               # Put the first section back into the result
   .$k                  # Append the increased index
   .$2                  # Append the value of the next token
 /e                     # Modifier - allows us to execute Perl inside the RegEx
 &&redo              # Repeat until it no longer changes the string

C #, 174 Bytes

Aus Gründen der Klarheit eingerückt:

class P{
    static void Main(string[]z){
        int a=0,b,i=-1;
        while(++i<z.Length){
            b=int.Parse(z[i++]);
            while(a<b)
                System.Console.Write((a==0?"":", ")+(a+=a==0?b:1)+" "+z[i].Trim(','));
        }
    }
}

Bash + Coreutils, 87

tr , \\n|while read a b
do for((p=p?p:a-1;p++<a;c=1)){
echo -n ${c+, }$p $b
}
p=$a
done

Testausgabe:

$ echo "6 125, 7 170, 10 185" | ./fillblanks.sh 
6 125, 7 170, 8 185, 9 185, 10 185

Python 3, 232 Bytes

Nicht wirklich so kurz, aber es verwendet eine andere Methode als die bereits veröffentlichte Python-Lösung

l=list(map(int,[y for x in input().split(',')for y in x.split(' ')]))
f=[];x=1
while x:
 x=0
 for i in range(0,len(l)-2,2):
  if l[i+2]-l[i]>1:l[:i+2]+=l[i]+1,;l[:i+3]+=l[i+4],;x+=1
for n in range(len(l)):print(l[n],end=','if n%2 else' ')

Java, 229 Bytes

Ich glaube, ich habe das so weit wie möglich reduziert. Es würde mich interessieren, ob es einen besseren Ansatz gibt, der zu einer kürzeren Java-Antwort führt:

String f(String s){String r="",g=" ",x[]=s.split(",\\s"),z[];int i=0,p=0,l=x.length,a,b;while(i<l){z=x[i].split(g);a=new Integer(z[0]);b=new Integer(z[1]);if(i++>0)while(a>++p)r+=p+g+b+", ";r+=a+g+b+(i==l?"":", ");p=a;}return r;}

Formatiert:

String f(String s) {
    String r = "", g = " ", x[] = s.split(",\\s"), z[];
    int i = 0, p = 0, l = x.length, a, b;
    while (i < l) {
        z = x[i].split(g);
        a = new Integer(z[0]);
        b = new Integer(z[1]);
        if (i++ > 0)
            while (a > ++p)
                r += p + g + b + ", ";
        r += a + g + b + (i == l ? "" : ", ");
        p = a;
    }
    return r;
}