Ruby, 72 bytes

Wow! A Ruby code golf! I don't think that's ever been attempted before!

In all reality though, this required some nice Ruby shortcuts and a couple patterns which I found. It was my first golf ever and it was very fun to do. Without further ado, here's the golfed code:

3.times{|x|x*=2;t=".txt";a=([?i,?a,?o]*2);File.rename(a[x]+t,a[x+1]+t)} 

And the ungolfed version

3.times do |x| x = x * 2 t=".txt" a=([?i,?a,?o]*2) File.rename(a[x]+t, a[x+1]+t)} end 

The key factor in this is that the parameters passed to the File.rename are this, exactly:

File.rename "i.txt", "a.txt" File.rename "o.txt", "i.txt" File.rename "a.txt", "o.txt" 

Hope this (doesn't) make sense!

Python, 77

import os;t='.txt';r,i,o,x=[os.rename,'i'+t,'o'+t,'1'+t];r(i,x);r(o,i);r(x,o) 

Python, 65

import os;t='.txt' for a,b in zip('iox','xio'):os.rename(a+t,b+t) 

Python, 63

import os;t='.txt' for a,b in 'ix','oi','xo':os.rename(a+t,b+t) 

PHP, 68

<?$r=rename;$t='.txt';$r("i$t","x");$r("o$t","i$t");$r("x","o$t");?> 

Windows Batch File, 42

move i.txt x&move o.txt i.txt&move x o.txt 

Windows Batch File (args), 30

move %1 x&move %2 %1&move x %2 

Ruby

i1="i.txt" i2="o.txt" c1=IO.readlines(i2) c2=IO.readlines(i1) File.open(i1){|x|x.puts(c1)} File.open(i2){|x|x.puts(c2)} 

Shortened version:

a=["i.txt","o.txt"] (0..1).each{|x|b[x]=IO.readlines(a[x])*"\n"} a.reverse! (0..1).each{|x|IO.write(a[x],b[x])} 

Not the shortest, but very simple and easy to read. Also, no intermediate files, only RAM.

PHP, 89

I thought I'd give it a shot.

<?php $f1='f1.txt';$f2='f2.txt';$ft='ft.txt';copy($f1,$ft);copy($f2,$f1);rename($ft,$f2); 

Ungolfed version:

<?php $f1 = 'f1.txt'; $f2 = 'f2.txt'; $ft = 'ft.txt'; copy($f1, $ft); copy($f2, $f1); rename($ft, $f2); 

Apparently I took 2 answers of here and combined them.. oh well.

VBA (148...132) and (126...110)

Renaming with a temp file t in the c:\ drive. Also first attempt at golf :S

Sub s():Set f=CreateObject("Scripting.FileSystemObject"):i="c:\i.txt":t="c:\t":f.MoveFile i,t:f.MoveFile "c:\o.txt",i:Kill t:End Sub 

If scrrun.dll is referenced already, could cut it down a bit to 126...110.

Sub s():Set f=new FileSystemObject:i="c:\i.txt":t="c:\t":f.MoveFile i,t:f.MoveFile "c:\o.txt",i:Kill t:End Sub 

Powershell, 44 49 bytes

$t='.txt' ren i$t a$t -fo ren o$t i$t ren a$t o$t 

where ren is alias for Rename-Item. The script uses and delete a third file a.txt.

Two bash based answers; 52 and 62 chars

shell: diff + patch (+ tee + sed...) 52

Maybe not the shorter, but I find this fun (and there is no use of temporary file):

diff -u [io]*|tee >(patch -r -)|sed 1s/i/o/|patch -R 

Where content is swapped and files are modified in place:

Sample run

swapContent() { diff -u $1 $2|tee >(patch -r -)|sed 1s/$1/$2/|patch -R ;} while read page file ;do man -Pcol\ -b $page >$file.txt;done <<<$'man i\nbash o' printf "%s %8d %s\n" $(join -j 2 <(stat -c '%s %n' [io]*) <(md5sum [io]*)) swapContent [io]* printf "%s %8d %s\n" $(join -j 2 <(stat -c '%s %n' [io]*) <(md5sum [io]*)) 

Could produce something like:

i.txt 46007 1da1f7533e0eab1e97cce97bb7ca1d3b o.txt 321071 7dcd230890faf4ef848d4745eda14407 patching file o.txt i.txt 321071 7dcd230890faf4ef848d4745eda14407 o.txt 46007 1da1f7533e0eab1e97cce97bb7ca1d3b 

use of xargs to simplify mv requests

Not as funny, but nice anyway.

set -- {i,o}.txt t&&eval 'xargs -n2 mv<<<"' \${1,3,2,1,3,2} \" 

05AB1E --no-lazy, 39 37 35 bytes

-2 thanks to Kevin Cruijssen.

'°ŽDÀøεS’.í¼t"’«`’File.‚™‚ˆ"ÿ,"ÿ’.E 

Try it online! Link includes a header and footer to create the files and prove that it worked.

'°ŽDÀøεS’...’«`’...’.E # trimmed program ε # for each in... ø # all characters of... '°Ž # "bio"... ø # paired with corresponding characters of... '°ŽD # "bio"... À # rotated left one character... .E # evaluate... ’...’ # "File.rename\"ÿ\",\"ÿ\""... # (implicit) with the first ÿ replaced by... ` # second element of... S # list of characters of... # (implicit) current element... # (implicit) with each element... « # concatenated with... ’...’ # ".txt"... # (implicit) with the second ÿ replaced by... ` # first element of... S # list of characters of... # (implicit) current element... # (implicit) with each element... « # concatenated with... ’...’ # ".txt"... .E # as Elixir code ==================== File.rename # full program File.rename # rename file with name argument 1 to argument 2 

Uiua, 21 bytes

⍜∩&frab:∩$"_.txt"@i@o 

Or, with file names input to the function, 8 bytes:

⍜∩&frab: 

This is a very beautiful piece of code which anybody who has not seen Uiua before should learn from. The crux of it is the modifier ⍜ under, which applies a transformation function, another function, and the inverse function of the transformation.

Here, the transformation function is ∩&frab and the applied function is :.

∩ both applies a function to two values, and &frab is a system function to read the file at a given path into an array of bytes, so ∩&frab says "read both files".

The function : flip takes the two arrays and flips them, so the first becomes the second and the second becomes the first.

Finally, the transformation function is undone, writing both files to the corresponding paths from before.

Shell script, 24

Works in Bash and probably most shells. Pass with your two filenames as parameters.

mv $1 ੴ;mv $2 $1;mv ੴ $2 

If you want fixed filenames then this will do it, for a 12 char penalty:

mv i.txt ੴ;mv o.txt i.txt;mv ੴ o.txt 

Python:

import os l,e='i_o'*2,'.txt' for x,y in zip(l,l[1:])[::2]: os.rename(x+e,y+e) 

Windows Batch File (48)

type i.txt>a&type o.txt>i.txt&type a>o.txt&del a 

I forgot about the move command when I wrote this...

C 162

Golfed: uses t.txt as tmp file and swaps names then removes t.txt.

#include <stdio.h> #define R(x,y) rename(x,y) #define X(x) remove(x) int main(){char *i="i.txt",*o="o.txt",*t="t.txt";R(i,t);X(i);R(o,i);R(t,o);X(t);return 0;} 

Edit: removed 2 spaces

PHP - 172

Golfed version of @EisaAdil's answer

$f1='file1.txt';$f2='file2.txt';$f1contents=file_get_contents($f1);$f2contents=file_get_contents($f2);file_put_contents($f1,$f2contents);file_put_contents($f2,$f1contents); 

Rebol - 46 (rename file) or 55 (r/w contents)

Rename file (using t as temporary file):

r: :rename r i: %i.txt %t r o: %o.txt i r %t o 

Read in then write out file contents:

a: read i: %i.txt b: read o: %o.txt write o a write i b 

PHP, 45

<?php copy('i','t');copy('o','i');rename('t','o'); 

Not very golfy but shortest PHP so far.

Groovy - 99 chars

This is my attempt, with Groovy 2.2.1. I tried to do it without renaming:

f={new File(it+".txt")} w={x,y->x.withWriter{it.write y}} i=f "i" o=f "o" t=i.text w i,o.text w o,t 

Ungolfed:

file = { new File(it+".txt") } writeTextToFile = { x,y -> x.withWriter{it.write y} } iFile = file("i") oFile = file("o") iText = iFile.text writeTextToFile (iFile,oFile.text) writeTextToFile (oFile,iText) 

C: 65 characters

#define r(a,b)rename(#a".txt",#b".txt"); main(){r(i,)r(o,i)r(,o)} 

A quite simple solution in C that does the job. It uses a temporary name (.txt) for one of the files before giving it its proper new name.

Ungolfed (note how the syntax highlighting fails in the define, a bug has been uncovered!):

#include <stdio.h> #define r(a, b) rename(#a ".txt", #b ".txt"); int main() { r(i, ) // rename("i.txt", ".txt"); r(o, i) // rename("o.txt", "i.txt"); r( , o) // rename( ".txt", "o.txt"); return 0; } 

Perl, 120 bytes (Contents swapping without file renaming)

use open IO,':bytes';undef$/;open I,"<i.txt";$I=<I>;open I,"<o.txt";open O,">i.txt";print O<I>;open O,">o.txt";print O$I 

The file contents is put into memory and written back to the other file. Thus i.txt and o.txt must fit into memory.

Since the file contents are actually exchanged, hard links are updated automatically, see AJManfield's comment.

Ungolfed:

use open IO => ':bytes'; # binmode, not needed for Unix, but needed for Windows undef $/; # read whole file instead of lines open I, "<i.txt"; # open i.txt for reading $I = <I>; # read i.txt open I, "<o.txt"; # open o.txt for reading open O, ">i.txt"; # open i.txt for writing print O <I>; # read o.txt and put the contents in i.txt open O, ">o.txt"; # open o.txt for writing print O $I; # write o.txt with contents of old i.txt 

Windows Batch, 39 bytes

ren i.txt x&ren o.txt i.txt&ren x o.txt

Lua, 71 70 bytes

_ENV=os t='.txt'i,o,r='i'..t,'o'..t,rename r(i,t)r(o,i)r(t,o)remove(t) 

Try it online!

Define os, the operating system library, as the global table so we can write rename and remove instead of os.rename and os.remove. (Incidentally this also means the one-letter variables are actually fields in the os table.) Make short alias for os.rename to save some space. Set up filename variables, using '.txt' as temporary file. Do the renaming and deleting.

PHP, 52 bytes

AsksAnyway´s php modernized & golfed:

($r=rename)(i.$e=".txt",x);$r(o.$e,i.$e);$r(x,o.$e); 

Run with php -nr '<code>'.

AWK, 66 bytes

a=FILENAME,b=!b?a:b{c[a]=c[a]$0RS}END{printf c[a]>b;printf c[b]>a} 

Try it online!

Note: I provided a TIO line, but I have no idea how to make it work when the code needs to read from input files?

The rename approaches seem to be much shorter, but here's one in AWK that copies the data instead. At a high level, it takes a commandline like,

gawk '...code...' i.txt o.txt 

which feeds both files into the program on STDIN. It uses the magic variable FILENAME to cache the contents of each one into a separate entry in an associative array. Then the END clause just overwrites each file with the content from the other one.

The "test" per line, which is always truthy, sets a to the current filename over and over. And it also ensures b is to the first filename seen.

a=FILENAME,b=!b?a:b 

The code block executed per line, just appends the current line to the accumulated data for the current filename.

c[a]=c[a]$0RS 

Then once all the lines from both files have been read, the END code block writes out the files with the content swapped.

printf c[a]>b;printf c[b]>a 

Pascal, 224 B

This complete Pascal program requires a processor meeting the requirements of ISO standard 7185 “Standard Pascal” or ISO standard 10206 “Extended Pascal”.

program X(A,B);var A,B,C:text;Z:char;procedure M(var S,D:text);begin reset(S);rewrite(D);while not EOF(S) do begin while not EOLn(S) do begin read(S,Z);write(D,Z)end;readLn(S);writeLn(D)end end;begin M(A,C);M(B,A);M(C,B)end. 

The notion of files being organized in a file system is foreign to Pascal so renaming files is not an option. Commented:

program swap(A, B); var A, B, C: text; procedure copy(var source, destination: text); var buffer: char; begin reset(source); rewrite(destination); while not EOF(source) do begin { A `text` file is a (possibly empty) sequence of lines. Each line is a (possibly empty) sequence of `char` values followed by one implementation‐defined end‐of‐line sequence. } while not EOLn(source) do begin read(source, buffer); write(destination, buffer) end; { `Read` can (by design) not read across lines. } readLn(source); { Upon reaching the end of a line, the file buffer `source↑` returns the `char` value of a space character. Therefore, in Pascal the only correct method of emitting an end‐of‐line character sequence is `writeLn`. } writeLn(destination) end end; begin copy(A, C); { original A = C } copy(B, A); { original B = new A } copy(C, B) { C = original A = new B } end. 

Note that the method of associating program parameters with external entities is implementation‐defined. For example the GNU Pascal Compiler prompts you for pathnames when reset or rewrite are invoked for the first time:

Input file `A': i.txt Input file `B': o.txt 

The i.txt and o.txt are user input (i. e. not generated by the program) and only program parameters are queried in this fashion (so not C).

The FreePascal Compiler in its (not yet mature) ISO compiler compatibility mode, on the other hand, expects pathnames as command‐line arguments. However, as of version 3.2.4 the FreePascal Compiler does not support anonymous files; the text file C is not associated with a pathname and the FPC cannot deal with that (fails miserably).

Tcl, 71 bytes

file ren i.txt m file ren -force o.txt i.txt file ren m o.txt file de m 

Try it online!

file rename i.txt m file rename -force o.txt i.txt file rename m o.txt file delete m 

set A [read [open i.txt]] puts [set i [open i.txt w]] [read [open o.txt]] puts [set o [open o.txt w]] $A close $i close $o 

SmileBASIC, 36 35 bytes

@L RENAME@OI[2-I],@IO[I]I=I+1GOTO@L