Numero tondo fino al multiplo più vicino di 3

Hay, come faccio a arrotondare un numero sul multiplo più vicino di 3?

vale a dire

25 would return 27 1 would return 3 0 would return 3 6 would return 6 

Grazie

  if(n > 0) return Math.ceil(n/3.0) * 3; else if( n < 0) return Math.floor(n/3.0) * 3; else return 3; 

Ecco qui!

 Number.prototype.roundTo = function(num) { var resto = this%num; if (resto <= (num/2)) { return this-resto; } else { return this+num-resto; } } 

Esempi:

 y = 236.32; x = y.roundTo(10); // results in x = 240 y = 236.32; x = y.roundTo(5); // results in x = 235 

Semplicemente:

 3.0*Math.round(n/3.0) 

?

Sto rispondendo a questo in psuedocode poiché programma principalmente in SystemVerilog e Vera (ASIC HDL). % rappresenta una funzione modulo.

 round_number_up_to_nearest_divisor = number + ((divisor - (number % divisor)) % divisor) 

Questo funziona in ogni caso.

Il modulo del numero calcola il resto, sottraendo che dal divisore risulta il numero richiesto per arrivare al successivo divisore multiplo, quindi si verifica la “magia”. Si potrebbe pensare che sia sufficiente avere la funzione modulo singolo, ma nel caso in cui il numero sia un multiplo esatto del divisore, calcola un multiplo in più. cioè, 24 restituirebbe 27. Il modulo aggiuntivo protegge da ciò facendo l’aggiunta 0.

Come menzionato in un commento alla risposta accettata, puoi semplicemente usare questo:

 Math.ceil(x/3)*3 

(Anche se non restituisce 3 quando x è 0, perché probabilmente era un errore dell’OP.)

Delle nove risposte pubblicate prima di questa (che non sono state cancellate o che non hanno un punteggio così basso da non essere visibili a tutti gli utenti), solo quelle di Dean Nicholson (eccetto il problema con la perdita di significato) e beauburrier sono corretti. La risposta accettata dà il risultato sbagliato per i numeri negativi e aggiunge un’eccezione a 0 per spiegare quello che era probabilmente un errore dell’OP. Altre due risposte arrotondano un numero al multiplo più vicino invece di arrotondare sempre, un altro dà il risultato sbagliato per i numeri negativi, e altri tre danno anche il risultato sbagliato per i numeri positivi.

Questa funzione arrotonda al multiplo più vicino di qualunque fattore tu fornisca. Non arrotonderà 0 o numeri che sono già multipli.

 round_up = function(x,factor){ return x - (x%factor) + (x%factor>0 && factor);} round_up(25,3) 27 round up(1,3) 3 round_up(0,3) 0 round_up(6,3) 6 

Il comportamento per 0 non è quello che hai chiesto, ma sembra più coerente e utile in questo modo. Se volessi comunque arrotondare 0, la seguente funzione lo farebbe:

 round_up = function(x,factor){ return x - (x%factor) + ( (x%factor>0 || x==0) && factor);} round_up(25,3) 27 round up(1,3) 3 round_up(0,3) 3 round_up(6,3) 6 

(n – n mod 3) +3

Basandosi sull’approccio di @ Makram, ho trovato che l’esempio originale di Math.prototype non arrotondava accuratamente i numeri negativi. Ecco una funzione leggermente modificata che riguarda sia i numeri positivi sia quelli negativi sia nell’istanza che in più valori:

 Number.prototype.mround = function(_mult) { var base = Math.abs(this); var mult = Math.abs(_mult); var mod = (base % mult); if (mod <= (mult / 2)) { base -= mod; } else { base += (mult - mod); } return (this<0)?-base:base ; } 

Esempi: (-2) .mround (3) restituisce -3;
(0) .mround (3) restituisce 0;
(2) .mround (3) restituisce 3;
(25.4) .mround (3) restituisce 24;

 $(document).ready(function() { var modulus = 3; for (i=0; i < 21; i++) { $("#results").append("
  • " + roundUp(i, modulus) + "
  • ") } }); function roundUp(number, modulus) { var remainder = number % modulus; if (remainder == 0) { return number; } else { return number + modulus - remainder; } }
      Round up to nearest multiple of 3: 
     if(x%3==0) return x else return ((x/3|0)+1)*3