给定一个正整数数组和两个不同的有效索引，则返回该数组，其中对应于两个索引的两个元素被交换。

您可以选择使用0索引或1索引，但是下面的测试用例将使用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]

这是代码高尔夫球。以字节为单位的最短答案将获胜。有标准漏洞。

C/ C ++， 53 50 39个字节

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

在线尝试

@Dennis节省了11个字节

操作Flashpoint脚本语言，98 95字节

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

直接修改数组。

说明：

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.

致电：

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

输出：

的JavaScript ES6，36 32个字节

瞧，妈，没有临时变量！

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

• 感谢Neil将这个共识引起我的注意，节省了4个字节。

试试吧

输入以逗号分隔的元素列表，a以及m＆的2个整数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个字节

-9个字节，感谢@notjagan

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

在线尝试！

修改其参数，这是有效的输出格式。

果冻，7个字节

Ṛ,ḷyJ}ị

在线尝试！

怎么运行的

Ṛ,ḷ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字节

hV(A=UgV UgW¹hWA

在线尝试！

多亏了ETHproductions节省了一个字节

MATL，7 6字节

yyP)w(

索引基于1。

在线尝试！

说明

考虑输入[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字节

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

在线尝试！

交换原始数组中的数字，不使用任何临时变量。但是，由于尼尔的想法，我不能为这个答案感到满意。

普通口齿不清，42字节

-2个字节感谢@coredump。

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

在线尝试！

很简单，因为有一个Common Lisp宏可以交换：rotatef。

的Javascript ES6，36个 34字节

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

• -2字节，因为该函数正在更改数组。无需返回数组。感谢@Neil

演示版

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个字节

{e\}

在线尝试！

Java 8，48字节

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

输入：

int[] a
int b
int c

05AB1E，10个字节

D²è³ǝ¹³è²ǝ

在线尝试！

八度，28字节

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

在线尝试！

实际上对此感到非常满意:)

接受以下格式的输入：f([1,2,3,4],[1,2])1索引。

说明：

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

水母，7个字节

p
ZRi
i

取得一个列表和一对索引。 在线尝试！

说明

水母恰好具有“在索引处修改项目”功能Z，该功能正是我们所需要的。这两个i从STDIN获取输入。 Z将第二个输入，反转函数R和列表作为参数。然后Z执行修改，并p打印结果。

R，38个字节

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

感觉相当长，但我无法将其缩短。可悲的是它需要显式的返回通过x，要求{}各地函数体。pryr::f()无法识别需要xas函数参数，因此无法正常工作：/。

深圳I / O，735字节

23¥，810电源，48行代码

[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

免责声明：数组以0结尾。否则，在深圳I / O中使用数组是一件很麻烦的事情。

我实际上为这款游戏设定了蒸汽强度。你可以在这里玩。

编辑：Aaand我刚刚意识到我说的数组是有序的。哎呀

Swift，111个 65字节（0索引）

Swift已经成为最差的代码高尔夫语言之一而臭名昭著，但这是一个使用三元表达式的函数：

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

看看这个！ - 用法： t(l:[1,2,3],m:0,n:1)。

k (kona), 13 bytes

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

Pretty basic, but it works. Ex:

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

Perl 5, 32 bytes

-3 bytes thanks to @Dom Hastings!

30 bytes of code + -pa flags.

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

Try it online!

Quite straight forward, using array slices.

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