Nota para los moderadores y editores : el título de esta publicación es válido y no debe modificarse. La falta de ortografía es intencional y parte del desafío.

Trasfondo

La típica (SO) mala pregunta de SO hace algo parecido a "¡por favor envía el codez!" En otras palabras, le pide a alguien que haga el trabajo para el autor de la pregunta y brinde una solución completa a un problema único. Cito esta pregunta en Meta.SE :

... se trata de una categoría específica de preguntas que consisten en absolutamente ninguna investigación, ningún esfuerzo, y simplemente piden la solución completa a un problema. Este tipo de preguntas generalmente tienden a suponer que Stack Overflow es un servicio de codificación gratuito ...

Entonces, ¿cuál es tu desafío real? Es simple:

Su programa o función, etc. debe tomar la entrada como una cadena (de STDIN, parámetro, etc.) y si la cadena contiene Plz send teh codez!salida -1 flag comment(voto negativo, marcar como fuera de tema y comentar qué tan mala es una pregunta). De lo contrario, la salida +1(Estás votando).

¡Pero espera hay mas!

Su programa no debe contener 5 o más de estos conjuntos de caracteres:

• Todos los caracteres especiales (cualquier cosa que no sea un espacio, una nueva línea ( 0x0a), un alfabeto que no distinga entre mayúsculas y minúsculas o un dígito)
• Cualquier dígito (0-9)
• Cualquiera de pzcm(sin distinción entre mayúsculas y minúsculas)
• Cualquiera de hten(sin distinción entre mayúsculas y minúsculas)
• Cualquiera de qwryuioasdfgjklxvb
• Cualquiera de QWRYUIOASDFGJKLXVB

Para ser claros, solo puedes usar hasta 4 de esos conjuntos de caracteres.

Los espacios, las pestañas y las nuevas líneas no están restringidos de ninguna manera, pero aún se incluyen en su recuento de bytes

Restricción final

Su programa debe contener Unicode SOLAMENTE en el rango de 0x20(espacio) a 0x7e(~), así como 0x0a(línea nueva LF) y 0x09(pestaña). Esto es para excluir los idiomas de golf de código y dar un cambio a los idiomas tradicionales o al menos nivelar el campo de juego.

Notas:

• Este es el código de golf , ¡la respuesta más corta en bytes gana!
• La entrada puede ser de STDIN, un parámetro de función, parámetro de línea de comando, etc., pero no una variable .
• La salida puede ser STDOUT, un valor de retorno de función o incluso un error / excepción. Puede incluir una nueva línea final.
• Se alienta a los idiomas tradicionales a competir porque este desafío prohíbe muchos idiomas de golf al excluir los caracteres Unicode altos. ¡C podría incluso tener una oportunidad de ganar!
• ¿Alguna pregunta? ¡Comenta abajo!

Si es muy difícil ...

Puede ignorar los conjuntos de caracteres en su respuesta, pero luego se vuelve no competitiva.

NOTA: Ahora puede usar hasta 4 juegos de caracteres. De nada.

Puede usar este fragmento para verificar si su código es 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)@

No utiliza dígitos ni el conjunto de letras mayúsculas.

Pruébalo en línea!

Explicación

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':'+'+-~[]

Todo era sencillo, excepto evitar usarlo en 1cualquier lugar. Yo uso ~xpara obtener -1(ya que si xcontienePlz send teh codez! , no es un número válido y, por ~xlo tanto , dará -1), y -~[]para obtener 1(ya que si xes '7', por ejemplo , -~xlo será 8, por lo que no podemos confiar x).

Fragmento de prueba

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

Aquí hay una esencia idea general, ya que PPCG odia los códigos largos.

Solo usa caracteres especiales. :PAGS

Aquí está el 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":"");}

No utiliza ningún dígito ni ninguno de QWERTYUIOASDFGHJKLXVBN. Pruébalo en línea!

Retina , 56 bytes

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

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

Pruébalo en línea!

Utiliza caracteres especiales, los dos conjuntos de letras que no distinguen entre mayúsculas y minúsculas y otras letras minúsculas.

Primero eliminamos toda la entrada si no contiene Plz send teh codez. Si queda alguna entrada, la reemplazamos con -1 flag comment, evitando el dígito con $#+. $+se refiere al último grupo de captura que es $0(toda la coincidencia) porque no hay grupos de captura. $#+luego da el número de capturas, que siempre es 1.

