O comando filhote

O puppyutilitário usa um nome de arquivo como entrada e faz exatamente o que você esperaria que um filhote fizesse: ele o destrói!

Como desfiar

~~Rasgue as páginas com os dentes~~ Divida o arquivo de entrada em novas linhas.
~~Rasgue cada página com suas patas~~ Para cada linha (sem incluir o avanço de linha), escolha um número inteiro aleatório, de nmodo que 2 <= n <= # of characters in the line. Divida a linha em nsubstrings não sobrepostos e não sobrepostos, de comprimento aleatório.
~~Espalhe os fragmentos por todo o piso~~ Crie cada substring de cada linha para um nome de arquivo aleatório exclusivo ( [a-zA-Z0-9]apenas, qualquer extensão consistente, incluindo nenhuma, comprimento 1 <= n <= 12) no diretório atual. A substituição de arquivos pré-existentes no diretório atual (incluindo o arquivo de entrada, se estiver no diretório atual) é aceitável, desde que não interfira na execução do seu envio.

Esclarecimentos

Nunca haverá uma entrada em que seja possível usar todos os nomes de arquivos possíveis.
Os arquivos consistirão apenas em ASCII imprimíveis (ordinais 32-127) e feeds de linha e usarão finais de linha no estilo UNIX / Linux (LF, não o CRLF no estilo Windows).
Uma única linha nova à direita nos arquivos de saída é aceitável desde que todo arquivo de saída tenha uma nova linha à direita, mas não é necessária. Você pode escolher se o arquivo de entrada contém ou não uma nova linha à direita.
Cada linha na entrada conterá pelo menos 2 caracteres.
Os valores aleatórios escolhidos devem ser escolhidos a partir de uma distribuição aleatória uniforme no conjunto determinado de valores possíveis.

Se seu idioma não puder executar a E / S do arquivo, você pode usar o conteúdo do arquivo de entrada como entrada e gerar pares de cadeias de caracteres representando o nome do arquivo e o texto desse arquivo. No entanto, seu envio não será elegível para ganhar.

Exemplo

Implementação de referência:

#!/usr/bin/env python3

import random
import string
import sys

fname = sys.argv[1]
with open(fname) as f:
  txt = f.read().rstrip().split('\n')

for line in txt:
  n = random.randint(2, len(line))-1
  idxs = [0]+random.sample(range(1, len(line)), n)+[len(line)]
  idxs.sort()
  splits = []
  for i in range(0, len(idxs)-1):
    splits.append(line[idxs[i]:idxs[i+1]])
  ofnames = []
  for s in splits:
    flen = random.randint(1, 10)
    ofname = ''
    while ofname == '' or ofname in ofnames:
      ofname = ''
      for i in range(flen):
        ofname += random.choice(string.ascii_letters+string.digits)
    ofnames.append(ofname)
    with open(ofname, 'w') as f:
      f.write(s)

Exemplo de execução:

$ cat bestsong.txt
Never gonna give you up
Never gonna let you down
Never gonna run around
And desert you!

$ puppy bestsong.txt

$ ls
8675309
a
bestsong.txt
cSdhg
Dq762
jq7t
ret865
rick4life
weu767g
xyzzy

$ cat 8675309
esert you!

$ cat a
Never gonna let you down

$ cat cSdhg
ive y

$ cat Dq762
And d

$ cat jq7t
Never gonna g

$ cat ret865
run arou

$ cat rick4life
Never gonna 

$ cat weu767g
nd

$ cat xyzzy
ou up

— Mego
fonte

Relacionado , Relacionado .

— cat

'rick4life' rofl #

— 077

PowerShell v2 +, 215 211 bytes

nal d Get-Random;gc $args[0]|%{$b=d(0..($l=($t=$_).length)) -C(d(2..$l));$b=$b+0+$l|select -u|sort;0..($b.count-2)|%{-join($t[$b[$_]..($b[$_+1]-1)])}}|%{$_>(-join[char[]](d(48..57+65..90+97..122) -c(d(1..12))))}

Requer v2 ou mais recente, pois a v1 não estava Get-Randomdisponível.
_{Editar - salvou 4 bytes usando a conversão de char-array em vez de converter individualmente cada letra}

Um pouco Ungolfed

Get-Content $args[0]|ForEach-Object{
  $t=$_
  $l=$t.length
  $b=Get-Random(0..$l) -Count(Get-Random(2..$l))
  $b=$b+0+$l|Select-Object -unique|Sort-Object
  0..($b.count-2)|ForEach-Object{
    -join($t[$b[$_]..($b[$_+1]-1)])
  }
}|ForEach-Object{
  $_>(-join[char[]](Get-Random(48..57+65..90+97..122) -count(Get-Random(1..12))))
}

Explicação

Começa com a configuração dcomo New-Aliasfor Get-Random, para que não tenhamos que digitar Get-Randomcada vez que a estiver usando (muito). Nós então Get-Contentde nossa entrada $argse os canalizamos através de um loop com |%{...}. Observe que Get-Content, por padrão, será dividido em novas linhas (CRLF ou apenas LF), portanto, não precisamos fazer nada adicional lá.

A cada iteração do loop, começamos a formular as fatias nas quais essa linha será inserida no Ginsu . Defina $tigual à linha com a qual estamos trabalhando e $ligual ao seu comprimento e construa uma coleção a partir de (0..$l). Isso representa todos os índices de caracteres possíveis em nossa linha atual. Em seguida, Get-Randomalternamos entre (2..$l)para determinar quantos selecionar e, em seguida, obtemos um número aleatório de índices iguais a esse -count. Armazene esses índices em $b.

Então nós também adicionar 0e $lpara $b, por isso temos o início eo fim de nossa linha de garantia de estar na coleção de índices. Canalize isso até Select-Objectcom a -ubandeira nique e, em seguida, canalize para Sort-Object, para que nossos índices agora sejam garantidos para começar com o primeiro caractere e terminar com o último caractere, e algum número aleatório no meio.

Em seguida, percorreremos todos os índices $bcom 0..($b.count-2)|%{...}. Cada uma dessas iterações de loop é dividida $t(nossa linha de texto atual) e, em seguida, -joinagrupada em uma string (em vez de um array de caracteres). Eles são agrupados e deixados no oleoduto e fechamos o circuito externo.

Portanto, agora temos uma coleção em ordem de fatias aleatórias de cada uma das linhas de texto. (O que significa que, neste ponto, se simplesmente os -joinagruparmos novamente, obteremos o texto original menos as novas linhas.) Em seguida, canalizamos essa coleção por outro loop |%{...}e a cada iteração estamos enviando essa fatia para um arquivo $_>.... O arquivo é criado usando de 1 a 12 números inteiros aleatórios que correspondem aos códigos ASCII para [0-9A-Za-z]. Nenhum arquivo terá uma extensão e o >comando emitirá uma nova linha à direita por padrão em todos os arquivos.

Exemplo

— AdmBorkBork
fonte