En mathématiques, un point d'exclamation !signifie souvent factoriel et vient après l'argument.

Dans la programmation, un point d'exclamation !signifie souvent la négation et vient avant l'argument.

Pour ce défi, nous n'appliquerons ces opérations qu'à zéro et un.

Factorial
0! = 1
1! = 1

Negation
!0 = 1
!1 = 0

Prenez une chaîne de zéro ou plus !, suivie de 0ou 1, suivie de zéro ou plus !( /!*[01]!*/).
Par exemple, l'entrée peut être !!!0!!!!ou !!!1ou !0!!ou 0!ou 1.

Les !avant les 0ou 1sont des négations et les !après sont des factorielles.

La factorielle a une priorité supérieure à la négation, les factorielles sont toujours appliquées en premier.
Par exemple, !!!0!!!!signifie vraiment !!!(0!!!!), ou mieux encore !(!(!((((0!)!)!)!))).

Affiche l'application résultante de toutes les factorielles et négations. La sortie sera toujours 0ou 1.

Cas de 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

Le code le plus court en octets gagne.

Mathematica, 25 17 octets

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

Prend les entrées à partir d'une invite utilisateur. Suppose l’ environnement de bloc - notes de Mathematica pour l’impression implicite. Pour en faire un script de ligne de commande, enveloppez-le Print[...]ou faites-en une fonction sans argument (qui prend ensuite des informations à partir de l'invite), ajoutez-la &.

Mathematica a les deux opérateurs requis (avec la priorité requise), nous pouvons donc simplement "évaluer" l'entrée (ce qui se fait automatiquement Input[]), mais l'opérateur de négation logique ne fonctionne pas sur les entiers (il restera donc non évalué). S'il reste un !xrésultat dans le résultat, nous le remplaçons par 1-x.

Quelques faits amusants sur l'évaluation:

1. En fait, Mathematica dispose également de l’opérateur à double facteur !!, qui calcule n*(n-2)*(n-4)*..., mais s’applique 0ou 1donne toujours 1, de sorte que 0!!!!!le fait que le résultat soit analysé importe peu ((0!!)!!)!.
2. Même si Mathematica part !0et !1n’est pas évalué, il sait qu’il !est inversé, il annulera automatiquement toutes les paires d’interlignage !. Après l' ToExpressionon toujours à gauche avec l' un 0, 1, !0, !1.

[Bash] + utilitaires Unix, 21 17 octets

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

Cela doit être enregistré dans un fichier et exécuté en tant que programme. Si vous essayez d'entrer la commande directement à partir de la ligne de commande, cela ne fonctionnera pas car !! est étendu en raison de l'activation de la substitution d'historique dans le mode interactif de bash. (Vous pouvez également désactiver la substitution d'historique avec set +H.)

Le cas de test s'exécute:

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 octets

Merci à Leo d’avoir économisé 1 octet.

0!
1
!!

^1|!0

Essayez-le en ligne!

Explication

0!
1

Tourner 0!dans 1. Nous ne nous soucions pas des autres signes de fin !, le nombre obtenu est le même que si nous avions appliqué toutes les factorielles.

!!

Annuler les paires de négations. Cela peut aussi annuler certaines factorielles, mais ce n'est pas pertinent.

^1|!0

Comptez le nombre de correspondances de cette regex, qui est soit 1ou 0et donne le résultat souhaité.

Grime , 14 12 9 octets

