拼多多java后台笔试题目总结(20180830)

1、回合攻击问题

package com.hone.pdd;

import java.util.Scanner;

/**
 * 题目：模拟一个游戏场景，两种伤害，一种正常伤害，一种是先蓄力(也算一个回合)，在伤害，问：最多需要多少个回合敌人就会打倒？
 * 思路：-主要区分bufferedAttach和normalAttach之间的大小，注意是两倍之间的大小区别。
 * @author Xia
 *
 */
public class Test1 {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int hp = Integer.parseInt(in.nextLine());
        int normalA = Integer.parseInt(in.nextLine());
        int bufferedA = Integer.parseInt(in.nextLine());
        int step = 0; // 回合数
        if (bufferedA > normalA * 2) {
            step = hp/bufferedA;
            step = step * 2;
            //计算利用聚力之后的两个回合的剩余血量
            hp = hp - bufferedA * step/2;
            //如果剩余血量不等于0,并且剩余血量小于正常操作的消耗血量
            if (hp != 0) {
                if (hp <= normalA)
                    step++;
                else 
                    step += 2;
            }
        }else {
            step = hp/normalA;
            if (hp % normalA != 0 ) 
                step++;
        }
        System.out.println(step);
    }
}

Test2

 

package com.hone.pdd;

import java.util.Scanner;

/**
 * 利用一个二维数组来模拟整个的棋盘掉落情况。
 * @author Xia
 *
 */
public class Test2 {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        int m = in.nextInt();
        char[][] samples = new char[12][12];        //定义一个二维数组来表示棋盘
        for (int i = 0; i < n; i++) {
            samples[i] = in.next().toCharArray();
        }
        
        //用一个二重的for循环来控制,但是外层的循环是以列为单位，遍历内部的行单元元素
        for (int j = 0; j < m; j++) {                //列
            for (int i = n-1; i >= 0; i--) {        //行
                if (samples[i][j] == '.') 
                    continue;
                if (samples[i][j] == 'x') 
                    continue;
                int k = i;
                while (k < n) {
                    samples[k][j] = '.';
                    k++;
                    if (k < n&&samples[k][j]!='.') {
                        samples[k-1][j] = 'o';
                        break;
                    }
                }
            }
            
        }
        
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                System.out.printf("%c",samples[i][j]);
            }
            System.out.println();
        }
        
        
        
    }
}

 Test3

 实际上求得是小数的循环结。

package com.hone.pdd;

import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;

/**
 * 分类：1：可以整除的数
 *         2：可以除尽的数(和第一种有重合)
 *         3：无限循环小数
 * 思路：首先可以在循环的外部做一次除法得到一个余数。
 *         其后在for循环中的得到的余数一定是小数点后面的数。
 *         利用map来存储小数点之后的数出现的位置。
 *         无限循环小数出现的条件(余数出现重复)
 * @author Xia
 *
 */
public class Test3 {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int a = in.nextInt();
        int b = in.nextInt();
        //用map来存储小数点后面的数，及该数在小数点后面位置。
        Map<Integer, Integer> map = new HashMap<Integer, Integer>();
        a %= b;
        
        //固定把小数点后一位定为0位
        for (int i = 0;; i++) {
            int x = a % b;
            if (x == 0) {
                System.out.println(i + " 0");
                break;
            }
            Integer t = map.get(x);
            if (t != null) {
                System.out.printf("%d %d
", t, i - t);
                break;
            }
            map.put(x, i);
            a = x * 10;
        }

    }
}

Test4

这道题个人没有理解，是参考考试完之后别人的答案。

package com.hone.pdd;

import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
import java.util.Set;
import java.util.TreeSet;

public class Test4 {
    // n 表示单词的个数 m表示单词的长度
    static int n;
    static int m;
    static List<Set<Character>> b;
    static Set<String> st;
    static boolean flag = false;

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        n = in.nextInt();
        m = in.nextInt();
        in.nextLine();
        String[] s = new String[n];
        st = new TreeSet<>();
        for (int i = 0; i < n; i++) {
            s[i] = in.nextLine();
            st.add(s[i]);
        }

        b = new ArrayList<>();
        for (int i = 0; i < m; i++) {
            b.add(new TreeSet<>());
        }

        for (int j = 0; j < m; j++) {
            for (int i = 0; i < n; i++) {
                b.get(j).add(s[i].charAt(j));
            }
        }

        // 深度优先搜索
        dfs(0, new StringBuilder());

    }

    private static void dfs(int k, StringBuilder sb) {
        if (flag)
            return;

        if (k == m) {
            if (!st.contains(sb.toString())) {
                System.out.println(sb);
                flag = true;
            }
            return;
        }
        //lambda表达式
        b.get(k).forEach(character -> {
            StringBuilder ssb = new StringBuilder(sb);
            ssb.append(character);
            dfs(k + 1, ssb);
        });
    }
}