¿La casilla de verificación no está desmarcada?

65

Al revisar el código, me topé con el siguiente código, que prueba el estado de una casilla de verificación:

if (!isNotUnchecked()) { ... }

Tuve que hacer una lluvia de ideas durante 30 minutos para averiguar qué estado de casilla de verificación real esperaba el código. ¡Por favor escríbeme un programa que pueda simplificar estas expresiones tontas!

El programa debe aceptar como entrada una cadena que representa la expresión para simplificar (por ejemplo:) !isNotUnchecked(). El programa debería generar una expresión simplificada lógicamente equivalente, ya sea isChecked()o !isChecked().

El nombre del método en la expresión de entrada siempre comienza con is, contiene 0..n Not, y termina con Checked()o Unchecked(). El método puede tener como prefijo cualquier número de !.

Ejemplos

isChecked() => isChecked()
isUnchecked() => !isChecked()
isNotChecked() => !isChecked()
!isNotChecked() => isChecked()
!!!isNotNotUnchecked() => isChecked()
code-golf 
— Arnaud
fuente
¿El texto siempre distingue entre mayúsculas y minúsculas? ¿Sería la entrada notunischecked?
— stevefestl
1
@SteveFest No, puede asumir que la entrada siempre está en el formato que he descrito anteriormente. No necesita manejar, isnotuncheckedpor ejemplo.
— Arnaud
66
Con un nombre de función como ese, le daría una probabilidad de 10 a 1 de que ni siquiera probara la condición verificada de acuerdo con su nombre.
— Caleb
2
En otras palabras, usted sabe qué es una casilla sin marcar, sabe qué es una casilla sin marcar (está marcada, si y solo si "marcado" y "no marcado" son los dos únicos estados posibles, de lo contrario podría ser cualquier cosa en la casilla de verificación: int, sign ...) y para esta casilla de verificación específica, no está (no está "marcada", ya sea con una marca de verificación o algo así). Si es cierto, entonces, está seguro de que la casilla de verificación no está "marcada" por nada. Si es falso, bueno, usted sabe que la casilla de verificación es una casilla no desmarcada, pero no necesariamente significa que esté marcada a menos que solo haya dos estados posibles (entonces está marcada).
— J Doe
1
@J Doe gracias por la aclaración!
— Arnaud

Respuestas:

31

Python , 51 bytes

lambda s:sum(map(s.count,'!NU'))%2*'!'+'isC'+s[-8:]

Pruébalo en línea!

— xnor
fuente
Eres un genio puro! Nunca habría pensado en éls[-8:]
— Sr. Xcoder
Seguramente 'isC'+s[-8:]es un byte más largo que 'isChecked'?
— Neil
99
pero 1 byte más corto que 'isChecked ()'
— Andrew Smith
¿Alguien puede explicar qué s[-8:]es / qué hace?
— ESR
1
@EdmundReed Toma los últimos 8 caracteres de la entrada, que son siempre hecked().
— xnor
24

Retina , 23 bytes

Unc
!C
Not
!
O`is|!
!!

Pruébalo en línea!

Explicación

Unc
!C

Conviértete Uncheckeden !Checked.

Not
!

Convierte todos los Nots en !. Ahora tenemos algo así !!!is!!!!Checked().

O`is|!

Ordenar todos los partidos de cualquiera iso !. Desde entonces ! < is, esto mueve todo !al principio de la cadena, por lo que el ejemplo anterior se convertiría !!!!!!!isChecked().

!!

Eliminar pares de !para cancelar la negación repetida.

— Martin Ender
fuente
13

Python , 43 bytes

lambda s:sum(map(ord,s))%2*'!'+'isC'+s[-8:]

Una función sin nombre que toma la cadena sy devuelve una cadena.

Pruébalo en línea!

No hay necesidad de comprobar la existencia de caracteres cuando !, Noty Untodos tienen exactamente un ordinal impar (y cy Cson ambos impares), por lo que sólo resumir los ordinales y utilizar el valor del módulo 2 para decidir si queremos una !o no.

Aparte de eso, la forma es la misma que la respuesta de xnor , ya que no encontré nada mejor. El siguiente también es 43:

lambda s:'!isC'[~sum(map(ord,s))%2:]+s[-8:]
— Jonathan Allan
fuente
10

JavaScript (ES6), 51 50 bytes

