Il comando del cucciolo

L' puppyutilità prende un nome file come input e fa esattamente quello che ti aspetteresti da un cucciolo: lo distrugge!

Come distruggere

~~Strappare le pagine con i denti~~ Dividere il file di input su nuove righe.
~~Strappa ogni pagina con le tue zampe~~ Per ogni riga (escluso il linefeed), scegli un numero intero casuale ntale che 2 <= n <= # of characters in the line. Dividi la linea in nsottostringhe non vuote non sovrapposte di lunghezza casuale.
~~Spargi i frammenti su tutto il pavimento.~~ Invia ogni sottostringa di ogni riga a un nome file casuale univoco ( [a-zA-Z0-9]solo, qualsiasi estensione coerente incluso nessuno, lunghezza 1 <= n <= 12) nella directory corrente. La sovrascrittura di file preesistenti all'interno della directory corrente (incluso il file di input, se presente nella directory corrente) è accettabile, purché non interferisca con l'inoltro in esecuzione.

chiarimenti

Non ci sarà mai un input in cui è possibile utilizzare tutti i nomi file possibili.
I file saranno costituiti solo da ASCII stampabili (ordinali 32-127) e avanzamenti di riga e utilizzeranno terminazioni di linea in stile UNIX / Linux (LF, non CRLF in stile Windows).
È accettabile una singola riga finale finale nei file di output, purché ogni file di destinazione abbia una nuova riga finale, ma non è necessaria. È possibile scegliere se il file di input contiene o meno una nuova riga finale.
Ogni riga nell'input conterrà almeno 2 caratteri.
I valori casuali scelti devono essere scelti da una distribuzione casuale uniforme sull'insieme dato di possibili valori.

Se la tua lingua non è in grado di eseguire l'I / O del file, puoi invece prendere il contenuto del file di input come input e generare coppie di stringhe che rappresentano il nome del file di output e il testo per quel file. Tuttavia, il tuo invio non sarà idoneo alla vincita.

Esempio

Implementazione di riferimento:

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

Esempio di esecuzione:

$ 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

Correlati , Correlati .

— gatto

'rick4life' rofl

— Rɪᴋᴇʀ

PowerShell v2 +, 215 211 byte

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

Richiede v2 o più recenti poiché v1 non era Get-Randomdisponibile.
_{Modifica: salvato 4 byte utilizzando il cast char-array anziché il cast individuale di ogni lettera}

Un po '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))))
}

Spiegazione

Inizia con l'impostazione dcome New-Aliasper Get-Random, quindi non dobbiamo scrivere Get-Randomogni volta che lo usiamo (molto). Quindi Get-Contentdel nostro input $argse reindirizziamo quelli attraverso un loop con |%{...}. Si noti che Get-Contentper impostazione predefinita verrà suddiviso su newline (o CRLF o solo LF), quindi non è necessario fare altro.

Ad ogni iterazione del ciclo, iniziamo con la formulazione delle sezioni in cui questa linea sarà Ginsu . Impostare $tuguale alla linea con cui stiamo lavorando e $luguale alla sua lunghezza, quindi costruire una raccolta da (0..$l). Ciò rappresenta tutti i possibili indici di caratteri nella nostra riga corrente. Abbiamo poi Get-Randomdi fra (2..$l)per determinare quante selezionare, e quindi ottenere un numero casuale di indici pari a quello -count. Conservare quegli indici in $b.

Quindi aggiungiamo anche 0e $lto $b, così abbiamo l'inizio e la fine della nostra linea garantiti per essere nella raccolta di indici. Pipa fino a Select-Objectcon la -ubandiera della nicchia, quindi a pipe Sort-Object, quindi i nostri indici sono ora garantiti per iniziare con il primo carattere e terminare con l'ultimo carattere e un numero casuale nel mezzo.

Successivamente, eseguiamo il loop su tutti gli indici $bcon 0..($b.count-2)|%{...}. Ognuna di queste iterazioni cicliche, stiamo tagliando $t(la nostra attuale riga di testo) e poi -joininserendoli insieme in una stringa (anziché in un array di caratteri). Questi vengono raggruppati e lasciati sulla tubazione e chiudiamo il circuito esterno.

Quindi ora abbiamo una raccolta in ordine di sezioni casuali di ciascuna delle righe di testo. (Significa che, a questo punto, se li -joinrielaboriamo semplicemente insieme, otterremo il testo originale meno le nuove righe.) Quindi reindirizziamo quella raccolta attraverso un altro ciclo |%{...}e ogni iterazione che stiamo trasmettendo quella sezione in un file $_>.... Il file viene creato prendendo da 1 a 12 numeri interi casuali che corrispondono ai codici ASCII per [0-9A-Za-z]. Nessun file avrà un'estensione e il >comando genererà una nuova riga finale per impostazione predefinita su ogni file.

Esempio

— AdmBorkBork
fonte