Vấn đề

Bạn được cung cấp một chuỗi các quả bóng màu (đỏ Rvà xanh lá cây G). Một chuỗi có thể là:

RGGGRRGGRGRRRGGGRGRRRG

Trong càng ít lần di chuyển càng tốt, bạn phải thực hiện sao cho mỗi quả bóng có màu khác nhau với các hàng xóm của nó (tức là chuỗi luân phiên.)

RGRGRGRGRGRGRGRGRGRGRG

Bạn nên viết một chương trình có thể chuyển đổi một chuỗi không có thứ tự (trong trường hợp này là một chuỗi) với số lượng bằng "R" và "G" thành một chuỗi trong đó các mục thay thế. Một phiên ví dụ bên dưới, đối với thuật toán ngây thơ ( <là đầu vào cho chương trình, >là đầu ra. Không cần thiết phải bao gồm các dấu mũ trên đầu vào hoặc đầu ra.)

< RGGGRRGGRGRRRGGGRGRRRG
> RGGRGRGGRGRRRGGGRGRRRG
> RGRGGRGGRGRRRGGGRGRRRG
> RGRGRGGGRGRRRGGGRGRRRG
> RGRGRGGRGGRRRGGGRGRRRG
> RGRGRGGRGRGRRGGGRGRRRG
> RGRGRGGRGRGRGRGRGGRRRG
> RGRGRGGRGRGRGRGRGRGRRG
> RGRGRGGRGRGRGRGRGRGRGR
> RGRGRGRGGRGRGRGRGRGRGR
> RGRGRGRGRGGRGRGRGRGRGR
> RGRGRGRGRGRGGRGRGRGRGR
> RGRGRGRGRGRGRGGRGRGRGR
> RGRGRGRGRGRGRGRGGRGRGR
> RGRGRGRGRGRGRGRGRGGRGR
> RGRGRGRGRGRGRGRGRGRGGR
> RGRGRGRGRGRGRGRGRGRGRG (15 moves)

Một khả năng khác là xuất ra "5,7" chẳng hạn để chỉ ra sự hoán đổi vị trí 5 và 7.

Bạn có thể xác định vị trí một trong hai màu đỏ hoặc màu xanh lá cây đầu tiên, và bạn không cần phải nhất quán. Mỗi chuỗi sẽ có cùng độ dài như mọi chuỗi khác.

Bạn chỉ có thể hoán đổi bất kỳ hai chữ cái trong mỗi lần di chuyển (chúng không cần phải liền kề.)

Tiêu chí chiến thắng

Chương trình phải hiển thị từng bước của quá trình sắp xếp. Chương trình thực hiện tổng số lần di chuyển ít nhất cho tất cả các chuỗi bên dưới, sẽ thắng. Nếu có hòa, mã ngắn nhất sẽ thắng.

Chuỗi đầu vào

Các chuỗi sau đây sẽ được sử dụng để kiểm tra các chương trình:

GGGGGGGGGGRRRRRRRRRR
GGRRGGRRGGRRGGRRGGRR
RRGGGGRRRRGGGGRRRRGG
GRRGRGGGGRRRGGGGRRRR
GRGGGRRRRGGGRGRRGGRR
RGRGRGRGRGRGRGRGRGRG

Trình tự cuối cùng sẽ dẫn đến không di chuyển.

Con trăn, 140 122 119 115

r=raw_input()
f=lambda x:[i for i in range(x,len(r),2)if x-(r[i]!=max('RG',key=r[::2].count))]
print zip(f(0),f(1))

APL 46

((2|y)/y←(i≠↑i)/n),[.1](~2|y)/y←(i=↑i)/n←⍳⍴i←⍞

Chạy các trường hợp thử nghiệm nhất định mang lại:

GGGGGGGGGGRRRRRRRRRR
11 13 15 17 19
 2  4  6  8 10

GGRRGGRRGGRRGGRRGGRR
3 7 11 15 19
2 6 10 14 18

RRGGGGRRRRGGGGRRRRGG
3 5 11 13 19
2 8 10 16 18

GRRGRGGGGRRRGGGGRRRR
3 5 11 17 19
4 6  8 14 16

GRGGGRRRRGGGRGRRGGRR
7  9 13 15 19
4 10 12 14 18

RGRGRGRGRGRGRGRGRGRG

Giải pháp trên sử dụng chỉ số gốc 1 với các hoán đổi được đưa ra trong các cột của ma trận kết quả. Hai ký tự có thể được lưu nếu vectơ đầu vào i được khởi tạo với chuỗi đầu vào trước khi thực hiện thay vì là đầu vào tại thời điểm thực hiện.

GolfScript (47 ký tự)

