Esta es una pregunta de código de golf. Debe tomar el contenido de dos archivos separados (i.txt y o.txt) e intercambiarlos. Puede crear un tercer archivo para ayudarlo con el proceso, pero haga que su programa lo elimine después de intercambiar el contenido del archivo. Cambiar el nombre de los archivos ahora está permitido nuevamente.

Los programas deben funcionar para cualquier contenido de archivo.

El código más corto gana, todos los envíos elegibles serán votados.

zsh, 20

<i*>t;<o*>i*;mv t o*

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");?>

Archivo por lotes de Windows, 42

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

Archivo por lotes de Windows (args), 30

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

Dos bash respuestas basadas en ; 52 y 62 caracteres

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

Tal vez no sea el más corto, pero me parece divertido (y no hay uso de archivos temporales ):

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

Donde el contenido se intercambia y los archivos se modifican en su lugar :

Ejecución de la muestra

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]*))

Podría producir algo como:

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

uso de xargs para simplificar mv solicitudes

No tan divertido, pero agradable de todos modos.

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

PHP, 89

Pensé en intentarlo.

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

Versión sin golf:

<?php
$f1 = 'f1.txt';
$f2 = 'f2.txt';
$ft = 'ft.txt';

copy($f1, $ft);
copy($f2, $f1);
rename($ft, $f2);

Aparentemente tomé 2 respuestas de aquí y las combiné ... oh, bueno.

Ruby, 72 bytes

¡Guauu! ¡Un código de rubí de golf! ¡No creo que se haya intentado antes!

Sin embargo, en realidad, esto requirió algunos atajos de Ruby agradables y un par de patrones que encontré. Fue mi primer golf y fue muy divertido hacerlo. Sin más preámbulos, aquí está el código de golf:

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

Y la versión sin golf

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

El factor clave en esto es que los parámetros pasados ​​al File.renameson esto, exactamente:

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

Espero que esto (no) tenga sentido!

Powershell, 44 49 bytes

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

donde renes alias para Rename-Item . El script usa y elimina un tercer archivo a.txt.

Rubí

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

Versión acortada:

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

No es el más corto, pero muy simple y fácil de leer. Además, no hay archivos intermedios, solo RAM.

PHP

$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);

Shell script, 24

Funciona en Bash y probablemente en la mayoría de las conchas. Pase con sus dos nombres de archivo como parámetros.

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

Si desea nombres de archivo fijos, esto lo hará, por una penalización de 12 caracteres:

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

Pitón:

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

Archivo por lotes de Windows (48)

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

Olvidé el comando mover cuando escribí esto ...

C 162

Golfed: utiliza t.txt como archivo tmp y cambia nombres y luego elimina 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;}

Editar: eliminado 2 espacios

PHP - 172

Versión de golf de la respuesta de @ EisaAdil

$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 (cambiar el nombre del archivo) o 55 (contenido de r / w)

Cambiar el nombre del archivo (usando tcomo archivo temporal):

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

Lea y luego escriba el contenido del archivo:

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');

No es muy golfoso pero el PHP más corto hasta ahora.

Groovy - 99 caracteres

Este es mi intento, con Groovy 2.2.1. Traté de hacerlo sin renombrar:

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

Sin golf:

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)

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

Cambiar el nombre con un archivo temporal t en la unidad c: \. También primer intento de 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

Si scrrun.dll ya está referenciado, podría reducirlo un poco a 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

C: 65 caracteres

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

Una solución bastante simple en C que hace el trabajo. Utiliza un nombre temporal (.txt ) para uno de los archivos antes de darle su nuevo nombre.

Ungolfed (observe cómo falla el resaltado de sintaxis en la definición, ¡se ha descubierto un error!):

#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 (intercambio de contenido sin cambio de nombre de archivo)

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

El contenido del archivo se guarda en la memoria y se vuelve a escribir en el otro archivo. Así i.txty o.txtdebe caber en la memoria.

Dado que el contenido del archivo se intercambia realmente, los enlaces duros se actualizan automáticamente, vea el comentario de AJManfield .

Sin golf:

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

Lote de Windows, 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)

Pruébalo en línea!

Defina os, la biblioteca del sistema operativo, como la tabla global para que podamos escribir renamey en removelugar de os.renamey os.remove. (Por cierto, esto también significa que las variables de una letra son en realidad campos de la ostabla). Haga un alias corto para os.renameahorrar algo de espacio. Configure variables de nombre de archivo, utilizando '.txt'como archivo temporal. Renombra y elimina.

PHP, 52 bytes

Pregunta php de Anyway modernizado y golf:

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

Corre con php -nr '<code>'.

Tcl , 122 bytes

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

Pruébalo en línea!

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

Pruébalo en línea!

SmileBASIC, 36 35 bytes

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