Lý lịch

Nghi thức phòng tắm, khi liên quan đến bồn tiểu có sẵn, nói rằng bồn tiểu tiếp theo được lấp đầy phải là thứ làm giảm thiểu sự khó chịu hoàn toàn. Phương trình tổng khó chịu được đưa ra bởi các phương trình sau:

dist (x, y) = khoảng cách tuyến tính giữa người x và người y trong Đơn vị tiết niệu
 khó chịu (x) = sum (1 / (dist (x, y) * dist (x, y))) cho tất cả những người y trừ người x
 Total_Diseasure = sum (sự khó chịu (x)) cho tất cả x

Một bài viết chuyên sâu hơn liên quan đến một vấn đề tương tự (không phải chính xác) có thể được tìm thấy ở đây: (Cảm ơn @Lembik đã cảnh báo tôi về whitepaper tuyệt vời này!)

Đầu ra đầu vào

Đưa ra một đầu vào của một bồn tiểu trống rỗng và đầy đủ, xuất ra tập hợp các bồn tiểu có thêm một người. Nếu có một chiếc cà vạt cho một vị trí, bồn tiểu nên điền từ trái sang phải. Đầu ra phải có cùng định dạng với đầu vào.

• Nếu được cung cấp một trường hợp với đầy đủ bồn tiểu, trả lại đầu vào.
• Đầu vào sẽ luôn có ít nhất một bồn tiểu được xác định.

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

VÀO -> ĐẦU RA
1000001 -> 1001001
101010101 -> 111010101
100 -> 101
00000 -> 10000
1111111 -> 1111111
0100 -> 0101
101000 -> 101001

Quy tắc

Đây là mã golf , vì vậy mã ngắn nhất tính bằng byte thắng. Lỗ vòng tiêu chuẩn bị cấm.

Thạch , 13 12 byte

J_þTݲSiṂ$Ṭo

Hãy thử trực tuyến! hoặc Xác minh tất cả các trường hợp thử nghiệm.

Giải trình

J_þTݲSiṂ$Ṭo  Input: boolean array A
J             Indices, returns [1, 2, ..., len(A)]
   T          Truthy indices, returns the indices which have a truthy value
 _þ           Form the subtraction (_) table (þ) between them
    İ         Inverse, find the reciprocal of each
     ²        Square each
      S       Sum the sublists column-wise
         $    Monadic chain
        Ṃ       Minimum
       i        Find the first index of that
          Ṭ   Untruth indices, returns a boolean array with 1's at those indices
           o  Logical OR between that and A, and return

MATL , 19 18 17 byte

