Soluciones de salto de ranas de codilidad [cerradas] -- python campo con programming-challenge campo con comparative-review camp codereview Relacionados El problema

Codility Frog Jump solutions [closed]


6
vote

problema

Español
cerrado. Esta pregunta es off-topic . Actualmente no está aceptando respuestas.

¿Quieres mejorar esta pregunta? Actualizar la pregunta por lo que es on-topic para el intercambio de pila de revisión de código.

cerrado hace 2 años .

Mejorar esta pregunta

Detalles del problema de la CODILIDAD:

Una pequeña rana quiere llegar al otro lado de la carretera. La rana se encuentra actualmente en la posición X y quiere llegar a una posición mayor o igual a Y. La pequeña rana siempre salta a una distancia fija, D. Cuente el número mínimo de saltos que debe realizar la pequeña rana para alcanzar su objetivo.

Escribir una función:

  def solution(X, Y, D)   

que, dado tres enteros x, y y d, devuelve el número mínimo de saltos de la posición x a una posición igual o mayor que y.

Método 1:

  def solution(X, Y, D):     if (X == Y):         jumps = 0     elif Y-X % D == 0:         jumps = (Y-X)/D     else:         jumps = ((Y-X)/D) + 1     return jumps   

Método 2:

  def solution(X, Y, D):     d = Y-X     jumps=d/D     rem=d%D     if rem != 0:         jumps+=1     return jumps   

Presenté la solución METHICE1 y recibí una puntuación del 55%. Por otro lado, el Método2 obtuvo el 100%. No está claro por qué METHICE2 es mejor que METHICE1. ¿Podría alguien explicar?

Original en ingles

Problem details from Codility:

A small frog wants to get to the other side of the road. The frog is currently located at position X and wants to get to a position greater than or equal to Y. The small frog always jumps a fixed distance, D. Count the minimal number of jumps that the small frog must perform to reach its target.

Write a function:

def solution(X, Y, D) 

that, given three integers X, Y and D, returns the minimal number of jumps from position X to a position equal to or greater than Y.

Method 1:

def solution(X, Y, D):     if (X == Y):         jumps = 0     elif Y-X % D == 0:         jumps = (Y-X)/D     else:         jumps = ((Y-X)/D) + 1     return jumps 

Method 2:

def solution(X, Y, D):     d = Y-X     jumps=d/D     rem=d%D     if rem != 0:         jumps+=1     return jumps 

I submitted the Method1 solution and received a 55% score. On the other hand, Method2 got 100%. It's not clear to me why Method2 is better than Method1. Could someone please explain?

        

Lista de respuestas

10
 
vote
vote
La mejor respuesta
 

El método 1 a veces da una solución incorrecta porque tiene un error:

  main()7  

En el main()8 allí, main()9 debería haber estado dentro de los soportes, ya que 99887766555443330 tiene mayor precedencia que typedef struct brainfuck_data { int * instructions; size_t memsize; size_t inssize; } bf_data_t; 1 operador. En otras palabras, typedef struct brainfuck_data { int * instructions; size_t memsize; size_t inssize; } bf_data_t; 22 no es lo mismo que typedef struct brainfuck_data { int * instructions; size_t memsize; size_t inssize; } bf_data_t; 3 .

Aparte de eso, son prácticamente equivalentes. Me gustaría limpiar el formato y eliminar algunas variables temporales obvias, como esta:

  typedef struct brainfuck_data {     int * instructions;     size_t memsize;     size_t inssize; } bf_data_t; 4  

En particular, en el typedef struct brainfuck_data { int * instructions; size_t memsize; size_t inssize; } bf_data_t; 5 en lugar de incrementar con typedef struct brainfuck_data { int * instructions; size_t memsize; size_t inssize; } bf_data_t; 6 , devuelvo el valor inmediatamente, porque prefiero evitar la mutación de variables en general.

 

Method 1 sometimes gives wrong solution because it has a bug:

def solution(X, Y, D):     if (X == Y):         jumps = 0     elif Y-X % D == 0:         jumps = (Y-X)/D     else:         jumps = ((Y-X)/D) + 1     return jumps 

In the elif there, Y-X should have been within brackets, because % has higher precedence than - operator. In other words, Y - X % D is not the same as (Y - X) % D.

Other than that, they are practically equivalent. I would clean up the formatting and remove some obvious temporary variables, like this:

def solution(X, Y, D):     jumps = (Y - X) / D     if (Y - X) % D > 0:         return jumps + 1     return jumps 

