La casella di controllo non è deselezionata?

65

Facendo la revisione del codice, mi sono imbattuto nel seguente codice, che verifica lo stato di una casella di controllo:

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

Ho dovuto fare un brainstorming per 30 minuti per scoprire quale stato attuale della casella di controllo si aspettava dal codice. Per favore, scrivimi un programma che può semplificare queste espressioni sciocche!

Il programma dovrebbe accettare come input una stringa che rappresenta l'espressione da semplificare (ad esempio:) !isNotUnchecked(). Il programma dovrebbe generare un'espressione semplificata logicamente equivalente, o isChecked()o !isChecked().

Il nome del metodo nell'espressione di input inizia sempre con is, contiene 0..n Note termina con Checked()o Unchecked(). Il metodo può essere preceduto da un numero qualsiasi di !.

Esempi

isChecked() => isChecked()
isUnchecked() => !isChecked()
isNotChecked() => !isChecked()
!isNotChecked() => isChecked()
!!!isNotNotUnchecked() => isChecked()
code-golf 
— Arnaud
fonte
Il testo fa sempre distinzione tra maiuscole e minuscole? Sarebbe l'input notunischecked?
— Stevefestl,
1
@SteveFest No, puoi supporre che l'input sia sempre nel formato che ho descritto sopra. Non è necessario gestire isnotuncheckedad esempio.
— Arnaud,
6
Con un nome di funzione del genere, darei da 10 a 1 probabilità che in realtà non testasse nemmeno la condizione verificata coerente con la sua denominazione.
— Caleb,
2
In altre parole, sai cos'è una casella non selezionata, sai cos'è una casella non selezionata (è selezionata, se e solo se "controllato" e "non selezionata" sono gli unici due stati possibili, altrimenti potrebbe essere qualsiasi cosa in la casella di controllo: int, sign ...) e per questa casella di controllo specifica, non lo è (non è "selezionata", sia con un segno di spunta o altro). Se vero, allora, sei sicuro che la casella di controllo non sia "selezionata" da nulla. Se falso, beh, sai che la casella di controllo è una casella non deselezionata ma non significa necessariamente che sia selezionata a meno che non ci siano solo due stati possibili (quindi è selezionata).
— J Doe,
1
@J Doe grazie per il chiarimento!
— Arnaud,

Risposte:

31

Python , 51 byte

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

Provalo online!

— XNOR
fonte
Sei un genio puro! Non ci avrei mai pensatos[-8:]
— signor Xcoder
Sicuramente 'isC'+s[-8:]un byte è più lungo di 'isChecked'?
— Neil,
9
ma 1 byte più corto di 'isChecked ()'
— Andrew Smith,
Qualcuno può spiegare cosa s[-8:]è / fa?
— ESR,
1
@EdmundReed Sono necessari gli ultimi 8 caratteri dell'input, che sono sempre hecked().
— xnor
24

Retina , 23 byte

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

Provalo online!

Spiegazione

Unc
!C

Trasforma Uncheckedin !Checked.

Not
!

Trasforma tutte le Nots in !. Ora abbiamo qualcosa del tipo !!!is!!!!Checked().

