Bạn được cung cấp một danh sách gồm 2 bộ số nguyên dương, có dạng:

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

Nói cách khác, 2 tuple được phân tách bằng dấu phẩy và các số nguyên trong mỗi bộ được phân tách bằng dấu cách. Tất cả các asố theo thứ tự tăng nghiêm ngặt, cũng như bs. Mục tiêu của bạn là "lấp đầy những khoảng trống." Điều đó có nghĩa là gì sau đây:

• Nếu a _i +1 == a _{i + 1} , đừng làm gì cả.
• Khác nếu a _i +1 <a _{i + 1} , bạn sẽ chèn các bộ dữ liệu vào chuỗi như sau: 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} .

Nói cách khác, nếu có một "khoảng trống" trong a _i , thì bạn sẽ chèn thêm vào danh sách với bs được chèn là b _{i + 1} (cuối của khoảng trống).

Ví dụ :

Đầu vào: 6 125, 7 170, 10 185

Đầu ra: 6 125, 7 170, 8 185, 9 185, 10 185

Chấm điểm : điểm của bài nộp là số byte cần thiết để xây dựng chương trình, khi được cung cấp một chuỗi như mô tả ở trên, xuất ra cùng định dạng danh sách các bộ dữ liệu "điền".

Điểm số thấp nhất chiến thắng!

Bình thường, 31 30 byte

Jsrz7Pjds,R+ehfghTdcJ2\,}hJePJ

1 byte nhờ Jakube.

Ở cấp độ cao, đối với mỗi số trong phạm vi của a, danh sách được lọc cho số lớn hơn số đó, sau đó b từ bộ đầu tiên như vậy được sử dụng làm b.

Trình diễn.

CJam, 42 41 39 38 byte

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

Hãy thử trực tuyến trong trình thông dịch CJam .

Python 2, 192 180 171 byte

Thật không may, phải mất một tấn byte để phân tích đầu vào và định dạng đầu ra. Ngoài ra, cảm ơn Sp3000 vì đã kích hoạt trí não của tôi :)

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 byte

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

Phân tích cú pháp đầu vào là một nỗi đau, vì vậy tôi chỉ cần bỏ qua nó và phân tích cú pháp như vậy. Điều này có nghĩa rằng

6 125, 7 170, 10 185

được phân tích cú pháp như

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

do đó splat trong định dạng chuỗi.

JavaScript ( ES6 ), 97 103

Tìm từ ngữ khó hiểu, tôi dựa vào công việc của mình dựa trên ví dụ.

Lần thử đầu tiên, có thể có một cách ngắn hơn chỉ với 1 lần phân tách Quét chuỗi đầu vào trong một lần sử dụng thay thế.

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 byte

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

Làm thế nào nó hoạt động

p là một hàm trợ giúp định dạng chuỗi đơn giản:

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

(%) là một chức năng "tra cứu" để điền vào chỗ trống:

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

[head a..last$init a]là phạm vi số cần sử dụng: từ số nguyên đầu tiên được phân tích cú pháp cho đến số nguyên thứ hai đến số cuối được phân tích cú pháp. (Việc 0+giúp trình kiểm tra loại suy ra rằng toàn bộ chương trình xử lý Numcác giá trị; nếu readkhông thì không biết phân tích cái gì.) Sau đó, chúng tôi concatMap(hoặc =<<) các chức năng trước đó của chúng tôi trong phạm vi để có được một chuỗi lớn. Đó là những gì g:

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

Cuối cùng, có main. Đó là hình thức interact$s, vì vậy tất cả những gì chúng ta quan tâm là chức năng s :: String -> Stringbiến stdin thành thiết bị xuất chuẩn .

Đầu tiên, để đọc đầu vào, chúng tôi chia thành các từ:

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

Sau đó, chúng tôi concatMapcác chức năng map(read.fst).lextrên danh sách này. Đối với một từ, điều này không:

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

Vì vậy, đối với một danh sách các từ, bạn nhận được concat [[6], [125], [7], ...] == [6, 125, 7...], đó là danh sách chúng tôi muốn chuyển đến g. Cuối cùng, chúng tôi dropdẫn đầu ", "từ chuỗi gcung cấp cho chúng tôi.

CJam, 34 byte

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

Tôi bắt đầu với câu trả lời của Dennis nhưng cuối cùng nó cũng không còn như ban đầu.

Hãy thử trực tuyến.

Perl, 67 byte

(Mã 66 ký tự + 1 ký tự tùy chọn dòng lệnh)

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

Ví dụ thực hiện:

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

Giải thích: Cách tiếp cận chung là xây dựng một regex có khả năng nhìn về phía trước mã thông báo tiếp theo để xác định xem nó có tăng thêm không (regex là rác theo số học, vì vậy chúng tôi thêm một thực thi perl để thực hiện bổ sung, sau đó tìm kiếm). Nếu không, chúng tôi sẽ thay thế kết quả khớp này bằng văn bản gốc, cộng với mã thông báo mới bằng chỉ mục tăng. Sau đó chúng tôi lặp lại điều này nhiều lần trên đầu vào cho đến khi nó không thay đổi.

Đối với giải thích bên dưới, 'phần' là giá trị được phân tách bằng dấu phẩy và 'mã thông báo' là các giá trị được phân tách bằng dấu cách trong phần này.

 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 byte

Ấn định cho rõ ràng:

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

Đầu ra thử nghiệm:

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

Python 3, 232 byte

Không thực sự ngắn như vậy , nhưng nó sử dụng một phương pháp khác với giải pháp Python đã được đăng

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 byte

Tôi nghĩ rằng tôi đã đưa nó xuống hết mức có thể. Tôi sẽ quan tâm xem liệu có cách tiếp cận nào tốt hơn dẫn đến câu trả lời Java ngắn hơn không:

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

Định dạng:

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