囚徒跳墙程序中测试用例的解释

Question

这将是一般的问题陈述：

一名囚犯通过跳过 N 面墙逃出监狱，每面墙的高度在一个数组中给出。他可以跳 x 米高，但每次跳跃后，由于某些不可控因素（风、湿滑的墙壁等），他会滑 y 米。

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。

所以他必须跳两次才能跳过墙壁。所以，这个函数应该return2（逃跑需要跳转的总次数）。

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

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

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->6->8->10->12->14->16->18->21->23->26->28->30-> 32->34->36->39->41->43->45->47->50->53

假设墙的高度为 20、25、37、48、51。

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

Answer 1

你可以用这个。

示例代码

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 2

试试这个

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

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 3

试试这个代码。可能未优化

$input1 = 跳跃高度

$input2 = 滑点

$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 4

一堵又一堵墙。跳完一号墙后，位置应该从零开始，而不是从最后一次跳跃的高度开始。对于第一种情况，输出实际上应该是 1，因为高度和跳跃是相同的。在第二个测试用例中，24 是正确的输出。我在 techgig 比赛中看到了完全相同的问题。对于第一个测试用例，输出应该是 1。测试用例已经自己解释过，如果跳跃和高度相同，则不会滑倒。

Answer 5

检查这是否解决了您的问题

def GetJumpCount(jump, slips, walls):
    """
    @jump:int, Height of 1 jump
    @slips:int, height of slip
    @walls:array, height of walls
    """
    jumps = []
    for wall_height in walls:
        wall_jump = 1
        wall_height -= jump
        while wall_height > 0:
            wall_height += slips
            wall_height -= jump
            wall_jump += 1
        jumps.append(wall_jump)
    return sum(jumps)

Answer 6

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

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

给定案例 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 8

我认为 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;
}

Answer 9

def jumpTheifCount(arr, X, Y):
    jump = 0
    remheight = 0

    for i in range(len(arr)):
        if X == arr[i]:
            jump = jump + 1
            continue
        if X < arr[i]:
            jump = jump + 1
            remheight = arr[i] - X + Y
        if remheight > X:
            jump = jump + 1
            remheight = arr[i] - X + Y
        if remheight < X:
            jump = jump + 1
            continue
    return jump

arr = [11, 10, 10, 9]
X = 10
Y = 1

print(jumpTheifCount(arr, X, Y))

囚徒跳墙程序中测试用例的解释

Explanation of test case in the prisoner wall jump program

debugging

function

integer-arithmetic