Wenn Sie ein Array mit positiven Ganzzahlen und zwei unterschiedlichen gültigen Indizes angeben, geben Sie das Array mit den beiden Elementen zurück, die den beiden getauschten Indizes entsprechen.

Sie können zwischen 0-Indizierung und 1-Indizierung wählen, die folgenden Testfälle werden jedoch mit 0-Indizierung behandelt.

array        m n output
[1,2,3,4]    0 1 [2,1,3,4]
[5,8,9]      0 2 [9,8,5]
[11,13,15,3] 1 2 [11,15,13,3]
[11,13,15,3] 2 1 [11,15,13,3]
[11,15,15,3] 2 1 [11,15,15,3]

Das ist Code-Golf . Kürzeste Antwort in Bytes gewinnt. Es gelten Standardlücken .

C/ C ++, 53 50 39 Bytes

f(a,m,n)int*a;{a[m]^=a[n]^=a[m]^=a[n];}

Probieren Sie es online aus

11 Bytes dank @Dennis gespeichert

Operation Flashpoint- Skriptsprache, 98 bis 95 Byte

f={t=_this;a=t select 0;b=+a;m=t select 1;n=t select 2;a set[m,b select n];a set[n,b select m]}

Ändert das Array direkt.

Erläuterung:

t=_this;                   // Give a shorter name for the array of arguments.

a=t select 0;              // Let 'a' be a pointer to the array that we modify.
                           // (The language doesn't have a concept of pointers really,
                           // yet its array variables are pointers to the actual array.)

b=+a;                      // Make a copy of the original array and save a pointer to it
                           // in the variable 'b'. This saves a few bytes later.

m=t select 1;              // Read the index arguments from the input array and save them
n=t select 2;              // to their respective variables.

a set[m,b select n];       // Do the swapping by reading the values from the copy and
a set[n,b select m]        // writing them to the original array. The last semicolon can
                           // be omitted because there are no more statements following 
                           // the last statement.

Rufen Sie an mit:

array = [1,2,3,4];
str = format["%1", array];
[array, 0, 1] call f;
hint format["%1\n%2", str, array];

Ausgabe:

JavaScript ES6, 36 32 Bytes

Schau, Ma, keine temporäre Variable!

(a,m,n)=>[a[m],a[n]]=[a[n],a[m]]

• 4 Bytes gespart dank Neil , der mich auf diesen Konsens aufmerksam gemacht hat.

Versuch es

Geben Sie eine durch Kommas getrennte Liste von Elementen für aund 2 Ganzzahlen für m& ein n.

f=
(a,m,n)=>[a[m],a[n]]=[a[n],a[m]]
oninput=_=>o.innerText=(f(b=i.value.split`,`,+j.value,+k.value),b);o.innerText=(f(b=(i.value="5,8,9").split`,`,j.value=0,k.value=2),b)

*{font-family:sans-serif}input{margin:0 5px 0 0;width:100px;}#j,#k{width:50px;}

<label for=i>a: </label><input id=i><label for=j>m: </label><input id=j type=number><label for=k>n: </label><input id=k type=number><pre id=o>

Python 3 , 41 32 Bytes

-9 Bytes dank @notjagan

def f(a,m,n):a[m],a[n]=a[n],a[m]

Probieren Sie es online!

Ändert das Argument, das ein gültiges Ausgabeformat ist .

Gelee , 7 Bytes

Ṛ,ḷyJ}ị

Probieren Sie es online!

Wie es funktioniert

Ṛ,ḷyJ}ị  Main link. Left argument: [i, j]. Right argument: A (array)

Ṛ        Reverse; yield [j, i].
  ḷ      Left; yield [i, j].
 ,       Pair; yield [[j, i], [i, j]].
    J}   Indices right; yield all indices of A.
   y     Transliterate; replace j with i and i with j.
      ị  Index into A.

Japt , 17 16 Bytes

hV(A=UgV UgW¹hWA

Probieren Sie es online!

Dank ETHproductions ein Byte gespart

MATL , 7 6 Bytes

yyP)w(

Indizes sind 1-basiert.

Probieren Sie es online!

Erläuterung

Betrachten Sie Eingänge [11 13 15 3], [2 3].

yy   % Take two inputs implicitly. Duplicate them
     % STACK: [11 13 15 3], [2 3], [11 13 15 3], [2 3]
P    % Flip
     % STACK: [11 13 15 3], [2 3], [11 13 15 3], [3 2]
)    % Reference indexing (pick indexed entries)
     % STACK: [11 13 15 3], [2 3], [15 13]
