El reto:

Ingrese texto de un archivo y envíelo a otro. La solución debe ser una función completa y funcional.

_{Nota: Esta es una pregunta de arrastre de código . Por favor, no tome en serio la pregunta y / o las respuestas. Más información aquí .}

C

El punto de tener múltiples lenguajes de programación es que necesitas usar la herramienta adecuada para el trabajo.
En este caso, queremos copiar bytes de un archivo a otro.
Si bien podríamos usar algo elegante como bash o ruby, o caer en el poder de ASM, necesitamos algo rápido, bueno con bits y rápido.
La elección obvia es C.
La forma más SIMPLE de hacerlo sería así:

#include <stdio.h>
#define THEORY FILE
#define AND *
#define PRACTICE myfile1
#define SOLUTIONS myfile2
#define ARE fopen
#define IMPORTANT "r"
#define BAD "w"
#define LOL fclose
#define PLEASE fgetc
#define HELP fputc
#define ME return
#define NEVER for
#define SURRENDER !=
#define VERY filename1
#define NOT filename2
#define _ 1

int copyFile(char* filename1, char* filename2)
{
  THEORY AND PRACTICE = ARE (VERY, IMPORTANT);
  THEORY AND SOLUTIONS = ARE (NOT, BAD);
  NEVER (;_;)
  {
    HELP(PLEASE(PRACTICE),SOLUTIONS);
  }
  ME _SURRENDER_;
}

Esto es malo porque leerá basura en cosas como Cygwin, es completamente chino para un principiante, lo asustará cuando se dé cuenta de que es un llamado de ayuda y, obviamente, porque C.

sh

Me gusta la simplicidad de este.

echo File1.txt > File2.txt

Realmente solo funciona correctamente si File1.txtcontiene "File1.text" ...

AutoHotKey

WinActivate, file1.txt
SendInput ^a^c
WinActivate, file2.txt
SendInput ^a^v^s

Primero debe abrir los archivos en el bloc de notas o algún otro editor de texto que haga que los nombres de las ventanas comiencen con los nombres de los archivos. Luego copia el contenido del archivo1 en el portapapeles (literalmente, usando ctrl+ c), y lo pega en el archivo2, sobrescribiendo todo lo que está actualmente en él, y lo guarda.

Resuelve el problema, pero de una manera muy inconveniente y bastante inútil. Probablemente sería más fácil copiar y pegar manualmente.

Como todos saben, Perl es muy bueno para manipular archivos. Este código copiará el contenido de un archivo a otro, y lo hará con redundancia adicional por si acaso.

#Good perl programs always start thusly
use strict;
use warnings;

my $input_file  = 'File1.txt';
my $output_file = 'File2.txt';
open(my $in, '<', $input_file) or die "Couldn't open $input_file $!";

my $full_line = "";
while (my $line = <$in>) {
    #Get each letter one at a time for safety, 
    foreach my $letter (split //, $line) {
        #You could and should add validity checks here
        $full_line .= $letter;

        #Get rid of output file if it exists!  You are replacing it with
        # new content so it's just wasting space.
        unlink $output_file if (-e $output_file);

        #Write data to new file
        open(my $out, '>', $output_file) or die "Couldn't open $output_file $!";
        print {$out} $full_line;
        close($out);
    }
}

Para estar seguro, pruebe esto en un archivo pequeño al principio. Una vez que esté convencido de su corrección, puede ponerlo en producción para usarlo en archivos muy grandes sin preocuparse.

C#

Para lograr esto, debe asegurarse de hacer varias cosas:

1. Leer cadena del archivo
2. Descargue Microsoft File IO y String Extension para Visual Studio
3. Eliminar virus de la cadena ("desinfectar")
4. Escribir archivo en ruta
5. Eliminar y recargar caché

Aquí está el código:

