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

Python , 51 bytes

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

Pruébalo en línea!

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.

/// , 26 bytes

/Unc/NotC//isNot/!is//!!//

Pruébalo en línea!

Puerto de mi respuesta Retina .

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:]

JavaScript (ES6), 51 50 bytes

f=
s=>(s.split(/!|n/i).length%2?'':'!')+'isChecked()'

<input oninput=o.textContent=f(this.value)><pre id=o>

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()`

Retina , 24 bytes

Unc
NotC
+`isNot
!is
!!

Pruébalo en línea!

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

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 .

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

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!

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

Rubí , 40 bytes.

->x{?!*(x.count('!UN')%2)+'isChecked()'}

Pruébalo en línea!

05AB1E , 22 bytes

…Unc„!C:'€–™'!:'!†„!!K

Pruébalo en línea!

05AB1E , 16 bytes

ÇOÉ'!×…isCyR8£RJ

Pruébalo en línea!

Utiliza el truco de sumar los ordinales de la respuesta en pitón de Jonathan Allan .

Explicación

 ÇO                # sum of ascii values of input
   É               # is odd
    '!×            # repeat "!" that many times
       …isC        # push the string "isC"
           IR8£R   # push the last 8 chars of input
                J  # join everything to string

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!

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

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

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()'
}

Sed, 36 bytes

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

:
s/Unc/NotC/
s/isNot/!is/
s/!!//
t

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/'

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

Excel, 90 bytes

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

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.

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)

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!

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 .

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.