w    % Swap
     % STACK: [11 13 15 3], [15 13], [2 3]
(    % Assignment indexing (write values into indexed entries). Implicitly display
     % STACK: [11 15 13 3]

C # (.NET Core) , 48 43 31 Bytes

(a,m,n)=>a[m]+=a[n]-(a[n]=a[m])

Probieren Sie es online!

Tauscht die Zahlen im ursprünglichen Array aus, ohne dass temporäre Variablen verwendet werden. Trotzdem kann ich diese Antwort nicht würdigen, da es Neils Idee war .

Common Lisp , 42 Bytes

-2 Bytes dank @coredump .

(lambda(a i j)(rotatef(elt a i)(elt a j)))

Probieren Sie es online!

Ganz gerade nach vorne, da es eine Common Lisp Makro swap: rotatef.

Javascript ES6, 36 34 Bytes

(a,m,n)=>(x=a[m],a[m]=a[n],a[n]=x)

• -2 Bytes, da die Funktion das Array ändert. Sie müssen das Array nicht zurückgeben. Vielen Dank an @Neil

Demo

f=

(a,m,n)=>(x=a[m],a[m]=a[n],a[n]=x)

let a1=[1,2,3,4], a2=[5,8,9], a3=[11,13,15,3]

f(a1,0,1);
f(a2,0,2);
f(a3,1,2);

console.log(JSON.stringify(a1)); //[2,1,3,4]
console.log(JSON.stringify(a2)); //[9,8,5]
console.log(JSON.stringify(a3)); //[11,15,13,3]

CJam , 4 Bytes

{e\}

Probieren Sie es online!

Java 8 , 48 Bytes

(a,b,c)->{int t=a[b];a[b]=a[c];a[c]=t;return a;}

Eingang:

int[] a
int b
int c

05AB1E , 10 Bytes

D²è³ǝ¹³è²ǝ

Probieren Sie es online!

Oktave , 28 Bytes

@(a,n){a(n)=a(flip(n)),a}{2}

Probieren Sie es online!

Sehr zufrieden damit :)

Übernimmt Eingaben in das Formular f([1,2,3,4],[1,2]):, 1-indiziert.

Erläuterung:

@(a,n)                         % Anonymous function that takes two 1-dimensional
                               % arrays as input
      {               , }      % Create a cell with two elements
       a(n)=a(flip(n))         % One element are the two number at indices given by
                               % the second input array. This will be a 1x2 array
      {a(n)=a(flip(n)),a}      % Place those two in a cell together with the entire array a
                               % a is now updated, thanks to Octave's inline assignment
      {a(n)=a(flip(n)),a}{2}   % Return the second element

Qualle , 7 Bytes

p
ZRi
i

Nimmt eine Liste und ein Paar Indizes auf. Probieren Sie es online!

Erläuterung

Qualle hat zufällig die Funktion "Elemente an Indizes ändern" Z, die genau das tut, was wir brauchen. Die beiden nehmen idie Eingänge von STDIN auf. ZNimmt als Argumente die zweite Eingabe, die Umkehrfunktion Rund die Liste. Dann Zführt die Modifikation und pdruckt das Ergebnis aus .

R, 38 Bytes

function(x,a,b){x[c(a,b)]=x[c(b,a)];x}

Fühlt sich ziemlich lang an, aber ich kann es nicht viel kürzer machen. Leider erfordert es das explizite Zurückkehren durch das xErfordernis {}um den Funktionskörper herum. pryr::f()erkennt die Notwendigkeit von xals Funktionsargument nicht und funktioniert nicht: /.

Shenzhen I / O, 735 Bytes

23 ¥, 810 Leistung, 48 Codezeilen

[traces] 
......................
......................
......................
......................
......................
......................
.14.14.14.............
.94.14.14.............
.A........1C..........
.3554..95556..........
.9554.16..............
.A....................
.2....................
......................

[chip] 
[type] UC6
[x] 4
[y] 2
[code] 
  slx x0
  mov x1 acc
  mov x1 dat
  mov acc x3
  mov dat x3
  mov acc x3
  mov dat x3

