Theo tinh thần của Patch the Image , đây là một thử thách tương tự nhưng với văn bản.

Thử thách

Thối bit đã ảnh hưởng đến văn bản quý giá của bạn! Đưa ra một đoạn gồm các ký tự ASCII, với một lỗ hình chữ nhật ở đâu đó, chương trình của bạn nên cố gắng điền vào lỗ đó bằng văn bản phù hợp, để đoạn văn đó hòa trộn tốt nhất có thể.

Định nghĩa thêm

• Lỗ sẽ luôn là hình chữ nhật, và nó có thể trải dài trên nhiều dòng.
• Sẽ chỉ có một lỗ.
• Lưu ý rằng lỗ hổng không nhất thiết rơi vào ranh giới từ (trên thực tế, nó thường sẽ không).
• Lỗ hổng sẽ nhiều nhất là 25% của đoạn đầu vào, nhưng có thể trùng lặp hoặc kéo dài qua "phần cuối" của văn bản "bình thường" (xem các ví dụ Euclid hoặc Badger bên dưới).
• Vì việc tìm ra lỗ hổng không phải là điểm chính của thử thách này, nên nó sẽ chỉ bao gồm các dấu băm # để cho phép nhận dạng dễ dàng.
• Không có vị trí nào khác trong đoạn đầu vào sẽ có dấu băm.
• Mã của bạn không thể sử dụng văn bản "bình thường" trong các ví dụ bên dưới - nó sẽ chỉ nhận và xử lý văn bản có lỗ hổng trong đó.
• Đầu vào có thể là một chuỗi nhiều dòng, như một chuỗi các chuỗi (một phần tử trên mỗi dòng), dưới dạng tệp, v.v. - sự lựa chọn của bạn về những gì thuận tiện nhất cho ngôn ngữ của bạn.
• Nếu muốn, một đầu vào bổ sung tùy chọn chi tiết tọa độ của lỗ có thể được lấy (ví dụ: một bộ tọa độ hoặc tương tự).
• Vui lòng mô tả thuật toán của bạn trong trình của bạn.

Bỏ phiếu

Các cử tri được yêu cầu đánh giá các mục dựa trên mức độ thuật toán lấp đầy trong lỗ văn bản. Một số gợi ý bao gồm:

• Có điền vào khu vực phù hợp với phân phối gần đúng của không gian và dấu chấm câu như phần còn lại của đoạn văn?
• Có điền vào khu vực giới thiệu cú pháp bị lỗi? (ví dụ: hai khoảng trắng trong một hàng, một khoảng thời gian theo sau là một dấu hỏi, một chuỗi sai lầm , ,, v.v.)
• Nếu bạn nheo mắt (vì vậy bạn không thực sự đọc văn bản), bạn có thể thấy lỗ hổng được sử dụng ở đâu không?
• Nếu không có từ CamelCase nào bên ngoài lỗ, lỗ đó có chứa từ nào không? Nếu không có chữ cái viết hoa nào bên ngoài lỗ, cái lỗ đó có chứa cái nào không? Nếu có rất nhiều chữ cái viết hoa bên ngoài lỗ, cái lỗ đó có chứa một lượng tương xứng không?

Tiêu chí hiệu lực

Để một bài nộp được coi là hợp lệ, nó không được thay đổi bất kỳ văn bản nào của đoạn bên ngoài lỗ (bao gồm cả dấu cách). Một dòng mới duy nhất ở cuối là tùy chọn.

Các trường hợp thử nghiệm

Định dạng là đoạn gốc trong một khối mã, theo sau là cùng một đoạn có lỗ. Các đoạn có lỗ sẽ được sử dụng cho đầu vào.

1 (Vá hình ảnh)

In a popular image editing software there is a feature, that patches (The term
used in image processing is inpainting as @minxomat pointed out.) a selected
area of an image, based on the information outside of that patch. And it does a
quite good job, considering it is just a program. As a human, you can sometimes
see that something is wrong, but if you squeeze your eyes or just take a short
glance, the patch seems to fill in the gap quite well.

In a popular image editing software there is a feature, that patches (The term
used in image processing is inpainting as @minxomat pointed out.) a selected
area of an image, #############information outside of that patch. And it does a
quite good job, co#############is just a program. As a human, you can sometimes
see that something#############t if you squeeze your eyes or just take a short
glance, the patch seems to fill in the gap quite well.

2 (Địa chỉ Gettysburg)

But, in a larger sense, we can not dedicate, we can not consecrate, we can not
hallow this ground. The brave men, living and dead, who struggled here, have
consecrated it, far above our poor power to add or detract. The world will
little note, nor long remember what we say here, but it can never forget what
they did here. It is for us the living, rather, to be dedicated here to the
unfinished work which they who fought here have thus far so nobly advanced. It
is rather for us to be here dedicated to the great task remaining before us-
that from these honored dead we take increased devotion to that cause for which
they gave the last full measure of devotion-that we here highly resolve that
these dead shall not have died in vain-that this nation, under God, shall have
a new birth of freedom-and that government of the people, by the people, for
the people, shall not perish from the earth.

But, in a larger sense, we can not dedicate, we can not consecrate, we can not
hallow this ground. The brave men, living and dead, who struggled here, have
consecrated it, far above our poor power to add or detract. The world will
little note, nor long remember what we say here, but it can never forget what
they did here. It is for us the living, rather, to be dedicated here to the
unfinished work which they who fought here h######################advanced. It
is rather for us to be here dedicated to the######################before us-
that from these honored dead we take increas######################use for which
they gave the last full measure of devotion-######################solve that
these dead shall not have died in vain-that ######################, shall have
a new birth of freedom-and that government of the people, by the people, for
the people, shall not perish from the earth.

3 (Lorem)

Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do
eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim
ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut
aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit
in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur
sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt
mollit anim id est laborum.

Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do
eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim
ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut
aliquip ex ea commodo conse################irure dolor in reprehenderit
in voluptate velit esse cil################giat nulla pariatur. Excepteur
sint occaecat cupidatat non################in culpa qui officia deserunt
mollit anim id est laborum.

4 (Jabberwocky)

'Twas brillig, and the slithy toves
Did gyre and gimble in the wabe;
All mimsy were the borogoves,
And the mome raths outgrabe.

'Twas brillig, and the slithy toves
Did gyre a######### in the wabe;
All mimsy #########borogoves,
And the mome raths outgrabe.

5 (Bằng chứng của Euclid về Định lý Pythagore)