f=
s=>(s.split(/!|n/i).length%2?'':'!')+'isChecked()'
<input oninput=o.textContent=f(this.value)><pre id=o>
Expandir fragmento

Funciona mediante la búsqueda de !, Ny npersonajes, que invierten el estado de activación. splitdevuelve una longitud de matriz impar de manera predeterminada, por lo que agregamos !cuando la splitlongitud es par. Editar: guardado 1 byte gracias a @ETHproductions. Versión alternativa, también para 50 bytes:

s=>`${s.split(/!|n/i).length%2?``:`!`}isChecked()`
— Neil
fuente
Huh, ahora vuelvo y miro las otras respuestas, todos están haciendo esto.
— Neil
Debería poder soltar el indicador global de RegEx para guardar un byte.
— Shaggy
@Shaggy En realidad mi longitud es correcta, simplemente no pude eliminar gla última edición.
— Neil
1
Creo que puede guardar un byte con/!|N/i
— ETHproductions
@ETHproductions Creo que querías decir /!|N/sin el imodificador
— SplittyDev
7

Java 7, 100 77 bytes

String c(String s){return(s.split("[!NU]").length%2<1?"!":"")+"isChecked()";}

Expansión:

String c(String s){  // Method with String parameter and String return-type
  return(s.split("[!NU]").length
                     //  Count the amount of '!', 'N' and 'U' in the input String (+ 1)
    %2<1?            //  and if they are an even number:
     "!"             //   Start with an examination mark
    :                //  Else:
     "")             //   Start with nothing
    +"isChecked()";  //  And append "isChecked()" to that
}                    // End of method

Código de prueba:

Pruébalo aquí.

class M{
  static String c(String s){return(s.split("[!NU]").length%2<1?"!":"")+"isChecked()";}

  public static void main(String[] a){
    System.out.println(c("isChecked()"));
    System.out.println(c("isUnchecked()"));
    System.out.println(c("isNotChecked()"));
    System.out.println(c("!isNotChecked()"));
    System.out.println(c("!!!isNotNotUnchecked()"));
  }
}

Salida:

isChecked()
!isChecked()
!isChecked()
isChecked()
isChecked()
— Kevin Cruijssen
fuente
7

Aceto , 49 bytes

