Étant donné un tableau d'entiers positifs et deux indices valides distincts, renvoyez le tableau avec les deux éléments correspondant aux deux indices échangés.

Vous pouvez choisir d'utiliser l'indexation 0 ou l'indexation 1, mais les cas de test ci-dessous seront indexés 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'est du code-golf . La réponse la plus courte en octets gagne. Des échappatoires standard s'appliquent.

C/ C ++, 53 50 39 octets

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

Essayez-le en ligne

Sauvegardé 11 octets grâce à @Dennis

Langage de script Operation Flashpoint , 98 95 octets

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

Modifie le tableau directement.

Explication:

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.

Appeler avec:

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

Sortie:

JavaScript ES6, 36 32 octets

Regardez, Ma, pas de variable temporaire!

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

• 4 octets économisés grâce à Neil qui a porté ce consensus à mon attention.

Essayez-le

Entrez une liste d'éléments séparés par des virgules pour aet 2 entiers pour 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 octets

-9 octets grâce à @notjagan

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

Essayez-le en ligne!

Modifie son argument, qui est un format de sortie valide .

Gelée , 7 octets

Ṛ,ḷyJ}ị

Essayez-le en ligne!

Comment ça marche

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

hV(A=UgV UgW¹hWA

Essayez-le en ligne!

Un octet enregistré grâce à ETHproductions

MATL , 7 6 octets

yyP)w(

Les indices sont basés sur 1.

Essayez-le en ligne!

Explication

Tenez compte des entrées [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 octets

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

Essayez-le en ligne!

Échange les nombres dans le tableau d'origine, aucune variable temporaire utilisée. Néanmoins, je ne peux pas m'attribuer le mérite de cette réponse car c'est l'idée de Neil .

Lisp commun , 42 octets

-2 octets grâce à @coredump .

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

Essayez-le en ligne!

Assez simple, car il y a une macro Common Lisp à échanger: rotatef.

Javascript ES6, 36 34 octets

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

• -2 octets car la fonction modifie le tableau. Pas besoin de retourner le tableau. Merci à @Neil

Démo

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 octets

{e\}

Essayez-le en ligne!

Java 8 , 48 octets

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

Contribution:

int[] a
int b
int c

05AB1E , 10 octets

D²è³ǝ¹³è²ǝ

Essayez-le en ligne!

Octave , 28 octets

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

Essayez-le en ligne!

Assez satisfait de celui-ci en fait :)

Prend entrée sur le formulaire:, f([1,2,3,4],[1,2])1-indexé.

Explication:

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

Méduse , 7 octets

p
ZRi
i

Prend une liste et une paire d'indices. Essayez-le en ligne!

Explication

Les méduses ont une fonction "modifier les éléments aux indices" Z, qui fait exactement ce dont nous avons besoin. Les deux is saisissent les entrées de STDIN. Zprend comme arguments la deuxième entrée, la fonction d'inversion Ret la liste. ZEffectue ensuite la modification et pimprime le résultat.

R, 38 octets

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

Cela me semble assez long, mais je ne peux pas le raccourcir beaucoup plus. Malheureusement, cela nécessite le retour explicite x, exigeant {}autour du corps de la fonction. pryr::f()ne reconnaît pas le besoin d' xargument as function, donc ne fonctionne pas: /.

E / S Shenzhen, 735 octets

23 ¥, puissance 810, 48 lignes de code

[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

AVERTISSEMENT: les tableaux sont terminés par 0 dans ce cas. Les tableaux sont une douleur dans le cul pour travailler avec Shenzhen I / O autrement.

J'ai fait un niveau de vapeur pour ce jeu. Vous pouvez y jouer ici.

EDIT: Aaand je viens de réaliser que j'ai dit que le tableau était commandé. Zut.

Swift, 111 65 octets (indexé 0)

Swift est déjà connu pour être l'un des pires langages de golf de code, mais voici une fonction qui utilise des expressions ternaires :

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

Vérifiez-le! - Utilisation: t(l:[1,2,3],m:0,n:1) .

k ( kona ), 13 octets

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

Assez basique, mais ça marche. Ex:

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

Perl 5 , 32 octets

-3 octets grâce à @Dom Hastings !

30 octets de code + -padrapeaux.

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

Essayez-le en ligne!

Assez simple, en utilisant des tranches de tableau.

Mathematica, 32 octets

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

C, 42 octets

Modifiez le tableau en place avec une valeur temporaire.

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

C, 60 58 octets

Un peu plus intéressant, n'utilisant aucune valeur temporaire ...

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

C, 49 octets

Utilisation de XOR

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

Pyth , 17 8 octets

9 octets enregistrés grâce à Leaky Num.

@LQ.rUQE

Testez-le en ligne!

Ceci est 0 indexées, et les indices sont fournis en tant que tuple: (n, m).

Explications

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

#~Permute~Cycles@#2&

Fonction pure prenant deux arguments dans le format 1-indexé (et éventuellement abusif) suivant: le deuxième cas de test [5,8,9]; 0 2; [9,8,5]serait appelé comme

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

(les espaces sont superflus et juste pour une analyse visible). Permuteest la fonction intégrée qui applique une permutation à une liste et Cycles[{{a,b}}]représente la permutation qui échange les ath et bth éléments d'une liste et ignore le reste.

Code machine x86, 10 octets

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

Il s'agit d'une fonction écrite en code machine x86 32 bits qui permute les valeurs aux indices spécifiés dans un tableau donné. Le tableau est modifié sur place et la fonction ne renvoie pas de valeur.

Une convention d'appel personnalisée est utilisée, exigeant que les paramètres de la fonction soient passés dans les registres :

• L'adresse du tableau (pointeur sur son premier élément) est passée dans le EBXregistre.
• L'index de base zéro de l'élément A est transmis dans le ECXregistre.
  _{(Supposé être un index valide.)}
• L'index de base zéro de l'élément B est transmis dans le EDXregistre.
  _{(Supposé être un index valide.)}

Cela réduit la taille et répond à toutes les exigences formelles, mais signifie que la fonction ne peut pas être facilement appelée à partir d'autres langages comme C. Vous devez l'appeler à partir d'un autre programme en langage assembleur. (Vous pouvez réécrire pour utiliser tout registre d'entrée, sans affecter le nombre d'octets; il n'y a rien de magique dans ceux que j'ai choisis.)

Non 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 octets

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

Java 8 + InverseY , 27 octets

java.util.Collections::swap

Appelle simplement la fonction swap ... c'est une référence de méthode du type Consumer3<List, Integer, Integer>.

Essayez-le en ligne! (en-tête et pied de page pour passe-partout et copie de l' Consumer3interface)

JavaScript (ES2015), 66 57 49 octets

Une approche différente (hélas, plus longue) que les réponses JavaScript précédentes

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

La source

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

awk, 31 octets

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

Essayez-le en ligne!

Prend entrée au format

1 2
1 2 3 4

et sorties comme

2 1 3 4

(1 index).

Explication

L'ensemble du programme est un motif manquant avec une action suivi d'un motif avec une action manquante.

Puisqu'un modèle manquant s'exécute sur chaque ligne, le code à l'intérieur des accolades s'exécute pour les deux lignes d'entrée. La c=$a;$a=$b;$b=c;partie échange les deux valeurs aux indices aet b(via la variable temporaire c). Cela n'a d'effet que sur la deuxième ligne, car sur la première ligne aet bn'est pas encore défini. La a=$1;b=$2partie définit aêtre le premier champ et ble deuxième champ, ce qui définit les valeurs appropriées pour que la première partie s'exécute sur la deuxième ligne.

Puisqu'une action manquante est équivalente à {print}, le motif imprime chaque ligne à laquelle il correspond. Ce modèle en particulier est le suivant NR>1: c'est-à-dire imprimer chaque fois que le numéro de ligne est supérieur à 1, ce qui se trouve être la ligne 2. Cela s'exécute après que l'échange de valeurs a eu lieu, terminant ainsi la tâche.

q / kdb +, 17 octets

Solution:

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

Exemple:

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

Explication:

Une version q de la réponse k de Simon. Appliquez la :fonction d' affectation à x aux indices inverses-y avec la valeur de x indexée à y. En panne, vous pouvez voir plus clairement:

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