[chip] 
[type] UC6
[x] 8
[y] 5
[code] 
  slx x2
  mov x2 x1
  mov x0 dat
  mov x2 x1
  mov x0 acc
  mov x2 x1
  mov dat 

[chip] 
[type] UC4X
[x] 2
[y] 6
[code] 
  slx x0
  mov 0 x3
j:  mov x0 acc
  mov acc x2
  teq acc 0
- jmp j
  mov -999 x1

[chip] 
[type] RAM
[x] 5
[y] 6

HAFTUNGSAUSSCHLUSS: Arrays sind in diesem Fall 0-terminiert. Arrays sind ein Problem, mit dem man sonst nur in Shenzhen I / O arbeiten kann.

Ich habe tatsächlich eine Dampfstufe für dieses Spiel gemacht. Du kannst es hier spielen.

EDIT: Und mir ist gerade aufgefallen, dass ich gesagt habe, dass das Array bestellt wurde. Teufel.

Swift, 111 65 Bytes (0-indiziert)

Swift ist bereits dafür berüchtigt, eine der schlechtesten Code-Golf-Sprachen zu sein, aber hier ist eine Funktion , die ternäre Ausdrücke verwendet :

func t(l:[Int],m:Int,n:Int){var r=l;r[m]=l[n];r[n]=l[m];print(r)}

Hör zu! - Verbrauch: t(l:[1,2,3],m:0,n:1) .

k ( kona ), 13 Bytes

{x[y]:x@|y;x}

Ziemlich einfach, aber es funktioniert. Ex:

k){x[y]:x@|y;x}[1 2 3 4; 0 1]
2 1 3 4

Perl 5 , 32 Bytes

-3 Bytes dank @Dom Hastings !

30 Byte Code + -paFlags.

@F[pop@p,@p]=@F[@p=<>];$_="@F"

Probieren Sie es online!

Ganz einfach, mit Array-Slices.

Mathematica, 32 Bytes

