El comando cachorro

La puppyutilidad toma un nombre de archivo como entrada y hace exactamente lo que esperaría que hiciera un cachorro: ¡lo destruye!

Cómo triturar

1. Extraiga las páginas con los dientes Divida el archivo de entrada en nuevas líneas.
2. Rasgue cada página con sus patas Para cada línea (sin incluir el salto de línea), elija un número entero aleatorio ntal que 2 <= n <= # of characters in the line. Divida la línea en nsubcadenas no vacías no superpuestas de longitud aleatoria.
3. Disperse las tiras por todo el piso. Exporte cada subcadena de cada línea a un nombre de archivo aleatorio único ( [a-zA-Z0-9]solo, cualquier extensión consistente que incluya ninguno, longitud 1 <= n <= 12) en el directorio actual. Sobrescribir archivos preexistentes dentro del directorio actual (incluido el archivo de entrada, si está en el directorio actual) es aceptable, siempre que no interfiera con la ejecución de su envío.

Aclaraciones

• Nunca habrá una entrada donde sea posible utilizar todos los nombres de archivo posibles.
• Los archivos consistirán solo en ASCII imprimible (ordinales 32-127) y avances de línea, y utilizarán terminaciones de línea de estilo UNIX / Linux (LF, no el CRLF de estilo Windows).
• Una nueva línea final en los archivos de salida es aceptable siempre que cada archivo de salida tenga una nueva línea final, pero no es necesaria. Puede elegir si el archivo de entrada contiene o no una nueva línea final.
• Cada línea en la entrada contendrá al menos 2 caracteres.
• Los valores aleatorios elegidos deben elegirse de una distribución aleatoria uniforme en el conjunto dado de valores posibles.

Si su idioma no puede realizar E / S de archivo, puede tomar el contenido del archivo de entrada como entrada y generar pares de cadenas que representan el nombre de archivo de salida y el texto de ese archivo. Sin embargo, su envío no será elegible para ganar.

Ejemplo

Implementación de referencia:

#!/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)

Ejemplo de ejecución:

$ 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

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

Requiere v2 o más reciente ya que v1 no tenía Get-Randomdisponible.
_{Editar: ahorró 4 bytes mediante el uso de la conversión de matriz de caracteres en lugar de emitir individualmente cada letra}

Algo no golfista

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

Explicación

Comienza con la configuración dcomo New-Aliaspara Get-Random, por lo que no tenemos que escribir Get-Randomcada vez que lo usamos (mucho). Luego Get-Contentde nuestra entrada $argsy canalizarlos a través de un bucle con |%{...}. Tenga en cuenta que Get-Content, de forma predeterminada, se dividirá en las nuevas líneas (ya sea CRLF o solo LF), por lo que no necesitamos hacer nada adicional allí.

Cada iteración del ciclo, comenzamos con la formulación de los cortes en los que esta línea va a ser Ginsu'd . Establezca $tigual a la línea con la que estamos trabajando e $ligual a su longitud, luego construya una colección a partir de (0..$l). Esto representa todos los índices de caracteres posibles en nuestra línea actual. Luego, Get-Randomdesde el medio (2..$l)para determinar cuántos seleccionar, y luego obtener un número aleatorio de índices igual a esa -cbúsqueda. Almacene esos índices en $b.

Luego también agregamos 0y $lpara $b, así tenemos el principio y el final de nuestra línea garantizados para estar en la colección de índices. Canalice eso hasta Select-Objectcon la -ubandera de nique, luego canalice hacia Sort-Object, por lo que nuestros índices ahora están garantizados para comenzar con el primer carácter y terminar con el último carácter, y algún número aleatorio en el medio.

A continuación, estamos recorriendo todos los índices $bcon 0..($b.count-2)|%{...}. En cada una de esas iteraciones de bucle, dividimos $t(nuestra línea de texto actual) y luego -joinlas unimos en una cadena (en lugar de una matriz de caracteres). Esos se agrupan y se dejan en la tubería, y cerramos el bucle exterior.

Así que ahora tenemos una colección en orden de cortes aleatorios de cada una de las líneas de texto. (Es decir, en este punto, si simplemente -joinlos volvemos a juntar, obtendremos el texto original menos las nuevas líneas). Luego canalizamos esa colección a través de otro bucle |%{...}y con cada iteración estamos generando ese corte en un archivo $_>.... El archivo se crea tomando de 1 a 12 enteros aleatorios que se corresponden con los códigos ASCII [0-9A-Za-z]. Ningún archivo tendrá una extensión, y el >comando generará una nueva línea final de forma predeterminada en cada archivo.

Ejemplo