Você recebe uma lista de duas tuplas de números inteiros positivos, no formato:

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

Em outras palavras, as duas tuplas são separadas por vírgula e os números inteiros em cada tupla são separados por espaço. Todos os anúmeros estão em ordem estritamente crescente, assim como os bs. Seu objetivo é "preencher as lacunas". O que se entende por isso é o seguinte:

• Se a _i +1 == a _{i + 1} , não faça nada.
• Caso contrário, se a _i +1 <a _{i + 1} , você inserirá as tuplas na sequência da seguinte maneira: 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} .

Em outras palavras, se houver uma "lacuna" em a _i , você inserirá mais na lista com os bs inseridos como b _{i + 1} (o final da lacuna).

Exemplo :

Entrada: 6 125, 7 170, 10 185

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

Pontuação : a pontuação da submissão é o número de bytes necessários para construir um programa que, quando recebe uma string como descrito acima, gera no mesmo formato a lista "cheia" de tuplas.

Menor pontuação ganha!

Pitão, 31 30 bytes

Jsrz7Pjds,R+ehfghTdcJ2\,}hJePJ

1 byte graças a Jakube.

No nível alto, para cada número no intervalo dos a's, a lista é filtrada por a's maiores que esse número, então o b da primeira tupla é usado como o b.

Demonstração.

CJam, 42 41 39 38 bytes

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

Experimente on-line no intérprete CJam .

Python 2, 192 180 171 bytes

Infelizmente, são necessários uma tonelada de bytes para analisar a entrada e formatar a saída. Além disso, graças ao Sp3000 por dar um chute no meu cérebro :)

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

Analisar a entrada foi uma dor, então eu a ignorei e a analisei como está. Isso significa que

6 125, 7 170, 10 185

é analisado como

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

daí a splat na formatação da string.

JavaScript ( ES6 ), 97 103

Achando a redação da pergunta difícil de entender, baseiei meu trabalho no exemplo.

Primeira tentativa, poderia haver uma maneira mais curta, com apenas 1 divisão. Digitalizando a sequência de entrada em uma única passagem usando substituir.

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

Como funciona

p é uma função auxiliar de formatação de string simples:

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

(%) é uma função de "pesquisa" para preencher espaços em branco:

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

[head a..last$init a]é o intervalo de números a ser usado: do primeiro inteiro analisado até o penúltimo inteiro analisado. ( 0+Isso ajuda o verificador de tipos a inferir que todo o programa lida com Numvalores; caso contrário read, não sabe o que analisar.) Em seguida, nós concatMap(ou =<<) nossas funções anteriores no intervalo para obter uma string grande. É o que gfaz:

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

Finalmente há main. É da forma interact$s, então tudo o que importa é a função s :: String -> Stringque transforma stdin em stdout .

Primeiro, para ler a entrada, dividimos em palavras:

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

Então nós concatMapa função map(read.fst).lexsobre esta lista. Por uma palavra, isso faz:

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

Então, para uma lista de palavras, você recebe concat [[6], [125], [7], ...] == [6, 125, 7...], qual é a lista que queremos passar g. Finalmente, nós, dropo líder ", "da cadeia, gnos dá.

CJam, 34 bytes

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

Comecei com a resposta de Dennis, mas finalmente ela se tornou nada parecido com o original.

Experimente online.

Perl, 67 bytes

(Código de 66 caracteres + opção de linha de comando de 1 caractere)

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

Exemplo de execução:

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

Explicação: A abordagem geral é construir um regex que seja capaz de olhar para o próximo token para determinar se ele aumenta em um (o regex é um lixo na aritmética, portanto, adicionamos uma execução perl para fazer a adição e, em seguida, procuramos por isso). Caso contrário, substituímos essa correspondência pelo texto original, mais o novo token pelo aumento do índice. Em seguida, repetimos isso várias vezes na entrada até que ela não mude.

Para a explicação abaixo, uma 'seção' é o valor separado por vírgula e os 'tokens' são os valores separados por espaço nele.

 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

Recuado para maior clareza:

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

Saída de teste:

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

Python 3, 232 bytes

Não realmente que curto, mas ele usa um método diferente para a solução Python já publicado

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

Eu acho que eu whittled este para baixo tanto quanto eu puder. Eu estaria interessado em ver se existe uma abordagem melhor que leve a uma resposta Java mais curta:

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

Formatado:

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