डॉग बैश की उपयोगिता को लागू करें

Question

dog एक कमांड-लाइन उपयोगिता है जो एक मनमानी संख्या में तर्कों को लेती है, जिनमें से पहला पाठ लिखा जाना है और अन्य मनमाने ढंग से कई फाइलें हैं।

dogउपयोगिता इन फ़ाइलों से अधिक बराबर भागों में पाठ विभाजित कर देगा। यदि कोई शेष है n, तो पहली nफ़ाइलों को एक अतिरिक्त बाइट मिलती है

dogके विपरीत है cat, इस तरह के रूप में, forall x, निम्नलिखित पकड़ चाहिए।

$> dog x a.txt b.txt ...
$> cat a.txt b.txt ...
x$>

जहां ...मनमाने ढंग से कई फाइलों को इंगित करता है।

एक उदाहरण (12 बाइट्स, 3 फाइलें, समान रूप से विभाजित की जा सकती हैं):

$> ./dog.py "Dogs vs Cats" a.txt b.txt c.txt
$> cat a.txt
Dogs$> cat b.txt
 vs $> cat c.txt
Cats$> cat a.txt b.txt c.txt
Dogs vs Cats$> 

शेष के साथ एक उदाहरण (13 बाइट्स, 5 फाइलें, शेष 3):

9$>./dog.py "0123456789abc" a.txt b.txt c.txt d.txt e.txt
$> cat a.txt
012$> cat b.txt
345$> cat c.txt
678$> cat d.txt
9a$> cat e.txt
bc$> cat a.txt b.txt c.txt d.txt e.txt
0123456789abc$>

Comments

यह निहित है, लेकिन सिर्फ दोहरी जांच करने के लिए: 1) क्या तर्क को कमांड लाइन के माध्यम से आना है? 2) क्या हमें हमेशा फाइलों को आउटपुट करना पड़ता है?

— Sp3000

@ Sp3000 हां, 1 से 2 तक

— कारिडोरक

@DigitalTrauma पहले से ही एक उत्तर है, मैं इसे एक नियम परिवर्तन द्वारा अमान्य करने के लिए बुरा महसूस

— करूंगा

मैं हाल ही में इस साइट (tac, dog, ...) से कुछ अजीब तरह से नामित यूनिक्स उपयोगिताओं के बारे में सीख रहा हूं।

— kirbyfan64sos

@ kirbyfan64sos और Caridorc: tacवास्तविक है ।

— DLosc

Answer 1

पायथ - 12 बाइट्स

.wMC,cl.zz.z

बिलियन स्प्लिट फ़ंक्शन का उपयोग करता है और फिर राइट-फंक्शन पर स्पैट-मैप का उपयोग करता है। ऑनलाइन काम नहीं करता है।

Answer 2

पायथन - 181 बाइट्स

import sys
a=sys.argv
l=len
d=a[2:]
s=a[1]
n,r=divmod(l(s),l(d))
p=0
for i in range(l(d)):
    with open(d[i],'w') as f:
        o=n+int(i<=n)
        f.write(s[p:p+o])
        p+=o

Answer 3

PHP, 107 बाइट्स

गोल्फ कोड:

for($i=1;++$i<$argc;fputs(fopen($argv[$i],w),substr($s=$argv[1],($i-2)*$l=ceil(strlen($s)/($argc-2)),$l)));

विस्तृत कोड:

$len = ceil(strlen($argv[1])/($argc - 2));
for ($i = 2; $i < $argc; $i ++) {
    $fh = fopen($argv[$i], 'w');
    fputs($fh, substr($argv[1], ($i - 2) * $len, $len));
    fclose($fh);          // omitted in the golfed version
}

Answer 4

शुद्ध बैश: 97

s=$1;shift;for((l=${#s}/$#,m=${#s}-l*$#,i=1;i<=$#;p+=q,i++)){
printf "${s:p:q=i>m?l:l+1}">${!i};}

एक समारोह के रूप में: ( p=केवल दूसरे रन के लिए आवश्यक है)

dog() { p=
    s=$1;shift;for((l=${#s}/$#,m=${#s}-l*$#,i=1;i<=$#;p+=q,i++)){
    printf "${s:p:q=i>m?l:l+1}">${!i};}
}

टेस्ट

$> rm *
$> dog "Dogs vs Cats" a.txt b.txt c.txt
$> ls -l
total 12
-rw-r--r-- 1 user user 4 May 13 22:09 a.txt
-rw-r--r-- 1 user user 4 May 13 22:09 b.txt
-rw-r--r-- 1 user user 4 May 13 22:09 c.txt
$> cat {a,b,c}.txt;echo
Dogs vs Cats
$> 

सभी फाइलें 4 बाइट लेन हैं और सही क्रम में संक्षिप्त हैं, जिनमें "डॉग्स बनाम कैट" हैं ।

$> rm *
$> dog "$(printf "%s" {0..9} {a..c})" {a..e}.txt 
$> ls -l
total 20
-rw-r--r-- 1 user user 3 May 13 22:09 a.txt
-rw-r--r-- 1 user user 3 May 13 22:09 b.txt
-rw-r--r-- 1 user user 3 May 13 22:09 c.txt
-rw-r--r-- 1 user user 2 May 13 22:09 d.txt
-rw-r--r-- 1 user user 2 May 13 22:09 e.txt
$> cat *;echo
0123456789abc
$> 

फर्स्ट फाइलें 3 बाइट लेन हैं और अंतिम 2 केवल अल्फ़ाबेटिक ऑर्डर द्वारा संक्षिप्त हैं, जिसमें "0123456789abc" है ।

स्पष्टीकरण (अनगलन):

अगर आप हिट: declare -f dog, बैश का जवाब देंगे:

$> declare -f dog
dog () 
{ 
    p=;
    s=$1;
    shift;
    for ((l=${#s}/$#,m=${#s}-l*$#,i=1; i<=$#; p+=q,i++))
    do
        printf "${s:p:q=i>m?l:l+1}" > ${!i};
    done
}

यह लिखा जा सकता है:

dog2 () 
{ 
    position=0;
    string=$1;
    shift;
    partLen=$((${#string}/$#));
    oneMore=$((${#string}-partLen*$#));
    for ((i=1; i<=$#; i++))
    do
        if ((i<=oneMore)); then
            partQuant=$((partLen+1));
        else
            partQuant=$partLen;
        fi;
        printf "${string:position:partQuant}" > ${!i};
        ((position+=partQuant));
    done
}

Answer 5

रूबी, 93 87 बाइट्स

कमांड लाइन तर्कों का उपयोग करके पूरा कार्यक्रम।

अगर मैं s.slice!स्ट्रिंग को उत्परिवर्तित करने के लिए उपयोग कर सकता हूं, तो मैं इसका उपयोग करने की आवश्यकता के बजाय करूंगा s[c..-1], लेकिन रूबी आपको पहले से नकल किए बिना argv से स्ट्रिंग्स को म्यूट करने नहीं देता है

s,*t=$*
d,r=s.size.divmod t.size
t.map{|e|open(e,?w)<<s[0,c=(0>r-=1)?d:d+1];s=s[c..-1]}