O`is|!

Ordina tutte le partite di uno iso !. Da allora ! < is, questo sposta tutto !all'inizio della stringa, quindi l'esempio sopra diventerebbe !!!!!!!isChecked().

!!

Rimuovere le coppie di !per annullare la negazione ripetuta.

— Martin Ender
fonte
13

Python , 43 byte

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

Una funzione senza nome che prende la stringa se restituisce una stringa.

Provalo online!

Non c'è bisogno di verificare l'esistenza di caratteri quando !, Note Untutti hanno esattamente un ordinale dispari (e ce Csono entrambi dispari), quindi basta riassumere gli ordinali e utilizzare il valore del modulo 2 per decidere se vogliamo una !o meno.

A parte questo, il modulo è lo stesso della risposta di xnor , poiché non ho trovato niente di meglio. Quanto segue è anche 43:

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

JavaScript (ES6), 51 50 byte

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

Opere di ricerca di !, Ne npersonaggi, che invertono lo stato controllato. splitrestituisce una lunghezza di array dispari per impostazione predefinita, quindi aggiungiamo !quando la splitlunghezza è pari. Modifica: salvato 1 byte grazie a @ETHproductions. Versione alternativa, anche per 50 byte:

s=>`${s.split(/!|n/i).length%2?``:`!`}isChecked()`
— Neil
fonte
Eh, ora torno indietro e guardo le altre risposte, lo stanno facendo tutti.
— Neil,
Dovresti essere in grado di eliminare il flag globale da RegEx per salvare un byte.
— Shaggy,
@Shaggy In realtà la mia lunghezza è corretta, non sono riuscito a rimuovere gil nell'ultima modifica.
— Neil,
1
Penso che puoi salvare un byte con/!|N/i
— ETHproductions,
@ETHproductions Penso che volevi dire /!|N/senza il imodificatore
— SplittyDev,
7

Java 7, 100 77 byte

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

Codice di prova:

Provalo qui.

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

Produzione:

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

Aceto , 49 byte

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

yadda yadda curva di Hilbert.

Prima di tutto, spingiamo i tre personaggi importanti in pila: 

!'
'N'U

Quindi impostiamo un segno di spunta e iniziamo leggendo un singolo personaggio. Lo dupliciamo e lo neghiamo, e se il risultato di questo è veritiero (quindi se la stringa era vuota; quindi l'input è terminato), saltiamo alla fine:

;`
d!
,@

Con la copia rimanente del carattere di input, controlliamo se è contenuto nel resto della pila (ovvero se è uno di!, N, U). In caso contrario, generiamo un errore, riportandoci al nostro segno di cattura in cui leggiamo un altro personaggio:

&c
`!

Altrimenti, cariciamo ciò che è in memoria rapida (essenzialmente un registro che inizialmente è una stringa vuota; falsa), lo neghiamo e lo rimandiamo in memoria rapida, quindi solleviamo anche l'errore (tornando a leggere i caratteri):

&M
L!

Quando l'input si è fermato, siamo inviati alla fine. Lì, invertiamo la direzione, spingiamo un punto esclamativo, cariciamo la memoria rapida e la annulliamo. Se questo è vero (cioè abbiamo avuto un numero dispari di cose di negazione), stampiamo il punto esclamativo che abbiamo premuto:

p !'
`!Lu

Infine, inseriamo la stringa in due parti e la stampiamo (per motivi di risparmio di spazio):