static void CopyTextFile(string path1, string path2)
    {
        try
        {
            FileStream fs = new FileStream(path1, FileMode.OpenOrCreate); //open the FTP connection to file
            byte[] file = new byte[fs.Length];
            fs.Read(file, 0, file.Length);
            string makeFileSafe = Encoding.UTF32.GetString(file);

            using (var cli = new WebClient())
            {
                cli.DownloadData(new Uri("Microsoft .NET File IO and String Extension Package")); //get MS package
            }

            fs.Dispose();

            File.Create(path2);
            StreamReader read = new StreamReader(path2);
            read.Dispose(); //create and read file for good luck

            var sb = new StringBuilder();
            foreach (char c in path1.ToCharArray())
            {
                sb.Append(c);
            }

            string virusFreeString = sb.ToString(); //remove viruses from string

            File.WriteAllText(path2, virusFreeString);
            File.Delete(path1);
            File.WriteAllText(path1, virusFreeString); //refresh cache
        }
        catch
        { 
            //Don't worry, exceptions can be safely ignored
        }
    }

En cuatro simples pasos:

1. Imprime el archivo. Puedes usar ellpr comando para esto.
2. Envíe las impresiones a un servicio de escaneo. (Necesitará franqueo para esto).
3. El servicio de escaneo escaneará las impresiones y hará OCR por usted.
4. Descargue en la ubicación de archivo adecuada.

Java

A muchas personas les resulta útil intentar usar expresiones regulares o evaluar cadenas para copiarlas de un archivo a otro, sin embargo, ese método de programación es descuidado. Primero usamos Java porque el OOP permite más transparencia en nuestro código, y segundo usamos una interfaz interactiva para recibir los datos del primer archivo y escribirlos en el segundo.

import java.util.*;
import java.io.*;

public class WritingFiles{



 public static void main(String []args){
    File tJIAgeOhbWbVYdo = new File("File1.txt");
    Scanner jLLPsdluuuXYKWO = new Scanner(tJIAgeOhbWbVYdo);
    while(jLLPsdluuuXYKWO.hasNext())
    {
        MyCSHomework.fzPouRoBCHjsMrR();
        jLLPsdluuuXYKWO.next();
    }
 }
}

class MyCSHomework{
    Scanner jsvLfexmmYeqdUB = new Scanner(System.in);
    Writer kJPlXlLZvJdjAOs = new BufferedWriter(new OutputStreamWriter( new  FileOutputStream("File2.txt"), "utf-8"));
    String quhJAyWHGEFQLGW = "plea";
   String LHpkhqOtkEAxrlN = "f the file";
   String SLGXUfzgLtaJcZe = "e nex";
   String HKSaPJlOlUCKLun = "se";
   String VWUNvlwAWvghVpR = " ";
   String cBFJgwxycJiIrby = "input th";
   String ukRIWQrTPfqAbYd = "t word o";
   String  CMGlDwZOdgWZNTN =   quhJAyWHGEFQLGW+HKSaPJlOlUCKLun+VWUNvlwAWvghVpR+cBFJgwxycJiIrby+SLGXUfzgLtaJcZe+ukRIWQrTPfqAbYd+LHpkhqOtkEAxrlN;
    public static void fzPouRoBCHjsMrR(){
        System.out.println(CMGlDwZOdgWZNTN);
        kJPlXlLZvJdjAOs.write(jsvLfexmmYeqdUB.next());
    }



}

En teoría (no lo he probado), esto hace que el usuario ingrese manualmente el contenido del primer archivo (palabra por palabra) y luego lo escriba en el segundo archivo. Esta respuesta es un juego sobre la ambigüedad de la pregunta en cuanto a lo que significa "ingresar texto de un archivo", y los nombres de variables locas (generados aleatoriamente) fueron solo para un poco más de diversión.

sh

Como señaló @Shingetsu, uno tiene que usar la herramienta adecuada para el trabajo correcto. Copiar el contenido de un archivo a otro es un viejo problema, y ​​la mejor herramienta para tales tareas de administración de archivos es usar el shell.

Un comando de shell con el que cada programador tiene que familiarizarse es el taccomando común , utilizado para abordar el contenido de los archivos, uno tras otro. Como un caso especial de esto, cuando solo se pasa un archivo, simplemente se vuelve a escupir como está. Luego simplemente redirigimos la salida al archivo apropiado:

tac inputfile.txt >outputfile.txt

Simple y directo, ¡sin trucos!

Perl

Antivirus incluido.

#!/usr/bin/perl -w
use strict;
use warnings;

print "Copy the text of the file here: (warning: I can't copy files with newlines):\n";
my $content = <STDIN>;

