Wyzwanie:

Wprowadź tekst z jednego pliku i wyślij go do innego. Rozwiązanie powinno być kompletną, działającą funkcją.

_{Uwaga: jest to pytanie trollujące kod . Proszę nie brać poważnie pytania i / lub odpowiedzi. Więcej informacji tutaj .}

do

Istotą posiadania wielu języków programowania jest to, że musisz użyć odpowiedniego narzędzia do pracy.
W takim przypadku chcemy skopiować bajty z jednego pliku do drugiego.
Chociaż moglibyśmy użyć czegoś wymyślnego, takiego jak bash lub rubin, lub poddać się potędze ASM, potrzebujemy czegoś szybkiego, dobrego z bitami i szybkiego.
Oczywistym wyborem jest C.
Najprostszym sposobem na zrobienie tego byłoby:

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

Jest to złe, ponieważ będzie czytać śmieci na temat takich rzeczy jak cygwin, jest całkowicie chiński dla początkującego, przestraszy go, gdy zda sobie sprawę, że to wołanie o pomoc, i oczywiście, ponieważ C.

sh

Podoba mi się prostota tego.

echo File1.txt > File2.txt

Naprawdę działa poprawnie tylko wtedy, gdy File1.txtzawiera „Plik1.tekst” ...

AutoHotKey

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

Najpierw należy otworzyć pliki w notatniku lub innym edytorze tekstów, który powoduje, że nazwy okien zaczynają się od nazw plików. Następnie kopiuje zawartość pliku 1 do schowka (dosłownie, używając ctrl+ c) i wkleja go do pliku 2, nadpisując wszystko, co się w nim znajduje, i zapisuje.

Rozwiązuje problem, ale w bardzo niewygodny i całkiem bezużyteczny sposób. Prawdopodobnie łatwiej byłoby po prostu skopiować i wkleić ręcznie.

Jak wszyscy wiedzą, perl jest bardzo dobry do manipulowania plikami. Ten kod skopiuje zawartość jednego pliku do drugiego i zrobi to z dodatkową redundancją dla zachowania dokładności.

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

Aby być bezpiecznym, najpierw przetestuj to na małym pliku. Po przekonaniu się o jego poprawności możesz bez obaw wprowadzić go do produkcji w celu użycia na bardzo dużych plikach.

DO#

Aby to osiągnąć, musisz wykonać kilka czynności:

1. Czytaj ciąg z pliku
2. Pobierz Microsoft File IO i String Extension dla Visual Studio
3. Usuń wirusy z łańcucha („dezynfekuj”)
4. Zapisz plik do ścieżki
5. Usuń i ponownie załaduj pamięć podręczną

Oto kod:

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

W czterech prostych krokach:

1. Wydrukuj plik. Możesz użyć lprdo tego polecenia.
2. Wyślij wydruki pocztą do usługi skanowania. (W tym celu potrzebujesz wysyłki).
3. Usługa skanowania zeskanuje wydruki i wykona dla Ciebie OCR.
4. Pobierz do odpowiedniej lokalizacji pliku.

Jawa

Wiele osób uważa, że ​​warto próbować używać wyrażeń regularnych lub oceniać łańcuchy w celu skopiowania ich z jednego pliku do drugiego, jednak ta metoda programowania jest niedbała. Po pierwsze używamy Javy, ponieważ OOP pozwala na większą przejrzystość naszego kodu, a po drugie używamy interaktywnego interfejsu do odbierania danych z pierwszego pliku i zapisywania go do drugiego.

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



}

Teoretycznie (nie testowałem tego) powoduje to, że użytkownik ręcznie wprowadza treść pierwszego pliku (słowo po słowie), a następnie zapisuje go do drugiego pliku. Ta odpowiedź jest grą na dwuznaczność pytania, co to znaczy „tekst wejściowy z jednego pliku”, a zwariowane nazwy zmiennych (generowane losowo) były tylko dla dodatkowej zabawy.

sh

Jak wskazał @Shingetsu, trzeba użyć odpowiedniego narzędzia do właściwej pracy. Kopiowanie zawartości z jednego pliku do drugiego to stary problem, a najlepszym narzędziem do takich zadań zarządzania plikami jest używanie powłoki.