"pp"
)(de
  Che"
  sick
   "

Successivamente, il programma ritorna ancora all'inizio originale, ma poiché nessuno dei comandi emette qualcosa o ha un comportamento a ciclo continuo, non importa. In realtà, il primo comando non-nopping che raggiungiamo genera un'eccezione, saltando la maggior parte del codice perché saltiamo al segno di cattura, il che significa che tutto Aceto vede in quella parte è:

&



!' @
'N'U

Poiché Unon è ora preceduto da un carattere virgoletta singola e non è quindi visto come un carattere letterale, viene interpretato come un comando: Uinverte tutti gli elementi in pila (ora è !, N, U, dall'alto), ed 'Ne '!spingere più caratteri, il che significa che finiamo con lo stack [U, N, !, N, !].

Nota a margine: questo è il primo programma Aceto scritto (in parte) con l'aiuto del nuovo editore Aceto .

— L3viathan
fonte
6

C, 78 70 68 byte

Grazie Christoph!

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

Provalo online

Produzione:

isChecked() => isChecked()
isUnchecked() => !isChecked()
isNotChecked() => !isChecked()
!isNotChecked() => isChecked()
!!!isNotNotUnchecked() => isChecked()
— Johan du Toit
fonte
1
c;f(char*s){for(c=1;*s;)c^=!!strchr("!NU",*s++);s="!isChecked()"+c;}usando xor per capovolgere si csalva 2 byte.
— Christoph,
6

Perl 5 , 31 byte

-2 byte grazie a @Dom Hastings .

30 byte di codice + -pflag.

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

Provalo online!

y/UN!//conta il numero di occorrenze di Un, Note !. Il risultato è che molti !moduli 2, seguiti da isChecked().

Un altro tentativo, basato su regex, per 38 byte (Dom Hastings ha salvato 1 byte su quello):

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

Provalo online!

— Dada
fonte
La tua versione regex non funziona perché ci sono due csecondi Unchecked.
— Neil,
1
@Neil il regex sostituisce solo il primo (dal momento che non sto usando /gflag). I casi di test mi stanno bene (vedi il link TryItOnline). Quindi non capisco davvero cosa intendi ...
— Dada,
Siamo spiacenti, il motivo corretto per cui la tua versione di regex non funziona è che sebbene ci sia un cin Uncheckedce ne sia anche uno in Checked, quindi quando lo abboni si finisce con CheCked.
— Neil,
1
Ehi, spero che tu stia bene! Non sono qui da un po ', ma ho avuto un po' di gioco con questi per -2 il primo e -1 il secondo
— Dom Hastings,
1
@DomHastings Hey! Fantastico, grazie mille! Felice di rivederti in giro :-)
— Dada,
6

Scala , 39 30 byte

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

Provalo online!

Sfortunatamente non sono riuscito a convincerlo a dedurre il tipo di s.

Modifica: spostata la dichiarazione del tipo nell'intestazione (penso che questo sia permesso, in caso contrario la rimetterò).

— musicman523
fonte
3

Japt , 24 23 byte

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

Spiegazione

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

Provalo online!

— Luca
fonte
1
Aspetta ... Come ... Perché ... Non fa odistinzione tra maiuscole e minuscole? Non sapevo che ...
— ETHproductions,
Neanche io lo sapevo, ma l'ho scoperto quando ho provato con "! NU". Anche la "n" minuscola in "Unchecked" è rimasta, così ho potuto rilasciare la "U"
— Luca
3

PHP (5,5 - 5,6), 52 50 49 byte

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

Provalo qui .

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

Senza regex diventa un po 'più complicato :) Provalo qui .

-4 Bytes by @Titus. Ty :)
— Christoph
fonte
1
error_reportingil valore predefinito è E_ALL&~E_NOTICE&~E_STRICT&~E_DEPRECATED.
— Tito,
1
@Titus batte JS in una sfida regex yay!
— Christoph,
$b^=$aMolto bella scoperta! Puoi anche farlo senza i tag PHP della stessa dimensione.
— Tito,
1
61 byte se è consentito lo spazio bianco iniziale:for($b=b;$a=$argn[$i++];)$b^=$a;echo$b&"!"|" ","isChecked()";
— Tito
@Titus Devo ammettere che è stato ispirato da questa risposta .
— Christoph,
3

Gelatina ,  16  15 byte

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

Un programma completo che accetta la stringa come argomento della riga di comando e stampa il risultato

Provalo online!

OSḂ⁾!iṫ-7³ṫṭ⁾sCo OSḂ⁾!iṫ-7³ṫ⁾sC;entrambi funzionerebbero anche per 15.

Come?

Utilizza la stessa idea della mia risposta Python , ma salva i byte utilizzando una diversa costruzione di !isCo isCuna stampa implicita 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()")

