Dada una matriz de enteros positivos y dos índices válidos distintos, devuelva la matriz con los dos elementos correspondientes a los dos índices intercambiados.

Puede optar por usar 0-indexing o 1-indexing, pero los siguientes casos de prueba serán 0-indexados.

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]

Este es el código de golf . La respuesta más corta en bytes gana. Se aplican lagunas estándar .

do/ C ++, 53 50 39 bytes

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

Pruébalo en línea

Guardado 11 bytes gracias a @Dennis

Lenguaje de script Operation Flashpoint , 98 95 bytes

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

Modifica la matriz directamente.

Explicación:

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.

Llamar con:

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

Salida:

JavaScript ES6, 36 32 bytes

¡Mira, mamá, no hay variable temporal!

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

• 4 bytes guardan gracias a Neil con lo que este consenso a mi atención.

Intentalo

Ingrese una lista de elementos separados por comas para ay 2 enteros para 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>

Pitón 3 , 41 32 bytes

-9 bytes gracias a @notjagan

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

Pruébalo en línea!

Modifica su argumento, que es un formato de salida válido .

Jalea , 7 bytes

Ṛ,ḷyJ}ị

Pruébalo en línea!

Cómo funciona

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

Pruébalo en línea!

Guardado un byte gracias a ETHproductions

MATL , 7 6 bytes

yyP)w(

Los índices están basados ​​en 1.

Pruébalo en línea!

Explicación

Considere insumos [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])

Pruébalo en línea!

Intercambia los números en la matriz original, no se utilizan variables temporales. Sin embargo, no puedo tomar el crédito por esta respuesta, ya que ha sido idea de Neil .

Lisp común , 42 bytes

-2 bytes gracias a @coredump .

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

Pruébalo en línea!

Muy sencillo, ya que hay una macro Common Lisp a swap: rotatef.

Javascript ES6, 36 34 bytes

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

• -2 Bytes porque la función está alterando la matriz. No es necesario devolver la matriz. Gracias a @Neil

Manifestación

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

Pruébalo en línea!

Java 8 , 48 bytes

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

Entrada:

int[] a
int b
int c

05AB1E , 10 bytes

D²è³ǝ¹³è²ǝ

Pruébalo en línea!

Octava , 28 bytes

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

Pruébalo en línea!

Bastante satisfecho con este en realidad :)

Toma entrada en el formulario: f([1,2,3,4],[1,2])1 indexado.

Explicación:

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

Medusa , 7 bytes

p
ZRi
i

Toma una lista y un par de índices. Pruébalo en línea!

Explicación

Jellyfish tiene una función de "modificar elementos en índices" Z, que hace exactamente lo que necesitamos. Los dos is toman las entradas de STDIN. Ztoma como argumentos la segunda entrada, la función de inversión Ry la lista. Luego Zrealiza la modificación e pimprime el resultado.

R, 38 bytes

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

Se siente bastante largo, pero no puedo hacerlo mucho más corto. Lamentablemente, requiere el retorno explícito x, que requiere {}alrededor del cuerpo de la función. pryr::f()no reconoce la necesidad de xcomo argumento de función, por lo que no funciona: /.

E / S de Shenzhen, 735 bytes

23 ¥, 810 de potencia, 48 líneas de código