In particular, in the if instead of incrementing with jumps += 1, I return the value immediately, because I prefer to avoid mutating variables in general.

 
 
   
   
4
 
vote

La respuesta de Janos es buena.

Vamos a agregar algunos comentarios independientes simples en la parte superior de su solución:

  • A diferencia de C o C ++, el operador de módulo de Python (%) siempre devuelve un número que tiene el mismo signo que el denominador (divisor). Por lo tanto, como D se supone que es positivo, 9988777665544330 . Por lo tanto, su cheque podría ser escrito if (Y - X) % D != 0 o de una manera más pythonic: 9988777665544332 .

  • Python tiene una bonita Función Divmod . Calcula el cociente y el recordatorio, lo que es exactamente lo que quieres aquí. Su función se convierte en:

      def solution(X, Y, D):     q, r = divmod(Y-X, D)     if r > 0:         return q + 1     return q   
  • Puede evitar el 9988776655544334 utilizando el operador Ternario: 9988777665544335 . Además, desde el Python 3 Doc y < un href = "https://docs.python.org/2/library/numbers.html#numbers.integral" rel = "nofollow"> el Python 2 Doc :

Los dos objetos que representan los valores falsos y verdaderos son los únicos Objetos booleanos. El tipo booleano es un subtipo de enteros planos, y Los valores booleanos se comportan como los valores 0 y 1, respectivamente, en casi Todos los contextos, la excepción es que cuando se convierte en una cadena, la Las cadenas "falsas" o "verdaderas" se devuelven, respectivamente.

Por lo tanto, puede escribir esto: return jumps + bool((Y - X) % D > 0) .

Al tomar en cuenta todos los comentarios, su código se convierte en:

  def solution2(X, Y, D):     q, r = divmod(Y-X, D)     return q + bool(r)   

Realmente no puede obtener más sencillo, ¿verdad?


Parece que me dije en el código antes de encender mi cerebro.

Puede usar math.ceil y todo irá bien:

  import math def solution2(X, Y, D):     return math.ceil((Y-X)/float(D))   

Tenga en cuenta que usé un poco de un truco para tener una división de números flotantes. En Python 3, este es el comportamiento predeterminado para la división y puede tenerlo fácilmente con from __future__ import division .

 

janos' answer is good.

Let's me add a few simple independant comments on top of his solution :

  • Unlike C or C++, Python's modulo operator (%) always return a number having the same sign as the denominator (divisor). Thus, as D is supposed to be positive, (Y - X) % D >= 0. Therefore, your check could be written if (Y - X) % D != 0 or in a more Pythonic way : if (Y - X) % D.

  • Python has a pretty cool divmod function. It computes quotient and reminder which is exactly what you want here. Your function becomes :

    def solution(X, Y, D):     q, r = divmod(Y-X, D)     if r > 0:         return q + 1     return q 
  • You could avoid the repeted return jump by using the ternary operator : return jumps + (1 if (Y - X) % D > 0 else 0). Also, from the Python 3 doc and the Python 2 doc:

The two objects representing the values False and True are the only Boolean objects. The Boolean type is a subtype of plain integers, and Boolean values behave like the values 0 and 1, respectively, in almost all contexts, the exception being that when converted to a string, the strings "False" or "True" are returned, respectively.

thus, you can write this : return jumps + bool((Y - X) % D > 0).

By taking all comments into account, your code becomes :

def solution2(X, Y, D):     q, r = divmod(Y-X, D)     return q + bool(r) 

It cannot really get any simpler, can it ?


It seems like I dove into the code before turning my brain on.

You can use math.ceil and everything will go fine :

import math def solution2(X, Y, D):     return math.ceil((Y-X)/float(D)) 

Note that I used a bit of a hack to have floating number division. In Python 3, this is the default behavior for division and you can have it easily with from __future__ import division.

 
 
       
       
3
 
vote

Su primer bloque de código tiene un error que fue señalado por @Janos. El segundo bloque produce las respuestas correctas. Pero, hay una mejor manera de hacer este cálculo, y es un tipo de problema que es común en la programación de computadora ...

¿Qué es lo que menos necesito hacer para cubrir un rango dado?

En este caso, lo que quiere hacer es calcular el rango, ya sabe el 'paso', y desea saber cuántos pasos tomar. El truco a una solución es conocer lo más lejos que puede pasar, mientras que aún comienza desde el rango.

