3D-Modellierungssoftware verwendet hauptsächlich UV-Mapping , um Texturen auf ein 3D-Objekt abzubilden. Die gültigen Werte für U und V liegen normalerweise in einem einschließlichen [0..1]Bereich.

Herausforderung

Sie haben eine neue 3D-Modellierungssoftware gekauft, die sehr einfach zu bedienen ist. Es gibt jedoch ein Problem: Es addiert oder subtrahiert eine zufällige ganze Zahl von UV-Werten. Ihre Aufgabe ist es, ein Programm oder eine Funktion zu erstellen, die einen Eingabewert ändert, um einen Gleitkommawert in einem inklusiven [0..1]Bereich zu erhalten.

Der resultierende Float sollte den gleichen Bruchteil wie das Original haben und so nah wie möglich am Original sein. Da beide 0und 1im Ausgabebereich liegen, sollten alle Ganzzahlen 0 oder weniger auf 0 und alle Ganzzahlen 1 oder mehr auf 1 geändert werden.

Ein Beispielalgorithmus in JavaScript:

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

Regeln

• Die Eingabe ist eine einzelne Ganzzahl oder ein Gleitkommawert. Jedes vernünftige Format ist zulässig, solange es in Ihrer Antwort angegeben ist.
• Die Ausgabe sollte eine dezimale Darstellung eines Gleitkommawerts sein.
• Die Ausgabegenauigkeit sollte mindestens die gleichen Dezimalstellen wie die Eingabe haben.
• Nachgestellte Nullen sind zulässig.
• Stellen Sie sicher, dass Ihr Code die 0 oder 1 für Ganzzahleingaben richtig auswählt.

Testfälle

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

Das ist Code-Golf , also gewinnt der kürzeste Code in Bytes!

Gelee , 6 Bytes

%1o>0$

Probieren Sie es online!

Jelly hat keine Trueoder False, sondern nutzt 1und 0an ihrer Stelle.

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

Probieren Sie es online!

Nimmt das Eingangsmodulo 1 und behandelt dann den Grenzfall, indem Ausgänge von 0 in 1 für positive Eingänge konvertiert werden. Eine Bool-Ausgabe würde zwei Bytes sparen.

lambda x:x%1or x>0

Brachylog , 14 11 Bytes

Danke an Fatalize für das Golfen mit 3 Bytes.

∧≜:?+.≥0∧1≥

Zur Abwechslung benutzt diese Antwort keinen Mod :)

Probieren Sie es online!

Erläuterung

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

Gibt in JavaScript n%xeine negative Zahl zurück, wenn sie nnegativ ist. Wenn wir also den positiven Rest erhalten möchten, müssen wir hinzufügen, xwenn sie nnegativ ist. (n%x+x)%xdeckt alle Fälle ab:

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

Eine andere funktionierende Lösung bei 20 Bytes, die ein bisschen mehr von einem Muster zeigt:

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

MATL , 9 Bytes

1&\0>yg>+

Probieren Sie es online! Oder überprüfen Sie alle Testfälle .

Erläuterung

Beispiel mit Eingabe 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

Verringert / erhöht die Werte rekursiv um 1, bis das Ergebnis in [0,1] angezeigt wird.

Japt , 8 Bytes

u1 ªUbV1

Testen Sie es online!

Ich denke, dies ist das erste Mal, dass ich jemals benutzt habe b...

Erläuterung

 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&

Erläuterung

Dies ist eine eher ungewöhnliche Anwendung, /;bei der ich sie eher als eine verwende, &&da die Bedingung danach nichts mit dem Muster zu tun hat, zu dem sie passt.

#~Mod~1...

Berechnen x % 1, was für alle Fälle außer positiven ganzen Zahlen korrekt ist.

.../. 0/;...

Ersetzen Sie Nullen im vorherigen Ausdruck, wenn ...

...#>0...

... der Eingang ist positiv ...

...->1...

mit 1.

PHP, 37 Bytes

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

Laufen Sie mit echo <number> | php -R '<code>'.

Es gibt so viele Möglichkeiten, dies zu tun ... dies sollte eine der kürzesten in PHP sein.

Das fmodErgebnis ist negativ für negative Floats und 0für positive ganze Zahlen. diese müssen !!$mangepasst werden : gilt für floats, xoring mit den $n>0Ergebnissen false für positives float und negatives int, true für negatives float und positives int; +wirft das zu 1oder 0- erledigt.

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 Danke für den Hinweis!

Ungolfed-Version:

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

Probieren Sie es online!

SmileBASIC, 28 Bytes

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

JavaScript (ES6), 19 Byte

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

Erklärung: %1liefert nicht in allen Fällen die richtigen Ergebnisse:

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

In den falschen Fällen muss eine zusätzliche 1 hinzugefügt werden. Dabei handelt es sich um eine negative, nicht ganzzahlige und eine positive ganze Zahl. Dies (n>0==!(n%1))berechnet der Ausdruck .

> <> 26 Bytes

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

Probieren Sie es online!

Da Lösungen in guten Golfsprachen fast immer sofort gegeben sind, habe ich beschlossen, die Dinge durcheinander zu bringen. Erste <> <Antwort!

Erläuterung

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

Eine lustige Tatsache: Die Erklärung ist ein gültiges <> <Programm!

Javascript, 41 28 Bytes

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

Math.floor() ist so lang ...

Pyth, 7 Bytes

|%Q1s<0

Erläuterung

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

Wenn es Ihnen nichts ausmacht, True und False als 1 und 0 zu verwenden, können Sie die s6 Bytes löschen.

Perl 6 , 15 Bytes

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

Probieren Sie es online!

Inspiriert von Seshoumaras Kommentar, dass Mod 1 fast funktioniert.

EDIT: Ha, Xnors Python-Lösung hat mich geschlagen.