Computación de descuentos basados ​​en la cantidad -- java camp codereview Relacionados El problema

Computing quantity-based discounts


10
vote

problema

Español

Soy profesor de CS y proporcionó este código como una pequeña parte de una asignación de refactorización:

  private double getTotalPrice(int quantity, double itemPrice) {     if (quantity == 13) {         return itemPrice * 12; // Baker's dozen     }     else if (quantity >= 6) {         return itemPrice * quantity * .95;     } else {         return itemPrice * quantity;     } }   

Se supone que los estudiantes eliminan los números mágicos inapropiados, pero, al discutir el código anterior con ellos, me di cuenta de que no conozco la mejor manera de mejorar el código anterior. No estoy interesado en mejorar el rendimiento, solo enseñando cómo escribir código limpio y mantenible.

Actualizaciones

Me doy cuenta de que hay otros problemas con el código, algunos intencionales. Lo que más le interesa es cómo nombrar los números mágicos.

El propósito del código es determinar el precio total para un pedido de hasta 13 elementos (límite en su lugar para evitar el acaparamiento). Mis prioridades son la legibilidad y la mantenabilidad.

Original en ingles

I'm a CS professor and provided this code as a small piece of a refactoring assignment:

private double getTotalPrice(int quantity, double itemPrice) {     if (quantity == 13) {         return itemPrice * 12; // Baker's dozen     }     else if (quantity >= 6) {         return itemPrice * quantity * .95;     } else {         return itemPrice * quantity;     } } 

Students are supposed to remove inappropriate magic numbers, but, when discussing the above code with them, I realized I don't know the best way to improve the above code. I'm not interested in improving performance, just teaching how to write clean and maintainable code.

Updates

I realize there are other problems with the code, some intentional. What I am most interested in is how to name the magic numbers.

The purpose of the code is to determine the total price for an order of up to 13 items (limit in place to prevent hoarding). My priorities are readability and maintainability.

  
         
         

Lista de respuestas

8
 
vote
vote
La mejor respuesta
 

refactorización

Lo primero que haría es eliminar las declaraciones redundantes 9988776665544330 . Si regresa de cada sucursal, realmente no hay necesidad de las cláusulas 9988776665544331 , solo están agregando ruido.

constantes?

Parece que hay algún alcance para constantes / o búsquedas, ya que hay algunos números que flotan alrededor que parecen tener un significado (cantidad de descuento, umbral de desencadenante de descuento), etc. Si está etiquetando un número con un comentario (docena de panadería), Es una buena indicación de que podría reemplazarse con una constante para "nombrar" el valor.

¿Qué está buscando realmente?

Sin embargo, para mí, creo que el código en realidad sirve más para obtener preguntas sobre si se está realizando o no como se desea. Si se está desempeñando como se esperaba, entonces es el tipo de sistema de precios que odio (porque se basa en el cliente para optimizar sus propias compras).

Si compro 12 artículos, me cobran 12 a la tarifa con descuento.

Si compro 13, me cobran 12 artículos a la tarifa estándar.

Si compro 14, me cobran 14 a la tarifa con descuento. Esto es más caro que yo comprando 13, luego comprando un solo artículo como una transacción separada.

es este correcto? ¿Me estás golpeando con el franqueo? ¿Por qué no obtengo 26 por el precio de 24?

etc ...

constantes revisados ​​

Creo que algunos de los anteriores contribuyen a su dificultad con constantes ... Iré con algo como esto:

  private static double getTotalPrice(int quantity, double itemPrice) {     if (quantity == SPECIAL_ONE_OFF_DISCOUNT_QUANTITY) {         return itemPrice * (SPECIAL_ONE_OFF_DISCOUNT_QUANTITY - 1);     }     if (quantity >= TRIGGER_DISCOUNT_QUANTITY) {         return itemPrice * quantity * DISCOUNT_MULTIPLIER;     }     return itemPrice * quantity; }   

Estoy usando 'especial_one_off_discount_quantity', porque realmente es una cantidad especial de OFF, con la lógica actual. No se duplica en 26, etc. Me he deshecho de la constante '12', porque realmente es solo 1 menos que el importe del gatillo. Tener una constante 'one_off_discountted_quantity' podría tener sentido si podía ver la necesidad de pagar por 10 cuando compró 13 por ejemplo, sin embargo, esto parece ser innecesario.

Como dije, preferiría volver a trabajar la lógica para que siempre pague la cantidad más baja + para que los descuentos sean aditivos. Esto cambia los precios de la salida, por lo que, obviamente, no sería posible si realmente no tenía sentido para el cliente. Aunque permite que algunas de las constantes tengan nombres diferentes:

  private static double getTotalPrice(int quantity, double itemPrice) {     var chargeableQuantity = quantity - quantity / BUY_X_GET_ONE_FREE_QUANTITY;     var valueMultiplier = chargeableQuantity >= TRIGGER_DISCOUNT_QUANTITY ? DISCOUNT_MULTIPLIER : 1;      return itemPrice * chargeableQuantity * valueMultiplier; }   

Creo que 'buy_x_get_one_free_quantity' es un nombre mejor que 'special_one_off_discount_quantity', pero solo tiene sentido si la compra el doble de la cantidad se traduce en el doble del descuento ...

 

Refactoring

The first thing I'd do is remove the redundant else statements. If you return from every branch, then there's really no need for the else clauses, they're just adding noise.

Constants?

It seems like there's some scope for constants / or lookups since there's some numbers floating around that seem to have meaning (discount amount, discount trigger threshold) etc. If you're labelling a number with a comment (baker's dozen), it's a good indication that it could be replaced with a constant to 'name' the value.

What are you really be looking for?

However, for me, I think the code actually serves more to prompt questions about whether or not it is performing as desired. If it is performing as expected, then it's the type of pricing system I hate (because it relies on the customer to optimize their own purchases).

If I buy 12 items, I'm charged for 12 at the discounted rate.

If I buy 13, I'm charged for 12 items at the standard rate.

If I buy 14, I'm charged for 14 at the discounted rate. This is more expensive than me buying 13, then buying a single item as a separate transaction.

Is this correct? Are you hitting me with the postage? Why don't I get 26 for the price of 24?

etc...

Constants Revisited

I think some of the above contribute to your difficulty coming up with constants... I'd go with something like this:

private static double getTotalPrice(int quantity, double itemPrice) {     if (quantity == SPECIAL_ONE_OFF_DISCOUNT_QUANTITY) {         return itemPrice * (SPECIAL_ONE_OFF_DISCOUNT_QUANTITY - 1);     }     if (quantity >= TRIGGER_DISCOUNT_QUANTITY) {         return itemPrice * quantity * DISCOUNT_MULTIPLIER;     }     return itemPrice * quantity; } 

I'm using 'SPECIAL_ONE_OFF_DISCOUNT_QUANTITY', because it really is a special one off amount, with the current logic. It doesn't duplicate at 26 etc. I've got rid of the '12' constant, because really it's just 1 less than the trigger amount. Having a 'ONE_OFF_DISCOUNTTED_QUANTITY' constant might make sense if you could see the need to pay for 10 when you bought 13 for example, however this seems a it unnecessary.

As I said, I'd prefer to rework the logic so that you always pay the lowest amount + so that discounts are additive. This changes the output prices, so obviously wouldn't be possible if it didn't actually make sense to the client. It does allow some of the constants to have different names though:

private static double getTotalPrice(int quantity, double itemPrice) {     var chargeableQuantity = quantity - quantity / BUY_X_GET_ONE_FREE_QUANTITY;     var valueMultiplier = chargeableQuantity >= TRIGGER_DISCOUNT_QUANTITY ? DISCOUNT_MULTIPLIER : 1;      return itemPrice * chargeableQuantity * valueMultiplier; } 

I think 'BUY_X_GET_ONE_FREE_QUANTITY' is a better name than 'SPECIAL_ONE_OFF_DISCOUNT_QUANTITY', but it only really makes sense if buying twice the amount results in twice the discount...

 
 
         
         
6
 
vote

Otra posibilidad sería un enfoque orientado a objetos en el que usamos el concepto de abstracción < / a>.

Para esto podríamos abstraer la lógica quantity == 13 como método con el ^ {}> 9988776665544331 :

  private boolean isOneOffDiscountFor(int quantity) {     return quantity == 13; }  private boolean isCheaperDiscountFor(int quantity) {     return quantity >= 6; }  private double calculateOneOffDiscountFor(double price) {     return price * 12; }  private double calculateCheaperDiscountFor(double price, int quantity) {     return calculateWithoutDiscount(price, quantity) * .95 }  private double calculateWithoutDiscount(double price, int quantity) {     return price * quantity }  private double getTotalPrice(int quantity, double itemPrice) {     if (isOneOffDiscountFor(quantity)) {         return calculateOneOffDiscountFor(itemPrice); // Baker's dozen     }          if (isCheaperDiscountFor(quantity)) {         return calculateCheaperDiscountFor(itemPrice, quantity);     }      return calculateWithoutDiscount(itemPrice, quantity); }   

Podemos ir más lejos, porque ahora hemos incluido la palabra descuento en todas partes en los nombres de métodos recién agregados, que es una indicación de que podemos encapsular estos métodos en un objeto separado. Eso nos lleva al siguiente principio básico de la programación orientada a objetos: Encapsulación

  class Discount {        public boolean isOneOffFor(int quantity) {         return quantity == 13;     }      public boolean isCheaperFor(int quantity) {         return quantity >= 6;     }      public double calculateOneOffFor(double price) {         return price * 12;     }      public double calculateCheaperFor(double price, int quantity) {         return calculateWithout(price, quantity) * .95     }      public double calculateWithout(double price, int quantity) {         return price * quantity     }  }   
  private final Discount discount;  private double getTotalPrice(int quantity, double itemPrice) {     if (discount.isOneOffFor(quantity)) {         return discount.calculateOneOffFor(itemPrice);     }          if (discount.isCheaperFor(quantity)) {         return discount.calculateCheaperFor(itemPrice, quantity);     }      return discount.calculateWithout(itemPrice, quantity); }   

Una ventaja de esta variante es que a través de la encapsulación, logramos que el objeto siga más de cerca el El principio de la responsabilidad única , que a su vez hará que nuestro código sea más fácil de probar y más mantenible.

Podemos hacer la dinámica de descuento si se agrega un constructor al Discount que hace que la variable de valores de descuento.


Las fotos auto-dibujadas se toman de mi GitHub Repositorio sobre los principios de la programación orientada a OBJEKT , en la que el principio de Herencia y polimorfismo también se visualizan. < / p>

 

Another possibility would be an object-oriented approach in which we use the concept of abstraction.

For this we could abstract the logic quantity == 13 as a method with the sigiture isOneOffDiscountFor(int quantity):

private boolean isOneOffDiscountFor(int quantity) {     return quantity == 13; }  private boolean isCheaperDiscountFor(int quantity) {     return quantity >= 6; }  private double calculateOneOffDiscountFor(double price) {     return price * 12; }  private double calculateCheaperDiscountFor(double price, int quantity) {     return calculateWithoutDiscount(price, quantity) * .95 }  private double calculateWithoutDiscount(double price, int quantity) {     return price * quantity }  private double getTotalPrice(int quantity, double itemPrice) {     if (isOneOffDiscountFor(quantity)) {         return calculateOneOffDiscountFor(itemPrice); // Baker's dozen     }          if (isCheaperDiscountFor(quantity)) {         return calculateCheaperDiscountFor(itemPrice, quantity);     }      return calculateWithoutDiscount(itemPrice, quantity); } 

We can go further, because now we have included the word Discount everywhere in the newly added method names - which is an indication that we can encapsulate these methods in a separate object. That leads us to the next basic principle of object-oriented programming: encapsulation

class Discount {        public boolean isOneOffFor(int quantity) {         return quantity == 13;     }      public boolean isCheaperFor(int quantity) {         return quantity >= 6;     }      public double calculateOneOffFor(double price) {         return price * 12;     }      public double calculateCheaperFor(double price, int quantity) {         return calculateWithout(price, quantity) * .95     }      public double calculateWithout(double price, int quantity) {         return price * quantity     }  } 
private final Discount discount;  private double getTotalPrice(int quantity, double itemPrice) {     if (discount.isOneOffFor(quantity)) {         return discount.calculateOneOffFor(itemPrice);     }          if (discount.isCheaperFor(quantity)) {         return discount.calculateCheaperFor(itemPrice, quantity);     }      return discount.calculateWithout(itemPrice, quantity); } 

An advantage of this variant is that through the encapsulation we achieve that the object more closely follow the Single Responsibility Principle, which in turn would make our code easier to test and more maintainable.

We can make the discount dynamic if a constructor is added to the Discount that makes the discount-values variable.


The self-drawn pictures are taken from my Github Repository about the Principles of Objekt-Oriented-Programming, in which the principle of inheritance and polymorphism are also visualized.

 
 
 
 
5
 
vote

Otros puntos:

  • Esto es Java, por lo que es importante que su método esté marcado static dado que se ve obligado a ser miembro de clase
  • Hacer una variable temporal double subTotal = itemPrice * quantity; para evitar la duplicación de la multiplicación en la parte inferior
  • Cuando hace un factor de los números mágicos, ya sea que pertenezcan como miembros de clase o lugareños dependen del resto de la clase, que no ha mostrado. Si el resto de la clase reutiliza estas constantes, entonces pertenecen como static final miembros. De lo contrario, solo hágalos locales final .
 

Other points:

  • This is Java, so it's important that your method be marked static given that it is forced to be a class member
  • Make a temporary variable double subTotal = itemPrice * quantity; to avoid duplication of the multiplication on the bottom
  • When you do factor out magic numbers, whether they belong as class members or locals depends on the rest of the class, which you haven't shown. If the rest of the class reuses these constants then they belong as static final members. Otherwise, just make them local final.
 
 
   
   
4
 
vote

En lo que estoy más interesado es cómo nombrar los números mágicos.

Opinión alternativa: ninguno de los números debe estar en código en primer lugar. Cada respuesta con constantes con nombre está mal. Todos deben estar en datos .

suposiciones:

    Las reglas de precios
  1. son todas predicadas solo en cantidad
  2. Las reglas de precios cambian con mayor frecuencia que la lógica de negocios
  3. Si compra 26 de algo, debe cobrarse por dos docenas de Baker (2 * 12 = 24), no para simplemente "al menos seis" (26 * 0.95 = 24.7)

Pseudocódigo:

  isOneOffDiscountFor(int quantity)0  

configurado con algo como

  isOneOffDiscountFor(int quantity)1  

que se podría leer fácilmente de JSON o similar cuando desee actualizar su lista de precios sin editar el código.

nb. Probablemente sea mejor usar un tipo racional / proporción que el doble para el multiplicador, aunque no creo que estamos golpeando ningún error de redondeo en este caso en particular.

 

What I am most interested in is how to name the magic numbers.

Alternative opinion - none of the numbers should be in code in the first place. Every answer with named constants is just wrong. They should all be in data.

Assumptions:

  1. pricing rules are all predicated only on quantity
  2. pricing rules change more frequently than business logic
  3. if you buy 26 of something, you should be charged for two baker's dozens (2 * 12 = 24), not for simply "at least six" (26 * 0.95 = 24.7)

Pseudocode:

double getTotalPrice(int quantity, double itemPrice, OrderedDiscountList rules) {     double totalPrice = 0.0;     int remaining = quantity;      // require this is ordered with the largest quantity rule first     for (rule in rules) {         if (remaining >= rule.quantity) {             int affected = remaining / rule.quantity;             remaining = remaining % rule.quantity;             totalPrice += affected * itemPrice * rule.multiplier;         }     }     // so long as the last rule has quantity=1 and multiplier=1.0     // we don't need to special-case anything in code     return totalPrice; } 

configured with something like

OrderedDiscountList defaultRules = {     { .quantity = 13, .multiplier = 12.0/13 },     { .quantity = 6,  .multiplier = 0.95 },     { .quantity = 1,  .multiplier = 1.0 } }; 

which could easily be read from JSON or similar when you want to update your price list without editing code.

NB. It's probably better to use a rational/ratio type than double for the multiplier, although I don't think we're hitting any rounding errors in this particular case.

 
 
   
   
2
 
vote

Una sugerencia adicional con respecto al .95 constante:

En las ventas, es más natural expresar los porcentajes de descuento en lugar del factor

  private static final double QUANTITY_DISCOUNT_PERCENT = 5.0; private static final double QUANTITY_DISCOUNT_FACTOR = 0.01 * (100.0 - QUANTITY_DISCOUNT_PERCENT); ... return itemPrice * quantity * QUANTITY_DISCOUNT_FACTOR;   

(Como ya se mencionó, el uso de doble aritmética no es una buena idea ...)

y (tal vez sea excesivo, pero de todos modos):

Generalizando los dos enfoques de descuento diferentes, esto solicita una interfaz 99887776555544332 con al menos dos implementaciones: 99887776655443333 y 9988776655544334 , una lista ordenada de las reglas de descuento, y el código que elige la primera regla aplicable para una cantidad dada.

 

One additional suggestion regarding the .95 constant:

In sales, it's more natural to express the discount percents instead of the factor

private static final double QUANTITY_DISCOUNT_PERCENT = 5.0; private static final double QUANTITY_DISCOUNT_FACTOR = 0.01 * (100.0 - QUANTITY_DISCOUNT_PERCENT); ... return itemPrice * quantity * QUANTITY_DISCOUNT_FACTOR; 

(As already mentioned, using double arithmetic isn't a good idea...)

And (maybe it's overkill, but anyway):

Generalizing the two different discount approaches, this asks for a DiscountRule interface with at least two implementations: QuantityPercentDiscount and OneForFreeDiscount, an ordered list of discount rules, and code that chooses the first applicable rule for a given quantity.

 
 
2
 
vote

Para mí, el mejor código de producción es el código que es conciso y simple, especialmente con respecto a la cantidad de ramificación. El siguiente código cambia ligeramente la semántica (de una buena manera, creo) y unifica la multiplicación:

  private double getTotalPrice(int quantity, double itemPrice) {     // Charge for 13 as if it were only 12     if (quantity == 13) quantity = 12;      // Reduce item price for bulk purchases     if (quantity >= 6) itemPrice *= 0.95;      return quantity * itemPrice; }   

Hay varias cosas buenas que decir sobre el código como este.

  • es simple y fácil de entender
  • es autónomo y no depende de otras funciones / constantes
  • Los comentarios dejan en claro lo que está haciendo cada paso, y los pasos se aplican en un orden lineal claro (que solicita al lector considerar lo que sucedería si se ejecutaban en un orden diferente: si el umbral de descuento a granel fuera También 13, haría una diferencia ...). Esta estructura también ayuda a evitar la trampa en el código original donde no obtiene el descuento a granel cuando compra exactamente 13 cosas!

¿Este código realmente se mejoraría al crear una nueva constante como BUY_X_GET_ONE_FREE_QUANTITY para pararse para 13? Argumentaría no, porque esa constante probablemente vivirá en otro lugar del programa y requerirá un "salto" adicional para que un lector lo revise. El resultado neto es una broca más ofuscación de su código. Parece especialmente improductivo para ocultar este número mágico dentro de una constante porque la mayoría de las personas reconocerán fácilmente como el número de docenas del panadero.

Por supuesto, en un sistema de software real Muchas otras consideraciones pueden aplicar, como:

  • ¿Necesito usar estos números en otras funciones, como quizás la suite de prueba? Tal vez entonces necesito constantes estáticas.
  • ¿Quiero poder configurar estos números como 13 , 9988776655544338 y 9988776655544339 a través de un sistema de configuración, o está bien para hornearlos en el programa? Si es el primero, entonces se pueden aplicar muchas otras consideraciones, involucrando cómo se realiza la configuración y qué tan poderoso debe ser.

FWIW, si tuviera la libertad de sobrecomprar esto tanto como quisiera, probablemente intentaría modelarlo como una serie de "promociones" que se aplican a través de la composición de la función. Esto sería más escalable y podría funcionar bien en una compañía más grande, donde diferentes equipos dentro de la compañía podrían querer aplicar sus propias promociones a la estructura de precios sin pisar los dedos de los dedos de los demás. Por ejemplo: (en un idioma Pseudocódigo porque Java no admite tuplas ...)

  private static final double QUANTITY_DISCOUNT_PERCENT = 5.0; private static final double QUANTITY_DISCOUNT_FACTOR = 0.01 * (100.0 - QUANTITY_DISCOUNT_PERCENT); ... return itemPrice * quantity * QUANTITY_DISCOUNT_FACTOR; 0  

Cambiando el enfoque de "Configuración de constantes individuales" a "Configuración de las funciones de promoción individuales", rompemos el problema más claramente en piezas lógicas. Por ejemplo, en un sistema real, podríamos imaginar la configuración de nuestro programa pasando en un archivo YAML como el siguiente, que incluso los no ingenieros de la empresa podrían editar:

  private static final double QUANTITY_DISCOUNT_PERCENT = 5.0; private static final double QUANTITY_DISCOUNT_FACTOR = 0.01 * (100.0 - QUANTITY_DISCOUNT_PERCENT); ... return itemPrice * quantity * QUANTITY_DISCOUNT_FACTOR; 1  
 

For me, the best production code is the code that is concise and simple, especially with respect to the amount of branching. The following code slightly changes the semantics (in a good way, I think) and unifies the multiplication:

private double getTotalPrice(int quantity, double itemPrice) {     // Charge for 13 as if it were only 12     if (quantity == 13) quantity = 12;      // Reduce item price for bulk purchases     if (quantity >= 6) itemPrice *= 0.95;      return quantity * itemPrice; } 

There are several good things to say about code like this.

  • It's simple and easy to understand
  • It's self-contained and doesn't depend on other functions/constants
  • The comments make it clear what each step is doing, and the steps are applied in a clear linear order (which prompts the reader to consider what would happen if they were run in a different order--if the bulk discount threshold were also 13, it would make a difference...). This structure also helps avoid the pitfall in the original code where you don't get the bulk discount when you buy exactly 13 things!

Would this code really be improved by coming up with a new constant like BUY_X_GET_ONE_FREE_QUANTITY to stand in for 13? I would argue no, because that constant will probably live somewhere else in the program and will require an extra "hop" for a reader to check it. The net result is a bit more obfuscation of your code. It seems especially unproductive to hide this magic number inside a constant because most people will readily recognize 13 as the baker's dozen number.

Of course, in a real software system many other considerations might apply, such as:

  • Do I need to use these numbers in other functions, such as perhaps the test suite? Maybe then I need static constants.
  • Do I want to be able to configure these numbers like 13, 6, and 0.95 via a configuration system, or is it okay to bake them into the program? If it's the former, then many other considerations might apply, involving how the configuration is done and how powerful it needs to be.

FWIW, if I were free to overengineer this as much as I wanted, I would probably try to model it as a series of "promotions" which are applied via function composition. This would be more scalable and might work well at a bigger company, where different teams within the company might want to apply their own promotions to the pricing structure without stepping on each other's toes too much. For example: (in a pseudocode language because Java doesn't support tuples...)

// Each promotion may transform the quantity and/or item price private [int, double] bakersDozenPromotion(int quantity, double itemPrice) {     if (quantity == 13) return [12, itemPrice];     else return [quantity, itemPrice]; } private [int, double] bulkDiscountPromotion(int quantity, double itemPrice) {     if (quantity >= 6) return [quantity, itemPrice * 0.95];     else return [quantity, itemPrice]; } // ...other promotions  private double getTotalPrice(int quantity, double itemPrice) {     const allPromotions = compose(         bakersDozenPromotion,          bulkDiscountPromotion,          ...     )     const [finalQuantity, finalItemPrice] = allPromotions(quantity, itemPrice);      return finalQuantity * finalItemPrice; } 

By shifting the focus from "configuring individual constants" to "configuring individual promotion functions," we break the problem down more clearly into logical pieces. For example, in a real system we could imagine configuring our program by passing in a YAML file like the following, which even non-engineers at the company could edit:

promotions:   bakers-dozen:     enabled: true     extra-free-unit-at: 13   bulk-discount:     enabled: true     threshold: 6     price-multiplier: 0.95 
 
 

Relacionados problema

5  Memoria / Performance of Merge Sort Code  ( Memory performance of merge sort code ) 
Escribí un código de tipo de combinación para un poco de bocadillo nocturno. Lo he puesto trabajando, pero solo estaba mirando a aprender si me faltaba algo e...

2  Fusionar la implementación de Sort Java  ( Merge sort java implementation ) 
¿Puede alguien revisar mi implementación de tipo de fusión en Java? ¿Es bueno / malo y puede mejorarse más? public class MyMergeSort { private int [] d...

1  Compruebe si dos cadenas son permutación entre sí  ( Check if two strings are permutation of each other ) 
private String sort(String word) { char[] content = word.toCharArray(); Arrays.sort(content); return new String(content); } private boolea...

8  Simple GCD Utility en Java  ( Simple gcd utility in java ) 
i anteriormente discutido El rendimiento se refiere a diferentes algoritmos GCD. Escribí una simple clase de Java que implementa el algoritmo binario GCD. E...

6  Encontrar el siguiente palíndromo de una cadena de números  ( Finding the next palindrome of a number string ) 
Aquí está el problema: Un entero positivo se llama palíndromo si su representación en el El sistema decimal es el mismo cuando se lee de izquierda a dere...

2  Eliminación de un nodo en un árbol de búsqueda binario  ( Deletion of a node in a binary search tree ) 
Estoy buscando ver si mi implementación del método de eliminación / eliminación en un árbol de búsqueda binario es suficiente, legible y se ejecuta en un tiem...

5  Encuentre el próximo número Prime - Control de flujo de los bucles anidados 'para `  ( Find the next prime number flow control of nested for loops ) 
Este código funciona perfectamente, pero me molesta. Tener un bucle etiquetado y anidado Bucle, con un Enumerable<T>.Empty()0 Declaración, y un 9988777665...

34  Clon a todo color del juego de la vida de Conway, con una GUI decente  ( Full color clone of conways game of life with a decent gui ) 
Escribí esto para aprender Javafx, y como excusa para volver a hacer el juego de la vida. Esta es la gui más compleja que he escrito, así que me gustaría come...

17  Implementación vectorial (física)  ( Vector physics implementation ) 
Recientemente comencé a aprender Java, y decidí implementar un sistema de vectores básico para otro sistema de partículas que estaba construyendo. join()9 ...

2  Solucionador de rompecabezas de rascacielos en Java [cerrado]  ( Skyscraper puzzle solver in java ) 
cerrado. Esta pregunta es off-topic . Actualmente no está aceptando respuestas. ¿Quieres ...




© 2022 respuesta.top Reservados todos los derechos. Centro de preguntas y respuestas reservados todos los derechos