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.

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.

[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

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.

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

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

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 .

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

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!

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

let f =

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

;[
  "0", "1", "0!", "1!", "!0", "!1", "!0!", "!1!", "0!!",
  "1!!", "!!0", "!!1", "!0!!", "!!!1", "!!!0!!!!", "!!!1!!!!"
].map(
  s => console.log(s, '=>', f(s))
)

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.

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

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!

Rubino, 12 + 1 = 39 24 15 13 byte

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

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

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.

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!

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.

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

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.

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.

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)

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.

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.

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;}

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.

Haskell , 67 65 byte

f s|foldr(\_->not)(last s`elem`"1!")$fst.span(<'0')$s="1"|1<3="0"

Provalo online! Uso:f "!!!0!!!!"

Due byte salvati grazie a @nimi.

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
]

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)

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:

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.

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
%

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)

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