Berechnen Sie den nächsten Wert auf einer Kreisvariablen

Question

Ich habe ein Problem, wo ich 3 Mal den 24-Stunden-Tag habe. Um es einfach i die Dezimaldarstellung verwenden:

a) 23.45 (23.75)

b) 11.30 (11.50)

c) 00:15 (00,25)

Ich möchte für jedes Mal wissen, welche andere Zeit am nächsten ist.

var closestTime = 24 
 
var closestActualTime = 0; 
 

 
for (var i = 0; i < times.length; i++) { 
 
    if (times[i].time == this.time) continue; 
 

 
    var temp = Math.abs(this.time - times[i].time) 
 

 
    if (temp < closestTime) { 
 
    closestTime = temp; 
 
    closestActualTime = times[i].time; 
 
    } 
 
}

Mein Problem ist, dass 23.45 und 00.25 Uhr tatsächlich ganz in der Nähe ist, aber ich weiß nicht, wie Prozess eine Variable mit einem Modulo-Typ

Answer 1

Schleife über Zeiten.

Probieren Sie Kombinationen von Delta-Zeit, Offset von 24 Stunden.

Wählen Sie die kleinste Delta-Zeit.

var times = [23.75, 11.50, 3, 6, 7]; 
 
/** 
 
* timeClosestTo 
 
* 
 
* @param {number} time 
 
* @returns {number} 
 
*/ 
 
function timeClosestTo(time) { 
 
    //Distance variable to compare against 
 
    var distance = 100; 
 
    //Hours in a day 
 
    var day = 24; 
 
    //Current best 
 
    var best = null; 
 
    //Test against all times 
 
    for (var i = 0; i < times.length; i++) { 
 
     //Find best score based upon day 
 
     var d = Math.min(Math.abs((times[i]) - (time)), Math.abs((times[i] + day) - time), Math.abs((times[i]) - (time + day)), Math.abs((times[i] + day) - (time + day))); 
 
     //If best found distance yet, set best to current 
 
     if (d < distance) { 
 
      best = times[i]; 
 
      distance = d; 
 
     } 
 
    } 
 
    //Return best 
 
    return best; 
 
} 
 
console.log("times to deal with:",times.join(", ")); 
 
console.log("closest to 1:", timeClosestTo(1), "closest to 11:", timeClosestTo(11), "closest to 5:", timeClosestTo(5));

Answer 2

Ich schlage vor, eine Liste mit den Paaren zu bauen und dann die Differenz berechnen.

Der Unterschied ist das dritte Element im Array pairs.

Grundsätzlich müssen Sie das Delta überprüfen und wenn es größer als 12 Stunden ist, nehmen Sie die Differenz von 24 und Delta.

delta = Math.abs(aa - bb); 

if (delta > 12) { 
    delta = 24 - delta; 
} 

function combination(array, size) { 
 
    function c(part, start) { 
 
     var i, l, p; 
 
     for (i = start, l = array.length + part.length + 1 - size; i < l; i++) { 
 
      p = part.slice(); 
 
      p.push(array[i]); 
 
      p.length < size ? c(p, i + 1) : result.push(p); 
 
     } 
 
    } 
 

 
    var result = []; 
 
    c([], 0); 
 
    return result; 
 
} 
 

 
function timeDelta(a, b) { 
 
    function decimalTime(s) { 
 
     var p = s.split(':'); 
 
     return +p[0] + p[1]/60; 
 
    } 
 

 
    function padZero(v) { 
 
     return (v < 10) ? '0' + v : String(v); 
 
    } 
 

 
    var aa = decimalTime(a), 
 
     bb = decimalTime(b), 
 
     delta = Math.abs(aa - bb); 
 

 
    if (delta > 12) { 
 
     delta = 24 - delta; 
 
    } 
 
    return padZero(Math.floor(delta)) + ':' + padZero(Math.round(60 * (delta - Math.floor(delta)))); 
 
} 
 

 
var times = ['23:45', '11:30', '00:15'], 
 
    pairs = combination(times, 2); 
 

 
pairs.forEach(function (a, i, aa) { 
 
    aa[i][2] = timeDelta(a[0], a[1]); 
 
}); 
 

 
console.log(pairs);

.as-console-wrapper { max-height: 100% !important; top: 0; }

Answer 3

Ganz funktionell würde ich diesen Job tun, wie folgt

var times = [23.75,11.50,0.25], 
 
    diffs = times.reduce((d,t1,i,a) => a[i+1] ? d.concat(a.slice(i+1) 
 
                  .map(t2 => [t1,t2,[Math.min(Math.abs(t1-t2),24-Math.abs(t1-t2))] 
 
                       .map(n => ~~n + ":" + (n%1)*60)[0]])) 
 
               : d,[]); 
 
console.log(diffs);