1.Let ACB be a right-angled triangle with right angle CAB.
2.On each of the sides BC, AB, and CA, squares are drawn,
CBDE, BAGF, and ACIH, in that order. The construction of
squares requires the immediately preceding theorems in Euclid,
and depends upon the parallel postulate. [footnote 14]
3.From A, draw a line parallel to BD and CE. It will
perpendicularly intersect BC and DE at K and L, respectively.
4.Join CF and AD, to form the triangles BCF and BDA.
5.Angles CAB and BAG are both right angles; therefore C, A,
and G are collinear. Similarly for B, A, and H.
6.Angles CBD and FBA are both right angles; therefore angle ABD
equals angle FBC, since both are the sum of a right angle and angle ABC.
7.Since AB is equal to FB and BD is equal to BC, triangle ABD
must be congruent to triangle FBC.
8.Since A-K-L is a straight line, parallel to BD, then rectangle
BDLK has twice the area of triangle ABD because they share the base
BD and have the same altitude BK, i.e., a line normal to their common
base, connecting the parallel lines BD and AL. (lemma 2)
9.Since C is collinear with A and G, square BAGF must be twice in area
to triangle FBC.
10.Therefore, rectangle BDLK must have the same area as square BAGF = AB^2.
11.Similarly, it can be shown that rectangle CKLE must have the same
area as square ACIH = AC^2.
12.Adding these two results, AB^2 + AC^2 = BD × BK + KL × KC
13.Since BD = KL, BD × BK + KL × KC = BD(BK + KC) = BD × BC
14.Therefore, AB^2 + AC^2 = BC^2, since CBDE is a square.

1.Let ACB be a right-angled triangle with right angle CAB.
2.On each of the sides BC, AB, and CA, squares are drawn,
CBDE, BAGF, and ACIH, in that order. The construction of
squares requires the immediately preceding theorems in Euclid,
and depends upon the parallel postulate. [footnote 14]
3.From A, draw a line parallel to BD and CE. It will
perpendicularly intersect BC and DE at K and L, respectively.
4.Join CF and AD, to form the triangles BCF and BDA.
5.Angles CAB and BAG are both right angles; therefore C, A,
and G are #############milarly for B, A, and H.
6.Angles C#############e both right angles; therefore angle ABD
equals ang############# both are the sum of a right angle and angle ABC.
7.Since AB#############FB and BD is equal to BC, triangle ABD
must be co#############iangle FBC.
8.Since A-#############ight line, parallel to BD, then rectangle
BDLK has t############# of triangle ABD because they share the base
BD and hav#############titude BK, i.e., a line normal to their common
base, conn#############rallel lines BD and AL. (lemma 2)
9.Since C #############with A and G, square BAGF must be twice in area
to triangl#############
10.Therefo############# BDLK must have the same area as square BAGF = AB^2.
11.Similar############# shown that rectangle CKLE must have the same
area as square ACIH = AC^2.
12.Adding these two results, AB^2 + AC^2 = BD × BK + KL × KC
13.Since BD = KL, BD × BK + KL × KC = BD(BK + KC) = BD × BC
14.Therefore, AB^2 + AC^2 = BC^2, since CBDE is a square.

6 (Badger, Badger, Badger bởi weebl)

Badger, badger, badger, badger, badger,
badger, badger, badger, badger, badger
Mushroom, mushroom, a-
Badger, badger, badger, badger, badger,
badger, badger, badger, badger, badger
Mushroom, mushroom, a-
Badger, badger, badger, badger, badger,
badger, badger, badger, badger, badger
Mush-mushroom, a
Badger, badger, badger, badger, badger,
badger, badger, badger, badger, badger
Argh! Snake, a snake!
Snaaake! A snaaaake, oooh its a snake!

Badger, badger, badger, badger, badger,
badger, badger, badger, badger, badger
Mushroom, mushroom, a-
Badger##################badger, badger,
badger##################badger, badger
Mushro##################
Badger##################badger, badger,
badger##################badger, badger
Mush-mushroom, a
Badger, badger, badger, badger, badger,
badger, badger, badger, badger, badger
Argh! Snake, a snake!
Snaaake! A snaaaake, oooh its a snake!

Con trăn 2

Tôi biết rằng @atlasologist đã đăng một giải pháp trong Python 2, nhưng cách làm việc của tôi hơi khác một chút. Điều này hoạt động bằng cách đi qua tất cả các lỗ, từ trên xuống dưới, từ trái sang phải, tìm kiếm 5 ký tự trở lại và vào nhân vật ở trên và tìm một nhân vật trong đó các nhân vật này khớp. Nếu nhiều ký tự được tìm thấy, nó chọn một ký tự phổ biến nhất. Trong trường hợp không tìm thấy ký tự nào, nó sẽ loại bỏ giới hạn ký tự ở trên. Nếu vẫn không tìm thấy ký tự nào, nó sẽ giảm số lượng ký tự mà nó nhìn lại và lặp lại.

def fix(paragraph, holeChar = "#"):
    lines = paragraph.split("\n")
    maxLineWidth = max(map(len, lines))
    lines = [list(line + " " * (maxLineWidth - len(line))) for line in lines]
    holes = filter(lambda pos: lines[pos[0]][pos[1]] == holeChar, [[y, x] for x in range(maxLineWidth) for y in range(len(lines))])

    n = 0
    for hole in holes:
        for i in range(min(hole[1], 5), 0, -1):
            currCh = lines[hole[0]][hole[1]]
            over = lines[hole[0] - 1][hole[1]]
            left = lines[hole[0]][hole[1] - i : hole[1]]

            same = []
            almost = []
            for y, line in enumerate(lines):
                for x, ch in enumerate(line):
                    if ch == holeChar:
                        continue
                    if ch == left[-1] == " ":
                        continue
                    chOver = lines[y - 1][x]
                    chLeft = lines[y][x - i : x]
                    if chOver == over and chLeft == left:
                        same.append(ch)
                    if chLeft == left:
                        almost.append(ch)
            sortFunc = lambda x, lst: lst.count(x) / (paragraph.count(x) + 10) + lst.count(x)
            if same:
                newCh = sorted(same, key=lambda x: sortFunc(x, same))[-1]
            elif almost:
                newCh = sorted(almost, key=lambda x: sortFunc(x, almost))[-1]
            else:
                continue
            lines[hole[0]][hole[1]] = newCh
            break


    return "\n".join(map("".join, lines))

Đây là kết quả của Badger, Badger, Badger:

Badger, badger, badger, badger, badger,
badger, badger, badger, badger, badger 
Mushroom, mushroom, a-                 
Badger, badger, badger, badger, badger,
badger, badger, badger, badger, badger 
Mushroom, mushroom, a- b               
Badger, badger, badger, badger, badger,
badger, badger, badger, badger, badger 
Mush-mushroom, a                       
Badger, badger, badger, badger, badger,
badger, badger, badger, badger, badger 
Argh! Snake, a snake!                  
Snaaake! A snaaaake, oooh its a snake! 

Đây là kết quả từ bằng chứng:

1.Let ACB be a right-angled triangle with right angle CAB.                 
2.On each of the sides BC, AB, and CA, squares are drawn,                  
CBDE, BAGF, and ACIH, in that order. The construction of                   
squares requires the immediately preceding theorems in Euclid,             
and depends upon the parallel postulate. [footnote 14]                     
3.From A, draw a line parallel to BD and CE. It will                       
perpendicularly intersect BC and DE at K and L, respectively.              
4.Join CF and AD, to form the triangles BCF and BDA.                       
5.Angles CAB and BAG are both right angles; therefore C, A,                
and G are the same areamilarly for B, A, and H.                            
6.Angles CAB and CA, sqe both right angles; therefore angle ABD            
equals angle ABD becaus both are the sum of a right angle and angle ABC.   
7.Since ABD because theFB and BD is equal to BC, triangle ABD              
must be construction ofiangle FBC.                                         
8.Since A-angle ABD becight line, parallel to BD, then rectangle           
BDLK has the same area  of triangle ABD because they share the base        
BD and have the base thtitude BK, i.e., a line normal to their common      
base, conngle and G, sqrallel lines BD and AL. (lemma 2)                   
9.Since C = BD × BK + with A and G, square BAGF must be twice in area     
to triangle FBC. (lemma                                                    
10.Therefore angle and  BDLK must have the same area as square BAGF = AB^2.
11.Similarly for B, A,  shown that rectangle CKLE must have the same       
area as square ACIH = AC^2.                                                
12.Adding these two results, AB^2 + AC^2 = BD × BK + KL × KC             
13.Since BD = KL, BD × BK + KL × KC = BD(BK + KC) = BD × BC             
14.Therefore, AB^2 + AC^2 = BC^2, since CBDE is a square.

Và kết quả của Jabberwocky:

'Twas brillig, and the slithy toves
Did gyre and the mo in the wabe;   
All mimsy toves, anborogoves,      
And the mome raths outgrabe.       

Con trăn 2

Đây là một giải pháp khá đơn giản. Nó tạo ra một chuỗi mẫu bao gồm các từ nằm giữa độ dài từ trung bình A- ( A/ 2) và A+ (A / 2), sau đó nó áp dụng các đoạn được cắt xén không gian hàng đầu và dấu vết từ mẫu đến khu vực vá. Nó không xử lý viết hoa và tôi chắc chắn có một trường hợp kiểm tra đường cong ngoài kia sẽ phá vỡ nó, nhưng nó không sao trên các ví dụ. Xem liên kết dưới đây để chạy tất cả các bài kiểm tra.

Tôi cũng đặt một bản vá trong mã cho biện pháp tốt.

def patch(paragraph):
    sample = [x.split() for x in paragraph if x.count('#') < 1]
    length = max([x.count('#') for x in paragraph if x.find('#')])
    s = sum(####################
    sample,[####################
    ])      ####################
    avg=sum(####################
    len(w)  ####################
    for w in####################
    s)//len(s)
    avg_range = range(avg-(avg//2),avg+(avg//2))
    sample = filter(lambda x:len(x) in avg_range, s)
    height=0
    for line in paragraph:
        if line.find('#'):height+=1
        print line.replace('#'*length,' '.join(sample)[(height-1)*length:height*length].strip())
    print '\n'

Lorem Ipsum, bản gốc sau đó được vá:

Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do
eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim
ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut
aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit
in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur
sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt
mollit anim id est laborum.

Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do
eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim
ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut
aliquip ex ea commodo conseore dolore magnairure dolor in reprehenderit
in voluptate velit esse cilenim minim quisgiat nulla pariatur. Excepteur
sint occaecat cupidatat nonnisi mollit aniin culpa qui officia deserunt
mollit anim id est laborum.

Thử nó

Java Shakespeare

Ai cần nắm bắt các quy ước tiếng Anh tiêu chuẩn? Chỉ cần làm cho riêng bạn! Giống như bard được phép tạo nên từ của riêng mình. Bot này không lo lắng nhiều về việc sửa các từ bị cắt, anh ta thực sự chỉ chèn các từ ngẫu nhiên. Kết quả là một số Thơ đẹp. Là một tính năng phần thưởng, bard có tầm cỡ cao hơn và có thể xử lý nhiều lỗ với điều kiện chúng có cùng kích thước!

---

Đầu vào mẫu

 Từ những sinh vật công bằng nhất, chúng tôi mong muốn tăng lên,
  Đó là hoa hồng có thể không bao giờ chết,
  Nhưng khi riper nên theo thời gian,
  Sự dịu dàng của anh ấy ############ mang ký ức của anh ấy:
  Nhưng ngươi c ############ ngươi là đôi mắt sáng,
  Feed'st th ############ ame với nhiên liệu tự thân,
  Làm cho nạn đói ở nơi phong phú,
  Kẻ thù của ngươi, kẻ tự cho mình ngọt ngào quá tàn nhẫn:
  Ngươi là nghệ thuật bây giờ trang trí tươi của thế giới,
  Và chỉ báo trước mùa xuân ảm đạm,
  Trong nội dung của bạn, nụ của bạn
  Và churl mak'st dịu dàng là ############ ding:
    Đáng tiếc cho thế giới, hoặc người nào khác t ############ được,
    Để ăn thế giới, b ############ và thee.


                     2
  Khi bốn mươi mùa đông sẽ bao vây trán ngươi,
  Và đào rãnh sâu trong lĩnh vực làm đẹp của ngươi,
  Tuổi trẻ kiêu hãnh của tuổi trẻ bây giờ nhìn chằm chằm vào,
  Sẽ là một cỏ dại rách nát của giá trị nhỏ được tổ chức:  
  Sau đó được hỏi, tất cả vẻ đẹp của ngươi nằm ở đâu,
  Nơi tất cả kho báu của những ngày mạnh mẽ của ngươi;
  Để nói trong đôi mắt trũng sâu của chính mình,
  Là một sự xấu hổ ăn tất cả, và khen ngợi tiết kiệm.
  Bao nhiêu lời khen ngợi xứng đáng được sử dụng làm đẹp của bạn,
  Nếu bạn không thể trả lời 'Đứa trẻ công bằng này của tôi
  Sẽ tính tổng của tôi, và làm cho cái cớ cũ của tôi '
  Chứng minh vẻ đẹp của mình bằng sự kế vị.
    Điều này đã được thực hiện khi bạn cũ,
    Và thấy máu ngươi ấm lên khi ngươi cảm thấy lạnh.


                     3
  Nhìn vào kính của bạn và nói với khuôn mặt bạn rõ nhất,
  Bây giờ là lúc khuôn mặt nên tạo thành một khuôn mặt khác,
  Sửa chữa mới nếu bây giờ bạn không gia hạn,
  Con làm ngơ cả đời, bỏ mặc mẹ.
  Vì đâu là cô ấy công bằng mà tử cung chưa được khám phá
  Khinh thị việc chăn nuôi của bạn?
  Hoặc anh ấy rất thích sẽ là ngôi mộ,
  Tự ái của mình để ngăn chặn hậu thế?  
  Con là mẹ của mẹ và mẹ
  Gọi lại tháng tư đáng yêu của cô ấy,
  Vì vậy, ngươi qua cửa sổ của thời đại ngươi sẽ thấy,
  Mặc dù ############ s thời gian vàng của bạn.
    Nhưng nếu ############ mbered không được,
    Die singl ############ hình ảnh chết với bạn.

Đầu ra đẹp

 Từ những sinh vật công bằng nhất, chúng tôi mong muốn tăng lên,
  Đó là hoa hồng có thể không bao giờ chết,
  Nhưng khi riper nên theo thời gian,
  Sự dịu dàng của anh nên mang theo trí nhớ của anh:
  Nhưng ngươi có đôi mắt sáng ngời của chính mình,
  Cung cấp thức ăn hoặc là tự nhiên liệu,
  Làm cho nạn đói ở nơi phong phú,
  Kẻ thù của ngươi, kẻ tự cho mình ngọt ngào quá tàn nhẫn:
  Ngươi là nghệ thuật bây giờ trang trí tươi của thế giới,
  Và chỉ báo trước mùa xuân ảm đạm,
  Trong nội dung của bạn, nụ của bạn
  Và anh chàng dịu dàng luôn luôn là anh ta:
    Đáng tiếc cho thế giới, hoặc người nào khác
    Để ăn thế giới do, bt thine so và ngươi.


                     2
  Khi bốn mươi mùa đông sẽ bao vây trán ngươi,
  Và đào rãnh sâu trong lĩnh vực làm đẹp của ngươi,
  Tuổi trẻ kiêu hãnh của tuổi trẻ bây giờ nhìn chằm chằm vào,
  Sẽ là một cỏ dại rách nát của giá trị nhỏ được tổ chức:  
  Sau đó được hỏi, tất cả vẻ đẹp của ngươi nằm ở đâu,
  Nơi tất cả kho báu của những ngày mạnh mẽ của ngươi;
  Để nói trong đôi mắt trũng sâu của chính mình,
  Là một sự xấu hổ ăn tất cả, và khen ngợi tiết kiệm.
  Bao nhiêu lời khen ngợi xứng đáng được sử dụng làm đẹp của bạn,
  Nếu bạn không thể trả lời 'Đứa trẻ công bằng này của tôi
  Sẽ tính tổng của tôi, và làm cho cái cớ cũ của tôi '
  Chứng minh vẻ đẹp của mình bằng sự kế vị.
    Điều này đã được thực hiện khi bạn cũ,
    Và thấy máu ngươi ấm lên khi ngươi cảm thấy lạnh.


                     3
  Nhìn vào kính của bạn và nói với khuôn mặt bạn rõ nhất,
  Bây giờ là lúc khuôn mặt nên tạo thành một khuôn mặt khác,
  Sửa chữa mới nếu bây giờ bạn không gia hạn,
  Con làm ngơ cả đời, bỏ mặc mẹ.
  Vì đâu là cô ấy công bằng mà tử cung chưa được khám phá
  Khinh thị việc chăn nuôi của bạn?
  Hoặc anh ấy rất thích sẽ là ngôi mộ,
  Tự ái của mình để ngăn chặn hậu thế?  
  Con là mẹ của mẹ và mẹ
  Gọi lại tháng tư đáng yêu của cô ấy,
  Vì vậy, ngươi qua cửa sổ của thời đại ngươi sẽ thấy,
  Mặc dù nhìn chằm chằm thời gian vàng của bạn.
    Nhưng nếu th Khi được, thì không được,
    Die singl sửa chữa hình ảnh chết với ngươi.

Những dòng cuối cùng là thơ sâu sắc nếu tôi nói như vậy bản thân mình. Nó cũng thực hiện tốt trên địa chỉ gettysburg.

But, in a larger sense, we can not dedicate, we can not consecrate, we can not
hallow this ground. The brave men, living and dead, who struggled here, have
consecrated it, far above our poor power to add or detract. The world will
little note, nor long remember what we say here, but it can never forget what
they did here. It is for us the living, rather, to be dedicated here to the
unfinished work which they who fought here h to of rather us of advanced. It
is rather for us to be here dedicated to the who be it, vain who before us 
that from these honored dead we take increas be dead the the what use for which
they gave the last full measure of devotion  dead government The solve that
these dead shall not have died in vain that  the take nor world , shall have
a new birth of freedom and that government of the people, by the people, for
the people, shall not perish from the earth.

---

Hãy xem những gì làm cho Shakespeare đánh dấu. Đây là mã. Về cơ bản, ông cố gắng xây dựng một nền tảng từ vựng từ đầu vào. Sau đó, anh ta sử dụng những từ này và đặt chúng ngẫu nhiên vào lỗ (đảm bảo rằng nó phù hợp độc đáo). Anh ta quyết đoán khi anh ta sử dụng một hạt giống cố định cho sự ngẫu nhiên.

package stuff;

import java.io.File;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.Random;
import java.util.Scanner;
import java.util.Stack;

/**
 *
 * @author rohan
 */
public class PatchTheParagraph {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
Scanner in = new Scanner(System.in);
System.out.println("File Name :");
        String[] text = getWordsFromFile(in.nextLine());
System.out.println("==ORIGINAL==");
        for(String s:text){
    System.out.println(s);
}
                    int lengthOfHole= 0;
        int rows = 0;
            for(String s: text){
                s = s.replaceAll("[^#]", "");

//      System.out.println(s);
                if(s.length()>0){
                    lengthOfHole = s.length();
                rows++;
                }
            }
            ArrayList<String> words = new ArrayList<>();
            words.add("I");
            for(String s:text){
                String[] w = s.replaceAll("#", " ").split(" ");
for(String a :w){
    words.add(a);
            }

            }
                        Iterator<String> j = words.iterator();
            while(j.hasNext()){
                String o;
                if((o = j.next()).equals("")){
                    j.remove();
                }
            }
            System.out.println(words);
            Stack<String> out = new Stack<>();
            String hashRow = "";
            for(int i = 0;i<lengthOfHole;i++){
                hashRow+="#";
            }

        for(int i = 0;i<rows;i++){
            int length = lengthOfHole-1; 
            String outPut = " ";
            while(length>2){
String wordAttempt = words.get(getRandom(words.size()-1));
while(wordAttempt.length()>length-1){
 wordAttempt = words.get(getRandom(words.size()-1));
}           
length -= wordAttempt.length()+1;
            outPut+=wordAttempt;
                outPut+=" ";
            }
        out.push(outPut);
    }
System.out.println("==PATCHED==");
        for(String s : text){
            if(s.contains(hashRow)){
                System.out.println(s.replaceAll(hashRow,out.pop()));
            }else{
                System.out.println(s);
            }
        }
                                    }
public static final Random r = new Random(42);
    public static int getRandom(int max){
    return (int) (max*r.nextDouble());
}
    /**
     *
     * @param fileName is the path to the file or just the name if it is local
     * @return the number of lines in fileName
     */
    public static int getLengthOfFile(String fileName) {
        int length = 0;
        try {
            File textFile = new File(fileName);
            Scanner sc = new Scanner(textFile);
            while (sc.hasNextLine()) {
                sc.nextLine();
                length++;
            }
        } catch (Exception e) {
System.err.println(e);
        }
        return length;
    }

    /**
     *
     * @param fileName is the path to the file or just the name if it is local
     * @return an array of Strings where each string is one line from the file
     * fileName.
     */
    public static String[] getWordsFromFile(String fileName) {
        int lengthOfFile = getLengthOfFile(fileName);
        String[] wordBank = new String[lengthOfFile];
        int i = 0;
        try {
            File textFile = new File(fileName);
            Scanner sc = new Scanner(textFile);
            for (i = 0; i < lengthOfFile; i++) {
                wordBank[i] = sc.nextLine();
            }
            return wordBank;
        } catch (Exception e) {
            System.err.println(e);
            System.exit(55);
        }
        return null;
    }
}

---

Hầu hết thơ của Shakespeare là phạm vi công cộng.

Python 2.7

Một giải pháp Python khác với cách tiếp cận khác. Chương trình của tôi xem văn bản là một chuỗi Markov , trong đó mỗi chữ cái được theo sau bởi một chữ cái khác với xác suất nhất định. Vì vậy, bước đầu tiên là xây dựng bảng xác suất. Bước tiếp theo là áp dụng xác suất đó cho bản vá.

Mã đầy đủ, bao gồm một văn bản mẫu bên dưới. Vì một ví dụ đã sử dụng các ký tự unicode, tôi đã bao gồm một bảng mã rõ ràng (utf-8) để tương thích với ví dụ đó.

#!/usr/bin/env python
# -*- coding: utf-8 -*-

from collections import defaultdict
import numpy

texts = [
"""'Twas brillig, and the slithy toves
Did gyre a######### in the wabe;
All mimsy #########borogoves,
And the mome raths outgrabe."""
]

class Patcher:
    def __init__(self):
        self.mapper = defaultdict(lambda: defaultdict(int))

    def add_mapping(self, from_value, to_value):
        self.mapper[from_value][to_value] += 1

    def get_patch(self, from_value):
        if from_value in self.mapper:
            sum_freq = sum(self.mapper[from_value].values())
            return numpy.random.choice(
                self.mapper[from_value].keys(),
                p = numpy.array(
                    self.mapper[from_value].values(),dtype=numpy.float64) / sum_freq)
        else:
            return None

def add_text_mappings(text_string, patcher = Patcher(), ignore_characters = ''):
    previous_letter = text_string[0]
    for letter in text_string[1:]:
        if not letter in ignore_characters:
            patcher.add_mapping(previous_letter, letter)
            previous_letter = letter
    patcher.add_mapping(text_string[-1], '\n')

def patch_text(text_string, patcher, patch_characters = '#'):
    result = previous_letter = text_string[0]
    for letter in text_string[1:]:
        if letter in patch_characters:
            result += patcher.get_patch(previous_letter)
        else:
            result += letter
        previous_letter = result[-1]
    return result

def main():
    for text in texts:
        patcher = Patcher()
        add_text_mappings(text, patcher, '#')
        print patch_text(text, patcher, '#')
        print "\n"

if __name__ == '__main__':
    main()

Đầu ra mẫu cho Lorem Ipsum:

Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do
eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim
ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut
aliquip ex ea commodo conse Exe eut ccadamairure dolor in reprehenderit
in voluptate velit esse cilore indipserexepgiat nulla pariatur. Excepteur
sint occaecat cupidatat non upir alostat adin culpa qui officia deserunt
mollit anim id est laborum.

Một dòng thơ thêm trong Jabberwocky:

'Twas brillig, and the slithy toves
Did gyre and me the in the wabe;
All mimsy was
An inborogoves,
And the mome raths outgrabe.

C # 5 đồ sộ hơn bao giờ hết

Tôi đã ném cái này cùng nhau, nó hơi lộn xộn, nhưng nó tạo ra một số kết quả OK đôi khi. Nó là một thuật toán chủ yếu mang tính xác định, nhưng với một số ngẫu nhiên (hạt giống cố định) được thêm vào để tránh nó tạo ra cùng một chuỗi cho các khoảng trống tương tự. Cần nỗ lực để tránh việc chỉ có các cột khoảng trống ở hai bên của các khoảng trống.

Nó hoạt động bằng cách mã hóa đầu vào thành các từ và dấu chấm câu (dấu câu xuất phát từ danh sách được nhập thủ công, vì tôi không bận tâm nếu Unicode có thể làm điều này cho tôi), để nó có thể đặt khoảng trắng trước các từ chứ không phải trước dấu câu, bởi vì điều này là khá điển hình. Nó phân chia trên khoảng trắng điển hình. Theo mạch của chuỗi markov (tôi nghĩ), nó tính tần suất mỗi mã thông báo theo dõi mã thông báo của nhau và sau đó không tính xác suất cho điều này (tôi cho rằng vì các tài liệu rất nhỏ, chúng tôi sẽ làm tốt hơn để thiên vị cho mọi thứ chúng ta thấy rất nhiều nơi chúng ta có thể). Sau đó, chúng tôi thực hiện tìm kiếm theo chiều rộng đầu tiên, lấp đầy khoảng trống còn lại của các giá trị băm và các từ 'một phần' ở hai bên, với chi phí được tính là -fabness(last, cur) * len(cur_with_space), trong đó fabnesstrả về số lầncur đã theo saulastcho mỗi mã thông báo được nối vào chuỗi được tạo. Đương nhiên, chúng tôi cố gắng giảm thiểu chi phí. Vì chúng tôi không thể luôn lấp đầy khoảng trống bằng các từ và dấu chấm câu được tìm thấy trong tài liệu, nên nó cũng xem xét một số mã thông báo 'đặc biệt' từ các trạng thái nhất định, bao gồm cả chuỗi một phần ở hai bên, mà chúng tôi thiên vị với chi phí tăng tùy ý.

Nếu BFS không tìm được giải pháp, thì chúng tôi ngây thơ cố gắng chọn một trạng từ ngẫu nhiên, hoặc chỉ chèn khoảng trắng để điền vào chỗ trống.

Các kết quả

Tất cả 6 có thể được tìm thấy ở đây: https://gist.github.com/anonymous/5277db726d3f9bdd950b173b19fec82a

Trường hợp thử nghiệm Euclid không suôn sẻ ...

Vá hình ảnh

In a popular image editing software there is a feature, that patches (The term
used in image processing is inpainting as @minxomat pointed out.) a selected
area of an image, that patches information outside of that patch. And it does a
quite good job, co the patch a is just a program. As a human, you can sometimes
see that something In a short it if you squeeze your eyes or just take a short
glance, the patch seems to fill in the gap quite well.

Jabberwocky

'Twas brillig, and the slithy toves
Did gyre and the in in the wabe;
All mimsy the mome borogoves,
And the mome raths outgrabe.

Con lửng

Badger, badger, badger, badger, badger,
badger, badger, badger, badger, badger
Mushroom, mushroom, a-
Badger, badger, badger, badger, badger,
badger, badger, badger, badger, badger
Mushroom, badger, badger
Badger, badger, badger, badger, badger,
badger, badger, badger, badger, badger
Mush-mushroom, a
Badger, badger, badger, badger, badger,
badger, badger, badger, badger, badger
Argh! Snake, a snake!
Snaaake! A snaaaake, oooh its a snake!

_ Tôi rất vui với cách mà cái này bật ra ... nó củng cố rằng "kẻ xấu, kẻ xấu", hoặc người này sẽ không làm tốt như vậy

Mã

Chạy nó với

csc ParaPatch.cs
ParaPatch.exe infile outfile

Có khá nhiều đó. Các bit thú vị từ xa duy nhất là Fillphương pháp. Tôi bao gồm việc thực hiện heap, vì .NET không có (TẠI SAO MS TẠI SAO?!).

using System;
using System.Collections.Generic;
using System.Linq;

namespace ParaPatch
{
    class Program
    {
        private static string[] Filler = new string[] { "may", "will", "maybe", "rather", "perhaps", "reliably", "nineword?", "definitely", "elevenword?", "inexplicably" }; // adverbs
        private static char[] Breaking = new char[] { ' ', '\n', '\r', '\t' };
        private static char[] Punctuation = new char[] { ',', '.', '{', '}', '(', ')', '/', '?', ':', ';', '\'', '\\', '"', ',', '!', '-', '+', '[', ']', '£', '$', '%', '^', '—' };

        private static IEnumerable<string> TokenizeStream(System.IO.StreamReader reader)
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder();

            HashSet<char> breaking = new HashSet<char>(Breaking);
            HashSet<char> punctuation = new HashSet<char>(Punctuation);

            while (!reader.EndOfStream)
            {
                int ci = reader.Read();
                if (ci == -1) // sanity
                    break;

                char c = (char)ci;

                if (breaking.Contains(c))
                {
                    if (sb.Length > 0)
                        yield return sb.ToString();
                    sb.Clear();
                }
                else if (punctuation.Contains(c))
                {
                    if (sb.Length > 0)
                        yield return sb.ToString();
                    yield return ""+c;
                    sb.Clear();
                }
                else
                {

                    sb.Append(c);
                }
            }

            if (sb.Length > 0)
                yield return sb.ToString();
        }

        private enum DocTokenTypes
        {
            Known,
            LeftPartial,
            RightPartial,
            Unknown,
        }

        private class DocToken
        {
            public DocTokenTypes TokenType { get; private set; }
            public string StringPart { get; private set; }
            public int Length { get; private set; }

            public DocToken(DocTokenTypes tokenType, string stringPart, int length)
            {
                TokenType = tokenType;
                StringPart = stringPart;
                Length = length;
            }
        }

        private static IEnumerable<DocToken> DocumentTokens(IEnumerable<string> tokens)
        {
            foreach (string token in tokens)
            {
                if (token.Contains("#"))
                {
                    int l = token.IndexOf("#");
                    int r = token.LastIndexOf("#");

                    if (l > 0)
                        yield return new DocToken(DocTokenTypes.LeftPartial, token.Substring(0, l), l);

                    yield return new DocToken(DocTokenTypes.Unknown, null, r - l + 1);

                    if (r < token.Length - 1)
                        yield return new DocToken(DocTokenTypes.RightPartial, token.Substring(r + 1), token.Length - r - 1);
                }
                else
                    yield return new DocToken(DocTokenTypes.Known, token, token.Length);
            }
        }

        private class State : IComparable<State>
        {
            // missing readonly params already... maybe C#6 isn't so bad
            public int Remaining { get; private set; }
            public int Position { get; private set; }
            public State Prev { get; private set; }
            public string Token { get; private set; }
            public double H { get; private set; }
            public double Fabness { get; private set; }
            public string FullFilling { get; private set; }

            public State(int remaining, int position, Program.State prev, double fabness, double h, string token, string toAdd)
            {
                Remaining = remaining;
                Position = position;
                Prev = prev;
                H = h;
                Fabness = fabness;
                Token = token;

                FullFilling = prev != null ? prev.FullFilling + toAdd : toAdd;
            }

            public int CompareTo(State other)
            {
                return H.CompareTo(other.H);
            }
        }

        public static void Main(string[] args)
        {
            if (args.Length < 2)
                args = new string[] { "test.txt", "testout.txt" };

            List<DocToken> document;
            using (System.IO.StreamReader reader = new System.IO.StreamReader(args[0], System.Text.Encoding.UTF8))
            {
                document = DocumentTokens(TokenizeStream(reader)).ToList();
            }

            foreach (DocToken cur in document)
            {
                Console.WriteLine(cur.StringPart + " " + cur.TokenType);
            }

            // these are small docs, don't bother with more than 1 ply
            Dictionary<string, Dictionary<string, int>> FollowCounts = new Dictionary<string, Dictionary<string, int>>();
            Dictionary<string, Dictionary<string, int>> PreceedCounts = new Dictionary<string, Dictionary<string, int>>(); // mirror (might be useful)

            HashSet<string> knowns = new HashSet<string>(); // useful to have lying around

            // build counts
            DocToken last = null;
            foreach (DocToken cur in document)
            {
                if (cur.TokenType == DocTokenTypes.Known)
                {
                    knowns.Add(cur.StringPart);
                }

                if (last != null && last.TokenType == DocTokenTypes.Known && cur.TokenType == DocTokenTypes.Known)
                {
                    {
                        Dictionary<string, int> ltable;
                        if (!FollowCounts.TryGetValue(last.StringPart, out ltable))
                        {
                            FollowCounts.Add(last.StringPart, ltable = new Dictionary<string, int>());
                        }

                        int count;
                        if (!ltable.TryGetValue(cur.StringPart, out count))
                        {
                            count = 0;
                        }
                        ltable[cur.StringPart] = count + 1;
                    }


                    {
                        Dictionary<string, int> ctable;
                        if (!PreceedCounts.TryGetValue(cur.StringPart, out ctable))
                        {
                            PreceedCounts.Add(cur.StringPart, ctable = new Dictionary<string, int>());
                        }

                        int count;
                        if (!ctable.TryGetValue(last.StringPart, out count))
                        {
                            count = 0;
                        }
                        ctable[last.StringPart] = count + 1;
                    }
                }

                last = cur;
            }

            // build probability grid (none of this efficient table filling dynamic programming nonsense, A* all the way!)
            // hmm... can't be bothered
            Dictionary<string, Dictionary<string, double>> fabTable = new Dictionary<string, Dictionary<string, double>>();
            foreach (var k in FollowCounts)
            {
                Dictionary<string, double> t = new Dictionary<string, double>();

                // very naive
                foreach (var k2 in k.Value)
                {
                    t.Add(k2.Key, (double)k2.Value);
                }

                fabTable.Add(k.Key, t);
            }

            string[] knarr = knowns.ToArray();
            Random rnd = new Random("ParaPatch".GetHashCode());

            List<string> fillings = new List<string>();
            for (int i = 0; i < document.Count; i++)
            {
                if (document[i].TokenType == DocTokenTypes.Unknown)
                {
                    // shuffle knarr
                    for (int j = 0; j < knarr.Length; j++)
                    {
                        string t = knarr[j];
                        int o = rnd.Next(knarr.Length);
                        knarr[j] = knarr[o];
                        knarr[o] = t;
                    }

                    fillings.Add(Fill(document, fabTable, knarr, i));
                    Console.WriteLine(fillings.Last());
                }
            }

            string filling = string.Join("", fillings);

            int fi = 0;

            using (System.IO.StreamWriter writer = new System.IO.StreamWriter(args[1]))
            using (System.IO.StreamReader reader = new System.IO.StreamReader(args[0]))
            {
                while (!reader.EndOfStream)
                {
                    int ci = reader.Read();
                    if (ci == -1)
                        break;

                    char c = (char)ci;
                    c = c == '#' ? filling[fi++] : c;

                    writer.Write(c);
                    Console.Write(c);
                }
            }

//            using (System.IO.StreamWriter writer = new System.IO.StreamWriter(args[1], false, System.Text.Encoding.UTF8))
//            using (System.IO.StreamReader reader = new System.IO.StreamReader(args[0]))
//            {
//                foreach (char cc in reader.ReadToEnd())
//                {
//                    char c = cc;
//                    c = c == '#' ? filling[fi++] : c;
//                    
//                    writer.Write(c);
//                    Console.Write(c);
//                }
//            }

            if (args[0] == "test.txt")
                Console.ReadKey(true);
        }

        private static string Fill(List<DocToken> document, Dictionary<string, Dictionary<string, double>> fabTable, string[] knowns, int unknownIndex)
        {
            HashSet<char> breaking = new HashSet<char>(Breaking);
            HashSet<char> punctuation = new HashSet<char>(Punctuation);

            Heap<State> due = new Heap<Program.State>(knowns.Length);

            Func<string, string, double> fabness = (prev, next) =>
            {
                Dictionary<string, double> table;
                if (!fabTable.TryGetValue(prev, out table))
                    return 0; // not fab
                double fab;
                if (!table.TryGetValue(next, out fab))
                    return 0; // not fab
                return fab; // yes fab
            };

            DocToken mostLeft = unknownIndex > 2 ? document[unknownIndex - 2] : null;
            DocToken left = unknownIndex > 1 ? document[unknownIndex - 1] : null;
            DocToken unknown = document[unknownIndex];
            DocToken right = unknownIndex < document.Count - 2 ? document[unknownIndex + 1] : null;
            DocToken mostRight = unknownIndex < document.Count - 3 ? document[unknownIndex + 2] : null;

            // sum of empty space and partials' lengths
            int spaceSize = document[unknownIndex].Length
                + (left != null && left.TokenType == DocTokenTypes.LeftPartial ? left.Length : 0)
                + (right != null && right.TokenType == DocTokenTypes.RightPartial ? right.Length : 0);

            int l = left != null && left.TokenType == DocTokenTypes.LeftPartial ? left.Length : 0;
            int r = l + unknown.Length;

            string defaultPrev =
                left != null && left.TokenType == DocTokenTypes.Known ? left.StringPart :
                mostLeft != null && mostLeft.TokenType == DocTokenTypes.Known ? mostLeft.StringPart :
                "";

            string defaultLast =
                right != null && right.TokenType == DocTokenTypes.Known ? right.StringPart :
                mostRight != null && mostRight.TokenType == DocTokenTypes.Known ? mostRight.StringPart :
                "";

            Func<string, string> topAndTail = str =>
            {
                return str.Substring(l, r - l);
            };

            Func<State, string, double, bool> tryMove = (State prev, string token, double specialFabness) => 
            {
                bool isPunctionuation = token.Length == 1 && punctuation.Contains(token[0]);
                string addStr = isPunctionuation || prev == null ? token : " " + token;
                int addLen = addStr.Length;

                int newRemaining = prev != null ? prev.Remaining - addLen : spaceSize - addLen;
                int oldPosition = prev != null ? prev.Position : 0;
                int newPosition = oldPosition + addLen;

                // check length
                if (newRemaining < 0)
                    return false;

                // check start
                if (oldPosition < l) // implies left is LeftPartial
                {
                    int s = oldPosition;
                    int e = newPosition > l ? l : newPosition;
                    int len = e - s;
                    if (addStr.Substring(0, len) != left.StringPart.Substring(s, len))
                        return false; // doesn't match LeftPartial
                }

                // check end
                if (newPosition > r) // implies right is RightPartial
                {
                    int s = oldPosition > r ? oldPosition : r;
                    int e = newPosition;
                    int len = e - s;
                    if (addStr.Substring(s - oldPosition, len) != right.StringPart.Substring(s - r, len))
                        return false; // doesn't match RightPartial
                }

                if (newRemaining == 0)
                {
                    // could try to do something here (need to change H)
                }

                string prevToken = prev != null ? prev.Token : defaultPrev;
                bool isLastunctionuation = prevToken.Length == 1 && punctuation.Contains(prevToken[0]);

                if (isLastunctionuation && isPunctionuation) // I hate this check, it's too aggresive to be realistic
                    specialFabness -= 50;

                double fab = fabness(prevToken, token);

                if (fab < 1 && (token == prevToken))
                    fab = -1; // bias against unrecognised repeats

                double newFabness = (prev != null ? prev.Fabness : 0.0)
                    - specialFabness // ... whatever this is
                    - fab * addLen; // how probabilistic

                double h = newFabness; // no h for now

                State newState = new Program.State(newRemaining, newPosition, prev, newFabness, h, token, addStr);

//                Console.WriteLine((prev != null ? prev.Fabness : 0) + "\t" + specialFabness);
//                Console.WriteLine(newFabness + "\t" + h + "\t" + due.Count + "\t" + fab + "*" + addLen + "\t" + newState.FullFilling);

                due.Add(newState);
                return true;
            };

            // just try everything everything
            foreach (string t in knowns)
                tryMove(null, t, 0);

            if (left != null && left.TokenType == DocTokenTypes.LeftPartial)
                tryMove(null, left.StringPart, -1);

            while (!due.Empty)
            {
                State next = due.RemoveMin();

                if (next.Remaining == 0)
                {
                    // we have a winner!!
                    return topAndTail(next.FullFilling);
                }

                // just try everything
                foreach (string t in knowns)
                    tryMove(next, t, 0);
                if (right != null && right.TokenType == DocTokenTypes.RightPartial)
                    tryMove(next, right.StringPart, -5); // big bias
            }

            // make this a tad less stupid, non?
            return Filler.FirstOrDefault(f => f.Length == unknown.Length) ?? new String(' ', unknown.Length); // oh dear...
        }
    }

    //
    // Ultilities
    //

    public class Heap<T> : System.Collections.IEnumerable where T : IComparable<T>
    {
        // arr is treated as offset by 1, all idxes stored need to be -1'd to get index in arr
        private T[] arr;
        private int end = 0;

        private void s(int idx, T val)
        {
            arr[idx - 1] = val;
        }

        private T g(int idx)
        {
            return arr[idx - 1];
        }

        public Heap(int isize)
        {
            if (isize < 1)
                throw new ArgumentException("Cannot be less than 1", "isize");

            arr = new T[isize];
        }

        private int up(int idx)
        {
            return idx / 2;
        }

        private int downLeft(int idx)
        {
            return idx * 2;
        }

        private int downRight(int idx)
        {
            return idx * 2 + 1;
        }

        private void swap(int a, int b)
        {
            T t = g(a);
            s(a, g(b));
            s(b, t);
        }

        private void moveUp(int idx, T t)
        {
        again:
            if (idx == 1)
            {
                s(1, t);
                return; // at end
            }

            int nextUp = up(idx);
            T n = g(nextUp);
            if (n.CompareTo(t) > 0)
            {
                s(idx, n);
                idx = nextUp;
                goto again;
            }
            else
            {
                s(idx, t);
            }
        }

        private void moveDown(int idx, T t)
        {
        again:
            int nextLeft = downLeft(idx);
            int nextRight = downRight(idx);

            if (nextLeft > end)
            {
                s(idx, t);
                return; // at end
            }
            else if (nextLeft == end)
            { // only need to check left
                T l = g(nextLeft);

                if (l.CompareTo(t) < 0)
                {
                    s(idx, l);
                    idx = nextLeft;
                    goto again;
                }
                else
                {
                    s(idx, t);
                }
            }
            else
            { // check both
                T l = g(nextLeft);
                T r = g(nextRight);

                if (l.CompareTo(r) < 0)
                { // left smaller (favour going right if we can)
                    if (l.CompareTo(t) < 0)
                    {
                        s(idx, l);
                        idx = nextLeft;
                        goto again;
                    }
                    else
                    {
                        s(idx, t);
                    }
                }
                else
                { // right smaller or same
                    if (r.CompareTo(t) < 0)
                    {
                        s(idx, r);
                        idx = nextRight;
                        goto again;
                    }
                    else
                    {
                        s(idx, t);
                    }
                }
            }
        }

        public void Clear()
        {
            end = 0;
        }

        public void Trim()
        {
            if (end == 0)
                arr = new T[1]; // don't /ever/ make arr len 0
            else
            {
                T[] narr = new T[end];
                for (int i = 0; i < end; i++)
                    narr[i] = arr[i];
                arr = narr;
            }
        }

        private void doubleSize()
        {
            T[] narr = new T[arr.Length * 2];
            for (int i = 0; i < end; i++)
                narr[i] = arr[i];
            arr = narr;
        }

        public void Add(T item)
        {
            if (end == arr.Length)
            {
                // resize
                doubleSize();
            }

            end++;
            moveUp(end, item);
        }

        public T RemoveMin()
        {
            if (end < 1)
                throw new Exception("No items, mate.");

            T min = g(1);

            end--;
            if (end > 0)
                moveDown(1, g(end + 1));

            return min;
        }

        public bool Empty
        {
            get
            {
                return end == 0;
            }
        }

        public int Count
        {
            get
            {
                return end;
            }
        }

        System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
        {
            return GetEnumerator();
        }

        public IEnumerator<T> GetEnumerator()
        {
            return (IEnumerator<T>)arr.GetEnumerator();
        }
    }
}