El software de modelado 3D utiliza principalmente el mapeo UV para mapear texturas en un objeto 3D. Los valores válidos para U y V generalmente se encuentran en un [0..1]rango inclusivo .

Desafío

Usted compró un nuevo software de modelado 3D que es súper fácil de usar. Sin embargo, hay un problema: agrega o resta un número entero aleatorio de los valores UV. Su tarea es crear un programa o una función que modifique un valor de entrada para obtener un valor flotante en un [0..1]rango inclusivo .

El flotador resultante debe tener la misma parte fraccional que el original y estar lo más cerca posible del original. Debido a que ambos 0y 1están en el rango de salida, cualquier número entero 0 o menos debería cambiar a 0, y cualquier número entero 1 o mayor debería cambiar a 1.

Un algoritmo de ejemplo en JavaScript:

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

Reglas

• La entrada es un entero único o valor flotante. Se permite cualquier formato razonable siempre que se especifique en su respuesta.
• La salida debe ser una representación decimal de un valor flotante.
• La precisión de salida debe ser al menos los mismos lugares decimales que la entrada.
• Se permiten ceros finales.
• Asegúrese de que su código elija correctamente cuál de 0 o 1 para generar entradas enteras.

Casos de prueba

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

Este es el código de golf , por lo que gana el código más corto en bytes.

Jalea , 6 bytes

%1o>0$

Pruébalo en línea!

Jelly no tiene Trueo False, pero usa 1y 0en su lugar.

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

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

Pruébalo en línea!

Toma el módulo de entrada 1, luego maneja el caso límite al convertir salidas de 0 a 1 para entradas positivas. Una salida bool ahorraría dos bytes.

lambda x:x%1or x>0

Brachylog , 14 11 bytes

Gracias a Fatalize por jugar al golf 3 bytes.

∧≜:?+.≥0∧1≥

Para variar, esta respuesta no usa mod :)

Pruébalo en línea!

Explicación

∧≜                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 bytes

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

En JavaScript, n%xdevuelve un número negativo si nes negativo, lo que significa que si queremos obtener el residuo positivo, debemos agregar xsi nes negativo. (n%x+x)%xcubre todos los casos:

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

Otra solución de trabajo a 20 bytes, que muestra un poco más de un patrón:

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

MATL , 9 bytes

1&\0>yg>+

Pruébalo en línea! O verificar todos los casos de prueba .

Explicación

Ejemplo con entrada 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 bytes

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

Recurrentemente disminuye / aumenta los valores en 1 hasta que el resultado esté en [0,1]

Japt , 8 bytes

u1 ªUbV1

¡Pruébalo en línea!

Creo que esta es la primera vez que uso b...

Explicación

 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 bytes

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

Explicación

Este es un uso bastante inusual de /;donde lo estoy usando más como &&porque la condición después de que no tiene nada que ver con el patrón que coincide.

#~Mod~1...

Calcular x % 1, que es correcto para todos los casos, excepto los enteros positivos.

.../. 0/;...

Reemplace ceros en la expresión anterior si ...

...#>0...

... la entrada es positiva ...

...->1...

con 1.

PHP, 37 bytes

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

Corre con echo <number> | php -R '<code>'.

Hay muchas maneras de hacer esto ... esta debería ser una de las más cortas en PHP.

El fmodresultado es negativo para flotantes negativos y 0para enteros positivos; esos necesitan ajuste: !!$mes verdadero para flotadores, xoring con $n>0resultados en falso para flotador positivo e int negativo, verdadero para flotador negativo e int positivo; +lanza eso a 1o 0- hecho.

C 57 56 73 bytes

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

@ pinkfloydx33 Gracias por señalar!

Versión sin golf:

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

Pruébalo en línea!

SmileBASIC, 28 bytes

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

JavaScript (ES6), 19 bytes

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

Explicación: %1no da los resultados correctos en todos los casos:

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

Es necesario agregar un 1 adicional en los casos que son incorrectos, que son los de un entero no negativo y un entero positivo. Esto es lo que (n>0==!(n%1))calcula la expresión .

> <> , 26 bytes

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

Pruébalo en línea!

Debido a que las soluciones en buenos idiomas de golf casi siempre se dan de manera bastante instantánea, decidí mezclar las cosas. Primero <> <respuesta!

Explicación

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

Dato curioso: ¡la explicación es un programa <> <válido!

Javascript, 41 28 bytes

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

Math.floor() es tan largo ...

Pyth, 7 bytes

|%Q1s<0

Explicación

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

Si no le importa usar Verdadero y Falso como 1 y 0, puede soltar s6 bytes.

Perl 6 , 15 bytes

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

Pruébalo en línea!

Inspirado por el comentario de seshoumara de que el mod 1 casi funciona.

EDITAR: Ja, la solución Python de xnor me ganó.