La sfida:

Immettere il testo da un file e inviarlo a un altro. La soluzione dovrebbe essere una funzione completa e funzionante.

_{Nota: questa è una domanda di code trolling . Si prega di non prendere sul serio la domanda e / o le risposte. Maggiori informazioni qui .}

C

Il punto centrale di avere più linguaggi di programmazione è che devi usare lo strumento giusto per il lavoro.
In questo caso, vogliamo copiare i byte da un file all'altro.
Mentre potremmo usare qualcosa di elegante come bash o ruby, o cadere nel potere di ASM, abbiamo bisogno di qualcosa di veloce, buono con i bit e veloce.
La scelta ovvia è C.
Il modo più semplice per farlo sarebbe così:

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

Questo è male perché leggerà immondizia su cose come Cygwin, è completamente cinese per un principiante, lo spaventerà quando si renderà conto che è una richiesta di aiuto e, ovviamente, perché C.

sh

Mi piace la semplicità di questo.

echo File1.txt > File2.txt

Funziona davvero solo se File1.txtcontiene "File1.text" ...

AutoHotKey

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

Devi prima aprire i file nel blocco note o in qualche altro editor di testo che fa iniziare i nomi delle finestre con i nomi dei file. Quindi copia il contenuto di file1 negli appunti (letteralmente, usando ctrl+ c), e lo incolla in file2, sovrascrivendo tutto ciò che è attualmente in esso e salva.

Risolve il problema, ma in modo molto scomodo e piuttosto inutile. Probabilmente sarebbe più semplice semplicemente copiare e incollare manualmente.

Come tutti sanno, perl è ottimo per manipolare i file. Questo codice copierà il contenuto di un file su un altro e lo farà con ridondanza aggiuntiva per una buona misura.

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

Per sicurezza, prova prima su un file di piccole dimensioni. Una volta che sei convinto della sua correttezza, puoi metterlo in produzione per l'uso su file molto grandi senza preoccupazioni.

C #

Per raggiungere questo obiettivo, devi assicurarti di fare diverse cose:

1. Leggi la stringa dal file
2. Scarica Microsoft File IO e String Extension per Visual Studio
3. Rimuovi virus dalla stringa ("sanitize")
4. Scrivi il file sul percorso
5. Elimina e ricarica la cache

Ecco il codice:

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

In quattro semplici passaggi:

1. Stampa il file. È possibile utilizzare il lprcomando per questo.
2. Invia le stampe a un servizio di scansione. (Avrai bisogno dell'affrancatura per questo).
3. Il servizio di scansione eseguirà la scansione delle stampe e eseguirà l'OCR.
4. Scarica nella posizione del file appropriata.

Giava

Molte persone trovano utile tentare di usare espressioni regolari o di valutare stringhe per copiarle da un file all'altro, tuttavia quel metodo di programmazione è sciatto. Innanzitutto utilizziamo Java perché OOP consente una maggiore trasparenza nel nostro codice, e in secondo luogo utilizziamo un'interfaccia interattiva per ricevere i dati dal primo file e scriverli nel secondo.

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



}

In teoria (non l'ho ancora testato), l'utente inserisce manualmente il contenuto del primo file (parola per parola) e quindi lo scrive nel secondo file. Questa risposta è un gioco sull'ambiguità della domanda su cosa significhi "input di testo da un file", e i nomi delle variabili folli (generati casualmente) erano solo per un po 'di divertimento in più.

sh

Come ha sottolineato @Shingetsu, si deve usare lo strumento giusto per il lavoro giusto. Copiare il contenuto da un file a un altro è un vecchio problema e lo strumento migliore per tali attività di gestione dei file è usare la shell.

Un comando di shell che ogni programmatore deve conoscere themself con il comune tacdi comando, utilizzato per tac k il contenuto dei file insieme, uno dopo l'altro. Come caso speciale, quando viene passato un solo file, viene semplicemente sputato di nuovo così com'è. Quindi reindirizziamo semplicemente l'output al file appropriato:

tac inputfile.txt >outputfile.txt

Semplice e puntuale, nessun trucco!

Perl

Antivirus incluso.

#!/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"};

Windows Batch

(perché devi avere questa lingua apparentemente "morta" ;-)

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

Lo chiami semplicemente come copy.bat file1.txt file2.txt (o file desideri)

Se solo potesse mantenere le interruzioni di riga ...

Linq

L'efficienza non è importante, la correttezza lo è. Scrivendo in uno stile funzionale si ottiene un codice più chiaro e meno soggetto a errori. Se le prestazioni si rivelano un problema, l'ultima riga ToArray () può essere omessa. È meglio essere pigri comunque.

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

Smalltalk

Esiste una libreria ancora trasferita su diversi dialetti Smalltalk (Visualworks, Gemstone Squeak / Pharo, ...) denominata Xtreams che rende questo compito più che semplice.

FileStream sarebbe semplice come 'foo' asFilename readinge 'bar' asFilename writingper esempio in Visualworks, ma è specifico del dialetto.
Per questo motivo dimostrerò invece l'algoritmo con flussi interni neutri in dialetto.
Una buona idea potrebbe essere quella di elaborare ciascun codice byte in ordine 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

Certo, è anche possibile elaborare in ordine casuale, ma temo che renda il codice un po 'troppo compatto:

| 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

MODIFICARE

Ah stupido me, non ho visto la soluzione 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

BASH

sul terminale n. 1 con IP, 192.168.1.2

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

sul terminale n. 2 con IP, 192.168.1.3

gpg -c mydocument.docx | nc 192.168.1.2 8080

Questo crittograferà e invierà mydocument.docx, usando nce gpg, al terminale # 1 Dovrete digitare la password sul terminale # 2, quindi sul terminale # 1

C ++

Questo è in qualche modo basato sulla risposta di Shingetsu , ma non ho resistito. Funziona perfettamente, ma nessuno studente lo sottopone al proprio insegnante (spero). Se sono disposti ad analizzare il codice, saranno in grado di risolvere il loro 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;
}

Pitone

Immette il testo da file1.txt e lo invia a file2.txt

È completo e "funzionante". Nessuno ha detto nulla sulla scrittura dell'input così com'è. Tutti i caratteri di input vengono visualizzati nell'output. "getchar" è la parte da traina.

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 caratteri

Implementazione

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

Esecuzione

f["one file", "another"]

Dai un'occhiata

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

DELPHI / PASCAL (copia da 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

Non sono certamente un esperto di assemblaggio, ma di seguito è riportato il mio piccolo frammento:

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

Hai notato il bit "funzione completa, funzionante"? Comunque, ecco la mia risposta:

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

Lua

io.read()

Esegui con un file di input contenente 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

Sembra ragionevole, ma piuttosto inefficiente se il file è di grandi dimensioni.

Funziona bene su file ASCII tranne quando il file di input contiene -n, -eo -E. (Perché questi sono interpretati come argomenti da echo.)

Non produce l'output corretto per tutti (la maggior parte) file binari.

(L'uso di printf "%s" "$contents" > outputunder /bin/bashfunziona un po 'meglio, ma ciò fa comunque perdere byte NULL.)

Oh, e ovviamente non funziona con filenames_contain_spaces. Ma tali file sono comunque illegali con UNIX% 20policy.