precedente a 16 byte 9 (utilizzando la concatenazione e l'associazione con la stessa idea di base):

OSḂ⁾!iṫ;⁾sC,ṫ€-7
— Jonathan Allan
fonte
Ah, dannazione, pensavo di essere coinvolto in qualcosa con il trucco mod 2. Poi ho trovato questo: PI aveva questo per 18 byte, forse potrebbe essere d'aiuto:OS1&”!x;“isC”;ṫ-7$
— Conor O'Brien,
2

Perl 6 ,  35  31 byte

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

Provalo

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

Provalo
(richiede una stringa di input mutabile che verrà mutilata)

Allargato:

{
  #(
    '!'
  x               # string repeat

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

  ~                # string concat

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

Sed, 36 byte

Stessa idea di tutte le altre risposte alla sostituzione diretta.

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

sed, 37 38 byte

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

37 + 1 per -rinterruttore:

sed -r ':;s/is(Not|Un)/!is/;s/!!//;t;s/ch/Ch/'
— F. Hauri
fonte
1
Quest'ultimo ha s/c/C/causato problemi per la risposta del Perl 5 ...
— Neil,
Sì, sembra che s/c/C/sta catturando la seconda "c" in casi senza "Un"
— Kevin,
1
Inoltre, è possibile salvare un byte rilasciando ge spostando l' s/!!//interno del loop.
— Kevin,
2

Mathematica, 82 61 60 byte

Piccola modifica, aggiunto un altro operatore infix:

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

In precedenza:

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

Conta tutte le o's, le n! E poi la mod 2 e metti tante! di fronte.

Vecchia versione:

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

Excel, 90 byte

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

Lotto di Windows, 120 byte

Precedentemente 268257253245 239 221 182 176 169 123 byte

@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%

Il programma sostituisce tutto !in N#. Perché ora tutti i segni di negazione,! (Ora lo è N#), Note Uncontiene N, il programma può contare il numero di aspetto Ne determinare se !è richiesto un vantaggio .

Ogni volta che il programma conta un N, il contatore viene aggiunto per 5. Il motivo per l'aggiunta di 5 è perché ogni valore alternato quando si aggiunge 5 termina in 0 o 5. Questo può essere usato per determinare se il valore è pari o dispari e il primo !noi aggiunti se richiesto.

Inoltre, viene utilizzato il trucco degli ultimi otto caratteri di xnor.

— stevefestl
fonte
Si potrebbe pensare che la programmazione in batch di Windows sia impossibile ...
— NieDzejkob,
Ovviamente ...... Il batch scripting è assurdo ....
— stevefestl,
1

Gelatina , 29 28 25 21 byte

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

Provalo 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 byte grazie a Jonathan Allan!
-4 byte grazie a Jonathan Allan! (usando stringhe compresse)

— HyperNeutrino
fonte
Salvare l'interfaccia che Lynn ha creato qui come modulo (diciamo jellyCompress.py), quindi sarebbe stata creata jellyCompress.Compress().string("is").dictionary("Checked").string("()").go(). (Se stai eseguendo un'installazione cmd di Windows e passa al carattere DejaVu Sans Mono e cambia la tabella codici con il comando chcp 65001prima di avviare Python per far visualizzare i personaggi)
— Jonathan Allan,
@JonathanAllan Oh okay. Grazie!
— HyperNeutrino,
1

PHP, 55 byte

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

Provalo online!

PHP, 58 byte

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

invece "#[!NU]#"puoi usare"#[!N]#i"

Provalo online!

PHP, 68 byte

Versione senza Regex 

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

Provalo online!

— Jörg Hülsermann
fonte
3
<?=preg_match_all("#[!UN]#",$argn)&1?"!":""?>isChecked()-2 byte
— Tito
Avevo esattamente la stessa risposta prima che mi venisse in mente count(split()): D @Titus bella idea!
— Christoph,
1
" !"[$d&1]salva un altro byte se lo spazio bianco iniziale è ok. $d^=!trim($c,"UN!")salva 3 byte (perché non è &1più necessario ).
— Tito,
1
@Titus Sì, un esempio in più che hai più conoscenza di me stesso. Grazie e per il problema degli spazi bianchi finali che ho fatto "!"[!$d]invece
— Jörg Hülsermann,
1
@Christoph hai ragione, ho dimenticato che mi dispiace per quello
— Jörg Hülsermann,
1

Japt , 19 byte

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

Provalo online!

Disimballato e come funziona

`‰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 il trucco della somma dei codici a barre della soluzione Python di Jonathan Allan .

— bubbler
fonte
1

Pascal (FPC) , 119 byte

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.

Provalo online!

Usando il metodo che fa quasi ogni risposta, sommando i punti di codice dei caratteri nell'input, quindi controllando la parità della somma.

— AlexRacer
fonte
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.