En este caso, necesita "HOPT" de if (Y - X) % D != 00 a if (Y - X) % D != 01 en el tamaño de tamaño 99887776655443312 . El rango if (Y - X) % D != 03 es if (Y - X) % D != 04 . Lo más leído que puede saltar mientras aún está estando en el rango es 99887776655443315 . El siguiente salto desde ese punto más lejano de la gama será if (Y - X) % D != 06 . Ese es el resultado válido más alejado. El resultado final para el número de saltos es el número 'entero' de los saltos al punto más lejano (división de enteros al rescate: tenga en cuenta que 99887766555443317 significa algo diferente en Python 3.x vs. Python 2. X - if (Y - X) % D != 08 es la división del piso (o entero) ahora):

  if (Y - X) % D != 09  

Esto puede simplificarse a la respuesta:

  if (Y - X) % D0  
 

Your first code block has a bug which was pointed out by @janos. The second block produces the right answers. But, there's an even better way to do this calculation, and it's a type of problem that is common in computer programming....

What is the least I need to do to cover a given range?

In this case, what you want to do is to calculate the range, you know the 'step', and you want to find out how many steps to take. The trick to a solution is to know the furthest you can step to, while still starting from in the range.

In this case, you need to 'hop' from X to Y in hops of size D. The range range is Y - X. The furthest you can hop while still being in the range is range - 1. The next hop from that furthest point in the range will be range - 1 + D. That's the furthest valid result. The end result for the number of hops is the 'integer' number of hops to the furthest point (integer division to the rescue - note that / means something different in Python 3.x vs. Python 2.x - // is floor (or integer) division now):

range = Y - X furthest = (range - 1) + D hops = furthest // D 

This can simplify down to the answer:

def solution(X, Y, D):     return ((Y - X) - 1 + D) // D 
 
 

Relacionados problema

1  Visualización de Wuuks completados y fallidos usando una o dos funciones  ( Displaying completed and failed wuuks using one or two functions ) 
He actualizado mi código. En el código antiguo tuve dos funciones: display_maker_success()1 y display_maker_fail() : function display_maker_success($lin...

2  Pasando funtores a algoritmos estándar  ( Passing functors to standard algorithms ) 
He creado 3 implementaciones diferentes (que producen los mismos resultados) utilizando la función en3 de STL. Deseo verificar la cantidad de elementos en e...

8  Contando novedades en un archivo  ( Counting newlines in a file ) 
He comenzado a pasar por tutoriales de nodos en nodoschool.io , y la segunda asignación fue escribir un programa que contará El número de nuevas líneas en un...

1  Configuración del camino a la barra de herramientasSociadaxIname, con retraso  ( Setting the path to toolbarassociatedxibname with fallback ) 
Tengo algún código que he incluido en un proyecto que quiero liberar. Aquí hay uno de esos bloques: NSString *path = nil; if (delegate && [delegate respond...

2  Validación instantánea de la longitud del campo de la forma  ( Instantaneous validation of form field length ) 
Dado que tengo una función que se puede hacer de unas maneras como de costumbre, me preguntaba qué sigue es el mejor para lograr la validación del formulario ...

5  Representando el tiempo de apertura y cierre para un negocio  ( Representing the opening and closing time for a business ) 
Tengo una clase de openclose que solo representa las horas de operación de un negocio por la apertura y el tiempo de cierre. Toma los tiempos de apertura y ci...

2  Formateo de un precio en SWIFT usando una extensión vs. una clase  ( Formatting a price in swift using an extension vs a class ) 
Tengo un precio como un Double , que debería formatearlo como un String . ¿Debo usar una extensión en lugar de clase clásica para encapsular "Formater", "...

2  Dos formas de aleatorias aleatoriamente las tarjetas  ( Two ways to randomly shuffle cards ) 
Aquí hay dos implementaciones que escribí para aleatorizar las tarjetas. El primer método ( dt5 ) Selecciona una tarjeta aleatoria, luego lo quita al frent...

18  Invirtiendo una cadena  ( Reversing a string ) 
Tuve esto como una pregunta de entrevista, y el entrevistador señaló esto. Esto es lo que escribí: //C# Syntax here public string Reverse(string s) { c...

3  Imitando la mensajería de la célula T9  ( Mimicking t9 cell messaging ) 
Hoy resolví una pregunta de Google Code Jam: imitando un teléfono celular de mensajería. Aquí está el programa, con goto Sé que es un estilo no estructura...




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