&M"pp"
L!)(de
&c;`Che"
`!d!sick
!',@p"!'
'N'U`!Lu

yadda yadda Hilbert curva.

En primer lugar, empujamos los tres personajes importantes en la pila: 

!'
'N'U

Luego establecemos una marca y comenzamos leyendo un solo carácter. Lo dduplicamos y lo negamos, y si el resultado de esto es verdadero (por lo tanto, si la cadena estaba vacía; así que la entrada terminó), saltamos al final:

;`
d!
,@

Con la copia restante del carácter de entrada, verificamos si está contenido en el resto de la pila (es decir, si es uno de!, N, U). Si no es así, generamos un error, devolviéndonos a nuestra marca de captura donde leemos otro personaje:

&c
`!

De lo contrario, cargamos lo que está en el almacenamiento rápido (esencialmente un registro que inicialmente es una cadena vacía; falso), lo negamos y lo enviamos de vuelta al almacenamiento rápido, luego también generamos el error (volviendo a leer los caracteres):

&M
L!

Cuando la entrada se detuvo, somos enviados al final. Allí, invertimos la dirección, empujamos un signo de exclamación y cargamos el almacenamiento rápido y lo negamos. Si eso es verdad (es decir, hemos tenido un número impar de cosas de negación), imprimimos el signo de exclamación que hemos empujado:

p !'
`!Lu

Finalmente, empujamos la cadena en dos partes e las imprimimos (por razones de ahorro de espacio):

"pp"
)(de
  Che"
  sick
   "

Después, el programa todavía se ejecuta de nuevo al principio original, pero dado que ninguno de los comandos genera nada o tiene un comportamiento en bucle, eso no importa. En realidad, el primer comando sin nopping que alcanzamos genera una excepción, omitiendo la mayoría del código porque saltamos a la marca de captura, lo que significa que todo lo que Aceto ve en esa parte es:

&



!' @
'N'U

Puesto que Uahora no está precedido por un carácter de comilla simple y por lo tanto no se ve como un carácter literal, se interpreta como un comando: Uinvierte todos los elementos en la pila (ahora es !, N, U, desde la parte superior), y 'Ne '!impulsar más caracteres, lo que significa que terminamos con la pila [U, N, !, N, !].

Nota al margen: este es el primer programa de Aceto escrito (en parte) con la ayuda del nuevo editor de Aceto .

— L3viatán
fuente
6

C, 78 70 68 Bytes

Gracias Christoph!

c;f(char*s){for(c=1;*s;)c^=!!strchr("!NU",*s++);s="!isChecked()"+c;}

Pruébalo en línea

Salida:

isChecked() => isChecked()
isUnchecked() => !isChecked()
isNotChecked() => !isChecked()
!isNotChecked() => isChecked()
!!!isNotNotUnchecked() => isChecked()
— Johan du Toit
fuente
1
c;f(char*s){for(c=1;*s;)c^=!!strchr("!NU",*s++);s="!isChecked()"+c;}El uso de xor para voltear cahorra 2 bytes.
— Christoph
6

Perl 5 , 31 bytes

-2 bytes gracias a @Dom Hastings .

30 bytes de código + -pbandera.

/c/i;$_="!"x(y/UN!//%2).isC.$'

Pruébalo en línea!

y/UN!//cuenta el número de veces que aparece Un, Noty !. El resultado es que muchos !módulo 2, seguido de isChecked().

Otro intento, basado en expresiones regulares, para 38 bytes (Dom Hastings guardó 1 byte en ese):

s/isNot|isUn(c)/!is\u$1/?redo:s/!!//g

Pruébalo en línea!

— Dada
fuente
Su versión de expresiones regulares no funciona porque hay dos cs Unchecked.
— Neil
1
@Neil the regex solo reemplaza al primero (ya que no estoy usando /gflag). Los casos de prueba me parecen buenos (vea el enlace TryItOnline). Así que realmente no entiendo lo que quieres decir ...
— Dada
Lo sentimos, la razón correcta de expresiones regulares que su versión no funciona es que aunque hay una cen la Uncheckedque también es uno de Checked, por lo que cuando subsitute que se termina con CheCked.
— Neil
1
¡Hey, espero que estés bien! No he estado aquí en mucho tiempo, pero he jugado un poco con estos durante -2 en el primero y -1 en el segundo
— Dom Hastings
1
@DomHastings ¡Hola! Impresionante, muchas gracias! Feliz de verte de nuevo :-)
— Dada
6

Scala , 39 30 bytes

s=>"!"*(s.sum%2)+"isChecked()"

Pruébalo en línea!

Lamentablemente no pude deducir el tipo de s.

Editar: moví la declaración de tipo al encabezado (creo que esto está permitido, si no, lo volveré a poner).

— musicman523
fuente
3

Japt , 24 23 bytes

o"!N" l u)ç'! +`‰C”×B()

Explicación

 o"!N" l u)ç'! +`‰C”×B()
Uo"!N" l u)ç'! +`‰C”×B()`
Uo"!N"                     # Only keep "!", "n" and "N" from the input
           ç'!             # Repeat the string "!" by
       l u)                # the parity of the length of the newly formed string
               +`‰C”×B()` # and concatenate with the string "isChecked()"

Pruébalo en línea!

— Luke
fuente
1
Espera ... ¿Cómo ... ¿Por qué ... Es oinsensible a mayúsculas y minúsculas? No sabía que ...
— ETHproductions
Yo tampoco lo sabía, pero lo descubrí cuando probé con "! NU". La "n" minúscula en "Sin marcar" también permaneció, por lo que pude soltar la "U"
— :)
3

PHP (5.5 - 5.6), 52 50 49 Bytes

<?='!'[count(spliti('!|N',$argn))%2]?>isChecked()

Probarlo aquí .

-2 Bytes by @Titus. Ty :)
-1 Byte  by @ETHproductions. Ty :)

PHP (> = 5.5), 66 65 61

for($b=b;$a=$argn[$i++];)$b^=$a;echo$b&"!"|" ","isChecked()";

Sin expresiones regulares se vuelve un poco más complejo :) Pruébelo aquí .

-4 Bytes by @Titus. Ty :)
— Christoph
fuente
1
error_reportingvalor por defecto es E_ALL&~E_NOTICE&~E_STRICT&~E_DEPRECATED.
— Tito
1
@Titus venciendo a JS en un desafío regex yay!
— Christoph
$b^=$aMuy buen hallazgo! También puede hacerlo sin las etiquetas PHP del mismo tamaño.
— Tito
1
61 bytes si se permite el espacio en blanco inicial:for($b=b;$a=$argn[$i++];)$b^=$a;echo$b&"!"|" ","isChecked()";
— Titus
@Titus Tengo que admitir que se inspiró en esta respuesta .
— Christoph
3

