Question

这将是一般问题陈述：

一名囚犯跳过N个墙壁，每个墙壁都有一个阵列的高度。他可以跳高x米的高度，但每次跳跃后，由于一些无法控制的因素（风，滑墙等），他滑了几米。

Similar problem statement mentioned here

给出的编程任务是调试一个包含四个参数的函数 -

NoOfJumps(int x, int y, int N, int Height[])

他跳的米数
他从墙上滑下来的米数
墙数
墙壁高度为阵列

第一个测试用例是参数 - （10,1,1，{10}）

10是他跳的米，1米他滑倒，墙的数量是1，墙的高度是10.现在：

effectiveJump = x - y = 9.

所以他必须跳两次跳过墙壁。因此，此函数应返回2 （转义所需的跳转总数）。

还有另一个参数测试用例 - （3,1,5，{20,5,12,11,3}）

3是他跳的米，1米他滑倒，墙的数量是5，墙的高度是20米，5米，12米，11米，3米。现在：

effectiveJump = x - y = 2.

我们得到以上参数值的输出为24。

NoOfJumps(3, 1, 5, {20,5,12,11,3})

我无法理解如何获得此输出值。墙是如何安排的？

我只能想到一个角落案例的解决方案，即当人跳过墙壁时

（when (x) > remaining height of the wall），

他不应该滑倒，否则我无法获得所需的解决方案。 例如，在第一个墙壁的第二个测试案例中，当人处于18米高度时，他跳跃3米到21米并且当他越过那堵墙时不会滑倒。接下来他开始从21而不是20跳。跳跃的顺序是：

0→2→4-＆GT; 6-＆GT; 8-＆GT; 10→12＆GT; 14-＆GT; 16-＆GT; 18-＆GT; 21-＆GT; 23-＆GT ; 26-＆GT; 28-＆GT; 30-＆GT; 32＆GT; 34-＆GT; 36-＆GT; 39-＆GT; 41-＆GT; 43-＆GT; 45-＆GT; 47-＆GT; 50- GT; 53

假设墙高，20,25,37,48,51。

这是解决问题的正确假设吗？

Answer 1

给定案例2的C代码将适用于案例1更改参数为（10,1,1,10）。

#include<conio.h>
#include<stdio.h>
int jump(int x,int y,int n,int z[]);
int jump(int x,int y,int n,int z[])
{
    int i, j, countjump, total = 0, extra = 0;
    clrscr();
    printf("\n%d\n", n);
    for (i = 0; i < n; i++) {
        printf("\n%d", z[i]);
    }
    printf("\n");
    for (j = 0; j < n; j++) {
        countjump = 1;
        z[j] = z[j] + (extra) - x;
        while (z[j] >= 0) {
            z[j] = z[j] + y;
            z[j] = z[j] - x;
            countjump = countjump + 1;
            if (z[j] < 0) {
                extra = z[j];
            }
        }
        total = (countjump + total);
    }
    return total;
}
void main()
{
    int res, manjump = 3, slip = 1, nwalls = 5;
    int wallheights[] = {20, 5, 12, 11, 3};
    clrscr();
    res = jump(manjump, slip, nwalls, wallheights);
    printf("\n\ntotal jumps:%d", res);
    getch();
}

Answer 2

你可以使用这个。

示例代码

public static int calculateJumps(int X, int Y, int height[]) {
    int tn=0,n;
    for(int i=0; i<height.length; i++) {
        if(height[i]<=X) {
            tn+=1;
            continue;
        }
        n=((height[i]-X)/(X-Y));
        n+=height[i]-((X-Y)*n)==X?1:2;
        tn+=n;
    }
    return tn;
}

您只需要传递X，Y和Array，而不是输出。

Answer 3

试试这个

您不需要墙的数量，因为它等于数组的大小

public class Jump {
    public static void main(String[] a) {
        int jump = 3;
        int slip = 1;
        int[] hights = {20,5,12,11,3};

        int count = 0;
        for (int hight : hights) {
            int temp = hight - jump;
            if (temp >= 0) {
                count = count + temp / (jump - slip)+1;
            }
            if (temp % (jump - slip) > 0) {
                count++;
            }
        }
        System.out.println(count);
    }
}

Answer 4

试试这段代码。可能无法优化

$ input1 =跳跃高度

$ input2 = Slipage

$ input =墙高数组

function GetJumpCount($input1,$input2,$input3)
{
    $jumps = 0;
    $wallsCrossed = 0;
    while($wallsCrossed != count($input3)){
        $jumps++;
        $input3[$wallsCrossed] = $input3[$wallsCrossed] - $input1;
        if($input3[$wallsCrossed] > 0){
            $input3[$wallsCrossed] = $input3[$wallsCrossed] + $input2;
        }else{
            $wallsCrossed++;
        }
    }
    return $jumps;
}

Answer 5

墙壁一个接一个地出现。跳墙1后，位置应从零开始，而不是从最后的跳高开始。对于第一种情况，输出应该是1，因为高度和跳跃是相同的。在第二个测试用例中，24是正确的输出。我在techgig比赛中看到了完全相同的问题。对于第一个测试用例，输出应为1.如果跳跃和高度相同，则测试用例已经解释为没有滑动。

Answer 6

逻辑在这里Plz检查这是否解决了你的问题。

package puzeels;

public class Jump
{
    int jump=6;
    int slip=1;
    int numberOfWals=4;
    int height[] ={21,16,10,5};

    static int count=0;
    int wallheight=0;

    private int findJump()
    {
        for(int i=0;i<height.length;i++)
        {             
            wallheight=height[i];
            while((wallheight>0))
            {
                count=count+1;
                wallheight=wallheight-(jump-slip);
                System.out.println(wallheight+"  "+count);
            }
            System.out.println("Out of while loop");
        }
        return count;
    }
    public static void main(String arr[])
    {
        Jump obj = new Jump();
        int countOfJumps=obj.findJump();

        System.out.println("number of jumps is==>   "+countOfJumps);
    }
}

Answer 7

我认为12是一个错误的答案，因为我尝试了这个代码我得到了11，最后一次跳转没有错误：

public static void main(String [] args) {

    int T;
    int jcapacity, jslip, nwalls;

    //BufferedReader bf = new BufferedReader(new InputStreamReader(System.in));

    Scanner sc = new Scanner(System.in);

    T = sc.nextInt();
    jcapacity = sc.nextInt();
    jslip = sc.nextInt();
    nwalls = sc.nextInt();
    int [] wallHeightArr = new int [nwalls];

    for (int i = 0; i< nwalls; i++) {

        wallHeightArr[i] = sc.nextInt();
    }

    sc.close();

    while(T-->0) {

        int distance = log(jcapacity,jslip,wallHeightArr);
        System.out.println(distance);
    }
}

private static int log(int jcapacity, int jslip, int[] wallHeightArr) {
    // TODO Auto-generated method stub

    int distance = 0;

    for(int i = 0; i< wallHeightArr.length; i++) {

        int cHeight = 0;
        int count = 0;

        while (wallHeightArr[i] - cHeight > jcapacity) {

            cHeight += (jcapacity - jslip);
            count++;
        }
        count++;
        distance += count;
    }

    return distance;
}

囚犯墙跳程序中的测试用例说明

7 个答案: