Le logiciel de modélisation 3D utilise principalement UV Mapping pour cartographier les textures sur un objet 3D. Les valeurs valides pour U et V sont généralement situées dans une [0..1]plage inclusive .

Défi

Vous avez acheté un nouveau logiciel de modélisation 3D extrêmement simple à utiliser. Cependant, il y a un problème: il ajoute ou soustrait un nombre entier aléatoire des valeurs UV. Votre tâche consiste à créer un programme ou une fonction qui modifie une valeur d'entrée pour obtenir une valeur flottante dans une [0..1]plage inclusive .

Le flotteur résultant doit avoir la même partie fractionnaire que l'original et être aussi proche que possible de l'original. Étant donné que les deux 0et se 1trouvent dans la plage de sortie, tous les entiers 0 ou moins doivent passer à 0 et tous les entiers 1 ou supérieur doivent passer à 1.

Un exemple d'algorithme en JavaScript:

function modFloat(input) {
    while (input < 0 || input > 1) {
        if (input < 0) input += 1;
        if (input > 1) input -= 1;
    }
    return input;
}

Règles

• L'entrée est un entier ou une valeur flottante unique. Tout format raisonnable est autorisé tant qu'il est spécifié dans votre réponse.
• La sortie doit être une représentation décimale d'une valeur flottante.
• La précision de sortie doit être au moins égale à la même décimale que l'entrée.
• Les zéros de fin sont autorisés.
• Assurez-vous que votre code choisit correctement celui de 0 ou 1 à afficher pour les entrées entières.

Cas de test

Input       | Output
------------+---------
         -4 | 0
         -1 | 0
          0 | 0
          1 | 1
          2 | 1
     1.0001 | 0.000100
 678.123456 | 0.123456
-678.123456 | 0.876544
        4.5 | 0.5

C'est le code-golf , donc le code le plus court en octets gagne!

Gelée , 6 octets

%1o>0$

Essayez-le en ligne!

La gelée n'a pas Trueou False, mais utilise 1et 0à sa place.

%1o>0$ - Main link: float v
%1     - v mod 1
     $ - last two links as a monad
   >0  -     v greater than zero?
  o    - or - replace the 0 result of the mod with 1 when v is greater than 0.

Python , 20 octets

lambda x:x%1or+(x>0)

Essayez-le en ligne!

Prend le module d'entrée 1, puis gère le cas limite en convertissant les sorties de 0 en 1 pour les entrées positives. Une sortie booléenne économiserait deux octets.

lambda x:x%1or x>0

Brachylog , 14 11 octets

Merci à Fatalize d'avoir joué au golf 3 octets.

∧≜:?+.≥0∧1≥

Pour changer, cette réponse n'utilise pas de mod :)

Essayez-le en ligne!

Explication

∧≜                Label an integer variable. This will start trying different
                  values for this variable, the ones closest to 0 first.
   :?+.           This variable summed to the input is equal to the output
      .≥0∧1≥      which is >= 0 and <= 1

JavaScript (ES6), 19 octets

n=>(n%1+1)%1||n>0|0

En JavaScript, n%xrenvoie un nombre négatif si nest négatif, ce qui signifie que si nous voulons obtenir le résidu positif, nous devons ajouter xsi nest négatif. (n%x+x)%xcouvre tous les cas:

n     n%1   n%1+1 (n%1+1)%1
0     0     1     0
1     0     1     0
2.4   0.4   1.4   0.4
-1    0     1     0
-2.4  -0.4  0.6   0.6

Une autre solution de travail à 20 octets, qui montre un peu plus d'un modèle:

n=>n%1+(n%1?n<0:n>0)

MATL , 9 octets

1&\0>yg>+

Essayez-le en ligne! Ou vérifiez tous les cas de test .

Explication

Exemple avec entrée 678.123456

1      % Push 1
       % STACK: 1
&\     % Implicit input. Divmod with 1
       % STACK: 0.123456, 678
0>     % Is it positive?
       % STACK: 0.123456, 1
y      % Duplicate from below
       % STACK: 0.123456, 1, 0.123456
g      % Convert to logical: nonzero becomes 1
       % STACK: 0.123456, 1, 1
>      % Greater than? This is true if fractional part of input was zero
       % and non-fractional part was positive
       % STACK: 0.123456, 0
+      % Add. Implicitly display
       % STACK: 0.123456

Javascript, 28 octets

m=f=>f<0?m(f+1):f>1?m(f-1):f