lyf!Gn:-H_^Xs&X<(

Hãy thử trực tuyến! Hoặc xác minh tất cả các trường hợp thử nghiệm (mã sửa đổi một chút).

Giải trình

Nó đủ để tính khoảng cách từ mỗi vị trí mới tiềm năng đến những vị trí đã chiếm. Các khoảng cách còn lại không phụ thuộc vào vị trí mới tiềm năng và do đó tạo thành một thuật ngữ không đổi, có thể bỏ qua.

Hãy lấy đầu vào [1 0 0 0 0 0 1]làm ví dụ.

l      % Push 1
       % STACK: 1
y      % Take input implicitly. Duplicate from below
       % STACK: [1 0 0 0 0 0 1], 1, [1 0 0 0 0 0 1]
f!     % Indices of nonzero elements, as a column array
       % STACK: [1 0 0 0 0 0 1], 1, [1 7]
Gn:    % Push [1 2 ... n], where n is input size (array of possible positions)
       % STACK: [1 0 0 0 0 0 1], 1, [1; 7], [1 2 3 4 5 6 7]
-      % Matrix with all pairs of differences 
       % STACK: [1 0 0 0 0 0 1], 1, [1; 7], [0 -1 -2 -3 -4 -5 -6;
                                             6  5  4  3  2  1  0]
H_^    % Raise each entry to -2
       % STACK: [1 0 0 0 0 0 1], 1, [   Inf 1.0000 0.2500 0.1111 0.0625 0.0400 0.0278;
                                     0.0278 0.0400 0.0625 0.1111 0.2500 1.0000    Inf]
Xs     % Sum of each column
       % STACK: [1 0 0 0 0 0 1], 1, [Inf 1.04 0.3125 0.2222 0.3125 1.04 Inf]
&X<    % Index of minimum. Takes the first if there is a tie
       % STACK: [1 0 0 0 0 0 1], 1, 4
(      % Assign: write 1 at the position of the minimizer
       % STACK: [1 0 0 1 0 0 1]
       % Implicitly display

JavaScript (ES6), 89 byte

a=>a[a.map((e,i)=>!e&&(t=0,a.map((e,j)=>t+=(j-=i)&&e/j/j),t<m&&(m=t,k=i)),k=0,m=1/0),k]=1

Đầu ra bằng cách sửa đổi mảng đầu vào.

R, 83 76 67 byte

Chỉ cần nhận ra rằng tôi có thể lưu một vài byte bằng cách không bận tâm kiểm tra xem các bồn tiểu của ứng viên có trống không. Bồn tiểu không trống sẽ luôn trả về Infgiá trị khó chịu, vì vậy chúng bị loại trừ trong quá trình tính toán. Ngoài ra, chỉ sử dụng lập chỉ mục trực tiếp chứ không phải replace, vì vậy nó ngắn hơn nhưng kém thanh lịch.

x=scan()
x[which.min(rowSums(outer(seq(x),which(!!x),`-`)^-2))]=1
x

Giải trình

x=scan()

Chúng tôi đọc trạng thái hiện tại từ stdin và gọi nó x. Chúng tôi giả định rằng đầu vào là một chuỗi các 1s và 0s được phân tách bằng dấu cách hoặc dòng mới. Đối với mục đích giải thích, giả sử chúng ta nhập liệu 1 0 0 0 0 0 1.

x[which.min(rowSums(outer(seq(x),which(!!x),`-`)^-2))]=1

Chúng tôi thay thế một giá trị xtại một chỉ mục cụ thể bằng 1. Mọi thứ giữa [ ]là tìm ra chỉ số tốt nhất là gì.

Vì các bồn tiểu hiện tại là bất biến, chúng ta không cần phải xem xét khoảng cách giữa chúng. Chúng ta chỉ cần xem xét khoảng cách giữa các bồn tiểu bị chiếm đóng và cái mới có thể. Vì vậy, chúng tôi xác định các chỉ số của bồn tiểu chiếm. Chúng tôi sử dụng which, một hàm để trả về các chỉ số của một vectơ logic TRUE. Tất cả các số trong R, khi bị ép buộc gõ logical, là TRUEnếu khác không và FALSEnếu không. Đơn giản chỉ cần làm which(x)sẽ dẫn đến một lỗi loại argument to 'which' is not logical, như xlà một vectơ số. Do đó chúng ta phải ép buộc nó hợp lý. !là hàm phủ định logic của R, tự động cưỡng chế logic. Áp dụng nó hai lần !!x, mang lại một vectơ TRUEvàFALSEchỉ ra những bồn tiểu nào bị chiếm đóng. (Alternative byte tương đương coercions để logic liên quan đến việc khai thác hợp lý &và |và các lệnh nội trú Tvà F, ví dụ F|xhay T&xvà vân vân. !!xVẻ thán nhiều hơn như vậy chúng tôi sẽ sử dụng.)

                                 which(!!x)

Điều này được ghép nối với seq(x), trả về chuỗi số nguyên từ 1đến chiều dài x, tức là tất cả các vị trí tiết niệu (và do đó tất cả các vị trí có thể xem xét).

                          seq(x)

Bây giờ chúng ta có các chỉ số của các bồn tiểu bị chiếm đóng của chúng ta: 1 7và các bồn tiểu trống rỗng của chúng ta 1 2 3 4 5 6 7. Chúng ta chuyển `-`, hàm trừ, đến outerhàm để lấy "phép trừ bên ngoài", là ma trận khoảng cách sau đây giữa tất cả các bồn tiểu và bồn tiểu bị chiếm đóng:

[, 1] [, 2]

[1,] 0 -6

[2,] 1 -5

[3,] 2 -4

[4,] 3 -3

[5,] 4 -2

[6,] 5 -1

[7,] 6 0

                    outer(seq(x),which(!!x),`-`)

Chúng tôi nâng điều này lên -2sức mạnh thứ. (Đối với những người bị mất một chút, trong OP, "sự khó chịu" được định nghĩa là 1 / (distance(x, y) * distance(x, y)), đơn giản hóa 1/d(x,y)^2, nghĩa là d(x,y)^-2.)

                    outer(seq(x),which(!!x),`-`)^-2

Lấy tổng của mỗi hàng trong ma trận.

            rowSums(outer(seq(x),which(!!x),`-`)^-2)

Lấy chỉ số của giá trị nhỏ nhất, tức là nước tiểu tối ưu. Trong trường hợp có nhiều giá trị nhỏ nhất, giá trị đầu tiên (tức là ngoài cùng bên trái) được trả về.

  which.min(rowSums(outer(seq(x),which(!!x),`-`)^-2))

Và voilà, chúng tôi có chỉ số của nước tiểu tối ưu. Chúng tôi thay thế giá trị tại chỉ số này xbằng 1. Trong trường hợp 1111là đầu vào, chúng ta không thay thế cái nào, chúng ta vẫn có đầu ra hợp lệ.

x[which.min(rowSums(outer(seq(x),which(!!x),`-`)^-2))]=1

Trả lại đầu vào sửa đổi.

x

PHP, 135 byte

$a=explode(1,$argv[1]);$b=0;foreach($a as$c=>$d){$l=strlen($d);if($l>$b){$b=$l;$e=$c;}}if($b)$a[$e][intval($b/2)]=1;echo implode(1,$a);

Tôi chắc chắn rằng có một cách nhanh hơn đáng kể để làm điều đó, nhưng tôi đã có một cái đầu mờ và không thể nghĩ ra!

Mã cũ

Mã mà không cần rút gọn:

$a=explode(1,$argv[1]);
$b=0;
foreach($a as $c=>$d){
    $l=strlen($d);
    if($l>$b){
        $b=$l;
        $e=$c;
    }
}
if($b){
    $a[$e][intval($b/2)]=1;
}
echo implode(1,$a);

Python 3 223 222 165 byte

Được rồi, tôi biết đây không phải là câu trả lời đẹp nhất ngoài kia, và tôi chắc chắn rằng nó có thể bị đánh golf khá nhiều, nhưng tôi chỉ loay hoay và xem những gì tôi có thể làm

Hét lên mbomb007 để biết các mẹo về khoảng trắng và bộ so sánh Ngoài ra, tôi thấy bộ đếm ký tự trực tuyến của mình đã lấy tất cả các tab và biến chúng thành khoảng trắng, vì vậy số lượng ít hơn nhiều so với ban đầu tôi có

def u(a):
 m,r,x=9,0,len(a)
 for i in range(x): 
    d=0
    if a[i]<'1':
     for j in range(x):
        if a[j]>'0':d+=float((j-i)**-2)
     if d<m:r=i;m=d
 return a[:r]+'1'+a[r+1:]

Hiển thị khoảng trắng sửa đổi:

def u(a):
<sp> m,r,x=9,0,len(a)
<sp> for i in range(x): 
<tab> d=0
<tab> if a[i]<'1':
<tab><sp> for j in range(x):
<tab><tab> if a[j]>'0':d+=float((j-i)**-2)
<tab><sp> if d<m:r=i;m=d
<sp> return a[:r]+'1'+a[r+1:]

Nguyên:

def u(a):
    m,r,x=9,0,len(a)
    for i in range(x): 
        d=0
        if a[i]!='1':
            for j in range(x):
                if a[j]=='1':d+=float(1/(j-i)**2)
            if d<m:r=i;m=d
    return a[:r]+'1'+a[r+1:]

Điều này hy vọng một chuỗi được truyền cho chuỗi 1 và 0 like "10001"và trả về một chuỗi"10101"

Chỉnh sửa: Thay đổi 1/float((j-i)**2)thànhfloat((j-i)**-2)

Python 3, 574 471 347 byte

Có lẽ tôi sẽ làm việc với điều này nhiều hơn nữa, coi giải pháp Python khác giống như một phần năm của giải pháp này: [.

def a(I):
 D,l,r={},len(I),range
 for i in r(l):
  if I[i]<1:
   n,t,n[i]=I[:],[],1
   for j in r(l):
    if n[j]>0:
     q,Q=[],0
     for k in r(l):
      if k!=j and n[k]>0:q.append((k-j,j-k)[k<j])
     for i in q:Q+=1/(i**2)
    t.append(Q)
   T=sum(t)
   if T not in D.keys():D[T]=i
 if len(D)>0:I[D[min(D.keys())]]=1
 print(I)

Chà, giờ thì tốt hơn nhiều rồi tôi đã học được rằng bạn có thể sử dụng các không gian duy nhất.

Python, 165 163 158 147 141 140 139 byte

def u(p):e=enumerate;a=[(sum((i-j)**-2for j,y in e(p)if"0"<y),i)for i,x in e(p)if"1">x];return a and p[:min(a)[1]]+"1"+p[min(a)[1]+1:] or p