Bei der Codeüberprüfung bin ich auf den folgenden Code gestoßen, der den Status eines Kontrollkästchens testet:

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

Ich musste 30 Minuten lang ein Brainstorming durchführen, um herauszufinden, welchen tatsächlichen Kontrollkästchenstatus der Code erwartete. Schreiben Sie mir bitte ein Programm, das diese albernen Ausdrücke vereinfachen kann!

Das Programm sollte als Eingabe eine Zeichenfolge akzeptieren, die den zu vereinfachenden Ausdruck darstellt (zum Beispiel:) !isNotUnchecked(). Das Programm sollte entweder isChecked()oder einen logisch äquivalenten vereinfachten Ausdruck ausgeben !isChecked().

Der Methodenname in dem Eingabeausdruck beginnt immer mit is, enthält 0..n Not, und endet mit Checked()oder Unchecked(). Der Methode kann eine beliebige Anzahl von vorangestellt werden !.

Beispiele

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

Python , 51 Bytes

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

Probieren Sie es online!

Netzhaut , 23 Bytes

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

Probieren Sie es online!

Erläuterung

Unc
!C

Biegen Sie Uncheckedin !Checked.

Not
!

Biegen Sie alle Nots in !. Wir bekommen jetzt so etwas wie !!!is!!!!Checked().

O`is|!

Sortieren Sie alle Übereinstimmungen von entweder isoder !. Da ! < isdies alles !an den Anfang der Zeichenkette verschiebt, würde das obige Beispiel so werden !!!!!!!isChecked().

!!

Entfernen Sie Paare von !, um die wiederholte Verneinung abzubrechen.

/// 26 Bytes

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

Probieren Sie es online!

Port meiner Retina-Antwort .

Python , 43 Bytes

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

Eine unbenannte Funktion, die die Zeichenfolge übernimmt sund eine Zeichenfolge zurückgibt.

Probieren Sie es online!

Keine Notwendigkeit , die Existenz von Zeichen zu überprüfen , wenn !, Notund Unalle genau einer ungeraden Ordnungs (und cund Csind beide ungerade), so dass nur die ordinals zusammenzufassen und verwenden Sie den Wert Modulo 2 zu entscheiden , ob wir eine wollen !oder nicht.

Ansonsten ist das Formular das gleiche wie die Antwort von xnor , da ich nichts Besseres gefunden habe. Folgendes ist auch 43:

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

JavaScript (ES6), 51 bis 50 Byte

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

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

Werke von der Suche nach !, Nund nZeichen, die den Überprüfungsstatus invertieren. splitgibt standardmäßig eine ungerade Array-Länge zurück, also addieren wir die, !wenn die splitLänge gerade ist. Bearbeiten: 1 Byte dank @ETHproductions gespeichert. Alternative Version, auch für 50 Bytes:

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

Retina , 24 Bytes

Unc
NotC
+`isNot
!is
!!

Probieren Sie es online!

Java 7, 100 77 Bytes

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

Erweiterung:

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

Testcode:

Probieren Sie es hier aus.

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

Ausgabe:

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

Aceto , 49 Bytes

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

yadda yadda Hilbert Kurve.

Zunächst verschieben wir die drei wichtigen Zeichen auf den Stapel:

!'
'N'U

Dann setzen wir eine Fangmarke und beginnen mit dem Lesen eines einzelnen Zeichens. Wir dduplizieren es und negieren es, und wenn das Ergebnis davon wahr ist (also wenn der String leer war; also die Eingabe endete), springen wir zum Ende:

;`
d!
,@

Mit der verbleibenden Kopie des Eingabezeichens prüfen wir, ob es im Rest des Stapels enthalten ist (dh ob es eines von!, N, U ist). Wenn nicht, werfen wir einen Fehler aus und werfen uns zurück zu unserer Fangmarke, wo wir ein anderes Zeichen lesen:

&c
`!

Andernfalls laden wir das, was sich im Schnellspeicher befindet (im Wesentlichen ein Register, das anfangs eine leere Zeichenfolge ist; falsch), negieren es und senden es zurück in den Schnellspeicher.

&M
L!

Wenn die Eingabe gestoppt ist, werden wir zum Ende gesendet. Dort kehren wir die Richtung um, drücken ein Ausrufezeichen, laden die Schnellspeicherung und negieren sie. Wenn das wahr ist (dh wir hatten eine ungerade Anzahl von Negationssachen), drucken wir das Ausrufezeichen, das wir gedrückt haben:

