Artigo Girando com Spintax

A rotação de artigos é uma técnica de otimização de mecanismo de pesquisa pela qual os otimizadores de mecanismo de postagem publicam uma versão exclusiva de conteúdo relevante nos diretórios do artigo, sites da Web 2.0 ou outras fontes de backlinks.

Ocasionalmente, é usado pelos autores do site em seus próprios sites, mas geralmente é evitado porque a qualidade do conteúdo gerado será menor do que o conteúdo escrito à mão. A rotação funciona reescrevendo artigos existentes, ou partes de artigos, e substituindo palavras, frases, sentenças ou até parágrafos inteiros por qualquer número de versões alternativas para fornecer uma variação ligeiramente diferente a cada rotação.

Esse processo pode ser completamente automatizado ou reescrito manualmente. Seu trabalho hoje será criar um programa ou função que interprete uma string contendo Spintax , a sintaxe pela qual um programa leria as diferentes opções disponíveis. Abaixo está um exemplo de string que usa Spintax:

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

Como você pode ver, as seções da string que devem ser 'giradas' são colocadas entre chaves, onde as opções individuais são divididas pelo |caractere. Aqui estão alguns exemplos de frases que isso poderia produzir.

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!

Seu emprego

Sua missão, se você optar por aceitá-la, é criar um programa ou função que utilize uma string de entrada que possa ou não conter Spintax e imprima 5 versões da string, selecionando aleatoriamente uma das opções de cada bloco de opções. Você pode fazer algumas suposições:

1. Você não precisará lidar com Spintax ( {This|is {an|one}|example}) aninhado .
2. Os caracteres |, {e }não ocorrerão em nenhum outro lugar que não seja dentro de um bloco Spintax.
3. Você não precisa verificar se as 5 frases de saída são distintas, desde que o código selecione opções usando a função de número aleatório do seu idioma.
4. Você pode assumir que a entrada termina com uma nova linha.

Regras

1. Sem brechas padrão.

Testes

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#

Um quarto teste pode ser encontrado aqui.

Isso é código-golfe , e o menor número de bytes vence.

Pyth, 18

V5sOMcR\|scR\{cz\}

Experimente online aqui

Explicação:

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

Com sinalizador de linha de comando -p, execute

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

Leia em uma string com uma nova linha à direita. Concatene para si mesmo 5 vezes, modifique-o no lugar e produza o resultado. /{(.+?)}/é uma expressão regular com um quantificador lento: sem o ?, ele corresponderia da esquerda {para a direita em }vez do mais próximo.$1é uma variável mágica que se refere ao primeiro grupo de capturas em cada partida, enquanto o ?|literal se refere ao |personagem. sampleé um método de matriz que retorna um elemento aleatório.

CJam, 25 22 19 18 bytes

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

Este código requer que a entrada contenha uma nova linha à direita.

Experimente online no intérprete CJam .

Como funciona

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#

Em cada iteração, dois blocos (uma constante, uma variável) são deixados na pilha e serão impressos quando o programa sair.

Python 3, 110 bytes

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

Regex dividindo, como os outros.

Python 3, 121 116 114 bytes

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

Este realiza as substituições apropriadas e depois avalia. Se não fosse por escapar de barras invertidas e apóstrofes, isso seria mais curto.

Por exemplo, suponha que tenhamos o Spintax

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

Ele .translaterealiza algumas conversões para fornecer:

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

Perl, 50

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

49caracteres +1para -p.

Funciona definindo primeiro $_as 5 frases. Em seguida, ele faz uma pesquisa global e substitui, onde pesquisamos cada { | | }grupo. Ele divide o grupo |e escolhe um elemento aleatório para a substituição.

Correr com:

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'

Avestruz v0.7.0 , 27 caracteres

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

Explicação:

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

(observação: a versão 0.7.0 foi feita depois que esta pergunta foi publicada, mas a resposta ainda é válida, pois todos os commits que compunham essa versão foram enviados antes que essas perguntas fossem publicadas.

Pip, 25 22 20 bytes

Tarde da festa, mas aqui está o meu. Recebe a entrada como um argumento da linha de comando, que pode precisar ser citado.

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

Explicação:

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 bytes (mas não um envio válido)

L5PRC_Ma^`}|{`^'|

Requer a versão mais recente do Pip, atualizada após a publicação desta pergunta. O operador RC (escolha aleatória) foi planejado há algum tempo, mas eu nunca tive a chance de implementá-lo até agora. : ^ (

Saiba mais sobre o Pip

JavaScript ES6, 86 84 bytes

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

Isso espera que a entrada tenha uma nova linha à direita. Ele começa repetindo a entrada 5 vezes e, em seguida, substituindo cada string Spintax por uma palavra aleatória, que é obtida dividindo os |caracteres e escolhendo um número aleatório entre 0 e o comprimento da matriz resultante menos 1. Nesse caso, |0é apenas uma maneira mais curta de fazer Math.floor. Obrigado a vihan1086 por me lembrar sobre as strings de modelo com tags.

O snippet de pilha abaixo contém código não testado e facilmente testável.

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 bytes

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

Python 2, 139 bytes

Adicionado dois bytes para aspas em torno da string de entrada. Se estes não forem necessários, informe-me.

Experimente aqui

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 bytes

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

Localiza cadeias dentro de chaves {}e as substitui por um elemento aleatório da matriz de cadeias criada pela divisão pelo caractere de barra vertical. (Percebi um pouco tarde demais que cinco frases tinham que ser impressas: P)

Bash: 144 138 caracteres

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

Exemplo de execução:

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 bytes

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 bytes

Usando uma função lambda na substituição de regex. Isso é um pouco parecido com o que fiz no meu módulo Spintax https://github.com/AceLewis/spintax, no entanto, ele não lida com Spintax aninhado ou com escape dos caracteres.

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

Se você não assumir que a entrada termina com uma nova linha, serão 104 bytes.

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