Swap Two Values in a List

Question

Introduction:

Although we have a lot of challenges where swapping two items in a list is a subtask, like Single swaps of an array; Swap to Sort an Array; \$n\$ swaps into a nop; etc., we don't have the simple challenge of just swapping two items given a list and two indices.

Input:
A list with some positive integers \$L\$, and two indices \$a\$ and \$b\$.

Output:
The same list, with the two items at the given indices swapped.

Challenge rules:

• The input-list is guaranteed to contain at least two items.
• The input-list is guaranteed to only contain positive integers.
• The input-indices can be either 0-based or 1-based (please specify in your answer which of the two you've used).
• The input-indices are guaranteed to be valid indices based on the length of the input-list.
• The input-indices are distinct, so will never be the same index. (The values in the input-list won't necessarily be distinct.)
• You can assume \$a<b\$ (and you're allowed to take the inputs in reversed order if it helps).
• I/O is flexible. You're allowed to take the input as a list/array/stream, from STDIN, as a delimited string, etc. You're allowed to modify the input-list directly, or return a new one with the two items swapped.

General rules:

• This is code-golf, so the shortest answer in bytes wins.
  Don't let code-golf languages discourage you from posting answers with non-codegolfing languages. Try to come up with an as short as possible answer for 'any' programming language.
• Standard rules apply for your answer with default I/O rules, so you are allowed to use STDIN/STDOUT, functions/method with the proper parameters and return-type, full programs. Your call.
• Default Loopholes are forbidden.
• If possible, please add a link with a test for your code (e.g. TIO).
• Also, adding an explanation for your answer is highly recommended.

Test cases

All test cases use 0-based indices.

Inputs: L=[1,2,3,4,5,6,7,8,9,10], a=3, b=7
Output:   [1,2,3,8,5,6,7,4,9,10]

Inputs: L=[ 3, 8, 1, 4,10,10,10,10], a=0, b=5
Output:   [10, 8, 1, 4,10, 3,10,10]

Inputs: L=[5,1,4,2,3], a=0, b=4
Output:   [3,1,4,2,5]

Inputs: L=[5,6], a=0, b=1
Output:   [6,5]

Inputs: L=[2,2,2], a=0, b=1
Output:   [2,2,2]

Answer 1

Perl 5, 42 bytes

Updated TIO link to show positive indices only per challenge instructions (thanks, Kevin!)

sub a{($a,$b,$l)=@_;@$l[$a,$b]=@$l[$b,$a]}

Try it online!

Takes arguments as (first index, second index, 0-bound array). Mutates array in-place. Works with arrays containing any valid values, not just positive integers!

Answer 2

Clojure, 27 bytes

#(assoc % %2(% %3)%3(% %2))

The first argument % is a vector of numbers (not a list!) so that we don't need to use the function nth.

Edit: TIO

Edit 2: And actually you cannot assoc a list anyway.

Answer 3

Raku, 19 18 bytes

{@^a[@^i].=rotate}

Try it online!

0-based indexing. Modifies the list in-place. Takes the indices as a two-element list.

Edit: rotate has the same effect as reverse and is one character shorter. D'oh!

Answer 4

Desmos, 49 bytes

l=[1...L.length]
f(L,a,b)=\{l=a:L[b],l=b:L[a],L\}

Try It On Desmos!

Try It On Desmos! - Prettified

Surprisingly readable (if you know a bit of Desmos) even after I code golfed it.

Python Equivalent (switching to 0-based)

def f(L,a,b):
    returnList = []
    for l in range(len(L)):
        if l == a:
            returnList.append(L[b])
        elif l == b:
            returnList.append(L[a])
        else:
            returnList.append(L[l])
    return returnList

Answer 5

Charcoal, 14 bytes

ＩＥθ⎇№ηκ§θ⁻Σηκι

Try it online! Link is to verbose version of code. Takes the 0-indexed indices as a 2-element array. Explanation:

  θ             Input array
 Ｅ              Map over elements
    №           Count of
      κ         Current index in
     η          Input indices
   ⎇            If found then
        θ       Input array
       §        Indexed by
           η    Input indices
          Σ     Take the sum
         ⁻      Minus
            κ   Current index
             ι  Else current element
Ｉ               Cast to string
                Implicitly print

Answer 6

C++, 51 46 38 bytes

#define f(a,i,j)a[i]^=a[j]^(a[j]=a[i])

Saved 5 bytes thanks to Kevin Cruijssen.

Saved 8 bytes thanks to AZTECCO.

Try it online!

Answer 7

Python 3, 49 bytes

lambda l,a,b:l[:a]+[l[b]]+l[a+1:b]+[l[a]]+l[b+1:]

Try it online!

The very simple way.

Answer 8

Python 2, 52 49 bytes

(longer than the approach by @pxeger, but doesn't mutate in-place

lambda a,b,l:l[:a]+[l[b]]+l[a+1:b]+[l[a]]+l[b+1:]

Try it Online!

EDIT: Thanks @Stephen Universe for saving me few bytes!

---

56 bytes by using list.pop and list.insert:

def f(a,b,l):l.insert(b,l.pop(a)),l.insert(a,l.pop(b-1))

Try it online!

Answer 9

Icon, 43 34 bytes

-9 bytes thanks to Kevin Cruijssen

procedure s(l,a,b)
l[a]:=:l[b]
end

Try it online!

1-indexed

Answer 10

Pari/GP, 34 bytes

f(l,a,b)=[l[a],l[b]]=[l[b],l[a]];l

Try it online!

1-indexed

Answer 11

x86-16 machine code, 7 bytes

00000000: 8a01 8600 8801 c3                        .......

Listing

8A 01   MOV  AL, BYTE PTR[BX][DI]       ; put 'b' value into AL 
86 00   XCHG AL, BYTE PTR[BX][SI]       ; swap 'b' value with 'a' position 
88 01   MOV  BYTE PTR[BX][DI], AL       ; put 'a' value into 'b' position 
C3      RET                             ; return to caller 

Input \$L\$ at [BX], indices \$a\$ in SI, \$b\$ in DI, 0-based.

A test with our old friend DOS DEBUG:

Answer 12

Ruby, 30 bytes

->(l,a,b){l[a],l[b]=l[b],l[a]}

Mutates the input in-place. Direct port of @pxeger's approach including the link below:

Attempt This Online!

Answer 13

Tcl, 75 bytes

proc S {L a b} {set x [lindex $L $a]
lset L $a [lindex $L $b]
lset L $b $x}

Try it online!

Answer 14

C++ (gcc), 36 bytes

#define f(a,i,j)std::swap(a[i],a[j])

Try it online!

Answer 15

AWK, 36 bytes

$$(NF-1)+=$$NF-($$NF=$$(NF-1)),NF-=2

Try it online!

Expected input

The input is a list of integers separated by spaces; the last two integers are the indexes of the values that must be swapped:

Input:
3 8 1 4 10 10 10 10 1 6
\_________________/ | |
 List of integers,  | L> Second index
starting index at 1 |
                    L> First index

Output:
10 8 1 4 10 3 10 10
|           |
\___________/
   Swapped

How it works

$$(NF-1)                        We take the integer which index is the value of the second-to-last integer,
        +=                      and add:
          $$NF                  the integer which index is the last integer
              -($$NF            minus itself,
                    =$$(NF-1))  except that it is now the integer which index is the second-to-last integer.
,NF-=2                          And let's remove the last two integers.
                                Phew! It should print the modified input, at last.

It uses this swapping oneliner: a+=b-(b=a).

For better understanding: NF is the variable for the number of fields, i.e, the number of integers in the input. $n is the nth integer in the input, so $NF is the last integer, and $(NF-1) the second-to-last integer. $$NF equals $($NF), that is the integer which index is the last integer.

NF-=2 reduces the number of fields by two, ignoring the two indexes.

Answer 16

MathGolf, 1 byte

µ

Apparently MathGolf has a builtin for this. Came across it in the docs when I was working on another challenge today. ¯\_(ツ)_/¯.

Takes the loose index-inputs before the list.

Try it online.

Answer 17

BQN, 18 10 bytes

Edit: -8 bytes thanks to Razetime

{⌽⌾(𝕨⊸⊏)𝕩}

Try it at BQN online REPL

Probably not the tersest code, but it works, which was no trivial accomplishment for my very limited BQN ability. Now quite short...
Will try to golf-down better as my abilities (gradually) improve. ...thanks to Razetime.

Swap ← {⌽⌾(𝕨⊸⊏)𝕩}          # define Swap function:
                            # list of 2 indices to swap on left = 𝕨
                            # array on right = 𝕩.
                            
         ⌾                  # 'under' = apply function on LHS
                            # to elements specified by RHS  
          (𝕨⊸⊏)            #   RHS: elements of 𝕩 at indices 𝕨
        ⌽                   #   LHS: reverse

Answer 18

Uiua, 3 bytes

⍜⊏⇌

Try it!

0-indexed.

Answer 19

C# (Visual C# Compiler), 75 bytes

List<int> f(List<int> L,int a,int b){var x=L[a];L[a]=L[b];L[b]=x;return L;}

Try it online!

Working only for int's. Thinking about evolving it to generics after.