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 0
ou 1
, suivie de zéro ou plus !
( /!*[01]!*/
).
Par exemple, l'entrée peut être !!!0!!!!
ou !!!1
ou !0!!
ou 0!
ou 1
.
Les !
avant les 0
ou 1
sont 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 0
ou 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.
Réponses:
Mathematica,
2517 octetsPrend 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!x
résultat dans le résultat, nous le remplaçons par1-x
.Quelques faits amusants sur l'évaluation:
!!
, qui calculen*(n-2)*(n-4)*...
, mais s’applique0
ou1
donne toujours1
, de sorte que0!!!!!
le fait que le résultat soit analysé importe peu((0!!)!!)!
.!0
et!1
n’est pas évalué, il sait qu’il!
est inversé, il annulera automatiquement toutes les paires d’interlignage!
. Après l'ToExpression
on toujours à gauche avec l' un0
,1
,!0
,!1
.la source
x=${x/[01]!*/1};echo $(($x))
- pas autorisé à poster une réponse appropriée :([Bash] + utilitaires Unix,
2117 octetsCela 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:
la source
mkdir -p 's/.!!'{bunch,of,different,directories}\$/1
? Ensuite, vous obtiendrez Pathname Expansion et Sed tentera de lire les répertoires comme s’il s’agissait de fichiers, au lieu de lire les entrées standard, sans produire quoi que ce soit! :)Retina ,
201514 octetsMerci à Leo d’avoir économisé 1 octet.
Essayez-le en ligne!
Explication
Tourner
0!
dans1
. 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.
Comptez le nombre de correspondances de cette regex, qui est soit
1
ou0
et donne le résultat souhaité.la source
\d.+
...^
avant!0
Grime ,
14 129 octetsEssayez-le en ligne!
Explication
Ceci fait correspondre l’entrée à un motif, l’impression
1
pour correspondance et0
pour aucune correspondance.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 un0
. Leur xor réussit à moins que l'entrée soit simple0
. 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.la source
Brainfuck,
8572 (84) octetsretourner numériquement, ou
pour le texte ASCII. > peut également être préfixé pour éviter le wrapping de mémoire.
Essayez-le en ligne!
Ou pour la réponse texte, remplacez la dernière ligne par
la source
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 .
la source
Python,
-44-42octets2 octets sauvés grâce à Zgarb!
Pas à pas:
x[-1]!='0'
si
x
se termine par1
ou!
⇔x
ne se termine pas par0
, la partie factorielle doit avoir une valeur1
, sinon0
^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,.rstrip
ne supprime pas le nombre de la chaîne, la longueur calculée est décalée de 1, donc la condition est inversée.!=
à 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!
la source
!!0
; il revient actuellement1
.lambda x:(x[-1]=='0')^len(x.rstrip('!'))%2
évite l'inversion supplémentaire.JavaScript (ES6),
434129 octetsMéthode non regex (
41 à31 octets)Ci-dessous, mon approche initiale. C'est un peu plus intéressant, mais
nettement plus longencore un peu plus longtemps même après une optimisation significative de Neil (10 octets sauvegardés) .Cas de test
Afficher l'extrait de code
la source
f=([c,...s])=>1/c?c|s>'':1-f(s)
.Gelée , 5 octets
Essayez-le en ligne!
Fonction monadique attendant une chaîne. Entrées avec conduit
!
de provoquer un1
à 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?
la source
05AB1E , 9 octets
Code:
Utilise le codage CP-1252 . Essayez-le en ligne! ou Vérifiez tous les cas de test!
Explication:
la source
Retina , 13 octets
Une approche un peu bizarre, mais c'est court et ça marche.
Avec les deux premières lignes, nous remplaçons une fin
0
par!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!
la source
1
plutôt que\d
.0!
restera inchangée jusqu'à la dernière ligneRuby, 12 + 1 =
39241513 octetsUtilise le
-n
drapeau. Merci à @GB pour -9 octets!la source
0
ou la fin de ligne!*$
c'est plus court de deux!Perl , 20 octets
19 octets de code +
-p
drapeau.Essayez-le en ligne!
Déclarations de négation de Perl
undef
ou1
, donc j'utiliser0+
pour numerify les résultats des0+undef
rendements0
. A part ça, pas grand chose à dire sur le code.la source
C,
68626153 octetsExtraire quelques octets de plus avec quelques abus
Essayez-le en ligne!
la source
int
de la fonction et vous pouvez changer le*a==33
à*a<34
.*a%2
est plus court que*a-48
for(;*a<34;a++)
qu'on peut écourterfor(;*a++<34;)
1 octetPerl 6 ,
322823 octetsComment ça fonctionne
la source
Haskell , 39 octets
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.la source
f('!':b)=[1,0]!!f b;f"0"=0;f _=1
.Befunge, 24 octets
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 un0
ou1
, 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:
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'un1
(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 base0
et1
sont à l’inverse de ce dont nous avons besoin.En regardant le code plus en détail:
la source
Haskell , 27 octets
Essayez-le en ligne!
Chaque interligne
!
complète la sortie pour le reste de l'expression, en tant que1-
. Nous continuons à tourner jusqu'à atteindre un chiffre. Si le reste est juste"0"
, le résultat est 0. Sinon, c'est un1
ou est suivi d'un ou plus!
, le résultat est donc 1.la source
Ruby,
22 2120 octetsExplication:
(-1 octet volant l'idée de @Value Ink)
la source
Gelée , 8 octets
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
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 simpleeval
(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.!
la source
Python, 38 octets
TryItOnline!
Une fonction sans nom prenant une chaîne d'entrée
s
et renvoyant un entier0
ou1
.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 simples.index(max(s))%2
.La
ord(s[-1])%2
vé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.la source
Java 7,
1058281 octetsEssayez-le en ligne!
Ancienne solution regex-ish
la source
c^=1
est super intelligent. C'est un opérateur inutilisé si jamais j'en ai vu un.CJam ,
12 à11 octetsEssayez-le en ligne! Suite de tests (imprime un
1
pour chaque cas de test correct).la source
Haskell ,
67 à65 octetsEssayez-le en ligne! Usage:
f "!!!0!!!!"
Sauvegardé deux octets grâce à @nimi.
la source
Brainfuck, 115 octets
Essayez-le en ligne!
Ungolfed:
la source
Lot, 62 octets
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:0!
en1
!!
(ceci est également sûr pour le!!
s avant le chiffre)!
(qui ne peut maintenant être qu'après a1
)la source
sed,
363331 octetsPure sed, pas de bc / shell utils. Fonctionne sur GNU sed <4.3; 33 octets sur BSD et GNU 4.3+.
Assez simple si vous êtes familier avec
sed
; commenté pour ceux qui ne sont pas:Tester:
la source
sed
vous permettent d'utiliser la chaîne NULL comme nom d'étiquette. Si vous pouvez obtenir que cela fonctionne ici, cela vous ferait économiser deux octets. En fait, je ne suis pas sûr que l'étiquette soit même nécessaire; À moins que quelque chose ne me manque, la première ligne est idempotente. Vous pourrez donc peut-être revenir au début du programme plutôt que d'avoir besoin d'un libellé.:
(plutôt qu’un bogue considéré comme une fonctionnalité), auquel cas les deuxt
etb
! les commandes sautent à la position de l'étiquette. De plus, un code sed doit fonctionner pour au moins une version de sed, similaire aux autres langages. Vous n'avez donc pas besoin de créer un code qui fonctionne également pour BSD.PHP 7.1,
5855543735 octetsRemarque: utilise l'encodage IBM-850
Courez comme ça:
Explication
Tweaks
-R
(ce qui rend$argn
disponible)la source
Formule IBM / Lotus Notes - 77 octets
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'expressionPremièrement, nous vérifions si la chaîne d'entrée dans le champ (entrée)
a
contient1
ou0
et 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 ajoutons1
à la!
chaîne (0!
et1!
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 un1
ou0
.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.la source
Bean , 24 octets
Hexdump:
JavaScript équivalent:
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!
avec1
, de sorte que le reste peut êtreeval
« D par JavaScript.Essayez la démo ou la suite de tests
la source