Selon Wikipédia , une fonction fortement Darboux est

celui pour lequel l'image de chaque intervalle ouvert (non vide) est la ligne réelle entière

En d'autres termes, une fonction $f$ est fortement Darboux si on lui donne 3 nombres réels arbitraires $a$ , $b$ et $y$ , il est toujours possible de trouver un $x$ entre (distinct) $a$ et $b$ tel que $f(x) = y$ .

Aux fins de ce défi, nous considérerons plutôt les fonctions de Darboux plutôt que les logiques.

Votre défi consiste à écrire un programme ou une fonction qui:

• donne un nombre rationnel en sortie pour chaque entrée de nombre rationnel,
• donne toujours la même sortie pour une entrée donnée, et
• a la propriété fortement Darboux.

L'entrée et la sortie peuvent être l'une des suivantes:

• un type de nombre à précision arbitraire, si votre langue en possède un (ou possède une bibliothèque pour un, par exemple GMP).
• une représentation sous forme de chaîne du nombre, que vous pouvez supposer, contiendra toujours un point décimal et au moins un chiffre de chaque côté. Il peut être dans n'importe quelle base $b \geq 2$ , mais l'entrée et la sortie doivent être dans la même base. Vous pouvez utiliser n'importe quel jeu de caractères pour les chiffres et le point décimal (mais encore une fois, ils doivent être cohérents entre l'entrée et la sortie).

L'entrée aura toujours une extension de base $b$ terminale . En ce qui concerne la sortie, qui peut avoir une expansion de base $b$ théoriquement non terminale en fonction de votre choix de fonction, vous pouvez choisir l'une des options suivantes:

• chiffres de sortie pour toujours.
• prendre un entier supplémentaire en entrée et en sortie au moins autant de chiffres.
• afficher au moins autant de chiffres que l'entrée (qui peut contenir des zéros de fin).

Notez que par la nature de ce défi, la convention selon laquelle les nombres peuvent être supposés être représentables par des types de nombres standard ne s'applique pas , sauf pour la deuxième entrée décrite dans l'option 2 ci-dessus.

Pour éviter les failles avec des fonctions qui ne sont définies que sur des justifications sans terminaison, votre soumission doit être capable de produire une sortie arbitrairement proche d'une valeur souhaitée dans la pratique . Formellement, compte tenu des nombres rationnels $a$ , $b$ , $y$ et $\varepsilon$ , il doit y avoir un nombre rationnel $x$ qui se termine dans votre base choisie de telle sorte que $a<x<b$ et $|f(x)-y|<\varepsilon$ .

Pour vous donner quelques idées, voici une description de la fonction Conway base 13 :

• Convertissez $x$ en base 13 et supprimez le séparateur décimal.
• Si le résultat est de la forme $[x]A[y]C[z]_{13}$ , où $[y]$ et $[z]$ sont constitués uniquement de chiffres de 0 à 9, alors $f(x) = [y].[z]$ .
• $[x]B[y]C[z]_{13}$$[y]$$[z]$$f(x) = -[y].[z]$
• $f(x) = 0$

$x$$123.456_{13}$$123.457_{13}$$f(x) = 7.89$$123.456A7C89_{13}$

Votre soumission peut être une implémentation de cette fonction, bien que je soupçonne qu'il existe d'autres fonctions fortement Darboux qui sont beaucoup plus courtes à implémenter. :)

Retina 0.8.2 , 43 50 octets

^.*\.(..)*1(.)((..)+)1.((..)*)$
$2$*-$3.$5
0(.)
$1

Essayez-le en ligne! L'E / S est une chaîne binaire. Encodez un nombre binaire yproche d'un autre nombre binaire acomme suit:

1. Si ane contient pas de .suffixe, un.
2. Si acontient un nombre impair de chiffres après le ., suffixe a 0.
3. Si yest négatif, alors suffixe 11sinon suffixe 10.
4. Pour chaque chiffre entrant y, suffixe 0suivi de ce chiffre.
5. Si ycontient un .suffixe 11à ce point, sinon suffixez-le après tous les chiffres y.

Explication:

^.*\.(..)*1(.)((..)+)1.((..)*)$
$2$*-$3.$5

Associez les chiffres commençant au point binaire. Si le nombre est un codage valide, décodez la dernière 1xpaire de chiffres en a .et l'avant-dernier en -signe facultatif . Les chiffres avant cela sont ignorés.

0(.)
$1

Cela devrait simplement laisser des paires qui commencent par 0, donc supprimez le 0s.

Gelée , 71 octets

L7*©ṛḅ7WµṪ×⁵d®µ⁴‘¤Ð¡ḊṖ
DF7,8ṣṪ¥ƒṣ9ḅ7×ɗÇƭ€j”,
DFf7r9¤ṫ-Ḍ⁼Ɱ“OY‘TịØ+³çƲ0Ẹ?

Essayez-le en ligne!

Un programme complet qui prend un nombre de base 10 comme entrée et sortie et implémente la fonction Conway base 13 mais en utilisant les bases 7 et 10 plutôt que 10 et 13. Les entrées et les sorties utilisent des virgules comme séparateur décimal. La sortie aura un début - pour les nombres négatifs.

Retina ,28 25 26 28 octets

.*11|22
.
D^`\.
^3
-
4(.)
$1

Essayez-le en ligne!

Explication

.*11|22     Delete up to the last 11 and prepend a dot. Also change 22 to a dot.
.
D^`\.       Keep only the last dot, if there is one.
^3          Change 3 at the beginning to a minus sign.
-
4(.)        4 is the escape character.
$1

Il peut générer des zéros de début et de fin et des nombres sans partie entière.

Il pourrait être joué 2 ou 3 octets de plus si je pouvais l'utiliser 4+. Mais je ne sais pas comment définir le résultat théorique si l'entrée a un flux sans fin de 4s.