print "\n\nPlease wait, removing viruses...";
my @array = split(//,"$content");
my @tarray;

foreach my $item (@array)
{
    if ($item ne "V" && $item ne "I" && $item ne "R" && $item ne "U" && $item ne "S")
    {
        push(@tarray, $item);
    }

}

print "\n\nNow copy this into the target file:\n";

foreach my $item (@tarray){ print "$item"};

Lote de Windows

(porque tienes que tener este lenguaje supuestamente "muerto" ;-)

@echo off
setlocal enabledelayedexpansion
for %%I in ('type %1') do set this=!this!%%I
echo !this!>%2 2>nul

Simplemente llame a esto como copy.bat file1.txt file2.txt(o los archivos que desee)

Si solo mantuviera saltos de línea ...

Linq

La eficiencia no es importante, la corrección sí lo es. Escribir en un estilo funcional da como resultado un código más claro y menos propenso a errores. Si el rendimiento resulta ser un problema, se puede omitir la última línea ToArray (). Es mejor ser perezoso de todos modos.

public void CopyFile(string input, string output)
{
    Enumerable
        .Range(0, File.ReadAllBytes(input).Length)
        .Select(i => new { i = i, b = File.ReadAllBytes(input)[i] })
        .Select(ib => {
            using (var f = File.Open(output, ib.i == 0 ? FileMode.Create : FileMode.Append))
                f.Write(new byte[] { ib.b }, 0, 1);
            return ib; })
        .ToArray();
}

Charla

Hay una biblioteca aún portada a varios dialectos Smalltalk (Visualworks, Gemstone Squeak / Pharo, ...) llamada Xtreams que hace que esta tarea sea más que fácil.

FileStream sería tan simple como 'foo' asFilename readingy 'bar' asFilename writingpor ejemplo en VisualWorks, pero son específicos dialecto.
Por esta razón, demuestro el algoritmo con dialectos neutrales corrientes internas en su lugar.
Una buena idea podría ser procesar cada código de byte en orden creciente:

| input |
input := 'Hello world' asByteArray reading.
^((ByteArray new writing)
    write: ((0 to: 255) inject: ByteArray new reading into: [:outputSoFar :code |
        | nextOutput |
        nextOutput := ByteArray new writing.
        ((input += 0; selecting: [:c | c <= code]) ending: code inclusive: true) slicing do: [:subStream |
            | positionable |
            positionable := subStream positioning.
            nextOutput write: (outputSoFar limiting: (positionable ending: code) rest size).
            nextOutput write: (positionable += 0; selecting: [:c | c = code])].
        nextOutput conclusion reading]);
    conclusion) asString

Por supuesto, también es posible procesar en orden aleatorio, pero me temo que hace que el código sea demasiado compacto:

| input output |
input := 'Hello world' asByteArray reading.
output := ByteArray new writing.
(0 to: 255) asArray shuffled do: [:code |
        output += 0.
        (input += 0; ending: code inclusive: true) slicing do: [:subStream |
            | positionable |
            positionable := subStream positioning.
            output ++ (positionable += 0; rejecting: [:c | c = code]) rest size.
            output write: (positionable += 0; selecting: [:c | c = code])]].
^output conclusion asString

EDITAR

Ah, estúpido, no vi la solución log2:

| input output |
input := 'Hello world' asByteArray reading.
(output := ByteArray new writing) write: (input collecting: [:e | 0]).
output := (0 to: 7) asArray shuffled inject: output into: [:outputSoFar :bit |
        (ByteArray new writing)
            write:
                (((input += 0; collecting: [:e | e >> bit bitAnd: 1]) interleaving: outputSoFar conclusion reading) 
                    transforming: [ :in :out | out put: in get << bit + in get]);
            yourself].
^output conclusion asString

GOLPETAZO

en la terminal # 1 con la IP, 192.168.1.2

nc -l 8080 | gpg -d > mydocument.docx

en la terminal # 2 con la IP, 192.168.1.3

gpg -c mydocument.docx | nc 192.168.1.2 8080

Esto encriptará y enviará mydocument.docx, usando ncy gpg, a la terminal # 1. Tendrá que escribir la contraseña en la terminal # 2, luego en la terminal # 1

C ++

Esto está algo basado en la respuesta de Shingetsu , pero no pude resistirme. Está funcionando completamente, pero ningún estudiante lo presentaría a su maestro (espero). Si están dispuestos a analizar el código, podrán resolver su problema:

#include <iostream>
#include <fstream>
#include <string>
using namespace std;
#define SOLVE ifs
#define IT >>
#define YOURSELF ofs

ifstream& operator IT(ifstream& ifs, ofstream& ofs) {
  string s;
  SOLVE IT s;
  YOURSELF << s;
  return ifs;
}

void output(ofstream& ofs, ifstream& ifs) {
  while (ifs) {
    SOLVE IT YOURSELF;
    ofs << ' ';
  }
}

int main() try {

  ofstream ofs("out.txt");
  ifstream ifs("in.txt");

  output(ofs, ifs);

  return 0;
}
catch (exception& e) {
  cerr << "Error: " << e.what() << endl;
  return 1;
}
catch (...) {
  cerr << "Unknown error.\n";
  return 2;
}

Pitón

Introduce texto desde file1.txt y lo envía a file2.txt

Está completo y "funcionando". Nadie dijo nada sobre escribir la entrada tal como está. Todos los caracteres de entrada aparecen en la salida. "getchar" es la parte de trolling.

from random import choice as getchar

f1 = open("file1.txt")
s1 = []
for line in f1:
    for char in line:
        s1.append(str(char))
s2 = ''
while len(s1) > 0:
    x = getchar(s1)
    s2 += x
    s1.remove(x)
f2 = open("file2.txt" , 'w')
f2.write(s2)

Mathematica, 44 caracteres

Implementación

f = (BinaryWrite[#2, BinaryReadList@#]; Close@#2) &

Ejecución

f["one file", "another"]

Cheque

check = Import[StringJoin["!diff \"", #, "\" \"", #2, "\" 2>&1"], "Text"] &;
check["one file", "another"]

DELPHI / PASCAL (copia de f1.txt a f2.txt)

program t;

{$APPTYPE CONSOLE}

uses
  classes;

var a : TStringlist;
begin
   a:=TStringlist.Create;
   a.LoadFromFile('e:\f1.txt');
   a.SaveToFile('e:\f2.txt');
   a.Free;
end.

MASM

Ciertamente no soy un experto en ensamblaje, pero a continuación está mi pequeño fragmento:

include \masm32\include\masm32rt.inc

.code

start:
call main
inkey
exit

main proc
LOCAL hFile :DWORD  
LOCAL bwrt  :DWORD 
LOCAL cloc  :DWORD 
LOCAL flen  :DWORD  
LOCAL hMem  :DWORD  

.if rv(exist,"out.txt") != 0  
  test fdelete("out.txt"), eax 
.endif

mov hFile, fopen("source.txt")
mov flen, fsize(hFile)
mov hMem, alloc(flen)   
mov bwrt, fread(hFile,hMem,flen)  
fclose hFile   

invoke StripLF,hMem

mov hFile, fcreate("out.txt") 
mov bwrt, fwrite(hFile,hMem,flen)   
fclose hFile   

free hMem   

ret

main endp
end start

C ++

¿Notó el bit de "función de trabajo completa"? De todos modos, aquí está mi respuesta:

#include <stdlib.h>
int main(void)
{
  system("echo < input > dest");
}

Lua

io.read()

Ejecutar con un archivo de entrada que contenga text from one file and output it to another. Solution should be a complete, working function..

PHP

function copyFile($input, $output) 
{
    return file_put_contents($output, file_get_contents($input));
}

#! / bin / sh

contents=`< $1` ; echo "$contents" > $2

Parece razonable, pero bastante ineficiente si el archivo es grande.

Funciona bien en archivos ASCII, excepto cuando el archivo de entrada contiene -n, -eo -E. (Porque estos son interpretados como argumentos porecho .)

No produce la salida correcta para todos (la mayoría) de los archivos binarios.

(Utilizando printf "%s" "$contents" > outputdebajo/bin/bash funciona un poco mejor, pero eso todavía deja caer NULL bytes).

Ah, y por supuesto, no funciona para nombres de archivos_espacios_contaminantes. Pero tales archivos son ilegales bajo UNIX% 20policy de todos modos.