Biorąc pod uwagę tablicę dodatnich liczb całkowitych i dwa różne poprawne indeksy, zwróć tablicę z dwoma elementami odpowiadającymi zamianie dwóch indeksów.

Możesz wybrać indeksowanie 0 lub indeksowanie 1, ale poniższe przypadki testowe będą indeksowane jako 0.

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]

To jest golf golfowy . Najkrótsza odpowiedź w bajtach wygrywa. Obowiązują standardowe luki .

do/ C ++, 53 50 39 bajtów

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

Wypróbuj online

Zaoszczędź 11 bajtów dzięki @Dennis

Operacyjny język skryptowy Flashpoint , 98 95 bajtów

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

Modyfikuje tablicę bezpośrednio.

Wyjaśnienie:

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.

Zadzwoń z:

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

Wydajność:

JavaScript ES6, 36 32 bajtów

Spójrz, Ma, nie ma zmiennej tymczasowej!

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

• 4 bajty zaoszczędzone dzięki Neilowi, który zwrócił moją uwagę na ten konsensus .

Spróbuj

Wpisz listę elementów oddzielonych przecinkami ai 2 liczby całkowite dla m& 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 bajty

-9 bajtów dzięki @notjagan

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

Wypróbuj online!

Zmienia argument, który jest prawidłowym formatem wyjściowym .

Galaretka , 7 bajtów

Ṛ,ḷyJ}ị

Wypróbuj online!

Jak to działa

Ṛ,ḷ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 bajtów

hV(A=UgV UgW¹hWA

Wypróbuj online!

Oszczędność bajtu dzięki produktom ETH

MATL , 7 6 bajtów

yyP)w(

Wskaźniki są oparte na 1.

Wypróbuj online!

Wyjaśnienie

Rozważmy wejść [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 bajtów

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

Wypróbuj online!

Zamienia liczby w oryginalnej tablicy, bez zmiennych tymczasowych. Niemniej jednak nie mogę uwierzyć w tę odpowiedź, ponieważ taki był pomysł Neila .

Common Lisp , 42 bajty

-2 bajty dzięki @coredump .

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

Wypróbuj online!

Dość proste, ponieważ istnieje Common Lisp makro do zamiany: rotatef.

JavaScript ES6, 36 34 bajtów

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

• -2 bajty, ponieważ funkcja zmienia tablicę. Nie trzeba zwracać tablicy. Dzięki @Neil

Próbny

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 bajty

{e\}

Wypróbuj online!

Java 8 , 48 bajtów

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

Wkład:

int[] a
int b
int c

05AB1E , 10 bajtów

D²è³ǝ¹³è²ǝ

Wypróbuj online!

Oktawa , 28 bajtów

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

Wypróbuj online!

Zadowolony z tego faktycznie :)

Pobiera dane z formularza f([1,2,3,4],[1,2]):, 1-indeksowane.

Wyjaśnienie:

@(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

Meduza , 7 bajtów

p
ZRi
i

Pobiera listę i parę wskaźników. Wypróbuj online!

Wyjaśnienie

Meduza ma funkcję „modyfikowania przedmiotów według indeksów” Z, która robi dokładnie to, czego potrzebujemy. Oba is pobierają dane wejściowe ze STDIN. Zprzyjmuje za argumenty drugie wejście, funkcję odwracania Ri listę. Następnie Zwykonuje modyfikację i pdrukuje wynik.

R, 38 bajtów

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

Wydaje się dość długi, ale nie mogę go skrócić. Niestety wymaga to wyraźnego powrotu x, wymagając {}od ciała funkcji. pryr::f()nie rozpoznaje potrzeby xjako argumentu funkcji, więc nie działa: /.

Shenzhen I / O, 735 bajtów

23 ¥, moc 810, 48 linii kodu

[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

ZASTRZEŻENIE: Tablice są w tym przypadku zakończone na 0. W przeciwnym razie tablice stanowią problem w pracy z we / wy w Shenzhen.

Właściwie zrobiłem poziom pary dla tej gry. Możesz zagrać tutaj.

EDYCJA: Aa i właśnie zdałem sobie sprawę, że powiedziałem, że tablica została zamówiona. Heck.

Swift, 111 65 bajtów (indeksowane 0)

Swift jest już znany z tego, że jest jednym z najgorszych języków kod-golfowych, ale oto funkcja, która korzysta z wyrażeń trójskładnikowych :

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

Sprawdź to! - Zastosowanie: t(l:[1,2,3],m:0,n:1) .

k ( kona ), 13 bajtów

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

Całkiem proste, ale działa. Dawny:

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

Perl 5 , 32 bajty

-3 bajty dzięki @Dom Hastings !

30 bajtów kodu + -paflagi.

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

Wypróbuj online!

Całkiem prosto, używając plasterków tablic.

Mathematica, 32 bytes

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

C, 42 bytes

Modify the array in place with a temp value.

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

C, 60 58 bytes

A little more interesting, not using any temp value...

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

C, 49 bytes

Using XOR

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

Pyth, 17 8 bytes

Saved 9 bytes thanks to Leaky Num.

@LQ.rUQE

Test it online!

This is 0-indexed, and the indices are provided as a tuple: (n, m).

Explanations

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

Pure function taking two arguments in the following 1-indexed (and possibly abusive) format: the second test case [5,8,9]; 0 2; [9,8,5] would be called as

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

(spaces are extraneous and just for visible parsing). Permute is the builtin function that applies a permutation to a list, and Cycles[{{a,b}}] represents the permutation that exchanges the ath and bth elements of a list and ignores the rest.

x86 Machine Code, 10 bytes

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

This is a function written in 32-bit x86 machine code that swaps the values at the specified indices in a given array. The array is modified in-place, and the function does not return a value.

A custom calling convention is used, requiring the function's parameters to be passed in registers:

• The address of the array (pointer to its first element) is passed in the EBX register.
• The zero-based index of element A is passed in the ECX register.
  _{(Assumed to be a valid index.)}
• The zero-based index of element B is passed in the EDX register.
  _{(Assumed to be a valid index.)}

This keeps the size down and complies with all formal requirements, but does mean that the function cannot be easily called from other languages like C. You'd need to call it from another assembly-language program. (You could rewrite it to use any input registers, though, without affecting the byte count; there's nothing magical about the ones I chose.)

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 bytes

java.util.Collections::swap

Just calls the swap function... this is a method reference of the type Consumer3<List, Integer, Integer>.

Try it online! (header and footer for boilerplate & copy of Consumer3 interface)

JavaScript (ES2015), 66 57 49 bytes

A different (alas, longer) approach than previous JavaScript answers

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

Source

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

Try it online!

Takes input in the format

1 2
1 2 3 4

and outputs as

2 1 3 4

(1-indexed).

Explanation

The entire program is a missing pattern with an action followed by a pattern with a missing action.

Since a missing pattern runs on each line, the code inside the braces runs for both input lines. The c=$a;$a=$b;$b=c; part swaps the two values at indices a and b (through the temporary variable c). This only has an effect on the second line, since on the first line a and b are not yet defined. The a=$1;b=$2 part defines a to be the first field and b to be the second field, which sets the appropriate values for the first part to run on the second line.

Since a missing action is equivalent to {print}, the pattern prints every line it matches. This pattern in particular is NR>1: that is, print whenever the line number is greater than 1, which happens to be line 2. This runs after the swapping of values has taken place, thus completing the task.

q/kdb+, 17 bytes

Solution:

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

Example:

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

Explanation:

A q version of the k answer by Simon. Apply the assign : function to x at indices reverse-y with value of x indexed at y. Broken down you can see more clearly:

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