Escreva um programa que defina uma função que possa verificar se uma variável de cadeia chamada "qualquer coisa que você deseja ou introduziu pelo usuário" é ou não um piem. (piem = uma história ou poema em que os comprimentos das palavras representam os dígitos de π ( da Wikipedia ))

Alguns exemplos:

myfunction("I am clearly wrong") # False
myfunction("How I want a drink, alcoholic of course, after the heavy lectures involving quantum mechanics") #True (Taken from Wikipedia)
myfunction("Law ' s fine") # True

Você deve excluir qualquer tipo de pontuação ou nova linha antes do processamento. Golfe de código puro, as vitórias mais curtas

Data final: noite de 10/01/2014

Várias respostas

• Quantos dígitos precisamos manusear? Mais do que 10
• Por uma questão de interesse, como os 0s no PI devem ser interpretados? Palavras puladas ou com 10 letras? Como 10 letras palavras
• "uma variável chamada piem" - então o nome do parâmetro deve ser piem? Não, o texto da pergunta não foi corrigido
• Um bônus divertido pode ser uma solução que é um piem. Se sua solução é um piem, você recebe * 0,5 de bônus
• Por uma questão de argumento, _ é sempre pontuação? Você pode decidir se é pontuação ou se não é
• Não está claro o que se entende por "qualquer tipo de pontuação", quero dizer,. '"?! ;; ()
• Então os dígitos devem ser contados? E a multa de Law seria falsa? Os dígitos devem ser tratados como letras; a multa de Law = False; Lei é boa = True

Comentários

• A solução APL deve ser contada em bytes
• Se sua solução funcionar com mais de 100 dígitos de pi, você recebe * 0,8 de bônus
• Por causa do grande interesse, a data final é mais um dia no futuro.

APL (39)

{N≡(≢N←≢¨('\w+'⎕S'\0')⍵)↑⍎¨'_. '~⍨99⍕○1}

Ele usa todos os dígitos que a constante pi do intérprete APL fornece, até um limite de 99. No meu caso (Dyalog APL 14 de 32 bits), eram 16 dígitos. A versão de 64 bits provavelmente tem mais dígitos. No entanto, 16 dígitos são suficientes para os exemplos fornecidos.

Seqüências de caracteres com mais do que essa quantidade de palavras falharão , mesmo se todos os dígitos que pudessem verificar fossem verdadeiros. (O mesmo se aplica a outras postagens, até o momento em que este artigo foi escrito.) Por exemplo, se houvesse apenas 10 dígitos, o "Como eu quero beber" falharia. Isso pode ser corrigido, mas ao custo de 14 caracteres:

{(≢¨('\w+'⎕S'\0')⍵){∧/(⌊/≢¨⍺⍵)↑∨⌿⍺∘.=⍵}⍎¨'_. '~⍨99⍕○1}

Essa versão aceita qualquer string em que os primeiros N dígitos estejam corretos.

JavaScript (169) (140) (137) (135) (63) para 17 dígitos de pi

Na minha versão Law's finee Law ' s fineretornar ambos verdadeiro.

Versão mais recente (63) de Ingo Bürk e hsl

f=s=>!s.split(/\W+/).some((x,i)=>x.length-(Math.PI*1e16+'')[i])

Nova versão (135) para 17 dígitos do pi (graças a Ingo Bürk):

