स्पिंक्स के साथ अनुच्छेद कताई

लेख कताई एक खोज इंजन अनुकूलन तकनीक है जिसके द्वारा खोज इंजन ऑप्टिमाइज़र लेख निर्देशिकाओं, वेब 2.0 साइटों या बैकलिंक के अन्य स्रोतों पर प्रासंगिक सामग्री का एक अनूठा संस्करण पोस्ट करते हैं।

यह कभी-कभी वेबसाइट लेखकों द्वारा अपनी साइटों पर उपयोग किया जाता है, लेकिन आमतौर पर इससे बचा जाता है क्योंकि काता सामग्री की गुणवत्ता हाथ से लिखी गई सामग्री से कम होगी। कताई मौजूदा लेखों, या लेखों के कुछ हिस्सों को फिर से लिखना और विशिष्ट शब्दों, वाक्यांशों, वाक्यों या यहां तक कि संपूर्ण पैराग्राफों की जगह लेती है, जिनमें प्रत्येक स्पिन के साथ थोड़ा भिन्नता प्रदान करने के लिए वैकल्पिक संस्करणों की संख्या होती है।

इस प्रक्रिया को पूरी तरह से स्वचालित या मैन्युअल रूप से फिर से लिखा जा सकता है। आज आपका काम एक प्रोग्राम या फंक्शन बनाना होगा , जिसमें स्पिंक्स , सिंटैक्स युक्त स्ट्रिंग की व्याख्या हो , जिसके द्वारा एक प्रोग्राम उपलब्ध विभिन्न विकल्पों को पढ़ेगा। नीचे एक उदाहरण स्ट्रिंग है जो Spintax का उपयोग करता है:

