При наличии массива положительных целых чисел и двух различных допустимых индексов, верните массив с двумя элементами, соответствующими двум индексам, поменяв местами.

Вы можете выбрать 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 ++, 53 50 39 байт

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

Попробуйте онлайн

Сохранено 11 байтов благодаря @Dennis

Язык сценариев работы 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]]

• 4 байта сохраняются благодаря Neil в результате чего этот консенсус моему вниманию.

Попытайся

Введите разделенный запятыми список элементов для aи 2 целых числа для 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 байта

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

Попробуйте онлайн!

Меняет местами числа в исходном массиве, временные переменные не используются. Тем не менее я не могу взять кредит на этот ответ, так как это была идея Нейла .

Common Lisp , 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, которая делает именно то, что нам нужно. Два is получают данные от STDIN. Zпринимает в качестве аргументов второй вход, функцию обращения Rи список. Затем Zвыполняет модификацию и pпечатает результат.

R, 38 байт

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

Чувствуется довольно долго, но я не могу получить это намного короче. К сожалению, это требует явного возврата через x, требуя {}вокруг тела функции. pryr::f()не распознает необходимость в xкачестве аргумента функции, поэтому не работает: /.

Шэньчжэньский ввод / вывод, 735 байт

23 ¥, 810 Power, 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. Массивы - боль в заднице, чтобы работать с вводом-выводом в Шэньчжэне иначе.

Я сделал паровой уровень для этой игры. Вы можете сыграть здесь.

РЕДАКТИРОВАТЬ: Aa, и я только что понял, что я сказал, что массив в был заказан. Heck.

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 байтов

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

Довольно простой, но это работает. Пример:

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

Perl 5 , 32 байта

-3 байта благодаря @Dom Hastings !

30 байтов кода + -paфлаги.

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

Попробуйте онлайн!

Совершенно прямо, используя кусочки массива.

Mathematica, 32 байта

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

C, 42 байта

Измените массив на месте с помощью временного значения.

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

C 60 58 байт

Немного интереснее, не используя никакого временного значения ...

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

C, 49 байтов

Использование XOR

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

Pyth , 17 8 байт

Сохранено 9 байтов благодаря Leaky Num.

@LQ.rUQE

Проверьте это онлайн!

Это 0 индексированные, а индексы представлены в виде кортежа: (n, m).

Пояснения

@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 байтов

#~Permute~Cycles@#2&

Чистая функция, принимающая два аргумента в следующем 1-индексированном (и, возможно, оскорбительном) формате: второй контрольный пример [5,8,9]; 0 2; [9,8,5]будет вызываться как

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

(пробелы посторонние и просто для видимого разбора). Permuteэто встроенная функция, которая применяет перестановку к списку и Cycles[{{a,b}}]представляет перестановку, которая обменивает ath- bй элемент списка и игнорирует остальные.

Машинный код x86, 10 байт

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

Это функция, написанная на 32-битном машинном коде x86, которая меняет значения по указанным индексам в данном массиве. Массив изменяется на месте , и функция не возвращает значение.

Используется пользовательское соглашение о вызовах, требующее передачи параметров функции в регистры :

• Адрес массива (указатель на его первый элемент) передается в EBXрегистр.
• Начинающийся с нуля индекс элемента A передается в ECXрегистр.
  _{(Предполагается, что действительный индекс.)}
• Начинающийся с нуля индекс элемента B передается в EDXрегистр.
  _{(Предполагается, что действительный индекс.)}

Это уменьшает размер и соответствует всем формальным требованиям, но означает, что функцию нельзя легко вызвать из других языков, таких как C. Вам нужно будет вызывать ее из другой программы на языке ассемблера. (Вы можете переписать его, чтобы использовать любые входные регистры, однако, не влияя на количество байтов; в тех, что я выбрал, нет ничего волшебного.)

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 байта

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

Java 8 + InverseY , 27 байт

java.util.Collections::swap

Просто вызывает функцию подкачки ... это ссылка на метод типа Consumer3<List, Integer, Integer>.

Попробуйте онлайн! (верхний и нижний колонтитулы для шаблона и копия Consumer3интерфейса)

JavaScript (ES2015), 66 57 49 байт

Другой (увы, более длинный) подход, чем предыдущие ответы JavaScript

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

Источник

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

awk, 31 байт

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

Попробуйте онлайн!

Принимает ввод в формате

1 2
1 2 3 4

и выводит как

2 1 3 4

(1-индексированных).

объяснение

Вся программа представляет собой отсутствующий шаблон с действием, за которым следует шаблон с отсутствующим действием.

Поскольку отсутствующий шаблон выполняется в каждой строке, код внутри фигурных скобок выполняется для обеих строк ввода. c=$a;$a=$b;$b=c;Часть обменивает два значения с индексами aи b(через временную переменную c). Это влияет только на вторую строку, так как в первой строке aи bеще не определены. В a=$1;b=$2части определяется , aчтобы быть первым полем , и bбудет второе поле, которое устанавливает соответствующие значения для первой части для запуска на второй линии.

Поскольку отсутствующее действие эквивалентно {print}, шаблон печатает каждую строку, которой он соответствует. В частности, этот шаблон NR>1: то есть печатать всякий раз, когда номер строки больше 1, что является строкой 2. Это выполняется после обмена значениями, что завершает задачу.

q / kdb +, 17 байт

Решение:

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

Пример:

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

Объяснение:

Q-версия ответа Саймона. Примените :функцию присваивания x для индексов в обратном направлении y со значением x, индексированным в y. Сломанные вы можете увидеть более четко:

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