Se le da una lista de 2 tuplas de enteros positivos, de la forma:

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

En otras palabras, las 2 tuplas están separadas por comas, y los enteros dentro de cada tupla están separados por espacios. Todos los anúmeros están en orden estrictamente creciente, así como el bs. Su objetivo es "llenar los vacíos". Lo que se entiende por eso es lo siguiente:

• Si a _i +1 == a _{i + 1} , no hagas nada.
• De lo contrario, si a _i +1 <a _{i + 1} , insertará tuplas en la secuencia de la siguiente manera: a _i b _i , a _i +1 b _{i + 1} , a _i +2 b _{i + 1} , ..., a _{i + 1} -1 b _{i + 1} , a _{i + 1} b _{i + 1} .

En otras palabras, si hay un "espacio" en el a _i , entonces insertará más en la lista con el bs insertado para ser b _{i + 1} (el final del espacio).

Ejemplo :

Entrada: 6 125, 7 170, 10 185

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

Puntaje : el puntaje del envío es el número de bytes necesarios para construir un programa para, cuando se le da una cadena como se describió anteriormente, generar en el mismo formato la lista de tuplas "llena".

¡La puntuación más baja gana!

Pyth, 31 30 bytes

Jsrz7Pjds,R+ehfghTdcJ2\,}hJePJ

1 byte gracias a Jakube.

En el nivel superior, para cada número en el rango de las a, la lista se filtra por a's mayores que ese número, luego la b de la primera tupla se usa como la b.

Demostración.

CJam, 42 41 39 38 bytes

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

Pruébelo en línea en el intérprete de CJam .

Python 2, 192 180 171 Bytes

Desafortunadamente, toma una tonelada de bytes analizar la entrada y el formato de salida. Además, gracias a Sp3000 por poner mi cerebro en marcha :)

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

Analizar la entrada fue un dolor, así que simplemente lo ignoré y lo analicé tal como está. Esto significa que

6 125, 7 170, 10 185

se analiza como

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

de ahí el splat en el formato de cadena.

JavaScript ( ES6 ), 97103

Al encontrar la redacción de la pregunta difícil de entender, basé mi trabajo en el ejemplo.

Primero intente, podría haber una forma más corta con solo 1 división Escaneando la cadena de entrada en una sola pasada usando reemplazar.

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

Cómo funciona

p es una función auxiliar de formato de cadena simple:

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

(%) es una función de "búsqueda" para rellenar espacios en blanco:

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

[head a..last$init a]es el rango de números a utilizar: desde el primer entero analizado hasta el penúltimo entero analizado. (Esto 0+ayuda al verificador de tipos a inferir que todo el programa trata con Numvalores; de lo contrario read, no sabe qué analizar). Luego concatMap(o =<<) nuestras funciones anteriores sobre el rango para obtener una cadena grande. Eso es lo que ghace:

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

Finalmente hay main. Es de la forma interact$s, por lo que todo lo que nos importa es la función s :: String -> Stringque convierte stdin en stdout .

Primero, para leer la entrada, nos dividimos en palabras:

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

Entonces tenemos concatMapla función map(read.fst).lexsobre esta lista. Por una palabra, esto hace:

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

Entonces, para una lista de palabras, obtienes concat [[6], [125], [7], ...] == [6, 125, 7...], que es la lista a la que queremos pasar g. Finalmente, nos da dropla guía ", "de la cadena g.

CJam, 34 bytes

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

Comencé con la respuesta de Dennis al golf , pero finalmente no se parece en nada al original.

Pruébalo en línea.

Perl, 67 bytes

(Código de 66 caracteres + opción de línea de comando de 1 carácter)

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

Ejemplo de ejecución:

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

Explicación: El enfoque general es construir una expresión regular que sea capaz de mirar hacia el próximo token para determinar si aumenta en uno (la expresión regular es basura en la aritmética, por lo que agregamos una ejecución perl para hacer la adición, luego busque eso). Si no es así, reemplazamos esta coincidencia con el texto original, más el nuevo token con el índice aumentado. Luego repetimos esto varias veces en la entrada hasta que no cambie.

Para la explicación a continuación, una 'sección' es el valor separado por comas, y los 'tokens' son los valores separados por espacios dentro de este.

 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

Sangrado por claridad:

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

Prueba de salida:

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

Python 3, 232 bytes

En realidad no es tan breve, pero utiliza un método diferente a la solución de Python ya publicada

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

Yo creo que he corté esto abajo lo más que pueda. Me interesaría ver si hay un mejor enfoque que conduzca a una respuesta Java más corta:

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

Formateado:

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