[Question]
  [
Your challenge is to write a program or function that, when given two strings of equal length, swaps every other character and outputs/returns the resulting strings in either order.
## Examples
```
"Hello," "world!" --> "Hollo!" "werld,"
"code" "golf" --> "codf" "gole"
"happy" "angry" --> "hnpry" "aagpy"
"qwerty" "dvorak" --> "qvertk" "dworay"
"1, 2, 3" "a, b, c" --> "1, b, 3" "a, 2, c"
"3.141592653589" "2.718281828459" --> "3.111291623489" "2.748582858559"
"DJMcMayhem" "trichoplax" --> "DrMcMoylex" "tJichapham"
"Doorknob" "Downgoat" --> "Doonkoot" "Dowrgnab"
"Halloween" "Challenge" --> "Hhlloeegn" "Caallwnee"
```
## Rules
* The strings will only contain ASCII chars (32-126).
* The strings will always be the same length, and will never be empty.
* You may accept input in any suitable format: separate parameters, items in an array, separated by one or more newlines, even concatenated. The only restriction is that one string must come fully before the other (e.g. `a1\nb2\nc3` for `"abc", "123"` is invalid).
* The output may be **in either order** (i.e. you can start swapping from the first or the second char), and in any valid format mentioned above. (2-item array, separated by newline(s), concatenated, etc.)
## Scoring
This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), so **the shortest code in bytes for each language wins.**
  
