पिल्ला आदेश

Question

puppyउपयोगिता इनपुट के रूप में एक फ़ाइल नाम लेता है, और वास्तव में आप एक पिल्ला करने के लिए उम्मीद करेंगे क्या: यह shreds!

कैसे बिखरना है

1. अपने दांतों के साथ पेजों को चीर दें नई लाइनों पर इनपुट फ़ाइल को विभाजित करें।
2. अपने पंजे के साथ प्रत्येक पृष्ठ को फाड़ें प्रत्येक पंक्ति के लिए (लाइनफीड सहित नहीं), nऐसे यादृच्छिक यादृच्छिक चुनें 2 <= n <= # of characters in the line। nयादृच्छिक लंबाई के गैर-खाली गैर-अतिव्यापी सब्सट्रिंग में लाइन को विभाजित करें ।
3. फर्श पर सभी कतरनों को बिखेरें वर्तमान डायरेक्टरी में एक अद्वितीय यादृच्छिक फ़ाइल नाम ( [a-zA-Z0-9]केवल, किसी भी लगातार विस्तार सहित कोई भी संगत एक्सटेंशन 1 <= n <= 12) में प्रत्येक पंक्ति के प्रत्येक आउटपुट को आउटपुट करें । वर्तमान निर्देशिका के भीतर पूर्व-मौजूदा फ़ाइलों को अधिलेखित करना (इनपुट फ़ाइल सहित, यदि यह वर्तमान निर्देशिका में है) स्वीकार्य है, जब तक कि यह आपके सबमिशन रनिंग में हस्तक्षेप नहीं करती है।

स्पष्टीकरण

• एक इनपुट कभी नहीं होगा जहां सभी संभव फ़ाइल नाम का उपयोग करना संभव हो।
• फ़ाइलों में केवल मुद्रण योग्य ASCII (32-127 ऑर्डिनल्स) और लाइनफ़ीड शामिल होंगे, और UNIX / लिनक्स-स्टाइल लाइन एंडिंग्स (LF, न कि विंडोज-स्टाइल CRLF) का उपयोग करेगा।
• आउटपुट फ़ाइलों में एक एकल अनुगामी न्यूलाइन तब तक स्वीकार्य है जब तक कि प्रत्येक आउटपुट फ़ाइल में एक अनुगामी न्यूलाइन हो, लेकिन आवश्यक नहीं है। आप चुन सकते हैं कि इनपुट फ़ाइल में अनुगामी न्यूलाइन है या नहीं।
• इनपुट में प्रत्येक पंक्ति में कम से कम 2 अक्षर होंगे।
• चुने गए यादृच्छिक मूल्यों को संभावित मूल्यों के दिए गए सेट पर एक समान यादृच्छिक वितरण से चुना जाना चाहिए।

Iff आपकी भाषा फ़ाइल I / O को निष्पादित करने में असमर्थ है, आप इसके बजाय इनपुट फ़ाइल की सामग्री को इनपुट के रूप में ले सकते हैं, और आउटपुट फ़ाइल का नाम आउटपुट फ़ाइल और उस फ़ाइल के लिए पाठ का प्रतिनिधित्व करते हैं। हालाँकि, आपका सबमिशन जीत के योग्य नहीं होगा।

उदाहरण

संदर्भ कार्यान्वयन:

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

उदाहरण रन:

$ 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

Comments

संबंधित , संबंधित ।

— बिल्ली

'rick4life' rofl

— Rick

Answer 1

PowerShell v2 +, 215 211 बाइट्स

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

V2 या नए की आवश्यकता है क्योंकि v1 Get-Randomउपलब्ध नहीं है ।
_{संपादित करें - प्रत्येक पत्र को व्यक्तिगत रूप से कास्टिंग करने के बजाय चार-सरणी कास्टिंग का उपयोग करके 4 बाइट्स को बचाया}

कुछ हद तक अनगढ़

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

व्याख्या

dएक New-Aliasके रूप में स्थापित करने के साथ शुरू होता है Get-Random, इसलिए हम Get-Randomहर बार हम इसे (बहुत) का उपयोग कर रहे हैं टाइप करने के लिए नहीं है । हम फिर Get-Contentअपने इनपुट के $argsसाथ उन लोगों को एक लूप के माध्यम से पाइप करते हैं |%{...}। ध्यान दें कि Get-Contentडिफ़ॉल्ट रूप से न्यूलाइन (या तो CRLF या सिर्फ LF) पर विभाजित होगा, इसलिए हमें वहां कुछ भी अतिरिक्त करने की आवश्यकता नहीं है।

लूप के प्रत्येक पुनरावृत्ति, हम स्लाइस को बनाने के साथ शुरू करते हैं यह रेखा जिनसु में होगी। $tहम जिस रेखा के साथ काम कर रहे हैं, और $lउसकी लंबाई के बराबर सेट करें , फिर उससे एक संग्रह बनाएँ (0..$l)। यह हमारी वर्तमान लाइन में सभी संभावित चरित्र सूचकांकों का प्रतिनिधित्व करता है। फिर हम Get-Randomबीच में (2..$l)से यह निर्धारित करते हैं कि कितने का चयन करना है, और फिर उस -count के बराबर सूचकांकों की एक यादृच्छिक संख्या प्राप्त करें । उन सूचकांकों को स्टोर करें $b।

हम तो यह भी पर जोड़ने 0और $lकरने के लिए $bहै, तो हम शुरुआत और अंत हमारी लाइन के सूचकांकों के संग्रह में होने की गारंटी है। पाइप कि करने के लिए के माध्यम से Select-Objectसाथ -unique झंडा, तो करने के लिए पाइप Sort-Object, इसलिए हमारे सूचकांक अब पहले चरित्र और अंतिम वर्ण के साथ अंत, और बीच में कुछ यादृच्छिक संख्या के साथ शुरू करने के लिए गारंटी है।

इसके बाद, हम सभी सूचकांकों के $bसाथ लूपिंग कर रहे हैं 0..($b.count-2)|%{...}। उन लूप पुनरावृत्तियों में से प्रत्येक, हम स्लाइस कर रहे हैं $t(हमारी पाठ की वर्तमान पंक्ति) और फिर -joinउन्हें एक स्ट्रिंग (एक चार-सरणी के बजाय) में एक साथ जोड़ते हैं। वे बंडल से जुड़ जाते हैं और पाइप लाइन पर छोड़ दिए जाते हैं, और हम बाहरी लूप को बंद कर देते हैं।

इसलिए अब हमारे पास पाठ की प्रत्येक पंक्ति के यादृच्छिक स्लाइस का इन-ऑर्डर संग्रह है। (मतलब, इस बिंदु पर, यदि हम बस -joinउन्हें वापस एक साथ संपादित करते हैं, तो हमें मूल पाठ माइनस न्यूलाइन्स मिलेंगे।) फिर हम उस संग्रह को दूसरे लूप के माध्यम से पाइप करते हैं |%{...}और प्रत्येक पुनरावृति हम उस स्लाइस को एक फाइल के साथ आउटपुट कर रहे हैं $_>...। फ़ाइल 1 से 12 रैंडम पूर्णांकों से बनाकर बनाई गई है जो ASCII कोड्स के लिए अनुरूप है [0-9A-Za-z]। किसी फ़ाइल में एक्सटेंशन नहीं होगा, और >कमांड हर फ़ाइल पर डिफ़ॉल्ट रूप से एक अनुगामी न्यूलाइन आउटपुट करेगा।

उदाहरण