Is the checkbox not not unchecked?

Question

Doing code review, I stumbled upon the following code, that tests the status of a checkbox:

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

I had to brainstorm for 30 minutes to find out what actual checkbox status the code was expecting. Please write me a program that can simplify these silly expressions!

---

The program should accept as input a string representing the expression to simplify (for example: !isNotUnchecked()). The program should output a logically equivalent simplified expression, either isChecked() or !isChecked().

The method name in the input expression always starts with is, contains 0..n Not, and ends with Checked() or Unchecked(). The method can be prefixed by any number of !.

Examples

isChecked() => isChecked()
isUnchecked() => !isChecked()
isNotChecked() => !isChecked()
!isNotChecked() => isChecked()
!!!isNotNotUnchecked() => isChecked()

Answer 1

Python, 51 bytes

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

Try it online!

Answer 2

Retina, 23 bytes

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

Try it online!

Explanation

Unc
!C

Turn Unchecked into !Checked.

Not
!

Turn all Nots into !. We now get something like !!!is!!!!Checked().

O`is|!

Sort all matches of either is or !. Since ! < is, this moves all the ! to the beginning of the string, so the above example would become !!!!!!!isChecked().

!!

Remove pairs of ! to cancel repeated negation.

Answer 3

///, 26 bytes

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

Try it online!

Port of my Retina answer.

Answer 4

Python, 43 bytes

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

An unnamed function taking the string, s and returning a string.

Try it online!

No need to check for existence of characters when !, Not, and Un all have exactly one odd ordinal (and c and C are both odd), so just sum up the ordinals and use the value modulo 2 to decide if we want a ! or not.

Other than that the form is the same as xnor's answer, as I didn't find anything better. The following is also 43:

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

Answer 5

JavaScript (ES6), 51 50 bytes

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

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

Works by looking for !, N, and n characters, which invert the checked state. split returns an odd array length by default, so we add the ! when the split length is even. Edit: Saved 1 byte thanks to @ETHproductions. Alternative version, also for 50 bytes:

s=>`${s.split(/!|n/i).length%2?``:`!`}isChecked()`

Answer 6

Retina, 24 bytes

Unc
NotC
+`isNot
!is
!!

Try it online!

Answer 7

Java 7, 100 77 bytes

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

Expanation:

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

Test code:

Try it here.

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()"));
  }
}

Output:

isChecked()
!isChecked()
!isChecked()
isChecked()
isChecked()

Answer 8

Aceto, 49 bytes

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

yadda yadda Hilbert curve.

First of all, we push the three important characters on the stack:

!'
'N'U

Then we set a catch mark and start by reading a single character. We duplicate it and negate it, and if the result of this is truthy (so if the string was empty; so the input ended), we jump to the end:

;`
d!
,@

With the remaining copy of the input character, we check whether it is contained in the rest of the stack (i.e. if its one of !, N, U). If it's not, we raise an error, throwing us back to our catch mark where we read another character:

&c
`!

Otherwise, we load what's on quick storage (essentially a register that's initially an empty string; falsy), negate it and send it back to quick storage, then raise the error too (going back to reading characters):

&M
L!

