Nota para moderadores e editores : o título desta publicação é válido e não deve ser alterado. O erro de ortografia é intencional e faz parte do desafio.

História de fundo

A típica pergunta SO ruim (estéreo) faz algo como "plz send the codez!" Em outras palavras, ele pede que alguém faça o trabalho para o solicitante e forneça uma solução completa para um problema único. Cito esta pergunta no Meta.SE :

... trata-se de uma categoria específica de perguntas que consistem em absolutamente nenhuma pesquisa, nenhum esforço e simplesmente pedem a solução completa para um problema. Esses tipos de perguntas geralmente tendem a assumir que o Stack Overflow é um serviço de codificação gratuito ...

Então, qual é o seu verdadeiro desafio? É simples:

Seu programa ou função, etc. deve receber a entrada como uma sequência (de STDIN, parâmetro etc.) e se a sequência contiver Plz send teh codez!saída -1 flag comment(voto negativo, sinalizador como fora do tópico e comentar sobre quão ruim é uma pergunta.) +1(você está votando).

Mas espere ... tem mais!

Seu programa não deve conter 5 ou mais desses conjuntos de caracteres:

• Todos os caracteres especiais (qualquer coisa que não seja um espaço, nova linha ( 0x0a), alfabeto que não diferencia maiúsculas de minúsculas ou dígito)
• Qualquer dígito (0-9)
• Qualquer um pzcm(sem distinção entre maiúsculas e minúsculas)
• Qualquer um hten(sem distinção entre maiúsculas e minúsculas)
• Qualquer um qwryuioasdfgjklxvb
• Qualquer um QWRYUIOASDFGJKLXVB

Para ficar claro, você pode usar apenas quatro desses conjuntos de caracteres.

Espaços, guias e novas linhas não são restritos de forma alguma, mas ainda estão incluídos na contagem de bytes

Restrição final

Seu programa deve conter apenas o Unicode no intervalo de 0x20(espaço) a 0x7e(~), bem como 0x0a(nova linha LF) e 0x09(guia). Isso é para excluir idiomas de código de golfe e alterar os idiomas tradicionais ou, pelo menos, nivelar o campo de jogo.

Notas:

• Este é o código-golfe , a resposta mais curta em bytes vence!
• A entrada pode ser de STDIN, um parâmetro de função, parâmetro de linha de comando, etc., mas não uma variável .
• A saída pode ser para STDOUT, um valor de retorno da função ou até mesmo um erro / exceção. Pode incluir uma nova linha à direita.
• Os idiomas tradicionais são incentivados a competir porque esse desafio proíbe muitos idiomas do golfe, excluindo caracteres Unicode altos. C pode até ter uma chance de ganhar!
• Alguma pergunta? Comente abaixo!

Se é muito difícil ...

Você pode ignorar os conjuntos de caracteres em sua resposta, mas eles se tornam não competitivos.

NOTA: Agora você pode usar até 4 conjuntos de caracteres. De nada.

Você pode usar esse trecho para verificar se seu código é válido:

let f = code => {
  let sets = Array(6).fill(false);
  code = code.replace(/\s/g, "");
  code = code.replace(/\d/g, _ => (sets[0] = true, ""));
  code = code.replace(/[pzcm]/gi, _ => (sets[1] = true, ""));
  code = code.replace(/[hten]/gi, _ => (sets[2] = true, ""));
  code = code.replace(/[qwryuioasdfgjklxvb]/g, _ => (sets[3] = true, ""));
  code = code.replace(/[QWRYUIOASDFGJKLXVB]/g, _ => (sets[4] = true, ""));
  if (code) sets[5] = true;
  return sets.reduce((a, b) => a + b, 0);
}

<textarea oninput="var x=f(value);O.innerHTML='You\'re using '+x+' charset'+(x===1?'':'s')+(x>4?', which is too many.':'. Nice job!')"></textarea><br>
<p id=O></p>

CJam , 50 49 48 bytes

q"Plz send teh codez!"#)"- flag comment""+"?(T)@

Não usa dígitos ou letras maiúsculas.

