Problem

Sie erhalten eine Folge von farbigen Kugeln (rot Rund grün G). Eine solche mögliche Sequenz ist:

RGGGRRGGRGRRRGGGRGRRRG

In so wenigen Zügen wie möglich müssen Sie es so machen, dass jeder Ball eine andere Farbe als seine Nachbarn hat (dh die Reihenfolge wechselt).

RGRGRGRGRGRGRGRGRGRGRG

Sie sollten ein Programm schreiben, das eine ungeordnete Sequenz (in diesem Fall eine Zeichenfolge) mit der gleichen Anzahl von "R" und "G" in eine Sequenz konvertieren kann, in der sich die Elemente abwechseln. Im Folgenden finden Sie eine Beispielsitzung für einen naiven Algorithmus ( <wird in das Programm eingegeben, >wird ausgegeben. Es ist nicht erforderlich, die Carets in die Eingabe oder Ausgabe aufzunehmen.)

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

Eine andere Möglichkeit ist die Ausgabe von "5,7", um beispielsweise das Vertauschen der Positionen 5 und 7 anzuzeigen.

Sie können zuerst entweder Rot oder Grün positionieren und müssen nicht konsistent sein. Jede Sequenz hat die gleiche Länge wie jede andere Sequenz.

Sie dürfen in jedem Zug nur zwei beliebige Buchstaben tauschen (sie müssen nicht nebeneinander liegen.)

Gewinnkriterien

Das Programm muss jeden Schritt des Sortiervorgangs anzeigen. Das Programm, das für alle unten aufgeführten Zeichenfolgen die wenigsten Gesamtbewegungen ausführt, gewinnt. Bei einem Unentschieden gewinnt der kürzeste Code.

Eingabezeichenfolgen

Die folgenden Zeichenfolgen werden zum Testen der Programme verwendet:

GGGGGGGGGGRRRRRRRRRR
GGRRGGRRGGRRGGRRGGRR
RRGGGGRRRRGGGGRRRRGG
GRRGRGGGGRRRGGGGRRRR
GRGGGRRRRGGGRGRRGGRR
RGRGRGRGRGRGRGRGRGRG

Die letzte Sequenz sollte zu Nullbewegungen führen.

Python, 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←⍞

Das Ausführen der angegebenen Testfälle ergibt:

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

Die obige Lösung verwendet den Indexursprung 1 mit den in den Spalten der Ergebnismatrix angegebenen Swaps. Zwei Zeichen können gespeichert werden, wenn der Eingabevektor i vor der Ausführung mit der Eingabezeichenfolge initialisiert wird, anstatt zum Zeitpunkt der Ausführung eingegeben zu werden.

GolfScript (47 Zeichen)

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

ZB (unter Verwendung eines Testfalls, der viel einfacher auf Richtigkeit zu überprüfen ist als jeder der vorgeschlagenen, auf den alle viele richtige Antworten haben):

< RRGGRGRGRGRGRGRGRGRG
> [[1 2]]

Die Ausgabe ist eine Liste von Paaren mit Nullindex, die ausgetauscht werden sollen.

Python, 213 Zeichen

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

Mfindet die Bewegungen umwandeln erforderlich Szu T. Dies geschieht, indem wiederholt eine Rund eine GPosition außerhalb der Position gefunden und ausgetauscht wird. Wir finden dann die kürzere Bewegungssequenz, um entweder RGRG...RGoder zu gelangen GRGR...GR.

Sollte für jede Eingabe eine optimale Abfolge von Bewegungen finden.

Mathematica 238

Code

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]ist ein einzelnes Zeichen, ein hochgestelltes "t" in Mathematica ]

Beispiele

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

Mathematica 134 oder 124

Abhängig davon, wie Sie "Transponieren []" zählen, was in Mathematica nur ein Zeichen ist (hier keine Darstellung). Zur Verdeutlichung hinzugefügte Leerzeichen

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]] &

Stichprobe:

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

Ausgabe

{{{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 Zeichen

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

Eine große Herausforderung, die mich einige Zeit beschäftigt hat.
Hier die Codeergebnisse für die Testfälle:

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 Züge - 193 Zeichen

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

Könnte immer noch versuchen, dies zu verbessern ...

red_green.php?a=GGGGGGGGGGRRRRRRRRRR

GRGGGGGGGGGRRRRRRRRR
GRGRGGGGGGGGRRRRRRRR
GRGRGRGGGGGGGRRRRRRR
GRGRGRGRGGGGGGRRRRRR
GRGRGRGRGRGGGGGRRRRR
GRGRGRGRGRGRGGGGRRRR
GRGRGRGRGRGRGRGGGRRR
GRGRGRGRGRGRGRGRGGRR
GRGRGRGRGRGRGRGRGRGR