La matematica è un fatto. La programmazione no


176

In matematica un punto esclamativo !spesso significa fattoriale e segue l'argomento.

Nella programmazione di un punto esclamativo !spesso significa negazione e viene prima dell'argomento.

Per questa sfida applicheremo queste operazioni solo a zero e una.

Factorial
0! = 1
1! = 1

Negation
!0 = 1
!1 = 0

Prendi una stringa di zero o più !'s, seguita da 0o 1, seguita da zero o più !' s ( /!*[01]!*/).
Ad esempio, l'input può essere !!!0!!!!o !!!1oppure !0!!oppure 0!oppure 1.

Il !prima 0o il 1sono negazioni e il !dopo sono fattoriali.

Il fattoriale ha una precedenza maggiore rispetto alla negazione, quindi i fattoriali vengono sempre applicati per primi.
Ad esempio, !!!0!!!!significa veramente !!!(0!!!!), o meglio ancora !(!(!((((0!)!)!)!))).

Produce l'applicazione risultante di tutti i fattoriali e le negazioni. L'output sarà sempre 0o 1.

Casi test

0 -> 0
1 -> 1
0! -> 1
1! -> 1
!0 -> 1
!1 -> 0
!0! -> 0
!1! -> 0
0!! -> 1
1!! -> 1
!!0 -> 0
!!1 -> 1
!0!! -> 0
!!!1 -> 0
!!!0!!!! -> 0
!!!1!!!! -> 0

Vince il codice più breve in byte.


18
Ma 0! = 1 !, quindi qual è il punto di gestire più fattoriali?
Boboquack,

30
@boboquack Perché questa è la sfida.
Calvin's Hobbies,

11
? <= '1'; ... correggi il 75% delle volte in php.
aslum,

10
Potrei sbagliarmi qui, ma non è possibile rimuovere un numero e nessun fattoriale dopo che è stato semplicemente rimosso e sostituito con 1? Mi piace 0 !!!! = 1 !! = 0 !!!!!!!! = 1 !!! = 1! = 0! = 1 ecc.
Albert Renshaw,

2
@AlbertRenshaw È corretto.
Calvin's Hobbies,

Risposte:


43

Mathematica, 25 17 byte

Input[]/.!x_:>1-x

Riceve input da una richiesta dell'utente. Suppone l' ambiente per notebook di Mathematica per la stampa implicita. Per renderlo uno script da riga di comando, includilo Print[...]o per renderlo una funzione senza argomenti (che quindi accetta input dal prompt), aggiungi &.

Mathematica ha entrambi gli operatori richiesti (con la precedenza richiesta), quindi possiamo semplicemente "valutare" l'input (che viene fatto automaticamente da Input[]), ma l'operatore di negazione logica non funziona sugli interi (quindi rimarrà sottovalutato). Se rimane un !xrisultato nel risultato, lo sostituiamo con 1-x.

Un paio di fatti divertenti sulla valutazione:

  1. Mathematica in realtà ha anche il doppio operatore fattoriale !!, che calcola n*(n-2)*(n-4)*..., ma applicato 0o 1dà ancora 1, quindi non importa che 0!!!!!verrà effettivamente analizzato ((0!!)!!)!.
  2. Anche se Mathematica lascia !0e non è !1valutata, sa che !è auto-inversa, quindi annullerà automaticamente tutte le coppie di lead !. Dopo la ToExpressionsiamo sempre partiti con uno dei 0, 1, !0, !1.

3
Da quando uno snippet REPL è consentito per impostazione predefinita?
LegionMammal978,

2
@ LegionMammal978 Apparentemente da dicembre 2015, ma continuo a dimenticarmene. Ad essere onesti, non è un "frammento" in quanto non presuppone che l'input sia già archiviato da qualche parte nella memoria. E supponendo che l'ambiente del notebook non sia molto diverso dall'avere un linguaggio con output implicito.
Martin Ender,

