Sur un plan bidimensionnel, le nombre de sauts nécessaires pour atteindre le point (d, 0) depuis l'origine

Dans cet article, nous discuterons des solutions possibles à un problème analytique passionnant, à savoir combien de sauts sont nécessaires pour atteindre le point (d, 0) depuis l'origine dans un plan 2D où une longueur de saut fixe est spécifiée. Nous utiliserons une longueur de saut fixe et des coordonnées cibles pour trouver le nombre minimum de sauts requis.

Scénarios d'entrée et de sortie

Supposons que la longueur du saut puisse être a ou b et que le point cible soit (d,0). Le résultat donné est alors le nombre minimum de sauts requis pour atteindre l’objectif.

Input: a = 7, b = 5, d = 9
Output: 2
Input: a = 7, b = 5, d = 5
Output: 1
Input: a = 7, b = 5, d = 24
Output: 4

Supposons que vous vous trouviez à l'origine (0, 0) du plan 2D. Vos coordonnées cibles sont (d, 0). La seule façon d’atteindre les coordonnées cibles est de faire un saut d’une longueur fixe. Votre objectif est de trouver un moyen efficace d'atteindre votre objectif avec le moins de sauts possible.

Utilisez l'instruction If

Nous utiliserons une instruction if pour trouver le nombre minimum de sauts requis pour atteindre (d, 0).

• Tout d'abord, nous devons nous assurer que a est toujours supérieur à b, de sorte que a représente une longueur de saut plus longue et b b> représente une longueur de saut plus courte. Par conséquent, si b > a, , alors nous attribuons le maximum de a et b à a.

• Ensuite, nous vérifions si d est supérieur ou égal à a. Si cette condition est remplie, alors nous pouvons simplement calculer le nombre minimum de sauts comme (d + a - 1) / a. Ici, (d + a - 1) signifie la distance totale de la longueur du saut "a" divisée par a (c'est-à-dire la longueur de chaque saut) donne le nombre de sauts.

• Si d = 0, aucun saut n'est requis.

• Si d = b, alors nous pouvons atteindre directement le point en sautant la longueur b.

• Si d > b et d < a< a, alors le nombre minimum de sauts est de 2. En effet, si nous prenons un triangle XYZ tel que X est l'origine, Z est le point cible et Y est le point qui satisfait XY = YZ = max(a, b). Ensuite, le saut minimum sera de 2, soit de X à Y et de Y à Z.

Exemple

#include <iostream>
using namespace std;

int minJumps(int a, int b, int d) {
   // Check if b > a, then interchange the values of a and b
   if (b > a) {
      int cont = a;
      a = b;
      b = cont;
   }
    
   // When d >= a
   if (d >= a)
      return (d + a - 1) / a;

   // When the target point is 0
   if (d == 0)
      return 0;

   // When d is equal to b.
   if (d == b)
      return 1;
     
   // When distance to be covered is not equal to b.    
   return 2;  
    
}

int main() {
   int a = 3, b = 5, d = 9;
   int result = minJumps(a, b, d);
   cout << "Minimum number of jumps required to reach (d, 0) from (0, 0) is: " << result << endl;
   return 0;
}

Sortie

Minimum number of jumps required to reach (d, 0) from (0, 0) is: 2

Utilisez les opérateurs de division et de modulo

Si la valeur de a ou b est 0, alors nous pouvons simplement utiliser les opérateurs de division et de modulo pour trouver le nombre minimum de sauts. Ici, nous divisons la distance d par la longueur du saut (puisque l'une des longueurs du saut est 0) pour obtenir le nombre de sauts.

Exemple

#include <iostream>
using namespace std;

int minJumps(int d, int jumpLength) {
   // To find number of complete jumps
   int numJumps = d / jumpLength;
   // If distance is not divisible by jump length
   if (d % jumpLength != 0) {
      numJumps++;  
   }
   return numJumps;
}
int main() {
   int d = 24, jumpLength = 4;
   int result = minJumps(d, jumpLength);
   cout << "Minimum number of jumps required to reach (d, 0) from (0, 0) is: " << result << endl;
   return 0;
}

Sortie

Minimum number of jumps required to reach (d, 0) from (0, 0) is: 6

REMARQUE - Nous pouvons également utiliser l'opérateur ternaire pour écrire du code de manière concise.

int minJumps(int d, int jumpLength) {
   int numJumps = (d % jumpLength == 0) ? (d / jumpLength) : (d / jumpLength) + 1;
   return numJumps;
}

Conclusion

Nous avons expliqué comment trouver le nombre minimum de sauts requis pour atteindre le point cible (d, 0) depuis l'origine dans le plan 2D. Nous utilisons une instruction if pour trouver le nombre de sauts pour les valeurs non nulles de a et b (a et b b> sont les longueurs de saut). Si a ou b est nul, alors nous pouvons utiliser les opérateurs de division et de modulo. Pour écrire du code de manière succincte, nous pouvons utiliser l'opérateur ternaire.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!