Implementar o utilitário dog bash

10

dog é um utilitário de linha de comando que recebe um número arbitrário de argumentos, o primeiro dos quais é o texto a ser escrito e os outros são arbitrariamente muitos arquivos.

O dogutilitário dividirá o texto em partes iguais sobre esses arquivos. Se houver um restante n, os primeiros narquivos receberão um byte adicional

dogé o oposto de cat, como tal, forall x, o seguinte deve valer.

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

Onde ...indica arbitrariamente muitos arquivos.

Um exemplo (12 bytes, 3 arquivos, podem ser divididos igualmente):

$> ./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$> 

Um exemplo com restante (13 bytes, 5 arquivos, restante 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$>
Caridorc
fonte
Está implícito, mas apenas para checar: 1) Os argumentos precisam entrar na linha de comando? 2) Nós sempre temos que imprimir em arquivos?
Sp3000
@ Sp3000 sim, para 1 e 2
Caridorc 5/10
11
@DigitalTrauma já existe uma resposta, eu me sentiria mal para invalidar-lo por uma mudança de regra
Caridorc
2
Ultimamente, tenho aprendido sobre alguns utilitários UNIX de nome estranho (site tac, dog, ...).
Kirbyfan64sos
11
@ Kirbyfan64sos e Caridorc: tacé real .
DLosc

Respostas:

4

Pitão - 12 bytes

.wMC,cl.zz.z

Usa a função de divisão interna e, em seguida, usa o mapa de splat na função de gravação. Não funciona online.

Maltysen
fonte
2

Python - 181 bytes

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
Zac Crites
fonte
1

PHP, 107 bytes

O código do golfe:

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

O código detalhado:

$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
}
axiac
fonte
0

Pure bash: 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};}

Como função: ( p=é necessária apenas para a segunda execução)

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

Testes

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

Todos os arquivos são de 4 bytes e concatenados na ordem correta, contêm "Dogs vs Cats" .

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

Os primeiros arquivos têm 3 bytes de len e os últimos apenas 2, concatenados por ordem alfabética, contêm "0123456789abc" .

Explicação (ungolfing):

Se você acertar: declare -f dog, irá responder:

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

Isso pode ser escrito:

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
}
F. Hauri
fonte
0

Ruby, 93 87 bytes

Programa completo usando argumentos de linha de comando.

Se eu pudesse usar s.slice!para alterar a string, faria isso em vez de precisar usá-la s[c..-1], mas Ruby não permite que você modifique as strings do argv sem duplicá-las primeiro

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]}
Value Ink
fonte