Questa è una domanda di code-golf. Devi prendere il contenuto di due file separati (i.txt e o.txt) e scambiarli. Puoi creare un terzo file per aiutarti con il processo, ma fai in modo che il tuo programma lo elimini dopo lo scambio del contenuto del file. La ridenominazione dei file ora è di nuovo consentita.

I programmi devono funzionare per qualsiasi contenuto di file.

Il codice più corto vince, tutti gli invii idonei verranno votati.

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 anni

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

File batch di Windows, 42

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

File batch di Windows (args), 30

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

Due bash risposte basate su ; 52 e 62 caratteri

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

Forse non il più breve, ma lo trovo divertente (e non c'è alcun file temporaneo ):

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

Dove il contenuto viene scambiato e i file vengono modificati in atto :

Esecuzione del campione

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

Potrebbe produrre qualcosa di simile:

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

uso di xargs per semplificare mv richieste

Non altrettanto divertente, ma comunque carino.

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

PHP, 89

Ho pensato di provarci.

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

Versione non golfata:

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

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

Apparentemente ho preso 2 risposte da qui e le ho combinate .. vabbè.

Rubino, 72 byte

Wow! Un golf con codice Ruby! Non credo che sia mai stato tentato prima!

In tutta la realtà, tuttavia, ciò ha richiesto alcune belle scorciatoie Ruby e un paio di modelli che ho trovato. È stato il mio primo golf in assoluto ed è stato molto divertente da fare. Senza ulteriori indugi, ecco il codice golf:

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

E la versione non golfata

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

Il fattore chiave in questo è che i parametri passati a File.renamesono esattamente questi:

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

Spero che questo (non) abbia senso!

Powershell, 44 49 byte

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

dove si rentrova l'alias per Rename-Item . Lo script utilizza ed elimina un terzo file a.txt.

Rubino

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

Versione abbreviata:

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

Non il più breve, ma molto semplice e facile da leggere. Inoltre, nessun file intermedio, 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);

Script di shell, 24

Funziona in Bash e probabilmente nella maggior parte delle shell. Passa con i tuoi due nomi di file come parametri.

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

Se vuoi nomi di file fissi, questo lo farà, con una penalità di 12 caratteri:

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

Pitone:

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

File batch di Windows (48)

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

Ho dimenticato il comando di spostamento quando ho scritto questo ...

C 162

Golf: usa t.txt come file tmp e scambia i nomi, quindi rimuove 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;}

Modifica: rimosso 2 spazi

PHP - 172

Versione golfata della risposta di @ 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 (rinomina file) o 55 (contenuto r / w)

Rinomina file (usando tcome file temporaneo):

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

Leggi e poi scrivi il contenuto del file:

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

Finora non molto golfy ma PHP più breve.

Groovy - 99 caratteri

Questo è il mio tentativo, con Groovy 2.2.1. Ho provato a farlo senza rinominare:

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)

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

Rinominare con un file temporaneo t nell'unità c: \. Anche il primo tentativo di 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

Se si fa già riferimento a scrrun.dll, potrebbe ridurlo un po '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 caratteri

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

Una soluzione abbastanza semplice in C che fa il lavoro. Utilizza un nome temporaneo (.txt ) per uno dei file prima di assegnargli il nuovo nome.

Ungolfed (nota come l'evidenziazione della sintassi non riesce nella definizione, un bug è stato scoperto!):

#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 byte (scambio di contenuti senza rinominare i file)

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

Il contenuto del file viene messo in memoria e riscritto nell'altro file. Quindi i.txte o.txtdeve adattarsi alla memoria.

Poiché il contenuto del file viene effettivamente scambiato, i collegamenti fisici vengono aggiornati automaticamente, vedere il commento di AJManfield .

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

Lotto di Windows, 39 byte

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

Lua ,71 70 byte

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

Provalo online!

Definire osla libreria del sistema operativo come tabella globale in modo che possiamo scrivere renamee removeinvece di os.renamee os.remove. (Per inciso, ciò significa anche che le variabili di una lettera sono in realtà campi nella ostabella.) Crea un breve alias per os.renamerisparmiare spazio. Imposta le variabili del nome file, usando '.txt'come file temporaneo. Esegui la ridenominazione e l'eliminazione.

PHP, 52 byte

Il php di Anyway è stato modernizzato e giocato a golf:

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

Corri con php -nr '<code>'.

Tcl , 122 byte

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

Provalo online!

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

Provalo online!

SmileBASIC, 36 35 byte

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