Solo curioso, potrebbe essere fornito un meta link? (Cercare di trovare informazioni è stressante, ancora un altro problema del formato domande e
risposte

@ LegionMammal978 è già nella risposta.
Martin Ender,

Soluzione ksh pura x=${x/[01]!*/1};echo $(($x))- non è possibile inviare una risposta corretta :(
DarkHeart

28

[Bash] + Utilità Unix, 21 17 byte

sed s/.!!*$/1/|bc

Questo deve essere salvato in un file ed eseguito come programma. Se provi a inserire il comando direttamente dalla riga di comando, non funzionerà perché !! viene ampliato a causa dell'abilitazione della sostituzione della cronologia nella modalità interattiva di bash. (In alternativa, puoi disattivare la sostituzione della cronologia con set +H.)

Esecuzioni del test case:

for x in 0 1 '0!' '1!' '!0' '!1' '!0!' '!1!' '0!!' '1!!' '!!0' '!!1' '!0!!' '!!!1' '!!!0!!!!' '!!!1!!!!'; do ./excl <<<"$x"; done

0
1
1
1
1
0
0
0
1
1
0
1
0
0
0
0

La vecchia versione funziona, questa no
Cows quack

Ho usato il link TIO
Cows quack

@KritixiLithos Ha funzionato bene quando l'ho provato sul mio Linux box. Apparentemente il problema era che TIO richiede una nuova riga alla fine della linea di input simulata. È una situazione confusa, quindi ho tolto il link TIO. Se vuoi provarlo, ecco di nuovo il link (ma assicurati di includere una nuova riga alla fine dell'input se cambi l'input per testarlo): tio.run/nexus/bash#@1@cmqJQrK @ nqKilom @ oX5OU / P @ /…
Mitchell Spector

2
E se qualcuno fosse scappato mkdir -p 's/.!!'{bunch,of,different,directories}\$/1? Quindi otterrai Pathname Expansion e Sed tenterà di leggere le directory come se fossero file, invece di leggere l'input standard e non produrrà nulla! :)
Wildcard il

1
@Wildcard Sono completamente d'accordo. Negli script di produzione, utilizzo sempre le virgolette in situazioni come questa. (In questo caso, metterei in realtà le doppie virgolette attorno all'argomento su sed, piuttosto che sfuggire al *. È più facile da leggere rispetto all'utilizzo di barre rovesciate, ed evita la possibilità di perdere qualche carattere speciale.)
Mitchell Spector

22

Retina , 20 15 14 byte

Grazie a Leo per aver salvato 1 byte.

0!
1
!!

^1|!0

Provalo online!

Spiegazione

0!
1

Trasforma 0!in 1. Non ci interessa nessun altro !s finale , il numero risultante è lo stesso di se avessimo applicato tutti i fattoriali.

!!

Annulla le coppie di negazioni. Questo può anche annullare alcuni fattoriali, ma questo è irrilevante.

^1|!0

Contare il numero di corrispondenze di questa regex, che è o 1o 0e dà il risultato desiderato.


Soluzione alternativa per lo stesso numero di addetti: \d.+...
Cows quack

@KritixiLithos Ho trovato un modo per evitarlo del tutto.
Martin Ender,

Puoi rimuovere il ^precedente!0
Leo

17

Grime , 14 12 9 byte

e`\0!~\!_

Provalo online!

Spiegazione

Ciò corrisponde all'input rispetto a un motivo, stampa 1per corrispondenza e 0per nessuna corrispondenza.

e`\0!~\!_
e`         Match entire input against this pattern:
    !      not
  \0       a sole 0
     ~     xor
      \!   exclamation mark
        _  followed by this pattern matched recursively.

L'idea è questa. Se l'input inizia con una cifra, la parte ricorsiva \!_fallisce sempre e ha \0!successo se non ne abbiamo una singola 0. Il loro xor ha esito positivo a meno che l'input non sia un singolo 0. Se l'input inizia con a !, quindi ha \0!sempre successo e ha \!_esito positivo se la corrispondenza ricorsiva ha esito positivo. Il loro xor riesce esattamente quando fallisce la partita ricorsiva, annullandola così.


16

Brainfuck, 85 72 (84) byte

,[>-[-----<->]<++[>++++[-<++++>]+<[[+],[[-]>-<]]]>[<<+[-->]>[<],>-]<]<+.

per tornare numericamente, oppure

,[>-[-----<->]<++[>++++[-<++++>]+<[[+],[[-]>-<]]]>[<<+[-->]>[<],>-]<]-[-----<+>]<--.

per il testo ASCII. > può anche essere prefissato per evitare il wrapping della memoria.

Provalo online!


Loops over the input.
On 1, ends.
On "!", toggles bool a stored as 0 or 255.
On "0", toggles if there is no trailing bit, then ends.

Memory labels  | BOOL | INPUT | FLAG |

,                   first input 
[                     # loop on INPUT
  >-[-----<->]<++     subtract 49 == "1"

  [                     # case not "1"
    >++++[-<++++>]      add 16 since 49 take 16 == "!"

    +                   set FLAG
    <                   move to INPUT
    [                     # case "0"
      [+],                clear and new INPUT
      [                     # case "0!"
        [-]>-<              clear INPUT and FLAG
      ]
    ]
  ]

  >                   move to FLAG
  [                     # case "!" or "0" without tail
    <<+[-->]>[<]        not the BOOL
    ,                   take new input
    >-                  clear FLAG
  ]
  <                   move to INPUT
]

+.                    return 0 or 1

O per la risposta al testo, sostituire l'ultima riga con

-[-----<+>]<--.       add 49 for "0" or "1" conversion and return

14

Brainfuck - strada per molti byte (232 byte)

Chiaramente la lingua sbagliata per vincere nel golf del codice. Principalmente ho notato la mancanza di qualcuno che utilizza questo esolang. C'è un buon interprete online bf interpeter oppure puoi effettivamente vedere cosa fa il programma usando questo visualizzatore bf .

>>>>>,[>+++[<---------------->-]<<<<<<[-]+>[-]>>>>[-[<<[>+<<<<->>>[<<+>>-] ]<<[>>+<<-]<[>>+<<[-]]>>>>>[-]]<<<<<[>>>++<<<-]>+>>>>[-]]<<<<-[>>+<<[-]]>>>>,]<<->[<[-]+>[-]]<<[<[-]>>[<<+>>[-]]+<<[->>-<<]>-]>>[-]+++[<++++++++++++++++>-]<.

3
Pazzo !!
Almo

Lo adoro, puoi farlo con malbolge? XD
Stefan Nolde,

Informazioni: ci sono troppe soluzioni più brevi di seguito.
user202729

14

Python, -44-42 byte

Salvato 2 byte grazie a Zgarb!

lambda x:(x[-1]=='0')^len(x.rstrip('!'))%2

Passo dopo passo:

  1. x[-1]!='0'
    se xtermina con 1o !xnon termina con 0, la parte fattoriale deve avere valore 1, altrimenti0
  2. ^len(x.rstrip('!'))%2
    sfruttare la proprietà di xor come "non condizionale". La condizione in questo caso è se la lunghezza della !s iniziale è dispari. Tuttavia, .rstripnon rimuove il numero dalla stringa, pertanto la lunghezza calcolata viene spostata di 1, pertanto la condizione viene invertita
  3. L'offset di 1 nel passaggio 2 viene corretto passando !=al ==passaggio 1. Zgarb ha suggerito di utilizzare un operatore di confronto delle differenze anziché applicare un'altra inversione, risparmiando 2 byte.

Provalo online!


Non riesce su un input di !!0; al momento sta tornando 1.
Value Ink

@ValueInk dovrebbe funzionare ora
busukxuan

1
lambda x:(x[-1]=='0')^len(x.rstrip('!'))%2evita l'inversione extra.
Zgarb,

15
barrato 44 è ancora regolare 44
Rɪᴋᴇʀ

3
Penso che stia affermando che un 44 barrato nel font usato non sembra barrato ... :) La porzione barrata si sovrappone alla porzione orizzontale dei 4s.
JeffC,

13

JavaScript (ES6), 43 41 29 byte

s=>+eval(s.replace(/.!+$/,1))

Metodo non regex ( 41 31 byte)

Di seguito è il mio approccio iniziale. È leggermente più interessante, ma significativamente più lungo ancora un po 'più a lungo anche dopo una significativa ottimizzazione di Neil (10 byte salvati) .

f=([c,...s])=>1/c?c|s>'':1-f(s)

Casi test


Posso salvare solo 10 byte dal vostro metodo non regex, quindi è ancora troppo lungo: f=([c,...s])=>1/c?c|s>'':1-f(s).
Neil,

@Neil Dato che è molto meglio del mio primo tentativo, mi sono preso la libertà di includere il tuo suggerimento.
Arnauld,

Ah, ho avuto la stessa idea ma tu l'hai giocata meglio. :)
Devsman,

11

Gelatina , 5 byte

VeMḂ$

Provalo online!

Funzione monadica in attesa di una stringa. Gli ingressi con !s iniziali causano la 1stampa su STDOUT lungo il percorso, quindi il collegamento TIO che do è un cablaggio di prova che stampa le coppie input-output sotto la prima riga di output.

Come?

VeMḂ$ - Monadic link: string
V     - eval the string
          - the implicit input of 0 causes !...! to evaluate to 1 (which gets printed),
          - the result is the evaluation of the rest: "0"=0; "0!"=1; "1"=1; "1!"=1; ...
 e    - exists in?
    $ - last two links as a monad:
  M   -     Maximal indexes - the "0" and "1" characters are greater than "!",
                            - so this results in a list of one item [i] where
                            - i is the 1-based index of the 0 or 1 character.
   Ḃ  -     %2 (vectorises) - [i%2], so a 0 if we need to logically negate and a 1 if not
                            - hence we check equality with e rather than inequality.

10

05AB1E , 9 byte

Codice:

.V¹'!ÜgG_

Utilizza la codifica CP-1252 . Provalo online! oppure Verifica tutti i casi di test!

Spiegazione:

.V         # Evaluate the input as 05AB1E code. This computes the factorial part.
   '!Ü     # Remove trailing exclamation marks..
  ¹        # ..from the first input
      g    # Get the length of the resulting string
       G   # Do the following length - 1 times:
        _  #   Negate the number

10

Retina , 13 byte

Un approccio un po 'strano, ma è breve e funziona.

0$
!1
!!

^\d

Con le prime due righe sostituiamo un finale 0con !1: con questa sostituzione ora sappiamo che la parte della nostra stringa dalla cifra in poi è uguale a 1.

Dopo due righe, rimuovi le coppie di !: la doppia negazione si cancella da sola e abbiamo già tenuto conto del fattoriale con il passaggio precedente.

Ultima riga, abbina una cifra all'inizio della stringa e restituisci il numero di corrispondenze: se le negazioni sono state tutte eliminate, troveremo una corrispondenza (e come abbiamo detto prima sappiamo che è uguale a 1), se c'è ancora una negazione che non corrisponderà.

Provalo online!


1
La cifra finale non sarebbe necessariamente sempre un 1? In tal caso, è possibile utilizzare 1anziché \d.

1
@ ais523 no, perché la prima parte sostituirà solo un finale 0, quindi ad esempio l'input 0!rimarrà invariato fino all'ultima riga
Leone

1
Soluzione davvero adorabile, bel lavoro! :)
Martin Ender,

10

Rubino, 12 + 1 = 39 24 15 13 byte

Usa la -nbandiera. Grazie a @GB per -9 byte!

p~/!*$|0$/%2

Dal momento che si controlla solo la lunghezza, è possibile eliminare lo zero finale, invece di controllare prima "! 0" e uno zero dopo.
GB

@GB è un'idea meravigliosa! Tuttavia, ho trovato una soluzione ancora più breve modificando la mia regex per cercare la posizione 0 o la fine della linea
Value Ink

Quindi potresti semplicemente controllare la presenza di "!" o zero o fine riga: p ~ /! + $ | 0 $ | $ /% 2 è solo 14 byte.
GB

E quindi "0 $ | $" potrebbe diventare "0? $" Per salvare un altro byte.
GB

1
Meglio ancora !*$è più breve di due!
Value Ink

9

Perl , 20 byte

19 byte di codice + -pflag.

s/\d!+/1/;$_=0+eval

Provalo online!

Ritorna negazione di Perl undefo 1, per cui uso 0+per numerify il risultato 0+undefritorna 0. Oltre a ciò, non c'è molto da dire sul codice.


2
Ho appena scritto esattamente questo. Prendi un +1.
primo

@primo Sono contento di vedere che per una volta non ho 20 byte dietro di te! Grazie :)
Dada,

9

C, 68 62 61 53 byte

c;e(char*a){for(c=1;*a<34;a++)c^=1;c=a[1]?c:*a&1^!c;}

Spremuto qualche altro byte con qualche abuso

Provalo online!


1
Penso che puoi rimuovere il intdalla funzione e puoi cambiare *a==33in *a<34.
Cack cows

Purtroppo *a%2è più breve di*a-48
Cows quack

Grazie per il consiglio. Sono stato anche in grado di eliminare un altro personaggio rimuovendo le parentesi attorno al ritorno e assegnandolo.
Ahemone,

Sono abbastanza sicuro che for(;*a<34;a++)può essere abbreviato per for(;*a++<34;)salvare 1 byte
Albert Renshaw,

Sfortunatamente no, poiché l'istruzione condizionale verrà sempre eseguita e quindi spingerà il puntatore troppo avanti per la dereference di ritorno.
Ahemone,

6

Perl 6 , 32 28 23 byte

{m/(\!)*(1|0.)*/.sum%2}

Come funziona

{                     }  # A lambda.
{m/            /      }  # Match the lambda argument against the regex:
   (\!)*                 #   Zero or more `!`.
                         #     (First capture will be an array with one element per negation).
        (1|0.)*          #   A `1`, or a `0` and another character, zero or more times.
                         #     (Second capture will be a one-element array if the factorial
                         #     part evaluates to 1, and an empty array otherwise.)
                .sum     # Add the lengths of the two captures,
                    %2   # and return that sum modulo 2.

6

Haskell , 39 byte

f('!':b)="10"!!read[f b]
f[a]=a
f _='1'

Definisce una funzione f, che accetta una stringa e restituisce un carattere. Provalo online!

Spiegazione

Esistono tre casi: l'input inizia con !, l'input ha lunghezza 1 e tutto il resto.

f('!':b)=    -- If input has head '!' and tail b,
 "10"!!      -- we index into the string "10"
  read[f b]  -- using f b converted to int. This essentially inverts f b.
f[a]=        -- If input has only one character, we know it's a digit,
 a           -- so we can just return it.
f _=         -- In all other cases, we know the input is a digit followed by !s,
 '1'         -- so we can return '1'.

Passare da stringa a intero come tipo di ritorno: f('!':b)=[1,0]!!f b;f"0"=0;f _=1.
nimi,

6

Befunge, 24 byte

~"!"-:#v_$1+
*+2%!.@>0~`

Provalo online!

Questo inizia contando il numero di !caratteri letti dallo stdin. Il primo personaggio che non è un !sarà o un 0o 1, ma nel processo di test !abbiamo sottratto 33, rendendolo 15 o 16. Quindi leggiamo un altro personaggio, che sarà o! o EOF, e confrontare se questo è inferiore a 0 (cioè EOF).

Prendendo questi tre punti di dati - il conteggio esclamativo ( c ), il valore della cifra, ( d ) e la condizione di fine file ( e ) - possiamo calcolare il risultato come segue:

!((c + d*e) % 2)

Moltiplicare il valore della cifra per la condizione di fine del file significa che verrà convertito in zero se la cifra è stata seguita da a !, dandogli quindi lo stesso valore modulo 2 di a 1(che ricorda che è stato convertito in 16). Ma prima di applicare il modulo 2, aggiungiamo il conteggio esclamativo iniziale, che attiva e disattiva il risultato del modulo 2 tutte le volte che erano !prefissi. E infine non siamo il risultato poiché i nostri valori di base sono 0e 1sono l'opposto di ciò di cui abbiamo bisogno.

Guardando il codice in modo più dettagliato:

~                Read a character from stdin.
 "!"-            Subtract 33 (ASCII for '!').
     :  _        Make a duplicate and check if zero (i.e. is it a '!').
         $1+     If so, drop the duplicate, increment a counter, and repeat.
       v         Otherwise move to the second line, leaving the digit value on the stack.
       >0~`      Read one more character and check if less than 0 (i.e. EOF).
*                Multiple by the digit value, making it zero if not followed by EOF.
 +               Add to the exclamation count.
  2%             Modulo 2 the result.
    !            Then not that value.
     .@          And finally write to stdout and exit.

6

Haskell , 27 byte

f('!':b)=1-f b
f"0"=0
f _=1

Provalo online!

Ogni inizio !completa l'output per il resto dell'espressione, fatto come 1-. Continuiamo a girare finché non colpiamo una cifra. Se il resto è giusto "0", il risultato è 0. Altrimenti, è a 1o è seguito da uno o più !, quindi il risultato è 1.


5

Rubino, 22 21 20 byte

->s{(s=~/!*$|0$/)%2}

Spiegazione:

  • Primo caso, ho ottenuto un po '! alla fine, rimuovili, ottieni lunghezza modulo 2.
  • Secondo caso, no '!', Se l'ultimo carattere è zero, rimuovilo, ottieni lunghezza modulo 2
  • Se l'ultimo carattere è 1, torna al primo caso

(-1 byte rubando l'idea di @Value Ink)


Fantastico, ho guardato questo puzzle per 10 minuti ma non ho avuto molto tempo e poi me ne sono dimenticato. Ora l'ho visto di nuovo in domande attive ed è stato felice di vedere un approccio così piacevole.
Akostadinov,

4

Gelatina , 8 byte

œr”!LḂ=V

Provalo online!

Questa è una funzione (collegamento monadico) che accetta un argomento e restituisce tramite il suo valore di ritorno. (Inoltre, spesso scrive junk sull'output standard come effetto collaterale, ma non ci interessa.)

Spiegazione

œr”!LḂ=V
œr”!      Take {the input}, with all trailing ! deleted
    L     Take the length of this
     Ḃ    Take the parity of that length
      =   Return 0 if unequal, 1 if equal to:
       V    the value of {the input} when eval'ed as a niladic Jelly program

Innanzitutto, nota che poiché l'input è sempre costituito da un numero di !, seguito da una cifra, seguita da più !, che se cancelliamo il trailing !e prendiamo la lunghezza, finiremo con uno più il numero di lead !nel programma. Prendendo la parità di questo verrà restituito 0 se ci fosse un numero dispari di !, o 1 se ci fosse un numero pari di !. Il confronto con 0 è una funzione "non", mentre il confronto con 1 è la funzione identità; œr”!LḂ=implementa quindi in modo efficace la parte "tratta !come operatori NOT" della domanda.

Per quanto riguarda la seconda parte, la gestione dei fattoriali !è un'operazione fattoriale in Jelly, quindi se il programma non ha alcun vantaggio !, possiamo risolvere il problema direttamente con un semplice eval( V). Se il programma non ha leader !, quelli saranno interpretati come prendere il fattoriale di 0 (eventualmente più volte), producendo un valore di ritorno di 1, che verrà stampata sullo standard output ed eliminato una volta cifre è visto; quindi, non hanno alcun impatto sul valore di ritorno della funzione che è la mia presentazione alla domanda.


Spiegazione molto bella e ottima.
ElPedro,

4

Python, 38 byte

lambda s:(s[1::2]>s[::2])^ord(s[-1])%2

TryItOnline!

Una funzione senza nome che prende una stringa di input se restituisce un numero intero 0o 1.

s[1::2] è una sezione della stringa di input che inizia all'indice 1 e ha una dimensione del passo di due:
'Like this' -> 'ieti'

s[::2] è simile ma inizia con l'indice predefinito 0:
'Like this' -> 'Lk hs'

Il test (s[1::2]>s[::2])verifica se l'indice in base 0 dello '0'o '1'è dispari, cioè se dobbiamo integrare.
Questo funziona perché l'ordinamento delle stringhe viene controllato lessicograficamente con qualsiasi stringa non vuota maggiore della stringa vuota e con l'ordinamento ASCII, quindi '1'>'0'>'!'. Questo è un byte più corto del più semplice s.index(max(s))%2.

I ord(s[-1])%2controlla se l'ultimo carattere non è un '0'(per input valido), e si traduce in un numero intero (mentre la stessa lunghezza (s[-1]!='0')restituirebbe un boolean).
Questo funziona perché l'ultimo carattere dell'input, s[-1]sarà a '0', '1'o '!'che hanno rispettivamente punti di codice ASCII 48, 49 e 33, che sono 0, 1 e 1 modulo 2.

L' ^poi esegui una bit esclusivo o operazione sui due valori sopra, restituendo un numero intero da un ingresso, quello di destra, è un numero intero. Se la sinistra è vera, viene restituito il complemento della destra, se la sinistra è falsa viene restituita la destra, come richiesto.


4

Java 7, 105 82 81 byte

int a(char[]a){int b=0,c=0;for(;a[b++]<34;c^=1);return(b<a.length?1:a[b-1]&1)^c;}

Provalo online!

Vecchia soluzione regex-ish

int a(String a){a=a.replace("0!","1").replaceAll("1.*","1");int b=a.length()-1;return b%2^a.charAt(b)&1;}

2
c^=1è super intelligente. È un operatore inutilizzato se mai ne ho visto uno.
Addison Crump,

3

CJam , 12 11 byte

r_W='0=!\~;

Provalo online! Suite di test (stampa a 1per ogni caso di test corretto).

r      e# Read input.
_W='0= e# Duplicate and check whether the string ends in '0'. This is the
       e# only case in which the factorial part results in 0.
!      e# Negate this to get the actual result of the factorial part.
\      e# Swap with the input.
~      e# Evalute the input as CJam code. The leading `!` will apply the logical
       e# negations to the factorial result. The 0 or 1 will then push a junk value
       e# which is potentially negated a few times as well, by the factorials.
;      e# Discard the junk value.


3

Brainfuck, 115 byte

>,[->++++[<-------->-]<[--------------->,[<[-]+>-]<<[->-[>+<+]>[-<+>]<<]>>++++++[-<++++++++>]<.>>+<]>-[<<+>,>[-]]<]

Provalo online!

Ungolfed:

% 0: inverter count
% 1: result
% 2: if/else flag; tmpspace in inner loop 0

>1,[
    ->2++++[<-------->-]<1 subtract 33 (!)
    [ 
        % we've reached the number
        ---------------
        % now it's either 0 or 1

        % check next char; If it's not 0 then it's '!'
        % 0! = 1! = 1!...! so we only need to determine if at least one ! exists
        >2,
                [<[-]+>-]<1

        % apply inversions
        <0
        [->1
            % invert cell 1 once each iteration
                       % cell 1 is 0 or 1
            -          % cell 1 is 255 or 1
            [>+<+]     % cell 1 is 0; cell 2 is 1 iff cell 1 should be 1
            >2[-<+>]<1 % cell 1 is 1 or 0
        <0]

        % print result
        >1>++++++[-<++++++++>]<1.

        >>2+< % tape={0 r 0 1}
    ]
    >2-[ % we haven't seen the number yet
        <<0+>1,>2 % add to inverter count
        [-]
    ]<1
]

2

Lotto, 62 byte

@set/ps=
@set s=%s:0!=1%
@set s=%s:!!=%
@cmd/cset/a%s:1!=1%

Accetta input su STDIN. Batch in realtà comprende i leader in modo !corretto per questa sfida, ma !è necessario affrontare i messaggi finali , che prevede tre passaggi:

  • Cambia 0!in1
  • Elimina le coppie di !!(questo è sicuro anche per le !!s prima della cifra)
  • Elimina eventuali tracce rimanenti !(che ormai possono essere solo dopo a 1)

2

Formula IBM / Lotus Notes - 77 byte

@Eval(@Left(a;@If(@Like(a;"%1%");"1";"0"))+@If(@Ends(a;"!");"1";@Right(a;1)))

Non esiste un TIO per la formula di Notes, quindi di seguito viene mostrato uno screenshot di tutti i casi di test:

Tutti i casi di test

Come funziona

@Eval() valuta una stringa come espressione

Per prima cosa controlliamo se la stringa di input nel campo (input) acontiene 1o0 e prende tutti i caratteri a sinistra di qualunque sia la stringa che sarà una stringa di !caratteri. Non ci importa di quanti. @Eval()ci penseremo noi.

Ora guardiamo per vedere se c'è un !alla fine della stringa. Se c'è un accodamento 1alla !stringa ( 0!e 1!sono entrambi 1 - non importa quanti !caratteri ci sono alla fine) altrimenti accodiamo l'ultimo carattere invariato perché non è un !e potrebbe essere un1 o 0.

Ora abbiamo una stringa contenente le inversioni iniziali più un numero definito dal fatto che ci siano caratteri fattoriali in modo da poter alimentare questo @Eval()e ottenere i risultati sopra.


2

sed, 36 33 31 byte

Pura sed, senza utilità bc / shell. Funziona su GNU sed <4.3; 33 byte su BSD e GNU 4.3+.

s/.!!*$/1/
:
s/!0/1/
s/!1/0/
t

Abbastanza semplice se hai familiarità sed; commentato per coloro che non lo sono:

# Since 0! == 1! == 1 and factorial has precedence, just collapse any trailing "!" 
s/.!!*$/1/
# Define an anonymous label
:
# Invert 0 if needed
s/!0/1/
# Invert 1 if needed
s/!1/0/
# If a change was made, go back to the anonymous label.
t

Test:

% cat 109248.sed
s/.!!*$/1/
:l
s/!0/1/
s/!1/0/
tl
% wc -c 109248.sed
      33 109248.sed
% cat cases
0
1
0!
1!
!0
!1
!0!
!1!
0!!
1!!
!!0
!!1
!0!!
!!!1
!!!0!!!!
!!!1!!!!
% sed -f 109248.sed cases
0
1
1
1
1
0
0
0
1
1
0
1
0
0
0
0
% gsed -f 109248.sed cases
0
1
1
1
1
0
0
0
1
1
0
1
0
0
0
0
%

IIRC alcune versioni (tutte?) Di sedconsentono di utilizzare la stringa null come nome di un'etichetta. Se riesci a farlo funzionare qui, ti risparmierebbe due byte. In realtà, non sono nemmeno sicuro che l'etichetta sia necessaria; a meno che non mi sia sfuggito qualcosa, la prima riga è idempotente, quindi potresti essere in grado di tornare all'inizio del programma invece di aver bisogno di un'etichetta.

@ ais523 L'ho pensato anch'io, ma evidentemente non funziona nelle versioni BSD. La pagina man dice "Se non viene specificata alcuna etichetta, diramare fino alla fine dello script" e anche quello non funzionava quando ho provato.
Kevin,

GNU sed non permettono un'etichetta di essere solo :(più di un bug preso come caratteristica), nel qual caso, sia l' te b! i comandi passano alla posizione dell'etichetta. Inoltre, un codice sed deve funzionare per almeno una versione di sed, simile ad altre lingue, quindi non è necessario creare codice che funzioni anche per BSD.
seshoumara,

2

PHP 7.1, 58 55 54 37 35 byte

Nota: utilizza la codifica IBM-850

echo!!$argn[-1]^strspn($argn,~Ì)%2;

Esegui in questo modo:

echo '!!!0!!!!' | php -nR 'echo!!$argn[-1]^strspn($argn,~Ì)%2;';echo
> 0

Spiegazione

echo
  strspn($a=$argv[1],~Ì) # Count the number of leading exclamation marks.
  % 2                    # Make 0 (even) or 1 (odd).
  ^ !!$a[-1];            # Negate with factorial part (truthy value of the 
                         # last char):
                         # - "0" is considered falsy.
                         # - "1" or "!" is considered truthy.

Ritocchi

  • Salvato 3 byte utilizzando la codifica IBM-850
  • Ho salvato un byte modificando leggermente la regex
  • Salvati 17 byte, nuova versione senza nomi di funzioni lunghi e ritorno
  • Salvato 2 byte utilizzando -R(che rende $argndisponibile)

1

Fagiolo , 24 byte

hexdump:

00000000 26 4a c1 53 a0 17 53 d0 80 a0 5d 20 80 0a a1 80  &JÁS .SÐ. ] ..¡.
00000010 81 00 25 3a ae a1 ab 24                          ..%:®¡«$
00000018

JavaScript equivalente:

+eval(a.replace(/.!+$/,1))

Scusa se ti calpesto, Arnauld .

Spiegazione:

Accetta la prima riga di input come stringa non formattata ae sostituisce qualsiasi cifra seguita da una o più !con 1, in modo che il resto possa essereeval 'd tramite JavaScript.

Prova la demo o la suite di test

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.