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:

Mostrar fragmento de código

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>

Expand snippet

code-golf string restricted-source programador 5000
fuente

3

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

Gato de negocios
fuente

11

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

Mostrar fragmento de código

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?"))

Expandir fragmento

ETHproducciones
fuente

Buen abuso de la lógica JSFuck!

Matthew Roh

9

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")

Matthew Roh
fuente

Usted no capitalizó la P.;)

darrylyeo

@darryleo Se supone que debe ser.

Matthew Roh el

La P en Plz send teh codez!, quiero decir.

darrylyeo 01 de

Oh espera ahora zestá mal. facepalm

Matthew Roh

4

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!

Betseg
fuente

4

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).

Martin Ender
fuente

2

C #, 77 bytes

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

No poder usar dígitos es un dolor.

apk
fuente

2

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.

Anthony Pham
fuente

Puede ahorrar 5 bytes evitando stry eliminando el espacio después de print: repl

math junkie

@math_junkie Eso crea el error de concatenar un entero con una cadena

Anthony Pham

Ver el enlace en mi comentario anterior

adicto a las matemáticas

puede guardar 2 bytes eliminando a = ord y en realidad usando ord ... parece que se está guardando, pero no es así ... Tenía lo mismo: D

officialaimm

Puedes ahorrar dos más con una lambda:lambda n,b=ord('b')-ord('a'):["+"+`b`,`-b`+" flag comment"][n=="Plz send teh codez!"]

adicto a las matemáticas el

2

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

L3viatán
fuente

1

Ahorre 4 bytes con una búsqueda de matriz: TIO

math junkie

1

Ahorre 4 más usando en +lugar de int: TIO

adicto a las matemáticas el

@math_junkie ¡Grandes ideas!

L3viathan

2

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

just_floating
fuente

Puede eliminar varios espacios, al igual que entre if "p", codez!" in, etc.

mbomb007

Asignar str(len('a'))a una variable puede ahorrarle un poco más. Empalmar el número en las cadenas directamente en lugar de llamar strtambién podría ser ventajoso.

Julian Wolf

1

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".

djeis
fuente

1

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.

Maxim Mikhaylov
fuente

1

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?

No un arbol
fuente

1

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.

officialaimm
fuente

1

Bueno, como ya está utilizando p (y se define como mayúsculas y minúsculas), no necesita el.upper()

Anthony Pham

1

Es necesario a la salida +1para la entrada que no contienePlz send teh codez!

drogadicto de matemáticas

Gracias por señalar eso, no estaba al tanto de eso hasta ahora ...: D

officialaimm

0

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

método estático
fuente

0

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!

Sr. Xcoder
fuente

por favor envíe el codez!

Trasfondo

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

¡Pero espera hay mas!

Restricción final

Notas:

Si es muy difícil ...

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

Respuestas:

CJam , 50 49 48 bytes

JavaScript (ES6), 60 bytes

Fragmento de prueba

JS (JSFuck), 37959 bytes

C, 102 bytes

Retina , 56 bytes

C #, 77 bytes

Python 2, 95 94 87 bytes

Python 2/3, 81 76 68 bytes

Python 3, 115 bytes

Lisp común, 81 bytes

sh + sed, 72 bytes

Mathematica, 265 bytes

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.

Groovy, 78 bytes

Swift (no competitivo) - 64 bytes