[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

DESCARGO DE RESPONSABILIDAD: Las matrices tienen terminación 0 en esto. Las matrices son un fastidio para trabajar en Shenzhen I / O de lo contrario.

Realmente hice un nivel de vapor para este juego. Puedes jugarlo aquí.

EDITAR: Aa y me acabo de dar cuenta de que dije que se ordenó la matriz Infierno.

Swift, 111 65 bytes (indexado 0)

Swift ya es conocido por ser uno de los peores lenguajes de código de golf, pero aquí hay una función que utiliza expresiones ternarias :

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

¡Echale un vistazo! - Uso: t(l:[1,2,3],m:0,n:1) .

k ( kona ), 13 bytes

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

Bastante básico, pero funciona. Ex:

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

Perl 5 , 32 bytes

-3 bytes gracias a @Dom Hastings !

30 bytes de código + -pabanderas.

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

Pruébalo en línea!

Muy sencillo, utilizando cortes de matriz.

Mathematica, 32 bytes

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

C, 42 bytes

Modifique la matriz en su lugar con un valor temporal.

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

C, 60 58 bytes

Un poco más interesante, sin usar ningún valor temporal ...

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

C, 49 bytes

Usando XOR

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

Pyth , 17 8 bytes

Guardado 9 bytes gracias a Leaky Num.

@LQ.rUQE

¡Pruébelo en línea!

Esto está indexado en 0, y los índices se proporcionan como una tupla: (n, m) .

Explicaciones

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

Función pura que toma dos argumentos en el siguiente formato 1 indexado (y posiblemente abusivo): el segundo caso de prueba [5,8,9]; 0 2; [9,8,5]se llamaría como

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

(los espacios son extraños y solo para el análisis visible). Permutees la función incorporada que aplica una permutación a una lista y Cycles[{{a,b}}]representa la permutación que intercambia los elementos ath y bth de una lista e ignora el resto.

Código de máquina x86, 10 bytes

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

Esta es una función escrita en código de máquina x86 de 32 bits que intercambia los valores en los índices especificados en una matriz dada. La matriz se modifica en el lugar y la función no devuelve un valor.

Se utiliza una convención de llamada personalizada, que requiere que los parámetros de la función se pasen en los registros :

• La dirección de la matriz (puntero a su primer elemento) se pasa en el EBXregistro.
• El índice de base cero del elemento A se pasa en el ECXregistro.
  _{(Se supone que es un índice válido).}
• El índice de base cero del elemento B se pasa en el EDXregistro.
  _{(Se supone que es un índice válido).}

Esto mantiene el tamaño bajo y cumple con todos los requisitos formales, pero significa que la función no se puede llamar fácilmente desde otros idiomas como C. Debería llamarlo desde otro programa en lenguaje ensamblador. (Puedes reescribirlo para usar cualquier registro de entrada, sin afectar el conteo de bytes; no hay nada mágico en los que elegí).

Sin golf:

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 + InversoY , 27 bytes

java.util.Collections::swap

Solo llama a la función de intercambio ... esta es una referencia de método del tipo Consumer3<List, Integer, Integer> .

Pruébalo en línea! (encabezado y pie de página para repetitivo y copia de la Consumer3interfaz)

JavaScript (ES2015), 66 57 49 bytes

Un enfoque diferente (por desgracia, más largo) que las respuestas anteriores de JavaScript

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

Fuente

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

Pruébalo en línea!

Toma entrada en el formato

1 2
1 2 3 4

y salidas como

2 1 3 4

(1 indexado).

Explicación

El programa completo es un patrón faltante con una acción seguida de un patrón con una acción faltante.

Como se ejecuta un patrón faltante en cada línea, el código dentro de las llaves se ejecuta para ambas líneas de entrada. La c=$a;$a=$b;$b=c;parte intercambia los dos valores en los índices ay b(a través de la variable temporal c). Esto solo tiene un efecto en la segunda línea, ya que en la primera línea ay baún no están definidos. La a=$1;b=$2parte se define acomo el primer campo yb el segundo campo, que establece los valores apropiados para que la primera parte se ejecute en la segunda línea.

Como una acción que falta es equivalente a {print}, el patrón imprime cada línea que coincide. Este patrón en particular es NR>1: es decir, imprimir siempre que el número de línea sea mayor que 1, que resulta ser la línea 2. Esto se ejecuta después del intercambio de valores, completando así la tarea.

q / kdb +, 17 bytes

Solución:

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

Ejemplo:

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

Explicación:

Una versión q de la k respuesta de Simon. Aplicar la asignación: función de a x en índices inversa-y con el valor de x indexado en y. Desglosado puedes ver más claramente:

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