有一个长为n的数组A,求满足0≤a≤b 给定数组A及它的大小n,请返回最大差值。
class LongestDistance {
public:
int getDis(vector A, int n) {
// write code here
int max_dis = 0;
int min_num = A.at(0);
int dis;
for(int i=0; i for (int j=i+1; j dis = A.at(j) - A.at(i);
if(dis > max_dis){
max_dis =dis;
}
}
}
return max_dis;
}
};
在4x4的棋盘上摆满了黑白棋子,黑白两色的位置和数目随机其中左上角坐标为(1,1),右下角坐标为(4,4),现在依次有一些翻转操作,要对一些给定支点坐标为中心的上下左右四个棋子的颜色进行翻转,请计算出翻转后的棋盘颜色。
给定两个数组A和f,分别为初始棋盘和翻转位置。其中翻转位置共有3个。请返回翻转后的棋盘。
测试样例:
[[0,0,1,1],[1,0,1,0],[0,1,1,0],[0,0,1,0]],[[2,2],[3,3],[4,4]]
返回:[[0,1,1,1],[0,0,1,0],[0,1,1,0],[0,0,1,0]]
import java.util.*;
public class Flip {
public int[][] flipChess(int[][] A, int[][] f) {
// write code here
for(int i=0; i int tran_row = f[i][0] - 1;
int tran_col = f[i][1] - 1;
int tal_col = A.length-1;
if(tran_row-1 >= 0)//上
{
A[tran_row-1][tran_col] = (A[tran_row-1][tran_col]==0)?1:0;
}
if(tran_row+1 <= tal_col)//下
{
A[tran_row+1][tran_col] = (A[tran_row+1][tran_col]==0)?1:0;
}
if(tran_col -1 >=0)//左
{
A[tran_row][tran_col-1] = (A[tran_row][tran_col-1]==0)?1:0;
}
if(tran_col +1 <=tal_col)//右
{
A[tran_row][tran_col+1] = (A[tran_row][tran_col+1]==0)?1:0;
}
}
return A;
}
}
现在有一个城市销售经理,需要从公司出发,去拜访市内的商家,已知他的位置以及商家的位置,但是由于城市道路交通的原因,他只能在左右中选择一个方向,在上下中选择一个方向,现在问他有多少种方案到达商家地址。
给定一个地图map及它的长宽n和m,其中1代表经理位置,2代表商家位置,-1代表不能经过的地区,0代表可以经过的地区,请返回方案数,保证一定存在合法路径。保证矩阵的长宽都小于等于10。
测试样例:
[[0,1,0],[2,0,0]],2,3
返回:2
方法一:
import java.util.*;
public class Visit {
public int countPath(int[][] map, int n, int m) {
// write code here
// write code here
int sale_row = 0;
int sale_col = 0;
int bus_row = 0;
int bus_col = 0;
// int[][] plan = new int[n][m];
for(int i=0; i for(int j=0; j< map[i].length; j++){
if(map[i][j] == 1){
sale_row = j;
sale_col = i;
}if(map[i][j] == 2){
bus_row = j;
bus_col = i;
}
}
}
int xgo = sale_row>bus_row?-1:1;//根据商家的位置判断向左还是向右
int ygo = sale_col>bus_col?-1:1;//向下还是向上
for(int y=sale_col; y!=(bus_col+ygo); y+=ygo)
{
for(int x=sale_row; x!=(bus_row+xgo); x+=xgo){
if(y==sale_col||x==sale_row){
map[y][x] = 1;
continue;
}
map[y][x] = map[y-ygo][x] + map[y][x-xgo];
}
}
return map[bus_col][bus_row];
}
}
方法二:
import java.util.*;
public class Visit {
public int countPath(int[][] map, int n, int m) {
// write code here
// write code here
int sale_row = 0;
int sale_col = 0;
int bus_row = 0;
int bus_col = 0;
int[][] plan = new int[n][m];
for(int i=0; i for(int j=0; j< map[i].length; j++){
if(map[i][j] == 1){
sale_row = i;
sale_col = j;
}if(map[i][j] == 2){
bus_row = i;
bus_col = j;
}
}
}
int xgo = sale_row>bus_row?-1:1;//根据商家的位置判断向左还是向右
int ygo = sale_col>bus_col?-1:1;//向下还是向上
for(int x=sale_row; x!=(bus_row+xgo); x+=xgo){
for(int y=sale_col; y!=(bus_col+ygo); y+=ygo){
if(x==sale_row||y==sale_col){
plan[x][y] = 1;
}else if(x==sale_row){
plan[x][y] = (map[x][y] == -1)?0:plan[x][y-ygo];
}else if(y==sale_col){
plan[x][y] = (map[x][y] == -1)?0:plan[x-xgo][y];
}else{
plan[x][y] = (map[x][y] == -1)?0:(plan[x][y-ygo]+plan[x-xgo][y]);
}
}
}
return plan[bus_row][bus_col];
}
}
有一个直方图,用一个整数数组表示,其中每列的宽度为1,求所给直方图包含的最大矩形面积。比如,对于直方图[2,7,9,4],它所包含的最大矩形的面积为14(即[7,9]包涵的7x2的矩形)。
给定一个直方图A及它的总宽度n,请返回最大矩形面积。保证直方图宽度小于等于500。保证结果在int范围内。
测试样例:
[2,7,9,4,1],5
返回:14
import java.util.*;
public class MaxInnerRec {
public int countArea(int[] A, int n) {
// write code here
int maxArea = 0;
int min;
for(int i=0; i min = Integer.MAX_VALUE;
for(int j=i; j>=0; j--){
min = Math.min(min, A[j]);
maxArea= Math.max(maxArea,(i-j+1)*min);
}
}
return maxArea;
}
}
求字典序在s1和s2之间的,长度在len1到len2的字符串的个数,结果mod 1000007。
输入描述:
每组数据包涵s1(长度小于100),s2(长度小于100),len1(小于100000),len2(大于len1,小于100000)
输入例子:
ab ce 1 2
输出例子:
56
import java.util.*;
public class Main{
public static void main(String []args){
Scanner sc = new Scanner(System.in);
while(sc.hasNext()){
long result = 0;
String begin = sc.next();
String end = sc.next();
int len1 = sc.nextInt();
int len2 = sc.nextInt();
int maxlen = begin.length()>end.length()?begin.length():end.length();
int minlen = begin.length() for(int i=0;i int distance;
if(i distance = end.charAt(i)-begin.charAt(i);
}else{
if(begin.length()>end.length())
distance = 'a' - begin.charAt(i)-1;
else
distance = end.charAt(i)-'a'+1;
}
long now=0;
for(int j=len1;j<=len2;j++){
if(j-i-1>=0){
now=now+(long)Math.pow(26,j-i-1);
}
}
now = (now*distance)%1000007;
result+=now;
}
System.out.println(result-1);
}
}
}
已知某公司总人数为W,平均年龄为Y岁(每年3月末计算,同时每年3月初入职新人),假设每年离职率为x,x>0&&x<1,每年保持所有员工总数不变进行招聘,新员工平均年龄21岁。
从今年3月末开始,请实现一个算法,可以计算出第N年后公司员工的平均年龄。(结果向上取整)。
输入例子:
5 5 0.2 3
输出例子:
15
import java.util.Scanner;
public class Main{
//这个题着实让我弄了好一会,首先有三个误区,
//第一个误区,每年在招纳新员工的同时,老员工的年龄是要增长的
//第二个误区,为什么最后的公式与 W 无关。
//第三个误区,是这个向上取整,题目给出的用例是5 5 0.2 3
//然后我计算第一年的平均年龄是9,不用取整。
//然后计算第二年的平均年龄是11.4,这时候我直接向上取整了,变成了12
//所以下一年的平均年龄我误以为是12+1,导致我的计算结果不符合
//其实题目是想让你把最后一年计算出来的年龄向上取整。
//下面看一下代码
public static int Average(int W ,double Y ,double x ,int N){
//W表示公司总人数,Y表示当年平均年龄,x表示离职率,N表示多年以后
for(int i = 0 ; i < N ; i++){
//原始公式是这个Y = ((Y+1)*(W-W*x) + 21*(W*x))/W;
//先求的离职之后还没有纳新时所有员工的总年龄,
//记得Y+1,老员工也是要长大的
//求得老员工的总年龄,然后加上纳新的员工的总年龄
//最后除去公司的总人数,就是当年公司的平均年龄。
//这个年龄是不进行向上取整的,而且我们发现这个公式是可以化简的
//*************************************
//下面是化简之后的公式,可以发现公式是与W没有关系的,
//这就是为啥有的人纳闷为啥别人直接给出公式为啥与W无关,
//但是自己又感觉最后公式肯定与W有关的原因了。
//所以传参的时候可以不用传W。此处只是为了说明,
Y = (Y+1)*(1-x)+21*x;
}
//最后对求得的结果进行向上取整。返回就OK了
return (int) Math.ceil(Y);
}
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
do{
int W = sc.nextInt();
double Y = sc.nextDouble();
double x = sc.nextDouble();
int N = sc.nextInt();
System.out.println(Average(W,Y,x,N));
}while(sc.hasNext());
}
}
请设计一个算法,给一个字符串进行二进制编码,使得编码后字符串的长度最短。
输入例子:
MT-TECH-TEAM
输出例子:
33
import java.util.*;
public class Main{
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
while(sc.hasNext()){
String value = sc.next();
int minLen = hafuman(value);
System.out.println(minLen);
}
}
private static int hafuman(String val){
//首先找出每个字符的个数
char[] chars = val.toCharArray();
Map map = new HashMap<>();
for(int i=0; i if(map.containsKey(chars[i])){
map.put(chars[i], map.get(chars[i])+1);
}else{
map.put(chars[i], 1);
}
}
//优先队列(最小推),每次能得到weigh最小的node
Queue q = new PriorityQueue<>(map.size(), new Comparator() {
@Override
public int compare(TreeNode o1, TreeNode o2) {
return Integer.compare(o1.weight, o2.weight);
}
});
for (Map.Entry entry : map.entrySet()) {
q.offer(new TreeNode(entry.getValue(), entry.getKey()));
}
while (q.size() > 1) {
//弹出两个最小的,合并为一个node
TreeNode left = q.poll();
TreeNode right = q.poll();
TreeNode father = new TreeNode(left.weight + right.weight);
father.left = left;
father.right = right;
q.offer(father);
}
TreeNode root = q.poll();
//计算长度
return valLength(root, 0);
}
public static int valLength(TreeNode node, int depth) {
if (node == null) return 0;//仅计算ch有值的
return (node.ch == null ? 0 : node.weight) * depth + valLength(node.left, depth + 1) + valLength(node.right, depth + 1);
}
static class TreeNode {
int weight;//权重,出现次数
Character ch;//如果是初始字符,则ch为字符,如果是合并的,则为null
TreeNode left;
TreeNode right;
public TreeNode(int weight) {
this.weight = weight;
}
public TreeNode(int weight, Character ch) {
this.weight = weight;
this.ch = ch;
}
}
}
对于一个由0..n的所有数按升序组成的序列,我们要进行一些筛选,每次我们取当前所有数字中从小到大的第奇数位个的数,并将其丢弃。重复这一过程直到最后剩下一个数。请求出最后剩下的数字。
import java.util.*;
public class Main{
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
while(sc.hasNext()){
int n = sc.nextInt();
// int[] num = new int[n+1];
List li= new ArrayList();
for(int i=0; i<=n; i++){
li.add(i);
}
while(li.size() != 1){
for(int i=0; i
li.remove(i);
}
}
System.out.println(li.get(0));
}
}
}
有一个二维数组(n*n),写程序实现从右上角到左下角沿主对角线方向打印。
给定一个二位数组arr及题目中的参数n,请返回结果数组。
测试样例:
[[1,2,3,4],[5,6,7,8],[9,10,11,12],[13,14,15,16]],4
返回:[4,3,8,2,7,12,1,6,11,16,5,10,15,9,14,13]
import java.util.*;
public class Printer {
public int[] arrayPrint(int[][] arr, int n) {
// write code here
int[] print = new int[n*n];
int startX = 0;
int index = 0;
int startY = n-1;
while(startX < n){
int x = startX;
int y = startY;
while(x print[index++] = arr[x++][y++];
if(startY>0)
startY--;
else
startX++;
}
return print;
}
}