e`\0!~\!_

Essayez-le en ligne!

Explication

Ceci fait correspondre l’entrée à un motif, l’impression 1pour correspondance et 0pour aucune correspondance.

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

L'idée est la suivante. Si l'entrée commence par un chiffre, la partie récursive \!_échoue toujours et \0!réussit à moins que nous n'en ayons un 0. Leur xor réussit à moins que l'entrée soit simple 0. Si l'entrée commence par a !, alors \0!toujours réussie, et \!_réussie si la correspondance récursive réussit. Leur xor réussit exactement lorsque la correspondance récursive échoue, la niant ainsi.

Brainfuck, 85 72 (84) octets

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

retourner numériquement, ou

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

pour le texte ASCII. > peut également être préfixé pour éviter le wrapping de mémoire.

Essayez-le en ligne!

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

Ou pour la réponse texte, remplacez la dernière ligne par

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

Brainfuck - chemin vers plusieurs octets (232 octets)

Clairement la mauvaise langue pour gagner en code golf. J'ai surtout remarqué un manque de personnes utilisant cet esolang. Il y a un bon interprète en ligne bf ou vous pouvez réellement regarder ce que le programme fait en utilisant ce visualiseur bf .

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

Python, -44-42 octets

2 octets sauvés grâce à Zgarb!

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

Pas à pas:

1. x[-1]!='0'
   si xse termine par 1ou !⇔ xne se termine pas par 0, la partie factorielle doit avoir une valeur 1, sinon0
2. ^len(x.rstrip('!'))%2
   exploiter la propriété de xor comme "conditionnelle". La condition dans ce cas est si la longueur de !s initiale est impair. Cependant, .rstripne supprime pas le nombre de la chaîne, la longueur calculée est décalée de 1, donc la condition est inversée.
3. Le décalage de 1 à l'étape 2 est corrigé en passant !=à l' ==étape 1. Zgarb a suggéré d'utiliser un opérateur de comparaison de différences plutôt que d'appliquer une autre inversion, économisant 2 octets.

Essayez-le en ligne!

JavaScript (ES6), 43 41 29 octets

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

Méthode non regex ( 41 à 31 octets)

Ci-dessous, mon approche initiale. C'est un peu plus intéressant, mais nettement plus long encore un peu plus longtemps même après une optimisation significative de Neil (10 octets sauvegardés) .

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

Cas de 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))
)

Gelée , 5 octets

VeMḂ$

Essayez-le en ligne!

Fonction monadique attendant une chaîne. Entrées avec conduit !de provoquer un 1à imprimer à STDOUT le long du chemin, de sorte que la liaison de TIO je donne est un faisceau de test qui affiche les paires d'entrée-sortie en dessous de la première ligne de sortie.

Comment?

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 octets

Code:

.V¹'!ÜgG_

Utilise le codage CP-1252 . Essayez-le en ligne! ou Vérifiez tous les cas de test!

Explication:

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

Une approche un peu bizarre, mais c'est court et ça marche.

0$
!1
!!

^\d

Avec les deux premières lignes, nous remplaçons une fin 0par !1: avec ce remplacement, nous savons maintenant que la partie de notre chaîne à partir du chiffre est égale à 1.

Les deux lignes suivantes suppriment les paires de !: la double négation s’efface, et nous avons déjà pris en compte factoriel avec l’étape précédente.

Dernière ligne, correspond à un chiffre au début de la chaîne et renvoie le nombre de correspondances: si les négations ont toutes été éliminées, nous trouverons une correspondance (et comme nous l'avons dit auparavant, nous savons qu'il est égal à 1), s'il reste encore une négation cela ne correspondra pas.

Essayez-le en ligne!

Ruby, 12 + 1 = 39 24 15 13 octets

Utilise le -ndrapeau. Merci à @GB pour -9 octets!

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

Perl , 20 octets

19 octets de code + -pdrapeau.

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

Essayez-le en ligne!

Déclarations de négation de Perl undefou 1, donc j'utiliser 0+pour numerify les résultats des 0+undefrendements 0. A part ça, pas grand chose à dire sur le code.

C, 68 62 61 53 octets

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

Extraire quelques octets de plus avec quelques abus

Essayez-le en ligne!

Perl 6 , 32 28 23 octets

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

Comment ça fonctionne

{                     }  # 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 octets

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

Définit une fonction f, qui prend une chaîne et retourne un caractère. Essayez-le en ligne!

Explication

Il y a trois cas: l'entrée commence par !, l'entrée a une longueur de 1 et tout le reste.

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 octets

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

Essayez-le en ligne!

Cela commence par compter le nombre de !caractères lus depuis stdin. Le premier caractère qui n'est pas un !testament sera un 0ou 1, mais dans le processus de test car !nous aurons soustrait 33, soit 15 ou 16. Nous lirons ensuite un autre caractère, qui sera un !ou EOF, et comparer si c'est inférieur à 0 (c.-à-d. EOF).

En prenant ces trois points de données - le nombre d'exclamations ( c ), la valeur numérique, ( d ) et la condition de fin de fichier ( e ) -, nous pouvons calculer le résultat comme suit:

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

Multiplier la valeur du chiffre par la condition de fin de fichier signifie qu'il sera converti à zéro si le chiffre était suivi d'un !, ce qui lui donne la même valeur modulo 2 qu'un 1(qui a été converti en mémoire de rappel à 16). Mais avant d'appliquer le modulo 2, nous ajoutons le nombre d'exclamations initial, ce qui bascule efficacement le résultat du modulo 2 autant de fois qu'il le !fallait. Et finalement, nous n’obtenons pas le résultat puisque nos valeurs de base 0et 1sont à l’inverse de ce dont nous avons besoin.

En regardant le code plus en détail:

~                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 octets

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

Essayez-le en ligne!

Chaque interligne !complète la sortie pour le reste de l'expression, en tant que 1-. Nous continuons à tourner jusqu'à atteindre un chiffre. Si le reste est juste "0", le résultat est 0. Sinon, c'est un 1ou est suivi d'un ou plus !, le résultat est donc 1.

Ruby, 22 21 20 octets

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

Explication:

• Premier cas, j'en ai un '!' à la fin, retirez-les, obtenez la longueur modulo 2.
• Deuxième cas, non '!', Si le dernier caractère est zéro, supprimez-le, obtenez longueur modulo 2
• Si le dernier caractère est 1, retour au premier cas

(-1 octet volant l'idée de @Value Ink)

Gelée , 8 octets

œr”!LḂ=V

Essayez-le en ligne!

C'est une fonction (lien monadique) qui prend un argument et retourne via sa valeur de retour. (Il écrit souvent aussi les effets indésirables sur la sortie standard comme effet secondaire, mais cela ne nous importe pas.)

Explication

œ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

Tout d’abord, notez que l’entrée étant toujours composée d’un certain nombre de !, suivie d’un chiffre, suivie de plusieurs autres !, que si nous supprimons la fin !et prenons la longueur, nous obtenons un plus le nombre de majuscules !du programme. En prenant la parité de ceci retournera 0 s'il y avait un nombre impair de !, ou 1 s'il y avait un nombre pair de !. La comparaison à 0 est une fonction "non", alors que la comparaison à 1 est la fonction d'identité; met donc œr”!LḂ=effectivement en œuvre la !partie de la question "traiter ce qui précède comme des opérateurs NON".

En ce qui concerne la seconde moitié, la gestion des factorielles !est une opération factorielle dans Jelly. Par conséquent, si le programme n’a pas d’avance !, nous pouvons résoudre le problème directement avec un simple eval( V). Si le programme n'ont conduit , ceux - ci seront interprétés comme prenant la factoriel de 0 (éventuellement plusieurs fois), la production d' une valeur de retour de 1, qui sera imprimé à la sortie standard et une fois mis au rebut un chiffre est vu; ainsi, ils n'ont aucun impact sur la valeur de retour de la fonction que je soumets à la question.!

Python, 38 octets

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

TryItOnline!

Une fonction sans nom prenant une chaîne d'entrée set renvoyant un entier 0ou 1.

s[1::2] est une tranche de la chaîne d'entrée qui commence à l'index 1 et a une taille de pas de deux:
'Like this' -> 'ieti'

s[::2] est similaire mais commence à l'index par défaut de 0:
'Like this' -> 'Lk hs'

Le test (s[1::2]>s[::2])vérifie si l'indice de '0'ou ou '1'est impair, c'est-à-dire s'il faut le compléter.
Cela fonctionne parce que l'ordre des chaînes est vérifié lexicographiquement avec toute chaîne non vide supérieure à la chaîne vide, et avec l'ordre ASCII, donc '1'>'0'>'!'. C'est un octet plus court que le plus simple s.index(max(s))%2.

La ord(s[-1])%2vérification vérifie si le dernier caractère n'est pas '0'(pour une entrée valide) et donne un entier (alors que la même longueur (s[-1]!='0')renverrait un booléen).
Cela fonctionne car le dernier caractère de l'entrée s[-1],, sera un '0', '1'ou '!'des points de code ASCII 48, 49 et 33 respectivement, qui sont 0, 1 et 1 modulo 2.

L' ^effectue ensuite une opération OU exclusif au niveau du bit sur les deux valeurs ci - dessus, retournant un entier depuis une entrée, l'une à droite, est un nombre entier. Si la gauche est Vrai, le complément de la droite est renvoyé, si la gauche est Faux, la droite est renvoyé, comme requis.

Java 7, 105 82 81 octets

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

Essayez-le en ligne!

Ancienne solution 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 octets

r_W='0=!\~;

Essayez-le en ligne! Suite de tests (imprime un 1pour chaque cas de test correct).

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 octets

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

Essayez-le en ligne! Usage:f "!!!0!!!!"

Sauvegardé deux octets grâce à @nimi.

Brainfuck, 115 octets

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

Essayez-le en ligne!

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
]

Lot, 62 octets

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

Prend une entrée sur STDIN. Batch comprend en fait !s diriger correctement pour ce défi, mais les problèmes suivants !doivent être résolus, ce qui se fait en trois étapes:

• Changer 0!en1
• Supprimer des paires de !!(ceci est également sûr pour le !!s avant le chiffre)
• Supprimer toute fin restante !(qui ne peut maintenant être qu'après a 1)

sed, 36 33 31 octets

Pure sed, pas de bc / shell utils. Fonctionne sur GNU sed <4.3; 33 octets sur BSD et GNU 4.3+.

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

Assez simple si vous êtes familier avec sed; commenté pour ceux qui ne sont pas:

# 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

Tester:

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

Remarque: utilise l'encodage IBM-850

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

Courez comme ça:

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

Explication

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.

Tweaks

• 3 octets enregistrés à l'aide du codage IBM-850
• Sauvegardé un octet en modifiant légèrement l'expression régulière
• 17 octets enregistrés, nouvelle version sans noms de fonction longs et retour
• Sauvegardé 2 octets en utilisant -R(ce qui rend $argndisponible)

Formule IBM / Lotus Notes - 77 octets

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

Il n'y a pas de TIO pour la formule Notes, une capture d'écran de tous les tests est donc présentée ci-dessous:

Comment ça fonctionne

@Eval() évalue une chaîne en tant qu'expression

Premièrement, nous vérifions si la chaîne d'entrée dans le champ (entrée) acontient 1ou 0et prenons tous les caractères à gauche de celle qui sera une chaîne de !caractères. Nous ne nous soucions pas combien. @Eval()va prendre soin de cela.

Ensuite, nous regardons pour voir s'il y a un !à la fin de la chaîne. S'il existe, nous ajoutons 1à la !chaîne ( 0!et 1!les deux sont 1 - peu importe le nombre de !caractères à la fin), sinon nous ajoutons le dernier caractère sans modification, car il ne s'agit pas d'un !et peut être un 1ou 0.

Nous avons maintenant une chaîne contenant les inversions en tête plus un nombre défini par l'existence ou non de caractères factoriels afin que nous puissions le nourrir @Eval()et obtenir les résultats ci-dessus.

Bean , 24 octets

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 équivalent:

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

Désolé de marcher sur vos orteils, Arnauld .

Explication:

Prend première ligne d'entrée sous forme de chaîne non formatée dans a, et remplace un chiffre suivi d'une ou plusieurs !avec 1, de sorte que le reste peut être eval« D par JavaScript.

Essayez la démo ou la suite de tests