Jedno polecenie powłoki, które każdy programista ma do zapoznania się z samym sobą jest wspólnym tacpolecenia używane do tac k zawartość plików razem, jeden po drugim. Jako szczególny przypadek, gdy tylko jeden plik jest przekazywany, jest po prostu wypluwany jak jest. Następnie po prostu przekierowujemy dane wyjściowe do odpowiedniego pliku:

tac inputfile.txt >outputfile.txt

Prosty i konkretny, żadnych sztuczek!

Perl

Zawiera program antywirusowy.

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

Pakiet Windows

(ponieważ musisz mieć ten rzekomo „martwy” język ;-)

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

Po prostu nazywaj to jako copy.bat file1.txt file2.txt(lub jakikolwiek inny plik)

Gdyby tylko zachował podziały linii ...

Linq

Wydajność nie jest ważna, poprawność jest. Pisanie w funkcjonalnym stylu daje bardziej przejrzysty i mniej podatny na błędy kod. Jeśli wydajność okaże się problemem, ostatnią linię ToArray () można pominąć. I tak lepiej być leniwym.

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

Pogawędka

Istnieje jeszcze biblioteka przeniesiona do kilku dialektów Smalltalk (Visualworks, Gemstone Squeak / Pharo, ...) o nazwie Xtreams, co sprawia, że ​​to zadanie jest więcej niż łatwe.

FileStream byłby tak prosty jak 'foo' asFilename readingi 'bar' asFilename writingna przykład w Visualworks, ale jest specyficzny dla dialektu.
Z tego powodu demonstruję algorytm z wewnętrznymi strumieniami neutralnymi dla dialektu.
Dobrym pomysłem może być przetwarzanie każdego kodu bajtowego w kolejności rosnącej:

| 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

Oczywiście możliwe jest również przetwarzanie w losowej kolejności, ale obawiam się, że sprawia to, że kod jest nieco zbyt zwarty:

| 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

EDYTOWAĆ

Ach, głupie mnie, nie widziałem rozwiązania 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

GRZMOTNĄĆ

na terminalu 1 z adresem IP 192.168.1.2

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

na terminalu 2 z adresem IP 192.168.1.3

gpg -c mydocument.docx | nc 192.168.1.2 8080

Spowoduje to zaszyfrowanie i wysłanie mydocument.docx, za pomocą nci gpg, do terminala nr 1 Musisz wpisać hasło na terminalu nr 2, a następnie na terminalu nr 1

C ++

Jest to nieco oparte na odpowiedzi Shingetsu , ale nie mogłem się oprzeć. Jest w pełni funkcjonalny, ale żaden uczeń nie podałby go swojemu nauczycielowi (mam nadzieję). Jeśli będą chcieli przeanalizować kod, będą w stanie rozwiązać swój problem:

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

Pyton

Wprowadza tekst z pliku1.txt i wysyła go do pliku2.txt

Jest kompletny i „działa”. Nikt nie powiedział nic o pisaniu danych wejściowych w obecnej formie. Wszystkie znaki wejściowe pojawiają się na wyjściu. „getchar” jest częścią trollingu.

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 znaki

Realizacja

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

Wykonanie

f["one file", "another"]

Czek

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

DELPHI / PASCAL (skopiuj z f1.txt do 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

Z pewnością nie jestem ekspertem od montażu, ale poniżej znajduje się mój mały fragment:

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

Czy zauważyłeś bit „kompletna, działająca funkcja”? Tak czy inaczej, oto moja odpowiedź:

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

Lua

io.read()

Uruchom z plikiem wejściowym zawierającym 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

Wygląda rozsądnie, ale raczej nieefektywnie, jeśli plik jest duży.

Współpracuje z plików ASCII z wyjątkiem, gdy plik wejściowy zawiera -n, -elub -E. (Ponieważ są one interpretowane jako argumenty przez echo.)

Nie generuje poprawnych danych wyjściowych dla wszystkich (większości) plików binarnych.

(Korzystanie z funkcji printf "%s" "$contents" > outputunder /bin/bashdziała trochę lepiej, ale nadal powoduje zmniejszenie NULL bajtów).

No i oczywiście to nie działa dla nazw plików_zawierających_przestrzeni. Ale i tak takie pliki są nielegalne w ramach UNIX% 20policy.