Le défi:

Saisissez le texte d'un fichier et exportez-le dans un autre. La solution doit être une fonction complète et fonctionnelle.

_{Remarque: Il s'agit d'une question de contrôle de code . Veuillez ne pas prendre la question et / ou les réponses au sérieux. Plus d'informations ici .}

C

L'intérêt d'avoir plusieurs langages de programmation, c'est que vous devez utiliser le bon outil pour le travail.
Dans ce cas, nous voulons copier des octets d'un fichier à un autre.
Bien que nous puissions utiliser quelque chose de fantaisiste comme bash ou rubis, ou tomber sous la puissance d'ASM, nous avons besoin de quelque chose de rapide, bon avec des bits et rapide.
Le choix évident est C.
La façon la plus simple de le faire serait la suivante:

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

C'est mal parce qu'il lira des ordures sur des choses comme cygwin, est complètement chinois pour un débutant, lui fera peur quand il réalisera que c'est un appel à l'aide et, évidemment, parce que C.

sh

J'aime la simplicité de celui-ci.

echo File1.txt > File2.txt

Ne fonctionne vraiment correctement que s'il File1.txtcontient "File1.text" ...

AutoHotKey

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

Vous devez d'abord ouvrir les fichiers dans le bloc-notes ou un autre éditeur de texte qui fait que les noms de fenêtre commencent par les noms de fichier. Ensuite, il copie le contenu de file1 dans le presse-papiers (littéralement, en utilisant ctrl+ c), et le colle dans file2, écrasant tout ce qu'il contient actuellement, et enregistre.

Résout le problème, mais d'une manière très gênante et assez inutile. Il serait probablement plus facile de simplement copier et coller manuellement.

Comme tout le monde le sait, perl est très bon pour manipuler des fichiers. Ce code copiera le contenu d'un fichier dans un autre et le fera avec une redondance supplémentaire pour faire bonne mesure.

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

Pour être sûr, testez d'abord cela sur un petit fichier. Une fois que vous êtes convaincu de son exactitude, vous pouvez le mettre en production pour l'utiliser sur de très gros fichiers sans souci.

C #

Pour ce faire, vous devez vous assurer de faire plusieurs choses:

1. Lire la chaîne du fichier
2. Télécharger Microsoft File IO et String Extension pour Visual Studio
3. Supprimer les virus de la chaîne ("aseptiser")
4. Écrire le fichier dans le chemin
5. Supprimer et recharger le cache

Voici le code:

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 quatre étapes simples:

1. Imprimez le fichier. Vous pouvez utiliser la lprcommande pour cela.
2. Envoyez les impressions à un service de numérisation. (Vous aurez besoin d'affranchissement pour cela).
3. Le service de numérisation numérisera les impressions et effectuera l'OCR pour vous.
4. Téléchargez à l'emplacement de fichier approprié.

Java

Beaucoup de gens trouvent utile d'essayer d'utiliser des expressions régulières ou d'évaluer des chaînes afin de les copier d'un fichier à un autre, mais cette méthode de programmation est bâclée. Premièrement, nous utilisons Java parce que la POO permet plus de transparence dans notre code, et deuxièmement nous utilisons une interface interactive pour recevoir les données du premier fichier et les écrire dans le second.

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 théorie (je ne l'ai pas testé), cela oblige l'utilisateur à saisir manuellement le contenu du premier fichier (mot par mot) puis à l'écrire dans le second fichier. Cette réponse est un jeu sur l'ambiguïté de la question de ce que cela signifie par «saisir du texte à partir d'un fichier», et les noms de variable fous (générés de manière aléatoire) étaient juste pour un amusement supplémentaire.

sh

Comme l'a souligné @Shingetsu, il faut utiliser le bon outil pour le bon travail. La copie du contenu d'un fichier à un autre est un ancien problème, et le meilleur outil pour de telles tâches de gestion de fichiers utilise le shell.

Une commande shell que chaque programmeur doit se familiariser est la taccommande commune , utilisée pour tac k le contenu des fichiers ensemble, l'un après l'autre. Dans un cas particulier, lorsqu'un seul fichier est passé, il est simplement recraché tel quel. Nous redirigeons ensuite simplement la sortie vers le fichier approprié:

tac inputfile.txt >outputfile.txt

Simple et direct, pas de trucs!

Perl

Antivirus inclus.

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

Lot Windows

(parce que tu dois avoir cette langue supposée "morte" ;-)

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

Vous appelez simplement cela comme copy.bat file1.txt file2.txt(ou tout autre fichier que vous voulez)

Si seulement cela gardait les sauts de ligne ...

Linq

L'efficacité n'est pas importante, l'exactitude l'est. L'écriture dans un style fonctionnel donne un code plus clair et moins sujet aux erreurs. Si les performances s'avèrent être un problème, la dernière ligne ToArray () peut être omise. Il vaut mieux être paresseux de toute façon.

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

Il existe une bibliothèque encore portée sur plusieurs dialectes Smalltalk (Visualworks, Gemstone Squeak / Pharo, ...) nommée Xtreams qui rend cette tâche plus que facile.

FileStream serait aussi simple que 'foo' asFilename readinget 'bar' asFilename writingpar exemple dans Visualworks, mais est spécifique au dialecte.
Pour cette raison, je démontre plutôt l'algorithme avec des flux internes neutres en dialecte.
Une bonne idée pourrait être de traiter chaque code d'octet dans l'ordre croissant:

| 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

Bien sûr, il est également possible de traiter dans un ordre aléatoire, mais je crains que cela rend le code un peu trop compact:

| 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

ÉDITER

Ah stupide moi, je n'ai pas vu la solution 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

FRAPPER

sur le terminal # 1 avec l'IP, 192.168.1.2

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

sur le terminal # 2 avec l'IP, 192.168.1.3

gpg -c mydocument.docx | nc 192.168.1.2 8080

Cela cryptera et enverra mydocument.docx, en utilisant ncet gpg, vers le terminal # 1 Vous devrez taper le mot de passe sur le terminal # 2, puis sur le terminal # 1

C ++

Ceci est quelque peu basé sur la réponse de Shingetsu , mais je n'ai pas pu résister. Il fonctionne pleinement, mais aucun élève ne le soumettrait à son professeur (j'espère). S'ils sont prêts à analyser le code, ils pourront résoudre leur problème:

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

Python

Entre du texte à partir de file1.txt et le renvoie à file2.txt

C'est complet et "fonctionnel". Personne n'a dit quoi que ce soit sur l'écriture de l'entrée telle qu'elle est. Tous les caractères saisis apparaissent dans la sortie. "getchar" est la partie de pêche à la traîne.

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 caractères

la mise en oeuvre

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

Exécution

f["one file", "another"]

Vérifier

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

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

Je ne suis certainement pas un expert en assemblage, mais voici mon petit extrait:

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

Avez-vous remarqué le bit "fonction complète et fonctionnelle"? Quoi qu'il en soit, voici ma réponse:

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

Lua

io.read()

Exécuter avec un fichier d'entrée contenant 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

Semble raisonnable, mais plutôt inefficace si le fichier est volumineux.

Fonctionne très bien sur les fichiers ASCII sauf lorsque le fichier d'entrée contient -n, -eou -E. (Parce que ceux-ci sont interprétés comme des arguments par echo.)

Ne produit pas la sortie correcte pour tous (la plupart) des fichiers binaires.

(Utilisation printf "%s" "$contents" > outputsous/bin/bash fonctionne un peu mieux, mais cela supprime toujours NULL octets.)

Oh et bien sûr, cela ne fonctionne pas pour filenames_containing_spaces. Mais ces fichiers sont de toute façon illégaux sous la politique UNIX% 20.