Finalmente, si la cadena aún está vacía (es decir, la borramos en la primera etapa), la reemplazamos con +1(nuevamente usando $#+para 1).

C #, 77 bytes

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

No poder usar dígitos es un dolor.

Python 2, 95 94 87 bytes

Utiliza caracteres especiales y todas las letras minúsculas (más tres conjuntos de caracteres y excepto "p", que no distingue entre mayúsculas y minúsculas) para un total de cuatro conjuntos de caracteres utilizados .

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

Pruébalo en línea! ¡Gracias a @math_junkie por guardar 8 bytes! ¡Gracias a @officialaimm por guardar dos bytes!

a=ord     

Dejar aser la ord()función incorporada.

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

Esto es realmente b=1.

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

Si la declaración en el segundo par de paréntesis es verdadera, imprima la segunda cadena en el primer par de paréntesis. De lo contrario, imprima el primero.

Python 2/3, 81 76 68 bytes

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

Usos:

• Todos los caracteres especiales (cualquier cosa que no sea un espacio, nueva línea (0x0a), mayúsculas y minúsculas o dígitos)
• Cualquiera de pzcm(sin distinción entre mayúsculas y minúsculas)
• Cualquiera de hten(sin distinción entre mayúsculas y minúsculas)
• Cualquiera de qwryuioasdfgjklxvb

No utiliza:

• Cualquiera de QWRYUIOASDFGJKLXVB
• Cualquier dígito (0-9)

-8 bytes gracias 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')))

No usa números ni letras mayúsculas.

Pruébalo en línea

Lisp común, 81 bytes

Especial + minúscula + 2 mayúsculas = 4 charsets

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

Sin golf

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

Explicación

(read-line)

Acepta una línea de entrada de *standard-input*(STDIN, por defecto).

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

Explora el segundo argumento (la línea de lectura) para el índice donde comienza el primer argumento. Devuelve este índice o nil(falso) si no se pudo encontrar.

(*)

La multiplicación en lisp se define para tomar un número arbitrario de argumentos, incluido ninguno, en ese caso siempre devuelve 1.

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

#'formates similar fprintfo sprintfen C. Su primer argumento t, designa la salida como *standard-output*(STDOUT, por defecto). El siguiente argumento es la cadena de formato. "~" se usa como "%" enprintf - los caracteres que lo siguen designan una operación de formateo.

"~:[<a>~;<b>~]"es la operación de formateo condicional. Toma un argumento y continúa con <a>si el argumento fue nil(falso). Cualquier otro valor, como t(verdadero) o un número (por ejemplo), tiene que continuar con <b>. El tercer argumento para formatear (el primero, después ty la cadena de formato) es la búsqueda, por <a>lo que se elegirá si la búsqueda falla (y<b> contrario).

En este caso, la rama <a>( nil/ false) imprime "+ ~ s". "~ s" convierte un argumento de formato en una cadena e imprime sus caracteres. El cuarto argumento para formatear (el segundo, después ty la cadena de formato) es (*)o 1, entonces obtenemos "+1" impreso.

La <b>rama es similar: "- ~ s flag comment". También utiliza el cuarto (segundo) argumento para completar sus "~ s", por lo que imprime "-1 comentario de bandera".

sh + sed, 72 bytes

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

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

Al principio, quería ir con sed puro, pero no tenía idea de cómo evitar el uso de dígitos. Así que usé sh solo por eso. let ""tiene un estado de salida de 1, ya que no se puede evaluar como una expresión aritmética.

z es solo una etiqueta y se puede reemplazar con cualquier otro carácter.

Mathematica, 265 bytes

Esto fue dificil.

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"]&

Versión legible:

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"] &

Utiliza caracteres especiales hten, qwryuioasdfgjklxvby QWRYUIOASDFGJKLXVB. Mathematica sin caracteres especiales sería básicamente imposible, y casi todas las funciones relacionadas con cadenas incluyen Stringen su nombre, por lo que realmente limita la elección aquí ...

Para obtener los otros conjuntos de caracteres, necesitamos algunos trucos. En primer lugar, para obtener 1tomamos el negativo del cuadrado del número imaginario I: i = -I I. Más tarde también definimos 3por e = i+i+i.

La letra Pera bastante sencilla: Mathematica trata a^binternamente como Power[a,b], por lo que todo lo que tenemos que hacer es tomar el encabezado de this ( Power), convertirlo en una cadena y tomar la primera letra (también conocida como ith). (Vamos a cambiar las cosas en cadenas y tomando el n º letra mucho, por lo definimos t[s_,n_]:=ToString@s~StringTake~{n}.) La carta mes similar: tomar la cabeza de a b, que es Times, y obtener la tercera (akae º) carta.

La letra ces un poco más difícil: usamos la identidad trigonométrica 1/Sin[x] == Csc[x](o mejor dicho, i/Sin[x]ya que no podemos usar 1), y tomamos la tercera letra de Csc[x].

La parte realmente difícil es la z. Para hacer un z, usamos la HurwitzZetafunción (sí, realmente). Lo obtenemos resolviendo la relación de recurrencia RSolve[f[a + i] == f@a - i/Sqrt@a, f@a, a], que produce la cadena

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

de los cuales es el 68 ° personaje z. Obtenemos el número 68 como 4^3 + 4.

Esto probablemente podría ser más golfizado: el material de Hurwitz zeta está prácticamente copiado de la documentación de Mathematica, y probablemente haya una forma más corta de obtener 68, o podríamos usar otro método completamente para el z. ¿Alguna sugerencia?

Python 3.5 ( 137 102 98 87 85 94 Bytes)

Utiliza letras minúsculas (3 caracteres) + caracteres especiales (1 juego de caracteres) = 4 caracteres

Casi estaba planeando evitar los espacios en blanco también, pero la sangría en Python me obligó a mantener una nueva línea, así que dejé los espacios en blanco como estaban.

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

Pruébalo en línea!

• ahorré 35 bytes !!!!: aparentemente había olvidado la existencia de la función upper () antes (¡tonto!)
• 4 bytes guardados: reducido i = input () a solo input ()
• guardado 11 bytes !!!: Gracias a Anthony-Pham (usó 'P' ya que es válido en charset)
• 2 bytes guardados: (eliminado a = ord; aprendí que acortar una función no siempre es una buena idea: D)
• 9 bytes agregados: Gracias a math-junkie por señalar que no estaba mostrando +1 para cadenas sin '¡Por favor envíe el codez!' antes de.

Groovy, 78 bytes

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

No utiliza los números o los conjuntos en mayúsculas.

Solo un uso directo del operador ternario. "a".length()es una solución para obtener 1

​

Swift (no competitivo) - 64 bytes

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

Lamentablemente utilicé 5 charsets, no podría hacerlo sin ellos ... ¡Las sugerencias son bienvenidas!