Il software di modellazione 3D utilizza principalmente la mappatura UV per mappare le trame su un oggetto 3D. I valori validi per U e V si trovano generalmente in un [0..1]intervallo inclusivo .

Sfida

Hai acquistato un nuovo software di modellazione 3D che è semplicissimo da usare. Tuttavia, esiste un problema: aggiunge o sottrae un numero intero casuale dai valori UV. Il tuo compito è creare un programma o una funzione che modifichi un valore di input per ottenere un valore float in un [0..1]intervallo inclusivo .

Il galleggiante risultante dovrebbe avere la stessa parte frazionaria dell'originale ed essere il più vicino possibile all'originale. Poiché entrambi 0e si 1trovano nell'intervallo di output, qualsiasi numero intero 0 o inferiore dovrebbe cambiare in 0 e qualsiasi numero intero 1 o maggiore dovrebbe cambiare in 1.

Un algoritmo di esempio in JavaScript:

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

Regole

• L'input è un singolo numero intero o float. È consentito qualsiasi formato ragionevole purché sia ​​specificato nella risposta.
• L'output dovrebbe essere una rappresentazione decimale di un valore float.
• La precisione dell'output deve essere almeno delle stesse cifre decimali dell'input.
• Sono consentiti zeri finali.
• Assicurati che il tuo codice scelga correttamente quale di 0 o 1 emettere per input interi.

Casi 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

Questo è code-golf , quindi vince il codice più corto in byte!

Gelatina , 6 byte

%1o>0$

Provalo online!

Jelly non ha Trueo False, ma usa 1e 0al loro posto.

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

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

Provalo online!

Accetta l'input modulo 1, quindi gestisce il caso limite convertendo le uscite da 0 a 1 per input positivi. Un output bool risparmierebbe due byte.

lambda x:x%1or x>0

Brachylog , 14 11 byte

Grazie a Fatalize per giocare a golf a 3 byte.

∧≜:?+.≥0∧1≥

Per una modifica, questa risposta non usa mod :)

Provalo online!

Spiegazione

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

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

In JavaScript, n%xrestituisce un numero negativo se nè negativo, il che significa che se vogliamo ottenere il residuo positivo, dobbiamo aggiungere xse nè negativo. (n%x+x)%xcopre tutti i casi:

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

Un'altra soluzione funzionante a 20 byte, che mostra un po 'più di uno schema:

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

MATL , 9 byte

1&\0>yg>+

Provalo online! Oppure verifica tutti i casi di test .

Spiegazione

Esempio con input 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 byte

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

Diminuisce / aumenta ricorsivamente i valori di 1 fino a quando il risultato è in [0,1]

Japt , 8 byte

u1 ªUbV1

Provalo online!

Penso che questa sia la prima volta che abbia mai usato b...

Spiegazione

 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 byte

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

Spiegazione

Questo è un uso piuttosto insolito di /;dove lo sto usando più come un &&perché la condizione dopo non ha nulla a che fare con il modello che corrisponde.

#~Mod~1...

Calcola x % 1, che è corretto per tutti i casi tranne i numeri interi positivi.

.../. 0/;...

Sostituisci gli zeri nell'espressione precedente se ...

...#>0...

... l'ingresso è positivo ...

...->1...

con 1.

PHP, 37 byte

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

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

Ci sono molti modi per farlo ... questo dovrebbe essere uno dei più brevi in ​​PHP.

Il fmodrisultato è negativo per i float negativi e 0per i numeri interi positivi; quelli necessitano di aggiustamento: !!$mè vero per i float, xoring con $n>0risultati falsi per float positivo e int negativo, vero per float negativo e int positivo; +lo proietta 1o 0fatto.

C 57 56 73 byte

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

@ pinkfloydx33 Grazie per la segnalazione!

Versione non golfata:

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

Provalo online!

SmileBASIC, 28 byte

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

JavaScript (ES6), 19 byte

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

Spiegazione: %1non fornisce i risultati corretti in tutti i casi:

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

È necessario aggiungere un ulteriore 1 nei casi errati, che sono quelli di un numero intero negativo e un numero intero positivo. Questo è ciò che (n>0==!(n%1))calcola l'espressione .

> <> , 26 byte

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

Provalo online!

Poiché le soluzioni in buone lingue del golf sono quasi sempre fornite all'istante, ho deciso di mescolare le cose. Prima <> <risposta!

Spiegazione

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

Curiosità: la spiegazione è un programma <> <valido!

Javascript, 41 28 byte

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

Math.floor() è così lungo ...

Pyth, 7 byte

|%Q1s<0

Spiegazione

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

Se non ti dispiace usare True e False come 1 e 0, puoi rilasciare sper 6 byte.

Perl 6 , 15 byte

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

Provalo online!

Ispirato dal commento di seshoumara che la mod 1 quasi funziona.

EDIT: Ah, la soluzione Python di xnor mi ha battuto.