Jalea ,  16  15 bytes

OSḂ⁾!iṫ⁾sCø³ṫ-7

Un programa completo que toma la cadena como argumento de línea de comando e imprime el resultado.

Pruébalo en línea!

OSḂ⁾!iṫ-7³ṫṭ⁾sCo OSḂ⁾!iṫ-7³ṫ⁾sC;ambos también funcionarían para 15.

¿Cómo?

Utiliza la misma idea que mi respuesta de Python , pero guarda bytes utilizando una construcción diferente de !isCo isCalguna impresión implícita en Jelly ...

OSḂ⁾!iṫ⁾sCø³ṫ-7 - Main link: s
O               - cast to ordinals
 S              - sum
  Ḃ             - mod 2
   ⁾!i          - literal ['!','i']
      ṫ         - tail -> ['i'] if OSḂ was 0; ['!','i'] if OSḂ was 1
                - this is printed due to the following starting a new leading
                - constant chain. Printing smashes so either "i" or "!i" is printed.
       ⁾sC      - literal ['s','C']
                - this is printed (as "sC") due to the following niladic chain.
          ø     - start a new niladic chain
           ³    - program's first input (3rd command line argument), s
            ṫ-7 - tail from index -7 = ['h','e','c','k','e','d','(',')']
                - implicit print (of "hecked()")

anterior @ 16 bytes 9 (usando concatenación y emparejamiento con la misma idea subyacente):

OSḂ⁾!iṫ;⁾sC,ṫ€-7
— Jonathan Allan
fuente
Ah, maldición, pensé que estaba haciendo algo con el truco del mod 2. Luego encontré esto: PI tenía esto para 18 bytes, tal vez podría ayudar:OS1&”!x;“isC”;ṫ-7$
— Conor O'Brien
2

Perl 6 ,  35  31 bytes

{'!'x m:g/<[!NU]>/%2~'isChecked()'}

Intentalo

