Cho một mảng các số nguyên dương và hai chỉ số hợp lệ riêng biệt, trả về mảng có hai phần tử tương ứng với hai chỉ số được hoán đổi.

Bạn có thể chọn sử dụng lập chỉ mục 0 hoặc lập chỉ mục 1, nhưng các testcase bên dưới sẽ được lập chỉ mục 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]

Đây là mã golf . Câu trả lời ngắn nhất trong byte thắng. Tiêu chuẩn áp dụng.

C/ C ++, 53 50 39 byte

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

Dùng thử trực tuyến

Đã lưu 11 byte nhờ @Dennis

Hoạt động ngôn ngữ kịch bản Flashpoint , 98 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]}

Sửa đổi mảng trực tiếp.

Giải trình:

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.

Gọi với:

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

Đầu ra:

JavaScript ES6, 36 32 byte

Hãy nhìn xem, Ma, không có biến tạm thời!

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

• 4 byte được lưu nhờ Neil mang lại sự đồng thuận này cho tôi chú ý.

Thử nó

Nhập danh sách các phần tử được phân tách bằng dấu phẩy cho avà 2 số nguyên cho 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 byte

-9 byte nhờ @notjagan

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

Hãy thử trực tuyến!

Sửa đổi đối số của nó, là một định dạng đầu ra hợp lệ .

Thạch , 7 byte

Ṛ,ḷyJ}ị

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

Ṛ,ḷ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 byte