Experimente online!

Explicação

q                       e# Push the input
"Plz send teh codez!"#  e# Find index of "Plz send teh codez!" in the input (-1 if not found)
)                       e# Increment the index
                        e# Check the truthiness of the index:
 "- flag comment"       e#   If truthy (i.e. it appeared in the input), push this string
 "+"                    e#   If falsy (it wasn't in the input), push this string
?                       e# 
(                       e# Uncons from left, removes the first character of the string and 
                        e#  pushes it on the stack
T)                      e# Push 0, and increment it to 1
@                       e# Bring third-from-top stack element to the top
                        e# Implicit output of stack contents

JavaScript (ES6), 60 bytes

x=>/Plz send teh codez!/.test(x)?~x+' flag comment':'+'+-~[]

Tudo foi direto, exceto evitar o uso em 1qualquer lugar. Eu uso ~xpara obter -1(desde que se xcontém Plz send teh codez!, não é um número válido e, portanto ~x, dará -1), e -~[]para obter 1(desde que se xfor '7', por exemplo , -~xserá 8, então não podemos confiar x).

Snippet de teste

let f =
x=>/Plz send teh codez!/.test(x)?~x+' flag comment':'+'+-~[];

console.log(f("Hello, Plz send teh codez!"))
console.log(f("Hello, Plz send teh codez?"))

JS (JSFuck), 37959 bytes

Aqui está uma essência , já que o PPCG odeia códigos longos.

Usa apenas caracteres especiais. : P

Aqui está o código original:

alert(prompt().includes("Plz send teh codez!")?"-1 flag comment":"+1")

C, 102 bytes

i;f(char*s){i=strstr(s,"Plz send teh codez!");printf("%+d%s",i?'a'-'b':'b'-'a',i?" flag comment":"");}

Não usa nenhum dígito ou nenhum dos QWERTYUIOASDFGHJKLXVBN. Experimente online!

Retina , 56 bytes

(?!.*Plz send teh codez).+

.+
-$#+ flag comment
^$
+$#+

Experimente online!

Usa caracteres especiais, os dois conjuntos de letras sem distinção entre maiúsculas e minúsculas e outras letras minúsculas.

Primeiro, removemos toda a entrada se ela não contiver Plz send teh codez. Se houver alguma entrada, substituí-la por -1 flag comment, evitando o dígito por $#+. $+refere-se ao último grupo de captura que é $0(a partida inteira) sind, não há grupos de captura. $#+depois, fornece o número de capturas, o que é sempre 1.