Diminue / augmente récursivement les valeurs de 1 jusqu'à ce que le résultat soit dans [0,1]

Japt , 8 octets

u1 ªUbV1

Testez-le en ligne!

Je pense que c'est la première fois que je l'utilise b...

Explication

 u1 ªUbV1  // Implicit: U = input, V = 0
Uu1        // Take U%1, but add 1 if U is negative. This is equivalent to %1 in Python.
    ª      // If the result is falsy (0), instead take
     UbV1  //   U bound between 0 and 1.
           // This converts positive integers to 1, zero/negative integers to 0.
           // Implicit: output result of last expression

Mathematica, 20 octets

#~Mod~1/. 0/;#>0->1&

Explication

C'est une utilisation plutôt inhabituelle de l' /;endroit où je l'utilise plus comme un &&parce que la condition après elle n'a rien à voir avec le motif auquel elle correspond.

#~Mod~1...

Calcul x % 1, qui est correct pour tous les cas sauf les entiers positifs.

.../. 0/;...

Remplacez les zéros dans l'expression précédente si ...

...#>0...

... l'entrée est positive ...

...->1...

avec 1.

PHP, 37 octets

<?=($m=fmod($argn,1))+(!!$m^$argn>0);

Courez avec echo <number> | php -R '<code>'.

Il y a tellement de façons de le faire ... cela devrait être l'un des plus courts en PHP.

Le fmodrésultat est négatif pour les flottants négatifs et 0pour les entiers positifs; ceux-ci doivent être !!$majustés : est vrai pour les flottants, xoring avec des $n>0résultats faux pour le flottant positif et int négatif, vrai pour le flottant négatif et int positif; +jette cela à 1ou 0- fait.

C 57 56 73 octets

b;f(float n){b=n;printf("%f",((!(n-b)&&n<=0)?0:n<0?1.+n-b:(n-b)?n-b:1));}

@ pinkfloydx33 Merci d'avoir souligné!

Version non golfée:

f(float n)
{
  int b=n;
  printf("%f",( (!(n-b)&&n<=0)?0:n<0?1.+n-b:(n-b)?n-b:1) );
}

Essayez-le en ligne!

SmileBASIC, 28 octets

INPUT N?N-FLOOR(N)+(N<<0==N)

JavaScript (ES6), 19 octets

n=>(n>0==!(n%=1))+n

Explication: %1ne donne pas les résultats corrects dans tous les cas:

input       %1          output
-ve int     -0
-ve frac    -ve frac    +ve frac
0           0
+ve frac    +ve frac
+ve int     0           1

Un 1 supplémentaire doit être ajouté dans les cas erronés, qui sont ceux d'un non-entier négatif et d'un entier positif. C'est ce que l'expression (n>0==!(n%1))calcule.

> <> , 26 octets

:1%:?vr1(?v1n;
     >n;n0<

Essayez-le en ligne!

Parce que les solutions sont bonnes langues de golf sont presque toujours fournies instantanément, j'ai décidé de mélanger les choses. Première <> <réponse!

Explication

:1%:?vr1(?v1n;    Assume input i in stack
     >n;n0<

:                 Duplicate i (need it if i%1 != 0)
 1                Push 1
  %               Pop i and 1, push i%1
   :              Duplicate top of stack because  we need one for the if     
    ?v            If i%1 != 0 ------------------------,
      r           Reverse stack so that i is TOS      | 
       1(?v       If i > 0 (not < 1)                  |
           1n;      Print 1 and Exit                  |
                  Else                                |                   
        n0<         Print 0 and --,                   |
     >n           Print n <-------|-------------------'
       ;          Exit <----------'

Fait amusant: l'explication est un programme <> <valide!

Javascript, 41 28 octets

n=>n-Math.floor(n)+(n<<0==n)

Math.floor() c'est si long ...

Pyth, 7 octets

|%Q1s<0

Explication

|%Q1s<0
|%Q1s<0Q      Implicitly add input
 %Q1          Input mod 1
|             Short-circuting or
    s<0Q      1 if input is positive, 0 otherwise

Si cela ne vous dérange pas d'utiliser True et False comme 1 et 0, vous pouvez supprimer le spour 6 octets.

Perl 6 , 15 octets

{+($_%1||$_>0)}

Essayez-le en ligne!

Inspiré par le commentaire de seshoumara que le mod 1 fonctionne presque .

EDIT: Ha, la solution Python de xnor m'a battu.