{Hello|Hi there|Bonjour}, user! {What's up?|How are you?|Feeling alright?|I caught a fish!}

जैसा कि आप देख सकते हैं, स्ट्रिंग के खंड जो 'काता' जा रहे हैं घुंघराले ब्रेसिज़ में संलग्न हैं, जहां व्यक्तिगत विकल्प |चरित्र द्वारा विभाजित हैं । यहाँ कुछ उदाहरण वाक्य हैं जो यह उत्पादन कर सकते हैं।

Hi there, user! What's up?
Hello, user! How are you?
Bonjour, user! Feeling alright?
Hello, user! What's up?
Hi there, user! I caught a fish!

आपका काम

आपका मिशन, क्या आपको इसे स्वीकार करना चाहिए, एक प्रोग्राम या फ़ंक्शन बनाना है जो एक इनपुट स्ट्रिंग लेता है जिसमें स्पिंटैक्स हो सकता है या नहीं , फिर स्ट्रिंग के 5 संस्करणों को प्रिंट करें, यादृच्छिक रूप से विकल्पों में से प्रत्येक ब्लॉक से विकल्पों में से एक का चयन करें। आप कुछ अनुमान लगा सकते हैं:

आपको नेस्टेड स्पिंटैक्स ( {This|is {an|one}|example}) को संभालने की आवश्यकता नहीं होगी ।
|, {और }वर्ण कहीं और एक spintax ब्लॉक के भीतर के अलावा अन्य घटित नहीं होगा।
आपको यह जांचने की आवश्यकता नहीं है कि 5 आउटपुट वाक्य अलग-अलग हैं, जब तक कि कोड आपकी भाषा के यादृच्छिक संख्या फ़ंक्शन का उपयोग करके विकल्प का चयन नहीं करता है।
आप मान सकते हैं कि इनपुट एक नई रेखा के साथ समाप्त होता है।

नियम

कोई मानक खामियां नहीं हैं।

टेस्ट

1. {A|The|One} {quick|magnificent|charming|lucky|fast|super|cool} {gold|tan|yellow|white|brown|silver} {beaver|packrat|cat|lion|tiger|fox|dog|wolf} {consumed|ate|pilfered} my {pastry|strudel|cake}.
-------------------------------------------
One cool brown wolf consumed my pastry.
...(3 more here)...
The charming yellow beaver ate my cake.
-------------------------------------------
2. This sentence is valid, and happens to have no Spintax!
-------------------------------------------
This sentence is valid, and happens to have no Spintax!
...(3 more here)...
This sentence is valid, and happens to have no Spintax!
-------------------------------------------
3. {beg|get|ton|sun|bun|can|top|big}{2|3|4|5}{A|B|C|D|E|F|G}{2|3|4|5|6|7}{at|as|be|ex|hi|}{!|#|%}
-------------------------------------------
top2F2hi%
...(3 more here)...
big3E4ex#

एक चौथा परीक्षण यहां पाया जा सकता है।

यह कोड-गोल्फ है , इसलिए सबसे कम संख्या में बाइट्स जीतती हैं।

code-golf

— Kade
स्रोत

2

अब, एक मामूली बदलाव के साथ ... पागल कामवासना!

— जोबिट्स

इनपुट में हम किस प्रकार के पात्रों की उम्मीद कर सकते हैं?

— Sp3000

@ AS3II 32-127 से Sp3000 सब कुछ। केवल जगह है जहाँ {, |, }इनपुट स्ट्रिंग में पाया जा रहा है जहां spintax नहीं है।

— काडे

8

अजगर, १,

V5sOMcR\|scR\{cz\}

इसे यहाँ ऑनलाइन आज़माएँ

स्पष्टीकरण:

V5sOMcR\|scR\{cz\}                     : z = input()
V5                                     : do this 5 times
              cz\}                     : split z on the } character
          cR\{                         : split each element of the resulting list on {
         s                             : join the list of lists back into a list of strings
     cR\|                              : split these strings on the | character
   OM                                  : Choose a random element from each inner list
  s                                    : join those choices, and print them

— FryAmTheEggman
स्रोत

1

मेरे भगवान, वह तेज था!

— काडे

7

रूबी, ४६

कमांड-लाइन ध्वज के साथ -p , चलाएँ

($_*=5).gsub!(/{(.+?)}/){$1.split(?|).sample}

एक अनुगामी न्यूलाइन के साथ एक स्ट्रिंग में पढ़ें। इसे अपने आप में 5 बार सम्‍मिलित करें, इसे स्‍थान पर म्यूट करें, और परिणाम को आउटपुट करें। /{(.+?)}/एक आलसी क्वांटिफायर के साथ एक नियमित अभिव्यक्ति है: इसके बिना ?, यह निकटतम के बजाय {सबसे बाईं ओर सबसे दाईं ओर मेल खाता है }। $1प्रत्येक मैच में पहले कैप्चर ग्रुप का जिक्र जादू चर है, जबकि ?|शाब्दिक |चरित्र को संदर्भित करता है । sampleएक यादृच्छिक विधि को लौटाने वाली एक सरणी विधि है।

— histocrat
स्रोत

6

CJam, 25 22 19 18 बाइट्स

q5*'}/{'{/~'|/mR}/

इस कोड को एक अनुगामी न्यूलाइन शामिल करने के लिए इनपुट की आवश्यकता होती है।

CJam दुभाषिया में इसे ऑनलाइन आज़माएं ।

यह काम किस प्रकार करता है

q     e# Read from STDIN.
5*    e# Repeat the input five times.
'}/   e# Split at right curly brackets.
{     e# For each chunk:
  '{/ e#   Split at left curly brackets.
  ~   e#   Dump both chunks on the stack.
  '|/ e#   Split the right chunk at vertical bars.
  mR  e#   Select a chunk, pseudo-randomly.
}/    e#

प्रत्येक पुनरावृत्ति में, दो विखंडू (एक स्थिर, एक चर) को स्टैक पर छोड़ दिया जाता है और प्रोग्राम से बाहर निकलने पर इसे मुद्रित किया जाएगा।

— डेनिस
स्रोत

6

पायथन 3, 110 बाइट्स

import re,random
exec('print("".join(random.choice(s.split("|"))for s in re.split("{(.*?)}",%r)));'%input()*5)

रेगेक्स विभाजन, दूसरों की तरह।

पायथन 3, 121 116 114 बाइट्स

from random import*
exec(("print(%r[:-1]);"%(input()+'"')).translate({123:"'+choice(['",124:"','",125:"'])+'"})*5)

यह एक उपयुक्त प्रतिस्थापन करता है और फिर उसका मूल्यांकन करता है। यदि यह बैकस्लैश और एपोस्ट्रोफ़्स से बचने के लिए नहीं था, तो यह छोटा हो जाता।

उदाहरण के लिए, मान लीजिए कि हमारे पास Spintax है

I {like|hate} {Python|C}.

.translateप्रदर्शन देने के लिए एक बहुत कम रूपांतरण:

print('I '+choice(['like','hate'])+' '+choice(['Python','C'])+'.')

— Sp3000
स्रोत

4

पर्ल, 50

$_=$_ x5;s/{(.*?)}/@r=split"\\|",$1;$r[rand@r]/ge

49पात्रों +1के लिए -p।

यह पहले $_5 वाक्यों को सेट करके काम करता है । फिर यह एक वैश्विक खोज और प्रतिस्थापित करता है, जहां हम प्रत्येक { | | }समूह की खोज करते हैं। यह समूह को विभाजित करता है| , और प्रतिस्थापन के लिए एक यादृच्छिक तत्व चुनता है।

साथ दौड़ो:

echo '{A|The|One} {quick|magnificent|charming|lucky|fast|super|cool} {gold|tan|yellow|white|brown|silver} {beaver|packrat|cat|lion|tiger|fox|dog|wolf} {consumed|ate|pilfered} my {pastry|strudel|cake}.' | perl -pe'$_=$_ x5;s/{(.*?)}/@r=split"\\|",$1;$r[rand@r]/ge'

— hmatt1
स्रोत

$_ x=5कुछ बाइट्स बचाता है।

— डेनिस

4

शुतुरमुर्ग v0.7.0 , 27 वर्ण

{`{.*?}`{);(;"|/.,R*F=}X}5*

स्पष्टीकरण:

{...}5*  repeat 5 times
  `{.*?}`  regex to match "spintax" sections
  {...}X   replace with...
    );(;     remove first and last characters (the curly brackets)
    "|/      split on |
    .,R*     multiply length of that array by a random number
    F=       take the floor of that and get the nth element of the array

(ध्यान दें: इस प्रश्न को पोस्ट किए जाने के बाद 0.7.0 रिलीज़ किया गया था, लेकिन उत्तर अभी भी मान्य है क्योंकि इस प्रश्न को पोस्ट करने से पहले उस रिलीज़ को बनाए गए सभी कमिट्स को धक्का दे दिया गया था।)

— Doorknob
स्रोत

4

पिप, २५ २२ 20 बाइट्स

पार्टी के लिए देर से, लेकिन यहाँ मेरा है। कमांड-लाइन तर्क के रूप में इनपुट लेता है, जिसे उद्धृत करने की आवश्यकता हो सकती है।

L5P_@RR#_Ma^`}|{`^'|

स्पष्टीकरण:

L5                    Loop 5 times:
          a^`}|{`     Split cmdline arg on curly braces using regex
                 ^'|  Split each item of the result on pipe (if there isn't one,
                        the result is a single-item list)
         M            Map this function to each item a in the result:
   _@RR#_             Calculate a random number between 0 and len(item)-1; use it to
                        index into item
  P                   Print the resulting list, concatenating elements together

17 बाइट्स (लेकिन वैध जमा नहीं)

L5PRC_Ma^`}|{`^'|

पिप के नवीनतम संस्करण की आवश्यकता है, इस प्रश्न को पोस्ट किए जाने के बाद अपडेट किया गया। आरसी (यादृच्छिक विकल्प) ऑपरेटर की कुछ समय के लिए योजना बनाई गई थी, लेकिन मुझे इसे लागू करने के लिए कभी नहीं मिला। : ^ (

पिप के बारे में अधिक जानें

— DLosc
स्रोत

1

गंभीरता से? आप गोल्फ प्रतियोगिता जीतने के लिए अपनी भाषा लिखते हैं?

— क्लो

3

@Chloe: CJam , GS2 , शुतुरमुर्ग , PYG , Pyth , रेटिना और रु सभी गोल्फ इस साइट के उपयोगकर्ताओं द्वारा आविष्कार भाषाएं हैं।

— डेनिस

3

जावास्क्रिप्ट ईएस 6, 86 84 बाइट्स

f=s=>s.repeat(5).replace(/{(.+?)}/g,(_,e)=>(p=e.split`|`)[Math.random()*p.length|0])

यह इनपुट की अनुगामी न्यूलाइन होने की उम्मीद करता है। यह इनपुट को 5 बार दोहराने से शुरू होता है, और फिर प्रत्येक स्पिंटैक्स स्ट्रिंग को इसके साथ एक यादृच्छिक शब्द से बदल देता है, जो |वर्णों को विभाजित करके प्राप्त किया जाता है और फिर 0 और परिणामी सरणी माइनस की लंबाई के बीच एक यादृच्छिक संख्या चुनता है। इसमें मामला, |0बस करने का एक छोटा तरीका है Math.floor। मुझे टैग किए गए टेम्पलेट स्ट्रिंग्स के बारे में याद दिलाने के लिए vihan1086 का धन्यवाद।

नीचे दिए गए स्टैक स्निपेट में असंगठित और आसानी से परीक्षण योग्य कोड होता है।

f=function(s){
  return s.repeat(5).replace(/{(.+?)}/g,function(_,e){
    return (p=e.split('|'))[Math.random()*p.length|0]
  })
}

run=function(){document.getElementById('output').innerHTML=f(document.getElementById('input').value+'\n')};document.getElementById('run').onclick=run;run()

<input type="text" id="input" value="{A|The|One} {quick|magnificent|charming|lucky|fast|super|cool} {gold|tan|yellow|white|brown|silver} {beaver|packrat|cat|lion|tiger|fox|dog|wolf} {consumed|ate|pilfered} my {pastry|strudel|cake}." style="width: 400px;" /><button id="run">Run</button><br />
<pre id="output"></pre>

स्निपेट का विस्तार करें

— NinjaBearMonkey
स्रोत

|0Math.floorनहीं के बराबर है Math.round। यद्यपि आप जैसा चाहते हैं वैसा Math.roundही असमान वितरण प्रदान करेगा।

— जॉर्ज रीथ

@GeorgeReith आप सही कह रहे हैं, मेरा मतलब फर्श डालना था लेकिन गलती से गोल हो गया। धन्यवाद

— NinjaBearMonkey

2

पर्ल, 82 बाइट्स

while($o=<>){for(0..4){$_=$o;s/{(.*?)}/@x=split\/\|\/,$1 and$x[rand@x]/ge;print;}}

— kirbyfan64sos
स्रोत

2

पायथन 2, 139 बाइट्स

इनपुट स्ट्रिंग के आसपास उद्धरणों के लिए दो बाइट्स जोड़े गए। अगर इनकी जरूरत न हो तो मुझे बताएं।

इसे यहाँ आज़माएँ

import re,random
s=input()
exec"print''.join(t*(t!=''and(t[0]!='{'))or random.choice(t[1:].split('|'))for t in re.split('({.*?)}',s));"*5

— mbomb007
स्रोत

1

जावा, 243 215 242 234 बाइट्स

int i,k;void f(String s){String a,b[],c=s;for(;k++<5;System.out.println(c),c=s)while((i=c.indexOf("{"))>=0){a=c.substring(i,c.indexOf("}")+1);b=a.replaceAll("\\{|\\}","").split("\\|");c=c.replace(a,b[(int)(Math.random()*b.length)]);}}

ब्रेसिज़ के भीतर तार ढूँढता है {}और उन्हें पाइप वर्ण द्वारा विभाजित करके बनाए गए तार के सरणी से एक यादृच्छिक तत्व के साथ प्रतिस्थापित करता है। (मुझे थोड़ी देर से पता चला कि पाँच वाक्यों को छापना था: P)

— टीएनटी
स्रोत

1

बैश: 144 138 अक्षर

IFS={} read -ap
w()(for o in "${p[@]}";{
[[ $o =~ \| ]]&&{
IFS=\| read -aa<<<"$o"
o=${a[RANDOM%${#a[@]}]}
}
echo -n "$o"
}
echo)
w
w
w
w
w

नमूना रन:

bash-4.3$ bash spintax.sh <<< "Look {ma'|daddy|mr. president}! No {bin|core|doc|find|mail}utils tools nor {Awk|Sed|jq|XML Starlet}!"
Look ma'! No docutils tools nor Awk!
Look daddy! No binutils tools nor XML Starlet!
Look mr. president! No docutils tools nor XML Starlet!
Look ma'! No docutils tools nor Awk!
Look mr. president! No binutils tools nor Sed!

— आदमी काम पर है
स्रोत

1

आप का उपयोग करके कुछ बाइट्स बचा सकता है w()(...)के बजाय w(){...}, (सफेद स्थान को खत्म करने के लिए अनुमति देता है) printfके बजाय echo -nऔर बजाय कर्ली कोष्ठक doऔर done।

— डेनिस

धन्यवाद, @ डेनिस। फिर। (अफसोस की बात यह है कि मैं पहली बार इन ट्रिक्स को नहीं भूल रहा हूं।) printfजब तक मैं कुछ गलत नहीं समझ लेता, तब तक इनपुट स्ट्रिंग में "%" नहीं होगा।

— पुरुषार्थ

1

जावास्क्रिप्ट, 143 142 बाइट्स

a=prompt(b=5);for(c=[];b--;c.push(a.replace(/{(.+?)}/g,function(_,j){return (d=j.split("|"))[d.length*Math.random()|0]})));alert(c.join("\n"))

— SuperJedi224
स्रोत

1

पायथन 3, 97 बाइट्स

रेगेक्स प्रतिस्थापन में एक लैम्ब्डा फ़ंक्शन का उपयोग करना। यह कुछ ऐसा ही है कि मैंने इसे अपने Spintax मॉड्यूल https://github.com/AceLewis/spintax में कैसे किया हालांकि यह नेस्टेड स्पिंटैक्स से निपटने या पात्रों से बचने के लिए नहीं है।

import re,random
print(re.sub("{(.*?)}",lambda x:random.choice(x.group(1).split('|')),input()*5))

यदि आप नहीं मानते हैं कि इनपुट एक नई रेखा के साथ समाप्त होता है तो यह 104 बाइट होगा।

import re,random
print(re.sub("{(.*?)}",lambda x:random.choice(x.group(1).split('|')),(input()+'\n')*5))

— AceLewis
स्रोत

एक Spintax {कार्य | समस्या | प्रश्न}

स्पिंक्स के साथ अनुच्छेद कताई

आपका काम

नियम

टेस्ट

अजगर, १,

स्पष्टीकरण:

रूबी, ४६

CJam, 25 22 19 18 बाइट्स

यह काम किस प्रकार करता है

पायथन 3, 110 बाइट्स

पायथन 3, 121 116 114 बाइट्स

पर्ल, 50

शुतुरमुर्ग v0.7.0 , 27 वर्ण

पिप, २५ २२ 20 बाइट्स

17 बाइट्स (लेकिन वैध जमा नहीं)

जावास्क्रिप्ट ईएस 6, 86 84 बाइट्स

पर्ल, 82 बाइट्स

पायथन 2, 139 बाइट्स

जावा, 243 215 242 234 बाइट्स

बैश: 144 138 अक्षर

जावास्क्रिप्ट, 143 142 बाइट्स

पायथन 3, 97 बाइट्स