When the input stopped, we are sent to the end. There, we reverse the direction, push an exclamation mark, and load quick storage and negate it. If that is truthy (i.e. we've had an odd number of negation things), we print the exclamation mark we've pushed:

p !'
`!Lu

Finally, we push the string in two parts and print them (for space saving reasons):

"pp"
)(de
  Che"
  sick
   "

Afterwards, the program still runs back to the original beginning, but since none of the commands output anything or have loopy behaviour, that doesn't matter. Actually, the first non-nopping command we reach raises an exception, skipping a majority of the code because we jump to the catch mark, meaning all Aceto sees in that part is:

&



!' @
'N'U

Since U is now not preceeded by a single-quote character and is therefore not seen as a character literal, it gets interpreted as a command: U reverses all the elements on the stack (now it's !, N, U, from the top), and 'N and '! push more characters, meaning we end with the stack [U, N, !, N, !].

Side note: This is the first Aceto program written (in part) with the help of Aceto's new editor.

Answer 9

C, 78 70 68 Bytes

Thank you Christoph!

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

Try it online

Output:

isChecked() => isChecked()
isUnchecked() => !isChecked()
isNotChecked() => !isChecked()
!isNotChecked() => isChecked()
!!!isNotNotUnchecked() => isChecked()

Answer 10

Perl 5, 31 bytes

-2 bytes thanks to @Dom Hastings.

30 bytes of code + -p flag.

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

Try it online!

y/UN!// counts the number of occurrences of Un, Not, and !. The result is that many ! modulo 2, followed by isChecked().

---

Another attempt, based on regex, for 38 bytes (Dom Hastings saved 1 byte on that one):

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

Try it online!

Answer 11

Scala, 39 30 bytes

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

Try it online!

Unfortunately I couldn't get it to deduce the type of s.

Edit: Moved the type declaration to the header (I think this is allowed, if not I'll put it back).

Answer 12

Ruby, 40 bytes

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

Try it online!

Answer 13

05AB1E, 22 bytes

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

Try it online!

Answer 14

05AB1E, 16 bytes

ÇOÉ'!×…isCyR8£RJ

Try it online!

Uses the trick of summing the ordinals from Jonathan Allan's python answer.

Explanation

 Ç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

Answer 15

Japt, 24 23 bytes

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

Explanation

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

Try it online!

Answer 16

PHP (5.5 - 5.6), 52 50 49 Bytes

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

Try it here.

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

Without regex it gets a bit more compex :) Try it here.

-4 Bytes by @Titus. Ty :)

Answer 17

Jelly,  16  15 bytes

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

A full program that takes the string as a command line argument and prints the result

Try it online!

OSḂ⁾!iṫ-7³ṫṭ⁾sC or OSḂ⁾!iṫ-7³ṫ⁾sC; would both also work for 15.

How?

Uses the same idea as my Python answer, but saves bytes using a different construction of !isC or isC and some implicit printing in 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()")

previous @ 16 bytes 9 (using concatenation and pairing with the same underlying idea):

OSḂ⁾!iṫ;⁾sC,ṫ€-7

Answer 18

Perl 6,  35  31 bytes

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

Try it

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

Try it
(requires mutable input string which will be mutilated)

Expanded:

{
  #(
    '!'
  x               # string repeat

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

  ~                # string concat

    'isChecked()'
}

Answer 19

Sed, 36 Bytes

Same idea as all the other direct substitution answers.

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

Answer 20

sed, 37 38 bytes

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

37 + 1 for -r switch:

sed -r ':;s/is(Not|Un)/!is/;s/!!//;t;s/ch/Ch/'

Answer 21

Mathematica, 82 61 60 Bytes

Small tweak, added one more infix operator:

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

Previously:

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

Count up all the o's, n's and !'s then mod 2 and put that many ! in front.

Old version:

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

Answer 22

Excel, 90 bytes

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

Answer 23

Windows Batch, 120 bytes

Previously _{268 257 253 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%

The programs replaces all the ! into N#. Because now all negation signs, !(Now it is N#), Not, and Un contains N, the program can counts the number of appearance of N and determines if an leading ! is required.

Each time the program counts an N, the counter is added by 5. The reason for adding 5 is because each alternating values when adding 5 ends in either 0 or 5. This can be used to determine whether the value is odd or even and the leading ! us added if required.

In addition, xnor's last-eight-character trick is utilized.

Answer 24

Jelly, 29 28 25 21 bytes

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

Try it online!

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 thanks to Jonathan Allan!
-4 bytes thanks to Jonathan Allan! (by using compressed strings)

Answer 25

PHP, 55 Bytes

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

Try it online!

PHP, 58 Bytes

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

instead "#[!NU]#" you can use "#[!N]#i"

Try it online!

PHP, 68 Bytes

Version without Regex

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

Try it online!

Answer 26

Japt, 19 bytes

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

Try it online!

Unpacked & How it works

`‰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

Using the charcode-sum trick from Jonathan Allan's Python solution.

Answer 27

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.

Try it online!

Using method that almost every answer does, summing codepoints of characters in the input, then checking parity of the sum.

Answer 28

ReRegex, 32 bytes

/!!//Not/!/Unc/!C/is!/!is/#input

Explained

Works like the Retina answer

/!!//                            #Remove all !! pairs
     Not/!/                      #Replace all Nots with !s
           Unc/!C/               #Replace any Unc's with !C (Turning Unchecked into !Checked)
                  is!/!is/       #Float all !'s past the is to the left
                          #input #Take the stdin as input

Try it online!