{'!'x tr/!NU//%2~'isChecked()'}

Pruébelo
(requiere una cadena de entrada mutable que será mutilada)

Expandido:

{
  #(
    '!'
  x               # string repeat

    # m:g/<[!NU]>/
    tr/!NU//      # find the number of negatives
      % 2         # modulus 2
  #)

  ~                # string concat

    'isChecked()'
}
— Brad Gilbert b2gills
fuente
2

Sed, 36 bytes

La misma idea que todas las otras respuestas de sustitución directa.

:
s/Unc/NotC/
s/isNot/!is/
s/!!//
t
— Kevin
fuente
2

sed, 37 38 bytes

:;s/is(Not|Un)/!is/;s/!!//;t;s/ch/Ch/

37 + 1 para -rinterruptor:

sed -r ':;s/is(Not|Un)/!is/;s/!!//;t;s/ch/Ch/'
— F. Hauri
fuente
1
Eso último s/c/C/causó problemas para la respuesta de Perl 5 ...
— Neil
Sí, parece que s/c/C/está atrapando la segunda "c" en casos sin "Un"
— Kevin
1
Además, puede guardar un byte soltando gy moviendo el s/!!//interior del bucle.
— Kevin
2

Mathematica, 82 61 60 Bytes

Pequeño ajuste, se agregó un operador infijo más:

"!"~Table~Mod[#~StringCount~{"o","n","!"},2]<>"isChecked()"&

Previamente:

"!"~Table~Mod[StringCount[#,{"o","n","!"}],2]<>"isChecked()"&

Cuente todas las o's, n's y! 'S luego mod 2 y ponga tantas! Al frente.

Versión antigua:

"!"~Table~Mod[StringCount[StringReplace[#,{{"o","n"}->"!"}],"!"],2]<>"isChecked()"&
— Ian Miller
fuente
2

Excel, 90 bytes

=IF(ISODD(SEARCH("C",SUBSTITUTE(SUBSTITUTE(A1,"Un","!"),"Not","!"))),"","!")&"isChecked()"
— Wernisch
fuente
2

Lote de Windows, 120 bytes

Anteriormente 268257253 245 239 221 182 176 169 123 bytes

@set a=%1
@set s=#%a:~,-2%
@set s=%s:!=N#%
@for %%a in (%s:N= %)do @set/ac+=5
@if %c:~-1%==0 cd|set/p=!
@echo isC%a:~-8%

Los programas reemplazan todo !en N#. Debido a que ahora todas las señales de negación, (ahora lo es N#), Noty Uncontiene N, el programa puede contar la cantidad de aparición Ny determinar si !se requiere un inicio .

Cada vez que el programa cuenta un N, el contador se agrega por 5. La razón para sumar 5 es porque cada valor alterno al sumar 5 termina en 0 o 5. Esto se puede usar para determinar si el valor es impar o par y el valor inicial !Nosotros agregamos si es necesario.

Además, se utiliza el truco de los últimos ocho personajes de xnor.

— stevefestl
fuente
Uno pensaría que la programación en lotes de Windows sería imposible ...
— NieDzejkob
Por supuesto ...... Las secuencias de comandos por lotes son absurdas ...
— stevefestl
1

Jalea , 29 28 25 21 bytes

f“NU!”LḂ”!x;“µịÆẹṠƊẹ»

Pruébalo en línea!

f“NU!”LḂ”!x;“µịÆẹṠƊẹ»  Main link, argument is z
f“NU!”                 Filter to only keep "NU!"
      LḂ”!x            Repeat exclamation mark by the parity of the length
           ;“µịÆẹṠƊẹ»  Concatenate to "isChecked()"

-4 bytes gracias a Jonathan Allan!
-4 bytes gracias a Jonathan Allan! (mediante el uso de cadenas comprimidas)

— Hiperneutrino
fuente
Guarde la interfaz que Lynn hizo aquí como un módulo (por ejemplo, jellyCompress.py), entonces eso se habría formado con jellyCompress.Compress().string("is").dictionary("Checked").string("()").go(). (Si está ejecutando una instalación de cmd de Windows, cambie a la fuente DejaVu Sans Mono y cambie la página de códigos con el comando chcp 65001antes de iniciar Python para que los caracteres se muestren)
— Jonathan Allan
@ JonathanAllan Oh, está bien. ¡Gracias!
— HyperNeutrino
1

PHP, 55 bytes

<?=preg_match_all("#!|N#i",$argn)&1?"!":""?>isChecked()

Pruébalo en línea!

PHP, 58 bytes

<?=preg_match_all("#[!NU]#",$argn)%2?"!":"","isChecked()";

en "#[!NU]#"su lugar puedes usar"#[!N]#i"

Pruébalo en línea!

PHP, 68 bytes

Versión sin expresiones regulares 

for(;$c=$argn[$i++];)$d^=!trim($c,"UN!");echo"!"[!$d],"isChecked()";

Pruébalo en línea!

— Jörg Hülsermann
fuente
3
<?=preg_match_all("#[!UN]#",$argn)&1?"!":""?>isChecked()-2 bytes
— Tito
Tenía exactamente la misma respuesta antes de que se me ocurriera count(split()): D @Titus ¡buena idea!
— Christoph
1
" !"[$d&1]guarda otro byte si el espacio en blanco inicial está bien. $d^=!trim($c,"UN!")ahorra 3 bytes (porque ya no necesita &1).
— Tito
1
@Titus Sí, un ejemplo más de que tienes más conocimiento que yo. Gracias y por el problema del espacio en blanco que he "!"[!$d]
— creado en su
1
@ Christoph tienes razón, lo olvidé, perdón por eso
— Jörg Hülsermann
1

Japt , 19 bytes

`‰C”×B()`i'!pU¬xc u

Pruébalo en línea!

Desempaquetado y cómo funciona

`‰C”×B()`i'!pUq xc u

`‰C”×B()`   Compressed string for "isChecked()"
i     Insert the following string at the beginning...
'!p     "!" repeated the following number of times...
Uq        Split the input into chars
xc        Sum the charcodes
u         Modulo 2

Usando el truco charcode-sum de la solución Python de Jonathan Allan .

— Bubbler
fuente
1

Pascal (FPC) , 119 bytes

var s:string;j:word;c:char;begin read(s);for c in s do j:=j+ord(c);if 1=j mod 2then write('!');write('isChecked()')end.

Pruébalo en línea!

Usando el método que hace casi todas las respuestas, sumando puntos de código de caracteres en la entrada, luego verificando la paridad de la suma.

— AlexRacer
fuente
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.