Finalmente, se a string ainda estiver vazia (ou seja, nós a limpamos no primeiro estágio), substituí-la por +1(novamente usando $#+for 1).

C #, 77 bytes

x=>x.Contains("Plz send teh codes!")?$"{'x'-'y'} flag comment":$"+{'x'/'x'}";

Não poder usar dígitos é uma dor.

Python 2, 95 94 87 bytes

Usa caracteres especiais e todas as minúsculas e minúsculas (mais três conjuntos de caracteres e exceto "p", que não diferencia maiúsculas de minúsculas) para um total de quatro conjuntos de caracteres usados .

b=ord('b')-ord('a')
print["+"+`b`,`-b`+" flag comment"][input()=="Plz send teh codez!"]

Experimente online! Obrigado a @math_junkie por salvar 8 bytes! Obrigado a @officialaimm por salvar dois bytes!

a=ord     

Let aSer a ord()função interna.

b=str(a('b')-a('a'))

Isso é mesmo b=1.

print["+"+b, "-"+b+" flag comment"][input()=="Plz send teh codez!"]

Se a instrução no segundo par de colchetes for verdadeira, imprima a segunda sequência no primeiro par de colchetes. Caso contrário, imprima o primeiro.

Python 2/3, 81 76 68 bytes

lambda x:["+%s","-%s flag comment"]["Plz send teh codez!"in x]%+True

Usos:

• Todos os caracteres especiais (qualquer coisa que não seja um espaço, nova linha (0x0a), alfabeto que não diferencia maiúsculas de minúsculas ou dígito)
• Qualquer um pzcm(sem distinção entre maiúsculas e minúsculas)
• Qualquer um hten(sem distinção entre maiúsculas e minúsculas)
• Qualquer um qwryuioasdfgjklxvb

Não usa:

• Qualquer um QWRYUIOASDFGJKLXVB
• Qualquer dígito (0-9)

-8 bytes graças a math_junkie

Python 3, 115 bytes

if"p".upper()+"lz send teh codez!"in input():print("-"+str(len('a'))+" flag comment")
else:print("+"+str(len('a')))

Não usa números ou letras maiúsculas.

Experimente online

Lisp comum, 81 bytes

Especial + letras minúsculas + 2 letras maiúsculas = 4 conjuntos de caracteres

(format t"~:[+~s~;-~s flag comment~]"(search"Plz send teh codez!"(read-line))(*))

Ungolfed

(format t "~:[+~s~;-~s flag comment~]"
        (search "Plz send teh codez!" (read-line))
        (*))

Explicação

(read-line)

Aceita uma linha de entrada de *standard-input*(STDIN, por padrão).

(search "Plz send teh codez!" ...)

Procura no segundo argumento (a linha de leitura) o índice onde o primeiro argumento começa. Retorna esse índice ou nil(false) se não puder ser encontrado.

(*)

A multiplicação no lisp é definida para receber um número arbitrário de argumentos, incluindo nenhum - nesse caso, ele sempre retorna 1.

(format t "~:[+~s~;-~s flag comment~]" ...)

#'formaté semelhante a fprintfou sprintfem C. Seu primeiro argumento t, designa a saída como *standard-output*(STDOUT, por padrão). O próximo argumento é a string de formato. "~" é usado como "%" no printf(s) caractere (s) a seguir designa uma operação de formatação.

"~:[<a>~;<b>~]"é a operação de formatação condicional. É necessário um argumento e continua com <a>se o argumento foi nil(falso). Qualquer outro valor, como t(true) ou um número (por exemplo), continua com ele <b>. O terceiro argumento a ser formatado (o primeiro, o depois te a string de formato) é a pesquisa, portanto <a>será escolhido se a pesquisa falhar (ou <b>não).

Nesse caso, a ramificação <a>( nil/ false) imprime "+ ~ s". "~ s" converte um argumento de formato em uma string e imprime seus caracteres. O quarto argumento para formatar (o segundo, o depois te a sequência de formatação) é (*)1 ou, portanto, obtemos "+1" impresso.

O <b>ramo é semelhante: "- ~ s comentário da bandeira". Ele também usa o quarto (segundo) argumento para preencher seus "~ s", para que ele imprima "-1 flag comment".

sh + sed, 72 bytes

Usa conjuntos de caracteres: 1, 3, 4, 5.

let ""
sed "s/.*Plz send teh codez!.*/-$? flag comment/
tz
s/.*/+$?/
:z"

No começo, eu queria usar o puro sed, mas não tinha ideia de como evitar o uso de dígitos. Então eu usei sh apenas para isso. let ""tem um status de saída de 1, pois não pode ser avaliado como uma expressão aritmética.

z é apenas um rótulo e pode ser substituído por qualquer outro caractere.

Mathematica, 265 bytes

Isso foi difícil.

t[s_,n_]:=ToString@s~StringTake~{n};If[StringFreeQ[#,t[Head[a^b],i=-I I]<>"l"<>(s=t[RSolve[f[a+i]==f@a-i/Sqrt@a,f@a,a],(i+i+i+i)^(e=i+i+i)+i+e])<>" send teh "<>(k=t[i/Sin@x,e])<>"ode"<>s<>"!"],"+"<>t[i,i],"-"<>t[i,i]<>" flag "<>k<>"o"<>(n=Head[a b]~t~e)<>n<>"ent"]&

Versão legível:

t[s_, n_] := ToString@s~StringTake~{n}; 
If[StringFreeQ[#, 
   t[Head[a^b], i = -I I] <> 
    "l" <> (s = 
      t[RSolve[f[a + i] == f@a - i/Sqrt@a, f@a, 
        a], (i + i + i + i)^(e = i + i + i) + i + e]) <> 
    " send teh " <> (k = t[i/Sin@x, e]) <> "ode" <> s <> "!"], 
  "+" <> t[i, i], 
  "-" <> t[i, i] <> " flag " <> k <> "o" <> (n = Head[a b]~t~e) <> n <>
    "ent"] &

Usa caracteres especiais, hten, qwryuioasdfgjklxvbe QWRYUIOASDFGJKLXVB. O Mathematica sem caracteres especiais seria basicamente impossível, e quase todas as funções relacionadas a strings incluem Stringem seus nomes, o que realmente limita a escolha aqui…

Para obter os outros conjuntos de caracteres, precisamos de alguns truques. Em primeiro lugar, para obter 1tomamos o negativo do quadrado do número imaginário I: i = -I I. Mais tarde, também definimos 3por e = i+i+i.

A carta Pera bastante direta: o Mathematica trata a^binternamente como Power[a,b], então tudo o que precisamos fazer é pegar o cabeçalho disso ( Power), transformá-lo em uma string e pegar a primeira (aka ith) letra. (Nós vamos estar virando as coisas em cordas e tomando o n º carta muito, então nós definimos t[s_,n_]:=ToString@s~StringTake~{n}.) A carta mé semelhante: tirar a cabeça do a bque é Times, e obter o terceiro (aka eth) carta.

A letra cé um pouco mais difícil: usamos a identidade trigonométrica 1/Sin[x] == Csc[x](ou melhor, i/Sin[x]uma vez que não podemos usar 1) e usamos a terceira letra de Csc[x].

A parte mais difícil é a z. Para fazer um z, usamos a HurwitzZetafunção (sim, realmente). Nós conseguimos isso resolvendo a relação de recorrência RSolve[f[a + i] == f@a - i/Sqrt@a, f@a, a], que produz a string

"                             1            1
 {{f[a] -> C[1] + HurwitzZeta[-, a] - Zeta[-]}}
                              2            2"

dos quais o 68º caractere é z. Temos o número 68 como 4^3 + 4.

Provavelmente isso poderia ser ainda mais complicado: o material zeta de Hurwitz é praticamente copiado da documentação do Mathematica, e provavelmente existe uma maneira mais curta de obter 68 - ou podemos usar outro método inteiramente para o z. Alguma sugestão?

Python 3.5 ( 137 102 98 87 85 94 Bytes)

Usa letras minúsculas (3 conjuntos de caracteres) + caracteres especiais (1 conjunto de caracteres) = 4 conjuntos de caracteres

Eu estava quase planejando evitar espaços em branco também, mas o recuo em python me forçou a manter uma nova linha, então deixei os espaços em branco como estavam.

i=str(ord('b')-ord('a'))
print(['+'+i,'-'+i+' flag comment']['Plz send teh codez!'in input()])

Experimente online!

• salvei 35 bytes !!!!: aparentemente eu tinha esquecido a existência da função upper () antes (bobo me !!)
• salvou 4 bytes: reduzido i = input () para apenas input ()
• salvou 11 bytes !!!: Graças a Anthony-Pham (usado 'P', pois é válido em charset)
• salvou 2 bytes: (removido a = ord; aprendeu que encurtar uma função nem sempre é uma boa ideia!: D)
• adicionou 9 bytes: Obrigado ao math-junkie por apontar que eu não estava exibindo +1 para strings sem 'Plz send the the codez!' antes.

Groovy, 78 bytes

{a="a".length();it.contains("Plz send teh codez!")?-a+" flag comment":"+"+a}

Não usa os números ou os conjuntos em maiúsculas.

Apenas um uso direto do operador ternário. "a".length()é uma solução alternativa para obter 1

O que outras pessoas estão dizendo

Swift (não competitivo) - 64 bytes

print(x.contains("Plz send teh codez!") ?"-1 flag comment":"+1")

Infelizmente usei 5 conjuntos de caracteres, não poderia fazê-lo sem eles ... Sugestões são bem-vindas!