Articolo di filatura con Spintax

La rotazione degli articoli è una tecnica di ottimizzazione dei motori di ricerca mediante la quale gli ottimizzatori dei motori di ricerca pubblicano una versione univoca dei contenuti pertinenti nelle directory degli articoli, nei siti Web 2.0 o in altre fonti per i backlink.

Occasionalmente viene utilizzato dagli autori di siti Web sui propri siti, ma di solito viene evitato perché la qualità dei contenuti trasmessi sarà inferiore a quella scritta a mano. La filatura funziona riscrivendo articoli esistenti o parti di articoli e sostituendo parole, frasi, frasi o persino interi paragrafi con un numero qualsiasi di versioni alternative per fornire una variazione leggermente diversa ad ogni giro.

Questo processo può essere completamente automatizzato o riscritto manualmente. Il tuo lavoro oggi sarà quello di creare un programma o una funzione che interpreti una stringa contenente Spintax , la sintassi con cui un programma legge le diverse opzioni disponibili. Di seguito è una stringa di esempio che utilizza Spintax:

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

Come puoi vedere, le sezioni della stringa che devono essere "filate" sono racchiuse tra parentesi graffe, in cui le singole opzioni sono divise dal |carattere. Ecco alcune frasi di esempio che questo potrebbe produrre.

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!

Il tuo lavoro

La tua missione, se scegli di accettarlo, è quella di creare un programma o una funzione che accetta una stringa di input che può contenere o meno Spintax , quindi stampare 5 versioni della stringa, selezionando casualmente una delle scelte da ciascun blocco di opzioni. Puoi fare alcune ipotesi:

1. Non sarà necessario gestire Spintax nidificato ( {This|is {an|one}|example}).
2. I |, {e }caratteri non si verificano in qualsiasi altro luogo diverso all'interno di un blocco Spintax.
3. Non è necessario verificare se le 5 frasi di output sono distinte, purché il codice selezioni le opzioni utilizzando la funzione di numero casuale della lingua.
4. È possibile supporre che l'input termini con una nuova riga.

Regole

1. Nessuna scappatoia standard.

test

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#

Un quarto test può essere trovato qui.

Questo è code-golf , quindi vince il minor numero di byte.

Pyth, 18 anni

V5sOMcR\|scR\{cz\}

Provalo online qui

Spiegazione:

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

Ruby, 46

Con flag della riga di comando -p , eseguire

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

Leggi in una stringa con una nuova riga finale. Concatenalo a se stesso 5 volte, mutalo in posizione e genera il risultato. /{(.+?)}/è un'espressione regolare con un quantificatore pigro: senza il ?, corrisponderebbe a quello più {a sinistra a quello più a destra }anziché a quello più vicino. $1è una variabile magica che si riferisce al primo gruppo di acquisizione in ogni partita, mentre il ?|letterale si riferisce al |personaggio. sampleè un metodo array che restituisce un elemento casuale.

CJam, 25 22 19 18 byte

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

Questo codice richiede che l'input contenga una nuova riga finale.

Provalo online nell'interprete CJam .

Come funziona

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#

In ogni iterazione, due blocchi (una costante, una variabile) vengono lasciati nello stack e verranno stampati all'uscita dal programma.

Python 3, 110 byte

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

Spaccatura del Regex, come le altre.

Python 3, 121 116 114 byte

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

Questo esegue le sostituzioni appropriate, quindi lo valuta. Se non fosse stato per sfuggire a barre rovesciate e apostrofi, questo sarebbe risultato più breve.

Ad esempio, supponiamo di avere Spintax

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

Le .translateesegue alcune conversioni da dare:

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

Perl, 50

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

49personaggi +1per -p.

Funziona impostando prima $_le 5 frasi. Quindi effettua una ricerca globale e sostituisce, dove cerchiamo ogni { | | }gruppo. Divide il gruppo| e seleziona un elemento casuale per la sostituzione.

Corri con:

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'

Struzzo v0.7.0 , 27 caratteri

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

Spiegazione:

{...}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

(nota: la versione 0.7.0 è stata rilasciata dopo la pubblicazione di questa domanda, ma la risposta è ancora valida in quanto tutti i commit che hanno costituito quella versione sono stati tutti inviati prima che questa domanda fosse pubblicata.)

Pip, 25 22 20 byte

In ritardo alla festa, ma ecco il mio. Accetta input come argomento della riga di comando, che potrebbe dover essere citato.

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

Spiegazione:

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 byte (ma non un invio valido)

L5PRC_Ma^`}|{`^'|

Richiede l'ultima versione di Pip, aggiornata dopo la pubblicazione di questa domanda. L'operatore RC (scelta casuale) è stato pianificato per un po 'di tempo, ma non sono mai riuscito a implementarlo fino ad ora. : ^ (

Ulteriori informazioni su Pip

JavaScript ES6, 86 84 byte

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

Questo si aspetta che l'input abbia una nuova riga finale. Inizia ripetendo 5 volte l'input, quindi sostituendo ogni stringa Spintax con una parola casuale da essa ottenuta, che si ottiene suddividendo i |caratteri e quindi scegliendo un numero casuale compreso tra 0 e la lunghezza della matrice risultante meno 1. In questo caso, |0è solo un modo più breve di fareMath.floor . Grazie a vihan1086 per avermi ricordato le stringhe di modelli con tag.

Lo snippet di stack di seguito contiene codice non modificato e facilmente testabile.

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>

Perl, 82 byte

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

Python 2, 139 byte

Aggiunti due byte per le virgolette attorno alla stringa di input. Se questi non sono necessari fammi sapere.

Provalo qui

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

Java, 243 215 242 234 byte

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

Trova le stringhe tra parentesi graffe {}e le sostituisce con un elemento casuale dall'array di stringhe creato dalla divisione per carattere del tubo. (Mi sono reso conto un po 'troppo tardi che dovevano essere stampate cinque frasi: P)

Bash: 144 138 caratteri

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

Esecuzione di esempio:

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!

Javascript, 143 142 byte

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

Python 3, 97 byte

Utilizzo di una funzione lambda nella sostituzione regex. Questo è in qualche modo simile a come l'ho fatto nel mio modulo Spintax https://github.com/AceLewis/spintax, tuttavia non si occupa di Spintax nidificato o di escape dei personaggi.

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

Se non si assume che l'input termina con una nuova riga, saranno 104 byte.

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