(a=#;a[[{##2}]]=a[[{#3,#2}]];a)&

C, 42 Bytes

Ändern Sie das Array mit einem temporären Wert.

f(r,m,n){int*a=r;r=a[m];a[m]=a[n];a[n]=r;}

C, 60 58 Bytes

Ein bisschen interessanter, ohne einen temporären Wert zu verwenden ...

f(a,m,n)int*a;{a[m]+=a[n];a[n]-=a[m];a[n]*=-1;a[m]-=a[n];}

C 49 Bytes

Verwendung von XOR

f(a,m,n)int*a;{a[m]^=a[n];a[n]^=a[m];a[m]^=a[n];}

Pyth , 17 8 Bytes

9 Bytes dank Leaky Num eingespart.

@LQ.rUQE

Online testen!

Dies ist 0-indiziert, und die Indizes werden als Tupel vorgesehen: (n, m).

Erklärungen

@LQ.rUQE

     UQ     # Generate [0, 1, 2, ..., len(input)]
       E    # Get the indices as the tuple (1, 2)
   .r       # Translate each element of UQ to its cyclic successor in E
            # Now the indices are permuted (e.g. [0, 2, 1, ..., len(input)]
@LQ         # For each index, get it's value. Implicit print

Mathematica, 20 Bytes

#~Permute~Cycles@#2&

Reine Funktion, die zwei Argumente im folgenden 1-indizierten (und möglicherweise missbräuchlichen) Format verwendet: Der zweite Testfall [5,8,9]; 0 2; [9,8,5]würde als aufgerufen

#~Permute~Cycles@#2& [ {5,8,9} , {{1,3}} ]

(Leerzeichen sind irrelevant und nur zum sichtbaren Parsen). Permuteist die eingebaute Funktion, die eine Permutation auf eine Liste anwendet und Cycles[{{a,b}}]die Permutation darstellt, die das ath- und bth-Element einer Liste austauscht und den Rest ignoriert.

x86-Maschinencode, 10 Byte

8B 04 8B 87 04 93 89 04 8B C3

Dies ist eine Funktion, die in 32-Bit-x86-Maschinencode geschrieben ist und die Werte an den angegebenen Indizes in einem bestimmten Array austauscht. Das Array wird direkt geändert und die Funktion gibt keinen Wert zurück.

Es wird eine benutzerdefinierte Aufrufkonvention verwendet, bei der die Parameter der Funktion in Registern übergeben werden müssen :

• Die Adresse des Arrays (Zeiger auf sein erstes Element) wird im EBXRegister übergeben.
• Der auf Null basierende Index von Element A wird im ECXRegister übergeben.
  _{(Wird als gültiger Index angenommen.)}
• Der auf Null basierende Index des Elements B wird im EDXRegister übergeben.
  _{(Wird als gültiger Index angenommen.)}

Dies hält die Größe niedrig und erfüllt alle formalen Anforderungen, bedeutet jedoch, dass die Funktion nicht einfach aus anderen Sprachen wie C aufgerufen werden kann. Sie müssten sie aus einem anderen Assembler-Programm aufrufen. (Sie können es jedoch umschreiben, um alle Eingaberegister zu verwenden , ohne die Anzahl der Bytes zu beeinflussen. An den ausgewählten Registern ist nichts Magisches.)

Ungolfed:

8B 04 8B     mov  eax, DWORD PTR [ebx+ecx*4]   ; get value of element A
87 04 93     xchg eax, DWORD PTR [ebx+edx*4]   ; swap element A and element B
89 04 8B     mov  DWORD PTR [ebx+ecx*4], eax   ; store new value for element A
C3           ret                               ; return, with array modified in-place

R, 34 Bytes

pryr::f(`[<-`(a,c(m,n),a[c(n,m)]))

Java 8 + InverseY , 27 Byte

java.util.Collections::swap

Ruft einfach die Swap-Funktion auf ... dies ist eine Methodenreferenz des Typs Consumer3<List, Integer, Integer>.

Probieren Sie es online! (Kopf- und Fußzeile für Boilerplate & Consumer3Interface- Kopie )

JavaScript (ES2015), 66 57 49 Byte

Ein anderer (leider längerer) Ansatz als frühere JavaScript-Antworten

(s,h,o,w=s.splice.bind(s))=>w(h,1,...w(o,1,s[h]))

Quelle

const swap = (arr, a, b, splice) => {
  splice(a, 1, ...splice(arr[b], 1, arr[a]))
}

awk, 31 bytes

{c=$a;$a=$b;$b=c;a=$1;b=$2}NR>1

Probieren Sie es online!

Übernimmt Eingaben im Format

1 2
1 2 3 4

und Ausgänge als

2 1 3 4

(1-indiziert).

Erläuterung

Das gesamte Programm ist ein fehlendes Muster mit einer Aktion, gefolgt von einem Muster mit einer fehlenden Aktion.

Da in jeder Zeile ein fehlendes Muster ausgeführt wird, wird der Code in den geschweiften Klammern für beide Eingabezeilen ausgeführt. Der c=$a;$a=$b;$b=c;Teil tauscht die beiden Werte bei Indizes aund b(über die temporäre Variable c) aus. Dies wirkt sich nur auf die zweite Zeile aus, da in der ersten Zeile aund bnoch nicht definiert. Das a=$1;b=$2Teil wird aals erstes Feld und bals zweites Feld definiert, wodurch die entsprechenden Werte für das erste Teil festgelegt werden, das in der zweiten Zeile ausgeführt werden soll.

Da eine fehlende Aktion der entspricht {print}, druckt das Muster jede Zeile, mit der es übereinstimmt. Dieses Muster lautet insbesondere NR>1: Das heißt, es wird gedruckt, wenn die Zeilennummer größer als 1 ist, was zufällig Zeile 2 ist. Dies wird ausgeführt, nachdem das Austauschen von Werten stattgefunden hat, wodurch die Aufgabe abgeschlossen wird.

q / kdb + 17 Bytes

Lösung:

{@[x;(|)y;:;x y]}

Beispiel:

q){@[x;(|)y;:;x y]}[1 2 3 4;0 1]
2 1 3 4

Erläuterung:

Eine q-Version der k-Antwort von Simon. Wenden Sie die Zuweisungsfunktion :auf x bei Indizes mit dem umgekehrten Wert y an, wobei x bei y indiziert ist. Aufgeschlüsselt sehen Sie deutlicher:

q)x:1 2 3 4
q)y:0 1
q)x y
1 2
q)(|)y
1 0
q)x(|)y
2 1
q)@[x;(|)y;:;x y]
2 1 3 4