चुनौती:
एक फाइल से इनपुट टेक्स्ट और दूसरे में आउटपुट। समाधान एक पूर्ण, कार्यशील कार्य होना चाहिए।
नोट: यह एक कोड-ट्रोलिंग प्रश्न है। कृपया प्रश्न और / या उत्तर को गंभीरता से न लें। अधिक जानकारी यहाँ ।
चुनौती:
एक फाइल से इनपुट टेक्स्ट और दूसरे में आउटपुट। समाधान एक पूर्ण, कार्यशील कार्य होना चाहिए।
नोट: यह एक कोड-ट्रोलिंग प्रश्न है। कृपया प्रश्न और / या उत्तर को गंभीरता से न लें। अधिक जानकारी यहाँ ।
जवाबों:
कई प्रोग्रामिंग भाषा होने का पूरा बिंदु यह है कि आपको नौकरी के लिए सही उपकरण का उपयोग करने की आवश्यकता है।
इस मामले में, हम बाइट्स को एक फ़ाइल से दूसरी फ़ाइल में कॉपी करना चाहते हैं।
जबकि हम कुछ फैंसी जैसे बैश या माणिक का उपयोग कर सकते हैं, या ASM की शक्ति में गिर सकते हैं, हमें बिट्स और फास्ट के साथ कुछ जल्दी, अच्छा चाहिए।
स्पष्ट पसंद सी है।
ऐसा करने का SIMPLEST तरीका ऐसा होगा:
#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_;
}
यह बुराई है क्योंकि यह साइबरविन जैसी चीजों पर कचरा पढ़ेगा, एक शुरुआत के लिए पूरी तरह से चीनी है, उसे डरा देगा जब उसे पता चलता है कि यह मदद के लिए कॉल है और जाहिर है, क्योंकि सी।
#define VERY filename1
#define NOT filename2
#define _ 1
, आप (;_;)
इसे एक स्माइली की तरह दिखने के लिए, लूप के साथ बना सकते हैं ।
#define LOL fclose
मेरा दिन बनाया
मुझे यह सरलता पसंद है।
echo File1.txt > File2.txt
वास्तव में केवल ठीक से काम करता है अगर File1.txt
"File1.text" ...
File2.txt
को वास्तविक सामग्री के रूप में File1.txt
WinActivate, file1.txt
SendInput ^a^c
WinActivate, file2.txt
SendInput ^a^v^s
आपको पहले नोटपैड या कुछ अन्य टेक्स्ट एडिटर में फाइल को खोलना होगा जो विंडो नामों को फाइल नामों से शुरू करता है। तब यह फाइल 1 की सामग्री को क्लिपबोर्ड पर कॉपी करता है (शाब्दिक, उपयोग करके ctrl+ c), और इसे फाइल 2 में पेस्ट करता है, वर्तमान में इसमें कुछ भी अधिलेखित कर देता है, और बचाता है।
समस्या को हल करता है, लेकिन एक बहुत ही असुविधाजनक और बहुत बेकार फैशन में। यह संभव है कि इसे आसानी से कॉपी करके पेस्ट किया जाए।
जैसा कि सभी जानते हैं, फ़ाइलों के हेरफेर के लिए पर्ल बहुत अच्छा है। यह कोड एक फ़ाइल की सामग्री को दूसरे में कॉपी करेगा, और अच्छे उपाय के लिए अतिरिक्त अतिरेक के साथ ऐसा करेगा।
#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);
}
}
सुरक्षित होने के लिए, पहले एक छोटी फ़ाइल पर इसका परीक्षण करें। एक बार जब आप इसकी शुद्धता के बारे में आश्वस्त हो जाते हैं, तो आप इसे बिना किसी चिंता के बहुत बड़ी फ़ाइलों के उपयोग के लिए उत्पादन में डाल सकते हैं।
सी#
इसे प्राप्त करने के लिए, आपको कई काम करने होंगे:
यहाँ कोड है:
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
}
}
चार सरल चरणों में:
lpr
कमांड का उपयोग कर सकते हैं ।बहुत से लोग नियमित अभिव्यक्ति का उपयोग करने या उन्हें एक फ़ाइल से दूसरी फ़ाइल में कॉपी करने के लिए स्ट्रिंग का मूल्यांकन करने के लिए उपयोगी पाते हैं, हालांकि प्रोग्रामिंग की वह विधि मैला है। पहले हम जावा का उपयोग करते हैं क्योंकि OOP हमारे कोड में अधिक पारदर्शिता की अनुमति देता है, और दूसरी बात यह है कि हम पहली फ़ाइल से डेटा प्राप्त करने और इसे दूसरे में लिखने के लिए एक इंटरैक्टिव इंटरफ़ेस का उपयोग करते हैं।
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());
}
}
सिद्धांत रूप में (मैंने इसका परीक्षण नहीं किया है) यह उपयोगकर्ता को पहले फाइल (शब्द द्वारा शब्द) की सामग्री को मैन्युअल रूप से इनपुट करता है और फिर दूसरी फाइल पर लिखता है। यह प्रतिक्रिया प्रश्न की अस्पष्टता पर एक नाटक है क्योंकि इसका अर्थ है "एक फ़ाइल से इनपुट पाठ," और पागल चर नाम (यादृच्छिक रूप से उत्पन्न) केवल कुछ अतिरिक्त मज़ा के लिए थे।
जैसे @Shingetsu ने बताया, किसी को सही काम के लिए सही उपकरण का उपयोग करना होगा। सामग्री को एक फ़ाइल से दूसरी फ़ाइल में कॉपी करना एक पुरानी समस्या है, और इस तरह के फ़ाइल-प्रबंधन कार्यों के लिए सबसे अच्छा उपकरण शेल का उपयोग करना है।
एक शेल कमांड हर प्रोग्रामर के साथ themself परिचित करने के लिए है कि आम है tac
आदेश, के लिए इस्तेमाल किया टैक कश्मीर फ़ाइलों की सामग्री एक साथ, एक के बाद एक। इस के एक विशेष मामले के रूप में, जब इसमें केवल एक फ़ाइल पास की जाती है, बस फिर से बाहर थूक दिया जाता है। हम तब आउटपुट को उपयुक्त फ़ाइल में पुनर्निर्देशित करते हैं:
tac inputfile.txt >outputfile.txt
सरल और टू-पॉइंट, कोई चाल नहीं!
एंटीवायरस शामिल थे।
#!/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"};
(क्योंकि आपको यह "मृत" भाषा है;;
@echo off
setlocal enabledelayedexpansion
for %%I in ('type %1') do set this=!this!%%I
echo !this!>%2 2>nul
आप बस इसे कॉल करें copy.bat file1.txt file2.txt
(या आप जो भी फाइल चाहते हैं)
यदि केवल यह लाइन ब्रेक रखना होगा ...
setlocal enabledelayedexpansion
और set thisline=!thisline!%%I
केवल विंडोज सीएमडी में काम करता है। DOS में सरल काम करना चाहिएset thisline=%thisline%%%I
दक्षता महत्वपूर्ण नहीं है, शुद्धता है। कार्यात्मक शैली में लिखने से परिणाम अधिक स्पष्ट और कम त्रुटि-प्रवण होता है। यदि प्रदर्शन समस्या का कारण बनता है, तो अंतिम ToArray () लाइन को छोड़ा जा सकता है। वैसे भी आलसी होना बेहतर है।
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();
}
छोटी बात
एक पुस्तकालय अभी तक कई स्मालटाक बोलियों (विजुअलवर्क्स, जेमस्टोन स्क्वीक / फारो, ...) के लिए पोर्ट किया गया है, जिसका नाम Xtreams है जो इस कार्य को आसान से अधिक बनाता है।
FileStream के रूप में सरल रूप में हो सकता है 'foo' asFilename reading
और 'bar' asFilename writing
VisualWorks में उदाहरण के लिए, लेकिन बोली विशिष्ट हैं।
इस कारण से मैं इसके बजाय बोली को तटस्थ आंतरिक धाराओं के साथ एल्गोरिथ्म प्रदर्शित करता हूं।
बढ़ते क्रम में प्रत्येक बाइट कोड को संसाधित करने के लिए एक अच्छा विचार हो सकता है:
| 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
बेशक, यादृच्छिक क्रम में प्रक्रिया करना भी संभव है, लेकिन मुझे डर है कि यह कोड को थोड़ा कॉम्पैक्ट बनाता है:
| 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
संपादित करें
मुझे बेवकूफ, मैं 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
IP, 192.168.1.2 के साथ टर्मिनल # 1 पर
nc -l 8080 | gpg -d > mydocument.docx
IP, 192.168.1.3 के साथ टर्मिनल # 2 पर
gpg -c mydocument.docx | nc 192.168.1.2 8080
यह टर्मिनल # 1 पर एन्क्रिप्ट और भेजेगा mydocument.docx
, उपयोग करेगा nc
और gpg
, आपको टर्मिनल # 2 पर पासवर्ड टाइप करना होगा, फिर टर्मिनल # 1 पर
यह कुछ हद तक Shingetsu के उत्तर पर आधारित है , लेकिन मैं विरोध नहीं कर सका। यह पूरी तरह से कार्य कर रहा है, लेकिन कोई भी छात्र इसे अपने शिक्षक (मुझे आशा है) को प्रस्तुत नहीं करेगा। यदि वे कोड का विश्लेषण करने के लिए तैयार हैं, तो वे अपनी समस्या को हल करने में सक्षम होंगे:
#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;
}
फ़ाइल से पाठ इनपुट
यह पूर्ण और "काम" है। इनपुट लिखने के बारे में किसी ने कुछ नहीं कहा। सभी इनपुट वर्ण आउटपुट में दिखाई देते हैं। "गेटचार" ट्रोलिंग पार्ट है।
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)
कार्यान्वयन
f = (BinaryWrite[#2, BinaryReadList@#]; Close@#2) &
क्रियान्वयन
f["one file", "another"]
चेक
check = Import[StringJoin["!diff \"", #, "\" \"", #2, "\" 2>&1"], "Text"] &;
check["one file", "another"]
CopyFile
कार्य का उपयोग कर सकता था ।
मैं निश्चित रूप से एक विधानसभा विशेषज्ञ नहीं हूं, लेकिन नीचे मेरा छोटा स्निपेट है:
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
io.read()
युक्त इनपुट फ़ाइल के साथ चलाएँ text from one file and output it to another. Solution should be a complete, working function.
।
पीएचपी
function copyFile($input, $output)
{
return file_put_contents($output, file_get_contents($input));
}
contents=`< $1` ; echo "$contents" > $2
यदि फ़ाइल बड़ी है तो उचित, बल्कि अक्षम लगती है।
जब इनपुट फ़ाइल होती है -n
, -e
या छोड़कर ASCII फ़ाइलों पर ठीक काम करता है -E
। (क्योंकि इनकी व्याख्या तर्क के रूप में की गई है echo
।)
सभी (अधिकांश) बाइनरी फ़ाइलों के लिए सही आउटपुट का उत्पादन नहीं करता है।
( printf "%s" "$contents" > output
अंडर /bin/bash
वर्क का उपयोग करना थोड़ा बेहतर है, लेकिन यह अभी भी NULL बाइट्स को छोड़ देता है।)
ओह और निश्चित रूप से यह filenames_contain_spaces के लिए काम नहीं करता है। लेकिन ऐसी फाइलें वैसे भी UNIX% 20policy के तहत अवैध हैं।