Dada uma matriz de números inteiros positivos e dois índices válidos distintos, retorne a matriz com os dois elementos correspondentes aos dois índices trocados.

Você pode optar por usar a indexação 0 ou a indexação 1, mas os casos de teste abaixo serão indexados em 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]

Isso é código-golfe . A resposta mais curta em bytes vence. Aplicam-se brechas padrão .

C/ C ++, 53 50. 39 bytes

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

Experimente online

Guardado 11 bytes graças a @Dennis

Linguagem de script da operação 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 a matriz diretamente.

Explicação:

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.

Ligue para:

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

Saída:

JavaScript ES6, 36 32 bytes

Olha, mãe, nenhuma variável temporária!

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

• 4 bytes salvos graças a Neil, trazendo esse consenso à minha atenção.

Tente

Digite uma lista de elementos separados por vírgula ae 2 números inteiros 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>

Python 3 , 41 32 bytes

-9 bytes graças a @notjagan

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

Experimente online!

Modifica seu argumento, que é um formato de saída válido .

Geléia , 7 bytes

Ṛ,ḷyJ}ị

Experimente online!

Como 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.

Japonês , 17 16 bytes

hV(A=UgV UgW¹hWA

Experimente online!

Guardou um byte graças a ETHproductions

MATL , 7 6 bytes

yyP)w(

Os índices são baseados em 1.

Experimente online!

Explicação

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

Experimente online!

Troca os números na matriz original, sem variáveis ​​temporárias usadas. No entanto, não posso me responsabilizar por essa resposta, pois foi idéia de Neil .

Lisp comum , 42 bytes

-2 bytes graças a @coredump .

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

Experimente online!

Bastante simples, uma vez que existe uma macro Lisp Comum de swap: rotatef.

Javascript ES6, 36 34 bytes

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

• -2 bytes porque a função está alterando a matriz. Não há necessidade de retornar a matriz. Graças a @Neil

Demo

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

Experimente online!

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²è³ǝ¹³è²ǝ

Experimente online!

Oitava , 28 bytes

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

Experimente online!

Bastante satisfeito com este realmente :)

Recebe entrada no formulário f([1,2,3,4],[1,2]):, 1 indexado.

Explicação:

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

Água-viva , 7 bytes

p
ZRi
i

Leva uma lista e um par de índices. Experimente online!

Explicação

A água-viva tem uma função "modificar itens nos índices" Z, que faz exatamente o que precisamos. Os dois is pegam as entradas do STDIN. Ztoma como argumentos a segunda entrada, a função de reversão Re a lista. Em seguida, Zrealiza a modificação e pimprime o resultado.

R, 38 bytes

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

Parece um pouco longo, mas não posso ficar muito mais curto. Infelizmente, isso requer o retorno explícito x, exigindo {}o corpo da função. pryr::f()não reconhece a necessidade de xcomo argumento de função, portanto não funciona: /.

E / S de Shenzhen, 735 bytes

23 ¥, 810 Potência, 48 Linhas 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

AVISO LEGAL: As matrizes são 0 terminadas neste. Matrizes são um pé no saco para trabalhar com E / S de Shenzhen, caso contrário.

Na verdade, eu fiz um nível de vapor para este jogo. Você pode jogar aqui.

EDIT: Aaand eu acabei de perceber que eu disse que a matriz foi ordenada. Heck.

Swift, 111 65 bytes (indexado 0)

O Swift já é notório por ser uma das piores linguagens de código-golfe, mas aqui está uma função que faz uso de expressões ternárias :

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

Confira! - Uso: t(l:[1,2,3],m:0,n:1) .

k ( kona ), 13 bytes

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

Bastante básico, mas funciona. Ex:

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

Perl 5 , 32 bytes

-3 bytes graças a @Dom Hastings !

30 bytes de código + -pasinalizadores.

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

Experimente online!

Para a frente, usando fatias de matriz.

Mathematica, 32 bytes

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

C, 42 bytes

Modifique a matriz no local com um valor temporário.

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

C, 60 58 bytes

Um pouco mais interessante, sem usar nenhum valor temporário ...

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

Pitão , 17 8 bytes

Economizou 9 bytes graças a Leaky Num.

@LQ.rUQE

Teste online!

Esta é 0-indexados, e os índices são fornecidos como uma tupla: (n, m).

Explicações

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

Função pura usando dois argumentos no seguinte formato indexado em 1 (e possivelmente abusivo): o segundo caso de teste [5,8,9]; 0 2; [9,8,5]seria chamado como

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

(os espaços são estranhos e apenas para análise visível). Permuteé a função interna que aplica uma permutação a uma lista e Cycles[{{a,b}}]representa a permutação que troca os ath e bth th elementos de uma lista e ignora o restante.

Código da máquina x86, 10 bytes

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

Essa é uma função escrita no código de máquina x86 de 32 bits que troca os valores nos índices especificados em uma determinada matriz. A matriz é modificada no local e a função não retorna um valor.

Uma convenção de chamada personalizada é usada, exigindo que os parâmetros da função sejam passados ​​nos registradores :

• O endereço da matriz (ponteiro para seu primeiro elemento) é passado no EBXregistro.
• O índice baseado em zero do elemento A é passado no ECXregistro.
  _{(Supõe-se que seja um índice válido.)}
• O índice baseado em zero do elemento B é passado no EDXregistro.
  _{(Supõe-se que seja um índice válido.)}

Isso mantém o tamanho baixo e está em conformidade com todos os requisitos formais, mas significa que a função não pode ser facilmente chamada de outros idiomas como C. Você precisaria chamá-lo de outro programa em linguagem assembly. (Você pode reescrevê-lo para usar qualquer registrador de entrada, sem afetar a contagem de bytes; não há nada de mágico nos que eu escolhi.)

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

Apenas chama a função swap ... esta é uma referência método do tipo Consumer3<List, Integer, Integer>.

Experimente online! (cabeçalho e rodapé para clichê e cópia da Consumer3interface)

JavaScript (ES2015), 66 57 49 bytes

Uma abordagem diferente (infelizmente, mais longa) do que as respostas JavaScript anteriores

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

Fonte

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

Experimente online!

Recebe entrada no formato

1 2
1 2 3 4

e saídas como

2 1 3 4

(Indexado 1).

Explicação

O programa inteiro é um padrão ausente com uma ação seguida por um padrão com uma ação ausente.

Como um padrão ausente é executado em cada linha, o código dentro das chaves é executado nas duas linhas de entrada. A c=$a;$a=$b;$b=c;peça troca os dois valores nos índices ae b(através da variável temporária c). Isso só tem efeito na segunda linha, pois na primeira linha ae bainda não está definido. A a=$1;b=$2parte define acomo o primeiro campo e bo segundo campo, que define os valores apropriados para que a primeira parte seja executada na segunda linha.

Como uma ação ausente é equivalente a {print}, o padrão imprime todas as linhas correspondentes. Esse padrão em particular é NR>1: isto é, imprima sempre que o número da linha for maior que 1, que passa a ser a linha 2. Isso é executado após a troca de valores, ocorrendo a conclusão da tarefa.

q / kdb +, 17 bytes

Solução:

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

Exemplo:

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

Explicação:

Uma versão q da resposta k de Simon. Aplique a :função de atribuição a x nos índices reversos-y com o valor de x indexado em y. Dividido, você pode ver mais 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