f=(s)=>{
s=s.split(/[!"#$%&'()*+, \-.\/:;<=>?@[\\\]^_`{|}~]+/);
p=Math.PI*1e16+'';
    r=0;
    for(a=s.length;a--;)r+=s[a].length!=p[a];
    return !r
}

Versão antiga (169) para 32 dígitos do pi:

f=(s)=>{
s=s.split(/[!"#$%&'()*+, \-.\/:;<=>?@[\\\]^_`{|}~]+/);
p="31415926535897932384626433832795".split('');
    r=1;
    for(a=s.length;a--;)if(s[a].length!=p[a]){r=0};
    return r;
}

Ruby, 113 101 79 (98 * 0,8)

require"bigdecimal/math"
x=->p{!(BigMath.PI(999).to_s[2..-1]!~/^#{p.scan(/\w+/).map(&:size)*''}/)}

Explicação

• A entrada é tomada como argumento para uma lambda. Espera a String.
• Pi é calculado até 999decimais e transformado em uma String com o .removido.
• Os sinais de pontuação são removidos do poema e são divididos em palavras individuais. "Let's"é contado como duas palavras: "Let"e "s".
• Use Array#mappara converter cada palavra no tamanho da palavra, concatená-las em a String.
• Usando um Regexp, verifique se os dois Strings criados começam com os mesmos caracteres.

Eu apliquei o bônus por lidar com mais de 100 dígitos. _não é tratado como pontuação nesta solução.

Mathematica, 123 bytes * 0,8 = 98,4

f=#&@@RealDigits[Pi,10,Length[d=StringLength/@StringSplit@StringReplace[#,RegularExpression@"[!-.:-?]
"->""]/. 10->0]]==d&;

Quase a inscrição mais longa até agora, mas:

• Funciona para qualquer número de dígitos do Pi.
• Ele remove todos os caracteres ASCII necessários e a quebra de linha, sem dividir as palavras nesses locais.
• Ele lida com 0 dígitos no Pi corretamente (como palavras de 10 letras)

Python - 130 127 116 - 17 dígitos de pi

Como em resposta 's @flawr , Law ' s finee Law's finetanto retorno True.

Agradecemos ao @Emil por remover 12 caracteres do programa.

import re
f=lambda x:all(j==int("31415926535897932"[i])for i,j in enumerate([len(s)for s in re.findall("[\w]+",x)]))

Java, 185

boolean f(String...s){s=s[0].replaceAll("\\W","~").replaceAll("~+","~").split("~");for(int i=0;i<s.length;){if(s[i].length()!=(int)(Math.PI*Math.pow(10,i++)%10))return 0>1;}return 1>0;}

python 3, 17 dígitos de pi, 104

import re;f=lambda s:all(map(int.__eq__, map(int, '31415926535897932'), map(len,re.findall('[\w]+',s))))

Python 3-129

Não considera pontuação:

import math
f=lambda p:all(1if len(p.split(' ')[i])!=int(str(math.pi).replace('.','')[i])else 1for i in range(len(p.split(' '))))

T-SQL 488 383

E agora para uma grande solução T-SQL :)

CREATE FUNCTION F(@s VARCHAR(MAX))RETURNS CHAR(6) AS BEGIN DECLARE @ CHAR='T',@p VARCHAR(50)='31415926535897932384626433832795028841971693993751',@i INT=0WHILE @='T'AND @s<>''BEGIN SET @i=PATINDEX('%[^a-z0-9]%',@s)IF @i=0RETURN'#True'IF @i-1<>LEFT(@p,1)RETURN'#False'SET @p=STUFF(@p,1,1,'')SET @s=STUFF(@s,1,@i,'')SET @s=STUFF(@s,1,PATINDEX('%[a-z0-9]%',@s)-1,'')END RETURN'#True'END

Isso cria uma função com valor de tabela embutida que usa um CTE recursivo para detectar limites de palavras.

Cria uma função escalar que percorre o caminho entre as palavras e o PI até 31 decimais (primeiro 0). É chamado da seguinte maneira

SELECT dbo.f('SQL I golf, a large procedure is normal. Hefty not terse') --#True

CJam, 40

"
,.'\"?!;:"{-}/S%{,PAV#*iA%=V):V}/]0#)!

Não está claro o que se entende por "qualquer tipo de pontuação"; Esta solução remove os ,.'"?!;;caracteres.

Ferramentas Bash e Unix, 111

f() { grep ^"$(echo "$@"|grep -Po '[\w]+'|xargs -n1 sh -c 'echo ${#0}'|xargs|tr -d ' ')"<<<31415926535897932; 

NodeJS 32 dígitos 230 bytes

Não consigo diminuí-lo com JS: D

var p = "31415926535897932384626433832795", i = 0;
console.log(process.argv[2].split(/[\s,.]+/).every(function(w) {
    if (parseInt(p.charAt(i)) !== w.length) {
        return false;
    }
    i++;
    return true;
}) ? 'True' : 'False');