hV(A=UgV UgW¹hWA

Hãy thử trực tuyến!

Đã lưu một byte nhờ vào ETHproductions

MATL , 7 6 byte

yyP)w(

Các chỉ số dựa trên 1.

Hãy thử trực tuyến!

Giải trình

Xem xét đầu vào [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 byte

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

Hãy thử trực tuyến!

Hoán đổi các số trong mảng ban đầu, không sử dụng biến tạm thời. Tuy nhiên, tôi không thể tin vào câu trả lời này vì đó là ý tưởng của Neil .

Lisp thông thường , 42 byte

-2 byte nhờ @coredump .

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

Hãy thử trực tuyến!

Khá thẳng về phía trước, vì có một macro Lisp chung để trao đổi : rotatef.

Javascript ES6, 36 34 byte

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

• -2 Byte vì hàm đang thay đổi mảng. Không cần trả về mảng. Cảm ơn @Neil

Bản giới thiệu

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 byte

{e\}

Hãy thử trực tuyến!

Java 8 , 48 byte

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

Đầu vào:

int[] a
int b
int c

05AB1E , 10 byte

D²è³ǝ¹³è²ǝ

Hãy thử trực tuyến!

Octave , 28 byte

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

Hãy thử trực tuyến!

Khá hài lòng với điều này thực sự :)

Đưa đầu vào vào biểu mẫu : f([1,2,3,4],[1,2]), 1 chỉ mục.

Giải trình:

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

Sứa , 7 byte

p
ZRi
i

Đưa ra một danh sách và một cặp chỉ số. Hãy thử trực tuyến!

Giải trình

Sứa tình cờ có chức năng "sửa đổi các mục tại các chỉ số" Z, thực hiện chính xác những gì chúng ta cần. Hai is lấy đầu vào từ STDIN. Zlấy làm đối số của đầu vào thứ hai, hàm đảo ngược Rvà danh sách. Sau đó Zthực hiện sửa đổi, và pin kết quả.

R, 38 byte

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

Cảm thấy khá dài, nhưng tôi không thể có được nó ngắn hơn nhiều. Đáng buồn thay, nó đòi hỏi phải quay trở lại rõ ràng x, yêu cầu {}xung quanh cơ thể chức năng. pryr::f()không nhận ra sự cần thiết của xđối số chức năng nên không hoạt động: /.

Thâm Quyến I / O, 735 byte

23, Công suất 810, 48 dòng mã

[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

TUYÊN BỐ TỪ CHỐI: Mảng được chấm dứt 0 trong này. Mảng là một nỗi đau ở mông để làm việc với Thâm Quyến I / O khác.

Tôi thực sự đã tạo ra một mức hơi cho trò chơi này. Bạn có thể chơi nó ở đây.

EDIT: Aaand Tôi mới nhận ra rằng tôi đã nói rằng mảng trong đã được đặt hàng. Chết tiệt

Swift, 111 65 byte (được lập chỉ mục 0)

Swift đã nổi tiếng là một trong những ngôn ngữ golf mã tồi tệ nhất, nhưng đây là một chức năng sử dụng các biểu thức ternary :

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

Kiểm tra nó ra! - Cách sử dụng : t(l:[1,2,3],m:0,n:1) .

k ( kona ), 13 byte

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

Khá cơ bản, nhưng nó hoạt động. Vd

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

Perl 5 , 32 byte

-3 byte nhờ @Dom Hastings !

30 byte mã + -pacờ.

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

Hãy thử trực tuyến!

Khá thẳng về phía trước, sử dụng các lát mảng.

Toán học, 32 byte

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

C, 42 byte

Sửa đổi mảng tại chỗ với giá trị tạm thời.

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

C, 60 58 byte

Thú vị hơn một chút, không sử dụng bất kỳ giá trị tạm thời nào ...

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

C, 49 byte

Sử dụng XOR

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

Bình , 17 8 byte

Đã lưu 9 byte nhờ Leaky Num.

@LQ.rUQE

Kiểm tra nó trực tuyến!

Đây là 0 chỉ mục và các chỉ số được cung cấp dưới dạng một tuple: (n, m) .

Giải thích

@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

Toán học, 20 byte

#~Permute~Cycles@#2&

Hàm thuần túy lấy hai đối số theo định dạng 1 được lập chỉ mục (và có thể lạm dụng) sau đây: trường hợp thử nghiệm thứ hai [5,8,9]; 0 2; [9,8,5]sẽ được gọi là

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

(không gian là không liên quan và chỉ để phân tích cú pháp có thể nhìn thấy). Permutelà hàm dựng sẵn áp dụng hoán vị cho danh sách và Cycles[{{a,b}}]biểu thị hoán vị trao đổi các phần tử thứ avà bthứ của danh sách và bỏ qua phần còn lại.

Mã máy x86, 10 byte

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

Đây là một hàm được viết bằng mã máy x86 32 bit, hoán đổi các giá trị tại các chỉ số được chỉ định trong một mảng nhất định. Mảng được sửa đổi tại chỗ và hàm không trả về giá trị.

Một quy ước gọi tùy chỉnh được sử dụng, yêu cầu các tham số của hàm được truyền trong các thanh ghi :

• Địa chỉ của mảng (con trỏ tới phần tử đầu tiên của nó) được truyền vào EBX ghi.
• Chỉ số dựa trên không của phần tử A được thông qua trong thanh ECXghi.
  _{(Được coi là một chỉ số hợp lệ.)}
• Chỉ số dựa trên không của phần tử B được thông qua trong thanh EDXghi.
  _{(Được coi là một chỉ số hợp lệ.)}

Điều này giữ kích thước xuống và tuân thủ tất cả các yêu cầu chính thức, nhưng điều đó có nghĩa là chức năng không thể được gọi dễ dàng từ các ngôn ngữ khác như C. Bạn cần phải gọi nó từ một chương trình ngôn ngữ lắp ráp khác. (Bạn có thể viết lại để sử dụng bất kỳ thanh ghi đầu vào , mà không ảnh hưởng đến số byte; không có gì kỳ diệu về những cái tôi đã chọn.)

Ung dung:

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 byte

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

Java 8 + Nghịch đảo , 27 byte

java.util.Collections::swap

Chỉ cần gọi hàm hoán đổi ... đây là tham chiếu phương thức của loại Consumer3<List, Integer, Integer>.

Hãy thử trực tuyến! (tiêu đề và chân trang cho bản tóm tắt & bản sao Consumer3giao diện)

JavaScript (ES2015), 66 57 49 byte

Một cách tiếp cận khác (than ôi, dài hơn) so với các câu trả lời JavaScript trước đây

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

Nguồn

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

ôi, 31 byte

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

Hãy thử trực tuyến!

Đưa đầu vào theo định dạng

1 2
1 2 3 4

và đầu ra như

2 1 3 4

(1 chỉ mục).

Giải trình

Toàn bộ chương trình là một mẫu bị thiếu với một hành động theo sau là một mẫu có một hành động bị thiếu.

Vì một mẫu bị thiếu chạy trên mỗi dòng, mã bên trong dấu ngoặc chạy cho cả hai dòng đầu vào. Phần c=$a;$a=$b;$b=c;hoán đổi hai giá trị tại các chỉ số avà b(thông qua biến tạm thời c). Điều này chỉ có hiệu lực trên dòng thứ hai, vì trên dòng đầu tiên avà bchưa được xác định. Phần a=$1;b=$2định nghĩa alà trường đầu tiên và blà trường thứ hai, thiết lập các giá trị phù hợp cho phần đầu tiên để chạy trên dòng thứ hai.

Vì một hành động bị thiếu tương đương với {print}, mẫu sẽ in mọi dòng mà nó khớp. Cụ thể mẫu này là NR>1: nghĩa là in bất cứ khi nào số dòng lớn hơn 1, xảy ra là dòng 2. Điều này chạy sau khi hoán đổi các giá trị đã diễn ra, do đó hoàn thành nhiệm vụ.

q / kdb +, 17 byte

Dung dịch:

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

Thí dụ:

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

Giải trình:

Một phiên bản q của câu trả lời k của Simon. Áp dụng :hàm gán cho x tại các chỉ số ngược-y với giá trị của x được lập chỉ mục tại y. Chia nhỏ bạn có thể thấy rõ hơn:

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