O desafio:

Insira o texto de um arquivo e faça a saída para outro. A solução deve ser uma função completa e funcional.

_{Nota: Esta é uma pergunta de controle de código . Por favor, não leve a sério a pergunta e / ou respostas. Mais informações aqui .}

C

O objetivo de ter várias linguagens de programação é que você precisa usar a ferramenta certa para o trabalho.
Nesse caso, queremos copiar bytes de um arquivo para outro.
Embora possamos usar algo sofisticado como bash ou ruby, ou cair no poder do ASM, precisamos de algo rápido, bom com bits e rápido.
A escolha óbvia é C.
A maneira mais simples de fazer isso seria assim:

#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_;
}

Isso é ruim, porque ele lê lixo em coisas como cygwin, é completamente chinês para iniciantes, o assusta quando ele percebe que é um pedido de ajuda e, obviamente, porque C.

sh

Eu gosto da simplicidade deste.

echo File1.txt > File2.txt

Realmente só funciona corretamente se File1.txtcontiver "File1.text" ...

AutoHotKey

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

Você deve primeiro abrir os arquivos no bloco de notas ou em algum outro editor de texto que faça com que os nomes das janelas iniciem com os nomes dos arquivos. Em seguida, ele copia o conteúdo do arquivo1 para a área de transferência (literalmente, usando ctrl+ c) e o cola no arquivo2, sobrescrevendo tudo o que está atualmente nele e salva.

Resolve o problema, mas de uma maneira muito inconveniente e bastante inútil. Provavelmente, seria mais fácil copiar e colar manualmente.

Como todos sabem, o perl é muito bom para manipular arquivos. Este código copiará o conteúdo de um arquivo para outro e fará isso com redundância extra para uma boa medida.

#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 segurança, teste-o em um arquivo pequeno primeiro. Quando você estiver convencido de sua correção, poderá colocá-lo em produção para uso em arquivos muito grandes sem se preocupar.

C #

Para conseguir isso, você deve fazer várias coisas:

1. Ler string do arquivo
2. Baixar IO de arquivo da Microsoft e extensão de string para o Visual Studio
3. Remover vírus da string ("higienizar")
4. Gravar arquivo no caminho
5. Excluir e recarregar o cache

Aqui está o 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
        }
    }

Em quatro etapas simples:

1. Imprima o arquivo. Você pode usar olpr comando para isso.
2. Envie as impressões para um serviço de digitalização. (Você precisará de postagem para isso).
3. O serviço de digitalização digitalizará as impressões e fará OCR para você.
4. Faça o download no local apropriado do arquivo.

Java

Muitas pessoas acham útil tentar usar expressões regulares ou avaliar seqüências de caracteres para copiá-las de um arquivo para outro, no entanto, esse método de programação é desleixado. Primeiro, usamos Java porque o OOP permite mais transparência em nosso código e, em segundo lugar, usamos uma interface interativa para receber os dados do primeiro arquivo e gravá-los no 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());
    }



}

Em teoria (não testei), isso faz com que o usuário insira manualmente o conteúdo do primeiro arquivo (palavra por palavra) e depois o grave no segundo arquivo. Essa resposta é uma brincadeira com a ambiguidade da pergunta sobre o que significa "inserir texto de um arquivo", e os nomes de variáveis ​​malucos (gerados aleatoriamente) foram apenas para diversão extra.

sh

Como o @Shingetsu apontou, é preciso usar a ferramenta certa para o trabalho certo. Copiar o conteúdo de um arquivo para outro é um problema antigo, e a melhor ferramenta para essas tarefas de gerenciamento de arquivos é usar o shell.

Um comando shell que todo programador tem de conhecimento themself com é o comum tacde comando, usado para tac k o conteúdo de arquivos juntos, um após o outro. Como um caso especial disso, quando apenas um arquivo é passado, ele é simplesmente cuspido novamente. Simplesmente redirecionamos a saída para o arquivo apropriado:

tac inputfile.txt >outputfile.txt

Simples e direto ao ponto, sem truques!

Perl

Antivírus incluído.

#!/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 do Windows

(porque você tem que ter essa linguagem supostamente "morta" ;-)

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

Você simplesmente chama isso como copy.bat file1.txt file2.txt(ou qualquer arquivo que desejar)

Se ao menos isso mantivesse quebras de linha ...

Linq

Eficiência não é importante, correção é. Escrever em um estilo funcional resulta em um código mais claro e menos propenso a erros. Se o desempenho for um problema, a última linha ToArray () poderá ser omitida. É melhor ser preguiçoso de qualquer maneira.

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

Conversa fiada

Ainda existe uma biblioteca portada para vários dialetos do Smalltalk (Visualworks, Gemstone Squeak / Pharo, ...) chamado Xtreams que tornam essa tarefa mais do que fácil.

FileStream seria tão simples como 'foo' asFilename readinge 'bar' asFilename writingpor exemplo, em VisualWorks, mas são dialeto específico.
Por essa razão, demonstro o algoritmo com fluxos internos neutros de dialeto.
Uma boa idéia seria processar cada código de byte em ordem crescente:

| 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

Obviamente, também é possível processar em ordem aleatória, mas receio que isso torne o código um pouco compacto demais:

| 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, eu não vi a solução 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

BATER

no terminal # 1 com o IP, 192.168.1.2

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

no terminal # 2 com o IP, 192.168.1.3

gpg -c mydocument.docx | nc 192.168.1.2 8080

Isso criptografará e enviará mydocument.docx, usando nce gpg, para o terminal nº 1. Você precisará digitar a senha no terminal nº 2 e depois no terminal nº 1.

C ++

Isso é um pouco baseado na resposta da Shingetsu , mas não pude resistir. Está em pleno funcionamento, mas nenhum aluno a enviaria ao professor (espero). Se eles estiverem dispostos a analisar o código, poderão resolver seu 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ão

Insere o texto do arquivo1.txt e o envia para o arquivo2.txt

Está completo e "funcionando". Ninguém disse nada sobre escrever a entrada como ela é. Todos os caracteres de entrada aparecem na saída. "getchar" é a parte 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

Implementação

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

Execução

f["one file", "another"]

Verifica

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

DELPHI / PASCAL (copiar de f1.txt para 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

Certamente não sou especialista em montagem, mas abaixo está meu pequeno trecho:

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 ++

Você notou o bit "função completa e funcional"? Enfim, aqui está a minha resposta:

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

Lua

io.read()

Execute com um arquivo de entrada contendo 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 razoável, mas ineficiente se o arquivo for grande.

Funciona bem em arquivos ASCII, exceto quando o arquivo de entrada contém -n, -eou -E. (Como esses são interpretados como argumentos porecho .)

Não produz a saída correta para todos os arquivos binários.

(Usando printf "%s" "$contents" > outputsob/bin/bash funciona um pouco melhor, mas isso ainda gera NULL bytes.)

Ah, e é claro que não funciona para nomes de arquivos_containing_spaces. Mas esses arquivos são ilegais no UNIX% 20policy de qualquer maneira.