Ruby map gives weird results

This is because the String#[]= method mutates the string.

Quick fix would be something like this:

a="123456789"
t=[[1,4],[3,4],[4,5],[1,2]]
p t.map{|x,y]
    b = "#{a}" # IMPORTANT - this builds a new string
    b[x],b[y]=b[y],b[x] # this mutates the new string
    #p b  
    b
}

An alternative to "#{a}" would be to say a.clone, it does the same thing in this case.

The reason this works, is because instead of directly modifying a with a[x],a[y]=a[y],a[x], you're making a temporary copy of a and modifying that instead

edit - I misread the question - if you want to show the result of chaining each operation on the previous result, use dup/clone after the modification as Stefan said in his answer

Is my understanding correct?

Yes, I believe it is. I second what Max says, and I'll also elaborate a bit in case it helps.

Each b is a newly created object because it gets created inside the block, so it gets recreated with every new iteration. The a is created outside the block, so the same object (a) keeps getting referenced inside the block for each iteration.

You can better understand how this works by experimenting with #object_id. Try running this code:

a="123456789"
t=[[1,4],[3,4],[4,5],[1,2]]
p t.map { |x,y|
    b = "#{a}" # IMPORTANT - this builds a new string
    b[x],b[y]=b[y],b[x]
    p "a.object_id = #{a.object_id}"
    p "b.object_id = #{b.object_id}"
    b
}

You will notice that a is the same object for each iteration of the #map method, while b is a new one.

This is an example of the concept of a closure. A closure is some sort of enclosed code structure that retains access to whatever state is available in the context in which it was created, while that context doesn't have access to its, the enclosed code's, state. Sort of like a "one way mirror": the enclosed code can see outside, but the outside can't see into the enclosed code.

In Ruby, closures are implemented as blocks: blocks are closures. So, everything that is visible to whatever context a block is created in (in this case, main) is also visible to that block, although the reverse is not true — for example, you can't reference b from outside the block. (Methods are not closures: if your block were a method, it wouldn't be able to see a unless you passed it in as an argument to your method.)

So, as Max says, when you make changes to a inside your block, you are actually changing (mutating) the same a that you defined up top each time.

Side topic

Now, if you are referencing individual characters in strings it's important to understand that the underlying structure of strings differs from that of arrays. Also, arrays behave differently when you mutate their elements from strings when you mutate their characters.

I'm mentioning this because I have this vague feeling that you are thinking of string character references as pretty much analogous to array element references. This is pretty much only true with respect to syntax.

You may find the results of running this code interesting:

a = '123456789'
p a.object_id
p a[0].object_id
p a[1].object_id
a[0] = '7'
p a.object_id
p a[0].object_id
p a[1].object_id

puts
a = '123456789'.chars
p a.object_id
p a[0].object_id
p a[1].object_id
a[0] = '7'
p a.object_id
p a[0].object_id
p a[1].object_id

In particular, a comparison of the four outputs of a[1].object_id should be instructive, because it shows where strings and arrays differ. If you reassign an element in an array, that element and only that element gets a new object id. If you reassign a character in a string, the string object itself remains the same, but every character in the string gets recreated.

Since you are returning a from map, the result will contain a four times. Those a's all refer to the same object.

You probably want to return a copy of a to preserve its current state:

a = '123456789'
t = [[1, 4], [3, 4], [4, 5], [1, 2]]
r = t.map { |x, y|
  a[x], a[y] = a[y], a[x]
  a.dup
}
r #=> ["153426789", "153246789", "153264789", "135264789"]