p !'
`!Lu

Zum Schluss schieben wir die Zeichenkette in zwei Teile und drucken sie (aus Platzgründen):

"pp"
)(de
  Che"
  sick
   "

Danach läuft das Programm immer noch zum ursprünglichen Anfang zurück, aber da keiner der Befehle irgendetwas ausgibt oder ein schleifenartiges Verhalten aufweist, spielt das keine Rolle. Tatsächlich löst der erste Non-Nopping-Befehl, den wir erreichen, eine Ausnahme aus, bei der ein Großteil des Codes übersprungen wird, weil wir zur Catch-Marke springen, was bedeutet, dass Aceto in diesem Teil nur Folgendes sieht:

&



!' @
'N'U

Da Uwird jetzt nicht von einem einzelnen Anführungszeichen vorangestellt und wird daher nicht als Zeichenliteral gesehen, wird es als Befehl interpretiert: Uumkehrt alle Elemente auf dem Stapel (jetzt ist es !, N, U, von oben), und 'Nund '!drücken mehr Zeichen, was bedeutet, dass wir mit dem Stapel enden [U, N, !, N, !].

Randnotiz: Dies ist das erste Aceto-Programm, das (teilweise) mit Hilfe von Acetos neuem Editor geschrieben wurde .

C 78 70 68 Bytes

Vielen Dank Christoph!

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

Probieren Sie es online aus

Ausgabe:

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

Perl 5 , 31 Bytes

-2 Bytes dank @Dom Hastings .

30 Byte Code + -pFlag.

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

Probieren Sie es online!

y/UN!//zählt die Anzahl von Vorkommen Un, Notund !. Das Ergebnis ist, dass viele !Modulo 2, gefolgt von isChecked().

Ein weiterer Versuch, basierend auf Regex, für 38 Bytes (Dom Hastings sparte 1 Byte auf diesem):

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

Probieren Sie es online!

Scala , 39 30 Bytes

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

Probieren Sie es online!

Leider konnte ich nicht die Art von s ableiten.

Bearbeiten: Die Typdeklaration wurde in die Kopfzeile verschoben (ich denke das ist erlaubt, wenn nicht, werde ich es zurücksetzen).

Ruby , 40 Bytes

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

Probieren Sie es online!

05AB1E , 22 Bytes

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

Probieren Sie es online!

05AB1E , 16 Bytes

ÇOÉ'!×…isCyR8£RJ

Probieren Sie es online!

Verwendet den Trick, die Ordnungszahlen aus Jonathan Allans Pythonantwort zu summieren .

Erläuterung

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

Erläuterung

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

Probieren Sie es online!

PHP (5.5 - 5.6), 52 50 49 Bytes

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

Probieren Sie es hier aus .

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

Ohne Regex wird es ein bisschen kompakter :) Probieren Sie es hier .

-4 Bytes by @Titus. Ty :)

Jelly ,  16  15 Bytes

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

Ein vollständiges Programm, das die Zeichenfolge als Befehlszeilenargument verwendet und das Ergebnis ausgibt

Probieren Sie es online!

OSḂ⁾!iṫ-7³ṫṭ⁾sCoder OSḂ⁾!iṫ-7³ṫ⁾sC;würden beide auch für 15 arbeiten.

Wie?

Verwendet die gleiche Idee wie meine Python-Antwort , speichert jedoch Bytes mit einer anderen Konstruktion von !isCoder isCund implizitem Drucken 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()")

vorherige @ 16 Bytes 9 (unter Verwendung von Verkettung und Pairing mit derselben zugrunde liegenden Idee):

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

Perl 6 ,  35  31 Bytes

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

Versuch es

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

Versuch es
(erfordert eine veränderbare Eingabezeichenfolge, die verfälscht wird)

Erweitert:

{
  #(
    '!'
  x               # string repeat

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

  ~                # string concat

    'isChecked()'
}

Sed, 36 Bytes

Dieselbe Idee wie alle anderen direkten Substitutionsantworten.

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

sed, 37 38 bytes

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

37 + 1 für -rSchalter:

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

Mathematica, 82 61 60 Bytes

Kleine Optimierung, ein weiterer Infix-Operator hinzugefügt:

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

Vorher:

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

Zähle alle o's, n's und! S, dann mod 2 und setze so viele! vor.

Alte Version:

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

Excel, 90 Bytes

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

Windows Batch, 120 Bytes

Bisher _{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%

Das Programm ersetzt alle !in N#. Da jetzt alle Negationszeichen,! (Now it is N#), Notund Unenthalten N, kann das Programm die Anzahl der Auftritte zählen Nund feststellen, ob ein Anführungszeichen !erforderlich ist.

Jedes Mal, wenn das Programm einen zählt N, wird der Zähler um 5 addiert. Der Grund für das Addieren von 5 ist, dass jeder abwechselnde Wert beim Addieren von 5 auf 0 oder 5 endet. Dies kann verwendet werden, um zu bestimmen, ob der Wert ungerade oder gerade ist und der führende! fügte uns bei Bedarf hinzu.

Außerdem wird der Trick der letzten acht Zeichen von xnor verwendet.

Jelly , 29 28 25 21 Bytes

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

Probieren Sie es 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 danke an Jonathan Allan!
-4 Bytes danke an Jonathan Allan! (durch Verwendung komprimierter Zeichenfolgen)

PHP, 55 Bytes

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

Probieren Sie es online!

PHP, 58 Bytes

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

stattdessen können "#[!NU]#"Sie verwenden"#[!N]#i"

Probieren Sie es online!

PHP, 68 Bytes

Version ohne Regex

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

Probieren Sie es online!

Japt , 19 Bytes

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

Probieren Sie es online!

Ausgepackt und wie es funktioniert

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

Verwenden Sie den Charcode-Summen-Trick aus Jonathan Allans Python-Lösung .

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.

Probieren Sie es online!

Mit der Methode, die bei fast jeder Antwort angewendet wird, werden die Codepunkte der Zeichen in der Eingabe summiert und anschließend die Parität der Summe überprüft.