Article Filature avec Spintax

La rotation d'articles est une technique d'optimisation de moteur de recherche par laquelle les optimiseurs de moteur de recherche publient une version unique de contenu pertinent sur des répertoires d'articles, des sites Web 2.0 ou d'autres sources de backlinks.

Il est parfois utilisé par les auteurs de sites Web sur leurs propres sites, mais généralement évité car la qualité du contenu filé sera inférieure à celle du contenu manuscrit. La rotation fonctionne en réécrivant des articles existants, ou des parties d'articles, et en remplaçant des mots, des phrases, des phrases ou même des paragraphes entiers par un nombre illimité de versions alternatives pour fournir une variation légèrement différente à chaque rotation.

Ce processus peut être complètement automatisé ou réécrit manuellement. Votre travail aujourd'hui consistera à créer un programme ou une fonction qui interprète une chaîne contenant Spintax , la syntaxe par laquelle un programme lirait les différentes options disponibles. Voici un exemple de chaîne qui utilise Spintax:

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

Comme vous pouvez le voir, les sections de la chaîne qui doivent être «filées» sont placées entre accolades, où les options individuelles sont divisées par le |caractère. Voici quelques exemples de phrases que cela pourrait produire.

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!

Votre travail

Votre mission, si vous l'acceptez, est de créer un programme ou une fonction qui prend une chaîne d'entrée qui peut ou non contenir Spintax , puis d'imprimer 5 versions de la chaîne, en sélectionnant au hasard l' un des choix de chaque bloc d'options. Vous pouvez faire quelques hypothèses:

1. Vous n'aurez pas besoin de gérer Spintax imbriqué ( {This|is {an|one}|example}).
2. Les caractères |, {et }n'apparaîtront nulle part ailleurs que dans un bloc Spintax.
3. Vous n'avez pas besoin de vérifier si les 5 phrases de sortie sont distinctes, tant que le code sélectionne des options à l'aide de la fonction de nombre aléatoire de votre langue.
4. Vous pouvez supposer que l'entrée se termine par une nouvelle ligne.

Règles

1. Pas de failles standard.

Les tests

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 quatrième test peut être trouvé ici.

Il s'agit de code-golf , donc le plus petit nombre d'octets gagne.

Pyth, 18

V5sOMcR\|scR\{cz\}

Essayez-le en ligne ici

Explication:

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

Rubis, 46

Avec l'indicateur de ligne de commande -p, exécutez

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

Lire dans une chaîne avec une nouvelle ligne de fin. Concatène-le à lui-même 5 fois, mute-le en place et produit le résultat. /{(.+?)}/est une expression régulière avec un quantificateur paresseux: sans le ?, il correspondrait à l'extrême gauche {à l'extrême droite }au lieu du plus proche. $1est une variable magique faisant référence au premier groupe de capture de chaque correspondance, tandis que le ?|littéral fait référence au |personnage. sampleest une méthode de tableau renvoyant un élément aléatoire.

CJam, 25 22 19 18 octets

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

Ce code nécessite que l'entrée contienne une nouvelle ligne de fin.

Essayez-le en ligne dans l' interpréteur CJam .

Comment ça fonctionne

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#

À chaque itération, deux morceaux (une constante, une variable) sont laissés sur la pile et seront imprimés à la fin du programme.

Python 3, 110 octets

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

Regex se dédoublant, comme les autres.

Python 3, 121 116 114 114 octets

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

Celui-ci effectue les remplacements appropriés puis l'évalue. Si ce n'était pas pour échapper aux barres obliques inverses et aux apostrophes, cela aurait été plus court.

Par exemple, supposons que nous ayons le Spintax

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

Le .translateeffectue quelques conversions pour donner:

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

Perl, 50

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

49caractères +1pour -p.

Cela fonctionne en définissant d'abord $_les 5 phrases. Ensuite, il fait une recherche globale et remplace, où nous recherchons pour chaque{ | | } groupe. Il divise le groupe |et sélectionne un élément aléatoire pour le remplacement.

Courir avec:

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'

Autruche v0.7.0 , 27 caractères

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

Explication:

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

(Remarque: la version 0.7.0 a été effectuée après la publication de cette question, mais la réponse est toujours valable car tous les commits qui ont constitué cette version ont tous été poussés avant la publication de cette question.)

Pip, 25 22 20 octets

Tard à la fête, mais voici le mien. Prend l'entrée comme argument de ligne de commande, qui peut devoir être cité.

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

Explication:

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 octets (mais pas une soumission valide)

L5PRC_Ma^`}|{`^'|

Nécessite la dernière version de Pip, mise à jour après la publication de cette question. L'opérateur RC (choix aléatoire) était prévu depuis un certain temps, mais je n'ai jamais réussi à l'implémenter jusqu'à présent. : ^ (

En savoir plus sur Pip

JavaScript ES6, 86 84 octets

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

Cela s'attend à ce que l'entrée ait une nouvelle ligne de fin. Il commence par répéter l'entrée 5 fois, puis en remplaçant chaque chaîne Spintax par un mot aléatoire, obtenu en divisant les |caractères puis en choisissant un nombre aléatoire entre 0 et la longueur du tableau résultant moins 1. Dans ce cas, |0est juste une façon plus courte de faire Math.floor. Merci à vihan1086 de m'avoir rappelé les chaînes de modèle balisées.

L'extrait de pile ci-dessous contient du code non golfé et facilement testable.

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 octets

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

Python 2, 139 octets

Ajout de deux octets pour les guillemets autour de la chaîne d'entrée. Si ceux-ci ne sont pas nécessaires, faites-le moi savoir.

Essayez-le ici

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 octets

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

Recherche les chaînes entre accolades {}et les remplace par un élément aléatoire à partir du tableau de chaînes créé par la division par le caractère de tuyau. (J'ai réalisé un peu trop tard qu'il fallait imprimer cinq phrases: P)

Bash: 144 138 caractères

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

Exemple d'exécution:

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 octets

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 octets

Utilisation d'une fonction lambda dans la substitution d'expression régulière. Ceci est quelque peu similaire à la façon dont je l'ai fait dans mon module Spintax https://github.com/AceLewis/spintax mais il ne traite pas de Spintax imbriqué ni d'échapper aux personnages.

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

Si vous ne supposez pas que l'entrée se termine par une nouvelle ligne, elle sera de 104 octets.

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