[Answer]
## Haskell, 37 bytes
```
l=(,):flip(,):l
(unzip.).zipWith3($)l
```
Zips the two strings, alternately swapping the characters, then unzips them.
A 37-byte recursive alternative:
```
(a:b)?(c:d)=a:d?b
e?_=e
a%b=(a?b,b?a)
```
[Answer]
## Python, 42 bytes with [I/O golfing](http://meta.codegolf.stackexchange.com/q/9501/20260)
```
def f(a,b):a[1::2],b[1::2]=b[1::2],a[1::2]
```
Swaps every other character of the two lists. Takes as input two [lists of characters](http://meta.codegolf.stackexchange.com/a/2216/20260), and outputs [by modifying them](http://meta.codegolf.stackexchange.com/a/4942/20260).
```
l=list('cat')
m=list('dog')    
print l,m
def f(a,b):a[1::2],b[1::2]=b[1::2],a[1::2]
f(l,m)
print l,m
```
gives
```
['c', 'a', 't'] ['d', 'o', 'g']
['c', 'o', 't'] ['d', 'a', 'g']
```
[Answer]
# Vim, ~~18~~, 17 bytes
```
qqyljvPkvPll@qq@q
```
[Try it online!](http://v.tryitonline.net/#code=cXF5bGp2UGt2UGxsQHFxQHE&input=REpNY01heWhlbQp0cmljaG9wbGF4)
This uses the V interpreter because of backwards compatibility. Input comes in this format:
```
string1
string2
```
Explanation:
```
 qq                 " Start recording in register 'q'
   yl               " Yank one letter
     j              " Move down a row
      vP            " Swap the yanked letter and the letter under the cursor
        k           " Move back up a row
         vP         " Swap the yanked letter and the letter under the cursor
           ll       " Move two letters to the right. This will throw an error once we're done
             @q     " Call macro 'q' recursively
               q    " Stop recording.
                @q  " Start the recursive loop
```
[Answer]
## Haskell, 41 bytes
```
(a:b)#(c:d)=(a,c):d#b
_#_=[]
(unzip.).(#)
```
Returns a pair with the strings. Usage example: `( (unzip.).(#) ) "Hello," "world!"`-> `("Hollo!","werld,")`.
Simple recursive approach: take the first char of each string as a pair and append a recursive call with the (rest of the) strings swapped. `unzip` makes a pair of lists out of the list of pairs.
[Answer]
# [05AB1E](http://github.com/Adriandmen/05AB1E), ~~11~~ 10 bytes
```
øvyNFÀ}})ø
```
[Try it online!](http://05ab1e.tryitonline.net/#code=w7h2eU5Gw4B9fSnDuA&input=WyJIYWxsb3dlZW4iLCJDaGFsbGVuZ2UiXQ)
**Explanation**
input = `["code", "golf"]` used as example.
```
ø             # zip strings into list of pairs
              # STACK: ['cg', 'oo', 'dl', 'ef']
 vy           # for each pair
   NFÀ        # rotate left index times
      }}      # end-if, end-loop
              # STACK: 'cg, 'oo', 'dl', 'fe'
        )ø    # wrap in list and zip
              # OUTPUT: ['codf', 'gole']
```
[Answer]
## Perl, 48 bytes
Bytecount includes 47 bytes of code and `-p` flag.
```
say<>=~s%.\K(.)%"s/.{$-[0]}\\K(.)/$1/;\$1"%geer
```
Run with `-p` and `-E` flag. Expect each string on a different line :
```
perl -pE 'say<>=~s%.\K(.)%"s/.{$-[0]}\\K(.)/$1/;\$1"%geer' <<< "Hello
World"
```
**Explanations** :
`-p` : capture input in `$_` and prints it at the end. (to get and print the first string)  
`<>` : get a line of input. (to get the second string).  
`=~` : apply a regex to `<>` : `s%%%geer`, where thanks to `r` the modified string is returned (and then printed thanks to `say`).  
The regex :  
`.\K(.)` finds two characters, and will replace the second one with the result of the evaluation of this code `"s/.{$-[0]}\\K(.)/$1/;\$1"` :  
The first part, `s/.{$-[0]}\\K(.)/$1/` applies a regex to `$_` : `.{$-[0]}` skips the first characters to get to the same point as the outer regex (since `$-[0]` contains the index of the first capture group, so in that case the index of the characters to substitute), and then we capture a char with `(.)` and replace it with the character of the outer regex (`$1`). And then we add `$1` so the result of `"s/.{$-[0]}\\K(.)/$1/;\$1"` is the character we captured in the inner regex.  
You may have noticed that `$1` refer to the character we want to replace in both strings (so two different characters), so we play with `/ee` modifier of the regex which evaluates the right side of the regex twice : the first one will substitute only the `$1` that isn't preceded by the `\`.
[Answer]
## Python, 55 bytes
```
lambda a,b:[(-~len(a)/2*s)[::len(a)+1]for s in a+b,b+a]
```
Slicing!
58 bytes:
```
def f(a,b):n=len(a);print[(s*n)[:n*n:n+1]for s in a+b,b+a]
```
---
**64 bytes:**
```
f=lambda a,b,s='',t='':a and f(b[1:],a[1:],s+a[0],t+b[0])or[s,t]
```
Recursively accumulates the characters of the two strings into `s` and `t`, and outputs the pair of them at the end. The alternation is done by switching the input strings each recursive call. Outputting a space-separated string was the same length:
```
lambda a,b,s='',t=' ':a and f(b[1:],a[1:],s+a[0],t+b[0])or s+t
```
This narrowly beat out a different recursive strategy of alternately taking characters from each string, with each of the two possible strings as the first one. (65 bytes)
```
g=lambda a,b:a and a[0]+g(b[1:],a[1:])
lambda a,b:(g(a,b),g(b,a))
```
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 5 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-page)
```
żṚż¥/
```
Input is as separate arguments, output is concatenated.
[Try it online!](http://jelly.tryitonline.net/#code=xbzhuZrFvMKlLw&input=&args=RG9vcmtub2I+RG93bmdvYXQ) or [verify all test cases](http://jelly.tryitonline.net/#code=xbzhuZrFvMKlLwrDpzIvWQ&input=&args=IkhlbGxvLCIsICJ3b3JsZCEiLCAiY29kZSIsICJnb2xmIiwgImhhcHB5IiwgImFuZ3J5IiwgInF3ZXJ0eSIsICJkdm9yYWsiLCAiMSwgMiwgMyIsICJhLCBiLCBjIiwgIjMuMTQxNTkyNjUzNTg5IiwgIjIuNzE4MjgxODI4NDU5IiwgIkRKTWNNYXloZW0iLCAidHJpY2hvcGxheCIsICJEb29ya25vYiIsICJEb3duZ29hdCIsICJIYWxsb3dlZW4iLCAiQ2hhbGxlbmdlIg).
### How it works
```
żṚż¥/  Main link. Left argument: s (string). Right argument: t (string)
ż      Zipwith; yield the array of pairs of corresponding characters of s and t.
   ¥   Combine the two links to the left into a dyadic chain:
 Ṛ         Reverse the chain's left argument.
  ż        Zip the result with the chain's right argument.
    /  Reduce the return value of the initial ż by the quicklink Ṛż¥.
```
[Answer]
# [MATL](http://github.com/lmendo/MATL), ~~11~~ ~~10~~ ~~9~~ 8 bytes
*Thanks to ETHproductions for 1 byte off!*
```
"@X@YS&h
```
Input is a 2D array containing the two strings, such as: `['Halloween'; 'Challenge']`. The output strings are in reverse order.
[Try it online!](http://matl.tryitonline.net/#code=IkBYQFlTJmg&input=WydIYWxsb3dlZW4nOyAnQ2hhbGxlbmdlJ10)
### Explanation
```
        % Input 2D array implicitly
"       % For each column
  @     %   Push current column
  X@    %   Push iteration index, starting at 1
  YS    %   Circularly shift the column by that amount
  &h    %   Concatenate horizontally with (concatenated) previous columns
        % End implicitly
        % Display implicitly
```
---
## Old version: 9 bytes
```
tZyP:1&YS
```
### Explanation
```
        % Take input implicitly
t       % Duplicate 
        % STACK: ['Halloween'; 'Challenge'], ['Halloween'; 'Challenge']
Zy      % Size
        % STACK: ['Halloween'; 'Challenge'], [2 9]
P       % Flip array
        % STACK: ['Halloween'; 'Challenge'], [9 2]
:       % Range. Uses first element of the array as input
        % STACK: ['Halloween'; 'Challenge'], [1 2 3 4 5 6 7 8 9]
1&YS    % Circularly shift each column by those amounts respectively
        % STACK: [Caallwnee';'Hhlloeegn']
        % Display implicitly
```
[Answer]
# [Jelly](http://github.com/DennisMitchell/jelly), ~~9~~ ~~8~~ 6 bytes
Thanks to *Dennis* for saving 2 bytes!
```
Zṙ"J$Z
```
Uses the [**Jelly** encoding](https://github.com/DennisMitchell/jelly/wiki/Code-page). 
[Try it online!](http://jelly.tryitonline.net/#code=WuG5mSJKJFo&input=&args=IkhlbGxvIiwgIldvcmxkIg)
[Answer]
# [V](http://github.com/DJMcMayhem/V), 12 bytes
```
lòyljvPkvPll
```
[Try it online!](http://v.tryitonline.net/#code=bMOyeWxqdlBrdlBsbA&input=REpNY01heWhlbQp0cmljaG9wbGF4)
Nothing too interesting, just a direct port of my vim answer so I can compete with (but not beat) 05AB1E.
[Answer]
## Pyke, 9 bytes
```
,Fo2%I_(,
```
[Try it here!](http://pyke.catbus.co.uk/?code=%2CFo2%25I_%28%2C&input=%22code%22%2C+%22golf%22)
```
          - o = 0
,         -   transpose(input)
 F     (  -  for i in ^:
  o2%     -    (o++ %2)
     I_   -   if ^: i = reverse(i)
        , - transpose(^)
```
[Answer]
# JavaScript (ES6), 51 ~~54~~
*Edit* 3 bytes saved thx @Neil
Function with array input/output
```
p=>p.map((w,i)=>w.replace(/./g,(c,j)=>p[i+j&1][j]))
```
I like this one more, but it's 55 (2 strings in input, array in output)
```
(a,b)=>[...a].reduce(([p,q],c,i)=>[q+c,p+b[i]],['',''])
```
**Test**
```
f=
p=>p.map((w,i)=>w.replace(/./g,(c,j)=>p[i+j&1][j]))
function go() {
  var a=A.value, b=B.value
  if (a.length == b.length)
    O.textContent = f([a,b]).join('\n')
  else
    O.textContent = '- different length -'
    
}
go()
```
```
<input id=A value='Hello,'><input id=B value='world!'>
<button onclick='go()'>go</button><pre id=O></pre>
```
[Answer]
# Pyth, 8 bytes
```
C.e_FbkC
```
Try it online: [Demonstration](http://pyth.herokuapp.com/?code=C.e_FbkC&input=%5B%22Hello%2C%22%2C%20%22world%21%22%5D&debug=0)
Transposes the words, reverses each pair of letters 'current index'-times, transpose again. 
[Answer]
## JavaScript (ES6), 55 bytes
```
f=([c,...s],[d,...t],o="",p="")=>c?f(t,s,o+c,p+d):[o,p]
```
I wanted to do something clever with using regexp to replace alternate characters but that ended up taking ~~67~~ 57 bytes:
```
a=>a.map((s,i)=>a[+!i].replace(/.(.?)/g,(_,c,j)=>s[j]+c))
```
[Answer]
# Perl, 40 bytes
Includes +1 for `-n`
Give strings as lines on STDIN
```
interlace.pl
hello
world
^D
```
`interlace.pl`
```
#!/usr/bin/perl -n
s/./${1&$.+pos}[pos]=$&/seg}{print@0,@1
```
[Answer]
## Java, 132 103 100 bytes
*Thanks to Kevin Cruijssen for suggesting returning the array (among other improvements) and saving 29 bytes! Also Olivier Grégoire for 3 bytes!*
```
char[]c(char[]s,int l){for(int o=l;o-->0;)if(o%2>0){char t=s[o];s[o]=s[l+o+1];s[l+o+1]=t;}return s;}
```
Called like this:
```
public static void main(String[] args) {
    System.out.println(c("Hello,world!".toCharArray(), 5)); // 5 is the length of each "String"
}
```
Output:
`Hollo,werld!`
Takes advantage of the fact that input can basically be formatted in any way (in this case, a single char array of Strings that are delimited by a comma), and pretty lenient output rules as well.
[Answer]
# C, 124 bytes
```
main(c,v)char**v;{char a[99],b[99];for(c=0;v[1][c]^0;++c){a[c]=v[1+c%2][c];b[c]=v[2-c%2][c];}a[c]=0;b[c]=0;puts(a);puts(b);}
```
Call with:
```
program.exe string1 string2
```
String length is limited to 98 characters.
[Answer]
# [Octave](https://www.gnu.org/software/octave/), ~~64~~ 61 bytes
```
@(x)reshape(x((t=1:end)+(2*mod(t,2)-1).*(mod(t-1,4)>1)),2,[])
```
Anonymous function that inputs a 2D char array with each string in a row, and produces the output in the same format.
[Try it at Ideone](http://ideone.com/8WZ5EG).
[Answer]
## Racket 208 bytes
```
(let((sl string->list)(ls list->string)(r reverse))(let p((s(sl s))(t(sl t))(u'())(v'())(g #t))(if(null? s)
(list(ls(r u))(ls(r v)))(p(cdr s)(cdr t)(cons(car(if g s t))u)(cons(car(if g t s))v)(if g #f #t)))))
```
Ungolfed: 
```
(define (f s t)
  (let ((sl string->list)                ; create short names of fns
        (ls list->string)
        (r reverse))
    (let loop ((s (sl s))                ; convert string to lists
               (t (sl t))
               (u '())                   ; create empty new lists
               (v '())
               (g #t))                   ; a boolean flag
      (if (null? s)                      ; if done, return new lists converted back to strings
          (list (ls (r u))
                (ls (r v)))
          (loop (rest s)
                (rest t)                 ; keep adding chars to new lists alternately
                (cons (first (if g s t)) u) 
                (cons (first (if g t s)) v)
                (if g #f #t))            ; alternate the boolean flag
          ))))
```
Testing: 
```
(f "abcdef" "123456")
```
Output: 
```
'("a2c4e6" "1b3d5f")
```
Above is recursive version. 
Iterative version: 
```
(let*((sl string->list)(ls list->string)(r reverse)(s(sl s))(t(sl t))(l'())(k'())(p(λ(a b g)(set! l(cons(if g a b)l))
(set! k(cons(if g b a)k)))))(for((i s)(j t)(n(in-naturals)))(p i j(if(= 0(modulo n 2)) #t #f)))(list(ls(r l))(ls(r k))))
```
Ungolfed: 
```
(define (f s t)
  (let* ((sl string->list)              ; create short form of fn names
         (ls list->string)
         (r reverse)
         (s (sl s))                     ; convert strings to lists
         (t (sl t))
         (l '())                        ; create empty lists for new sequences
         (k '())
         (p (λ(a b g)                   ; fn to add chars to one or other list
              (set! l (cons (if g a b) l))
              (set! k (cons (if g b a) k)))))
    (for ((i s)(j t)(n (in-naturals)))  ; loop with both strings
          (p i j                        ; add to new lists alternately
             (if (= 0 (modulo n 2)) #t #f)))
    (list (ls (r l))                  ; convert reversed lists to strings
          (ls (r k)))))
```
[Answer]
## PowerShell v2+, 82 bytes
```
param($a,$b)$i=0;[char[]]$a|%{$c+=($_,$b[$i])[$i%2];$d+=($b[$i],$_)[$i++%2]};$c;$d
```
~~Still golfing...~~ Nope. Can't seem to golf this down any without using a regex like other answers (boo on copying algorithms).
So we take `$a` and `$b` as strings, set index `$i` to `0`, cast `$a` as a `char`-array, and send it through a loop `|%{...}`. Each iteration, we're string-concatenating onto `$c` and `$d` by indexing into an array-select (i.e., so it alternates back and forth). Then, we leave `$c` and `$d` on the pipeline, and output via implicit `Write-Output` happens at program completion.
[Answer]
# [Lithp](https://github.com/andrakis/node-lithp), 120 characters (+3 for -v1 flag)
Line split in 2 for readability:
```
#P::((invoke P "map" (js-bridge #W,I::(replace W (regex "." "g")
     (js-bridge #C,J::(index (index P (& (+ I J) 1)) J))))))
```
Requires the `-v1` flag to `run.js` as some functions are not yet part of the standard library.
Sample usage:
```
(
    (def f #P::((invoke P "map" (js-bridge #W,I::(replace W (regex "." "g")
                (js-bridge #C,J::(index (index P (& (+ I J) 1)) J)))))))
    (print (f (list "Hello," "world!")))
)
```
This sort of highlights that I haven't spent enough time on the standard library. Having to use `js-bridge/1` twice and the long regex form, as well as invoking map using `invoke/*` all contribute to this being much longer than it needs to be.
Time to work on my standard library more I think.
[Answer]
# PHP, 79 Bytes
```
for(;$i<=strlen(($a=$argv)[1]);$y.=$a[2-$i%2][$i++])echo$a[1+$i%2][+$i]??" $y";
```
Previous Version PHP, 82 Bytes
```
for(;$i<strlen(($a=$argv)[1]);$y.=$a[2-$i%2][$i++])$x.=$a[1+$i%2][$i];echo"$x $y";
```
[Answer]
# C, ~~54~~ 52 bytes
```
f(char*a,char*b,char*c){while(*c++=*a++,*c++=*b++);}
```
Assumes output `c` has already the desired length.
Usage:
```
main(){
 char a[]="123456";
 char b[]="abcdef";
 char c[sizeof(a)+sizeof(b)-1];
 f(a,b,c);
 puts(c);
```
}
If you insist on creating the output, here is a **91 bytes** solution:
```
char*g(char*a,char*b){char*c=malloc(2*strlen(a)),*d=c;while(*c++=*a++,*c++=*b++);return d;}
```
Usage:
```
main(){
 char a[]="123456";
 char b[]="abcdef";
 puts(g(a,b));
}
```
[Answer]
# [Japt](https://github.com/ETHproductions/japt), ~~8~~ 4 [bytes](https://en.wikipedia.org/wiki/ISO/IEC_8859-1)
```
yÈéY
```
[Try it](https://petershaggynoble.github.io/Japt-Interpreter/?v=1.4.6&code=ecjpWQ&input=WyJIZWxsbywiLCJ3b3JsZCEiXQotUQ)
```
yÈéY     :Implicit input of array U
y        :Transpose
 È       :Map each element at 0-based index Y then transpose back
  éY     :  Rotate right Y times
```
[Answer]
# [q](https://code.kx.com/home/), 32 bytes
```
{?[;x;y]each(not\)count[x]#10b}.
```
# k, 24 bytes
```
{?[;x;y]'(~:\)(#x)#10b}.
```
[Answer]
# C, 150 bytes
I used the typical omissions of header files and `main()`'s return type and return statement. It throws a warning, but compiles without issue. I also used a GCC-specific trick that allows array declarations with variable expressions.
The program expects the strings from the command line, and as such, the program should be run with `./a.out string1 string2`.
```
main(int a,char**v){int x=strlen(v[1]);char s[x],t[x],c;strcpy(s,v[1]);strcpy(t,v[2]);for(a=0;a<x;++a)if(a%2)c=s[a],s[a]=t[a],t[a]=c;puts(s),puts(t);}
```
Or more legibly,
```
main(int a,char**v){
    int x=strlen(v[1]);
    char s[x],t[x],c;
    strcpy(s,v[1]);strcpy(t,v[2]);
    for(a=0;a<x;++a)
        if(a%2)c=s[a],s[a]=t[a],t[a]=c;
    puts(s),puts(t);
}
```
[Answer]
# Mathematica, 51 bytes
Takes input as an array of two arrays of characters, with output in the same format. The function simply constructs the new array using a (mod 2) operation.
```
Table[#[[Mod[j+i,2]+1,j]],{i,2},{j,Length@#[[1]]}]&
```
[Answer]
# QBasic 4.5, 172 bytes
Ouch, this one gets painful with the ol' QBasic...
```
DEFSTR A-D:INPUT A,B
IF LEN(A)MOD 2=1 THEN A=A+" ":B=B+" "
FOR x=1 TO LEN(A) STEP 2
C=C+MID$(A,x,1)+MID$(B,x+1,1):D=D+MID$(B,x,1)+MID$(A,x+1,1):NEXT:?RTRIM$(C),RTRIM$(D)
```
Fun fact: Using `DEFSTR` saved more bytes than it cost because now I could use `A` instead of `a$`.
[Answer]
# [QBIC](https://drive.google.com/drive/folders/0B0R1Jgqp8Gg4cVJCZkRkdEthZDQ?usp=sharing), 112 bytes
QBIC can streamline a lot of the QBasic boilerplate, but the main `MID$`engine still needs to be done in QBasic because QBIC lacks a substring-function. Still, saves me 60 bytes.
```
;;_LA|~a%2=1|A=A+@ | B=B+C][1,a,2|X=X+$MID$(A$,b,1)+MID$(B$,b+1,1):Y$=Y$+MID$(B$,b,1)+MID$(A$,b+1,1)|]?_tX|,_tY|
```
]