:S;4,{S,,{.S=1&3*\1&2*^1$=},\;}%2/{zip}%{,}$0=`

Ví dụ: (sử dụng trường hợp kiểm tra dễ kiểm tra tính chính xác hơn bất kỳ trường hợp nào được đề xuất, tất cả đều có nhiều câu trả lời đúng):

< RRGGRGRGRGRGRGRGRGRG
> [[1 2]]

Đầu ra là một danh sách các cặp chỉ số không để trao đổi.

Python, 213 ký tự

I=raw_input()
def M(S,T):
 S=list(S);m=[]
 while S!=list(T):z=zip(S,T);x=z.index(('R','G'));y=z.index(('G','R'));m+=[(x,y)];S[x],S[y]='GR'
 return m
N=len(I)/2
x=M(I,N*'RG')
y=M(I,N*'GR')
print[x,y][len(x)>len(y)]

Mtìm thấy các động thái cần thiết để chuyển đổi Ssang T. Nó thực hiện điều này bằng cách liên tục tìm Rvà Gthoát khỏi vị trí và hoán đổi chúng. Sau đó chúng tôi tìm thấy chuỗi di chuyển ngắn hơn để đến RGRG...RGhoặc GRGR...GR.

Nên tìm một chuỗi di chuyển tối ưu cho mọi đầu vào.

Toán học 238

Mã

f[x_] := With[{g = "GRGRGRGRGRGRGRGRGRGR", c = Characters, p = Position},
y = c[x]; s = c[g]; {v = Equal @@@ ({s, y}\[Transpose]), 
w = Not /@ v}; {vv = Thread[{y, v}], ww = Thread[{y, w}]};
((Flatten /@ {p[#, {"R", False}], p[#, {"G", False}]}) &[If[Count[Equal @@@ 
({s, y}\[Transpose]), False] < 10, vv, ww]])\[Transpose]]

NB: \[Transpose]là một ký tự đơn, một chữ "t" được viết lại, trong Mathicala ]

Ví dụ

f@"GGGGGGGGGGRRRRRRRRRR"
f@"GGRRGGRRGGRRGGRRGGRR"
f@"RRGGGGRRRRGGGGRRRRGG"
f@"GRRGRGGGGRRRGGGGRRRR"
f@"GRGGGRRRRGGGRGRRGGRR"
f@"RGRGRGRGRGRGRGRGRGRG"
f@"GRGRGRGRGRGRGRGRGRGR"

{{12, 1}, {14, 3}, {16, 5}, {18, 7}, {20, 9}}
{{4, 1}, {8, 5}, {12, 9}, {16, 13}, {20, 17}}
{{2, 3}, {8, 5}, {10, 11}, {16, 13}, {18, 19}}
{{2, 1}, {10, 7}, {12, 9}, {18, 13}, {20, 15}}
{{2, 1}, {6, 3}, {8, 5}, {16, 11}, { 20, 17}}
{}
{}

Toán học 134 hoặc 124

Tùy thuộc vào cách bạn đếm "Transpose []" mà trên Mathicala chỉ là một char (không có đại diện ở đây). Không gian được thêm vào cho rõ ràng

G = 0; R = 1; 
x_~ d ~ y__:= Transpose[Position[Symbol /@ Characters@x - PadLeft[{}, 20, {y}], #, 1] &
                                                                                 /@ {1, -1}]
f = SortBy[{d[#, 0, 1], d[#, 1, 0]}, Length][[1]] &

Mẫu vật:

f@"GGGGGGGGGGRRRRRRRRRR"
f@"GGRRGGRRGGRRGGRRGGRR"
f@"RRGGGGRRRRGGGGRRRRGG"
f@"GRRGRGGGGRRRGGGGRRRR"
f@"GRGGGRRRRGGGRGRRGGRR"
f@"RGRGRGRGRGRGRGRGRGRG"
f@"GRGRGRGRGRGRGRGRGRGR"

Đầu ra

{{{11}, {2}}, {{13}, {4}}, {{15},  {6}}, {{17},  {8}}, {{19}, {10}}}
{{{3},  {2}}, {{7},  {6}}, {{11}, {10}}, {{15}, {14}}, {{19}, {18}}}
{{{1},  {4}}, {{7},  {6}}, {{9},  {12}}, {{15}, {14}}, {{17}, {20}}}
{{{2},  {1}}, {{10}, {7}}, {{12},  {9}}, {{18}, {13}}, {{20}, {15}}}
{{{2},  {1}}, {{6},  {3}}, {{8},   {5}}, {{16}, {11}}, {{20}, {17}}}
{}
{}

Javascript - 173 ký tự

a=prompt(w=[[],[]]).split('');for(i=a.length,f=a[0];i--;)if(i%2<1&&a[i]!=f)w[0].push(i);else if(i%2>0&&a[i]==f)w[1].push(i);for(i=w[0].length;i--;)alert(w[0][i]+','+w[1][i])

Một thử thách lớn, khiến tôi bận rộn một thời gian.
Đây là kết quả mã cho các trường hợp thử nghiệm:

GGGGGGGGGGRRRRRRRRRR: [10, 1] [12, 3] [14, 5] [16, 7] [18, 9]
GGRRGGRRGGRRGGRRGGRR: [ 2, 1] [ 6, 5] [10, 9] [14,13] [18,17]
RRGGGGRRRRGGGGRRRRGG: [ 2, 1] [ 4, 7] [10, 9] [12,15] [18,17]
GRRGRGGGGRRRGGGGRRRR: [ 2, 3] [ 4, 5] [10, 7] [16,13] [18,15]
GRGGGRRRRGGGRGRRGGRR: [ 6, 3] [ 8, 9] [12,11] [14,13] [18,17]
RGRGRGRGRGRGRGRGRGRG:

PHP - 34 di chuyển - 193 ký tự

$l=strlen($a=$_GET["a"]);$n=$a[0]=="R"?"G":"R";while($i<$l){if($a[++$i]!=$n){echo$o."
";$o=$a=substr($a,0,$i).$n.preg_replace("/".$n."/",$n=="R"?"G":"R",substr($a,$i+1),1);}$n=$n=="R"?"G":"R";}

Vẫn có thể cố gắng cải thiện điều này ...

red_green.php?a=GGGGGGGGGGRRRRRRRRRR

GRGGGGGGGGGRRRRRRRRR
GRGRGGGGGGGGRRRRRRRR
GRGRGRGGGGGGGRRRRRRR
GRGRGRGRGGGGGGRRRRRR
GRGRGRGRGRGGGGGRRRRR
GRGRGRGRGRGRGGGGRRRR
GRGRGRGRGRGRGRGGGRRR
GRGRGRGRGRGRGRGRGGRR
GRGRGRGRGRGRGRGRGRGR