牛客算法入门25-ranko的手表

已于 2022-12-02 23:10:21 修改
阅读量287 收藏
点赞数
分类专栏： 算法 Java 文章标签： java 算法
于 2022-12-02 22:50:37 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_65068830/article/details/128155938
版权

描述

ranko 的手表坏了，正常应该显示 xx:xx 的形式（4 个数字），比如下午 1 点半应该显示 13:30 ，但现在经常会有一些数字有概率无法显示。
ranko 在  t_1t1​ 时刻看了下时间，过了一段时间在 t_2t2​ 时刻看了下时间。她想知道， t_1t1​ 和 t_2t2​ 这两个时刻之间相距的时间的最大值和最小值是多少？
保证 t_1t1​ 在 t_2t2​ 之前（且 t_1t1​ 和 t_2t2​ 不等）。t_1t1​和 t_2t2​在同一天的 00:00 到 23:59 之间。

输入描述：

两行输入两个时间，为 xx:xx 的形式。其中 xx 为数字或者字符 '?' ，问号代表这个数字没有显示。
保证输入是合法的。

输出描述：

一行输出两个整数，分别代表 t_1t1​ 和 t_2t2​ 相距时间的最小值和最大值（单位分钟）。

示例1

输入：

18:0?
2?:1?

复制输出：

121 319

复制说明：

相距最小的时间为 18:09 到 20:10 ，相距121分钟。
相距最大的时间为 18:00 到 23:19 ，相距319分钟。

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

// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        String s1=sc.nextLine();
        String s2=sc.nextLine();
        
       System.out.println(min(s1,s2)+" "+max(s1,s2));
	}
	public static int max(String s1,String s2)
	{
		char[] c1=s1.toCharArray();
		char[] c2=s2.toCharArray();
		//分别装入map
		Map<Integer,Integer> m=new HashMap<>();
		Map<Integer,Integer> m2=new HashMap<>();
		
		for (int i=0;i<c1.length;i++)
		{
			if (c1[i]>='0'&&c1[i]<='9')
			{
				m.put(i+1,Integer.parseInt(c1[i]+""));
			}
		}
		//System.out.println("m:"+m.toString());
		for (int i=0;i<c2.length;i++)
		{
			if (c2[i]>='0'&&c2[i]<='9')
			{
				m2.put(i+1,Integer.parseInt(c2[i]+""));
			}
		}
	//	System.out.println("m2:"+m2.toString());
				
		//添加缺少的数
		for (int i=1;i<=5;i++)
		{
			if (i!=3&&!m.containsKey(i))
			{
				m.put(i, 0);
			}
		}
		
		if (!m2.containsKey(1))
		{
			m2.put(1,2);
		}
		if (!m2.containsKey(2))
		{
			if (m2.get(1)==2)
			{
				m2.put(2, 3);
			}
			else
			{
				m2.put(2, 9);
			}
		}
		if (!m2.containsKey(4))
		{
			m2.put(4,5);
		}
		if (!m2.containsKey(5))
		{
			m2.put(5,9);
		}
		//System.out.println("m:"+m.toString());
		//System.out.println("m2:"+m2.toString());
		
		int number1=0,number2=0;
		number1=60*(m.get(1)*10+m.get(2))+m.get(4)*10+m.get(5);
		number2=60*(m2.get(1)*10+m2.get(2))+m2.get(4)*10+m2.get(5);
		return number2-number1;
		
	}
	public static int min(String s1,String s2)
	{
		char[] c1=s1.toCharArray();
		char[] c2=s2.toCharArray();
		//分别装入map
		Map<Integer,Integer> m=new HashMap<>();
		Map<Integer,Integer> m2=new HashMap<>();
		
		for (int i=0;i<c1.length;i++)
		{
			if (c1[i]>='0'&&c1[i]<='9')
			{
				m.put(i+1,Integer.parseInt(c1[i]+""));
			}
		}
		//System.out.println("m:"+m.toString());
		for (int i=0;i<c2.length;i++)
		{
			if (c2[i]>='0'&&c2[i]<='9')
			{
				m2.put(i+1,Integer.parseInt(c2[i]+""));
			}
		}
	//	System.out.println("m2:"+m2.toString());
		//第一位
		if (!m.containsKey(1)&&m2.containsKey(1))
		{
			if (m.containsKey(2)&&m2.containsKey(2)&&m.get(2)>=m2.get(2))
			{
				
				m.put(1, m2.get(1)-1);
			}
			else
			{
			m.put(1, m2.get(1));
			}
		}
		if (!m2.containsKey(1)&&m.containsKey(1))
		{
			if (m.containsKey(2)&&m2.containsKey(2)&&m.get(2)>=m2.get(2))
			{
				
				m2.put(1, m.get(1)+1);
			}
			else
			{
			m2.put(1, m.get(1));
			}
		}
		if (!m.containsKey(1)&&!m2.containsKey(1))
		{
			if (m.containsKey(2)&&m2.containsKey(2)&&m.get(2)>=m2.get(2))
			{
				m.put(1, 0);
				m2.put(1, 1);
			}
			else 
			{
			m.put(1,0);
			m2.put(1, 0);
			}
		}
		//第二位
		if (!m.containsKey(2)&&m2.containsKey(2))
		{
			if (m.get(1)==m2.get(1)&&m.containsKey(4)&&m2.containsKey(4)&&m.get(4)>=m2.get(4))
			{
				m.put(2, m2.get(2)-1);
			}
			else if (m.get(1)==m2.get(1))
		{
			m.put(2, m2.get(2));
		}
		else
		{
			m.put(2, 9);
		}
		}
		
		if (!m2.containsKey(2)&&m.containsKey(2))
		{
			if (m.get(1)==m2.get(1)&&m.containsKey(4)&&m2.containsKey(4)&&m.get(4)>=m2.get(4))
			{
				m2.put(2, m.get(2)+1);
			}
			else if (m.get(1)==m2.get(1))
		{
			m2.put(2, m.get(2));
		}
		else
		{
			m2.put(2, 0);
		}
		}
		
		if (!m.containsKey(2)&&!m2.containsKey(2))
		{
			
			if (m.get(1)==m2.get(1)&&m.containsKey(4)&&m2.containsKey(4)&&m.get(4)>=m2.get(4))
			{
				m.put(2, 0);
				m2.put(2, 1);
			}
			else if (m.get(1)==m2.get(1))
		{
			m.put(2, 0);
			m2.put(2, 0);
		}
		else
		{
			m.put(2, 9);
			m2.put(2, 0);
		}
		}
		//第三位
		if (!m.containsKey(4)&&m2.containsKey(4))
		{
			if (m.get(1)==m2.get(1)&&m.get(2)==m2.get(2)&&m.containsKey(5)&&m2.containsKey(5)&&m.get(5)>=m2.get(5))
			{
				m.put(4, m2.get(4)-1);
			} else if (m.get(1)==m2.get(1)&&m.get(2)==m2.get(2))
			{
				m.put(4, m2.get(4));
			}
			else
			{
				m.put(4, 5);
			}
		}
		
		if (!m2.containsKey(4)&&m.containsKey(4))
		{
			if (m.get(1)==m2.get(1)&&m.get(2)==m2.get(2)&&m.containsKey(5)&&m2.containsKey(5)&&m.get(5)>=m2.get(5))
			{
				m2.put(4, m.get(4)+1);
			}
			else if (m.get(1)==m2.get(1)&&m.get(2)==m2.get(2))
		{
			m2.put(4, m.get(4));
		}
		else
		{
			m2.put(4, 0);
		}
		}
		
		if (!m.containsKey(4)&&!m2.containsKey(4))
		{
			if (m.get(1)==m2.get(1)&&m.get(2)==m2.get(2)&&m.containsKey(5)&&m2.containsKey(5)&&m.get(5)>=m2.get(5))
			{
				m.put(4, 0);
				m2.put(4, 1);
			}
			else if (m.get(1)==m2.get(1)&&m.get(2)==m2.get(2))
		{
			m.put(4, 0);
			m2.put(4, 0);
		}
		else
		{
			m.put(4, 5);
			m2.put(4, 0);
		}
		}
		//第四位
		if (!m.containsKey(5)&&m2.containsKey(5))
		{
			if (m.get(1)==m2.get(1)&&m.get(2)==m2.get(2)&&m.get(4)==m2.get(4))
			{
				m.put(5, m2.get(5)-1);
			}
			else
			{
				m.put(5, 9);
			}
		}
		
		if (!m2.containsKey(5)&&m.containsKey(5))
		{
			if (m.get(1)==m2.get(1)&&m.get(2)==m2.get(2)&&m.get(4)==m2.get(4))
			{
				m2.put(5, m.get(5)+1);
			}
			else
			{
				m2.put(5, 0);
			}
		}
		
		if (!m.containsKey(5)&&!m2.containsKey(5))
		{
		if (m.get(1)==m2.get(1)&&m.get(2)==m2.get(2)&&m.get(4)==m2.get(4))
		{
			m.put(5, 0);
			m2.put(5, 1);
		}
		else
		{
			m.put(5, 9);
			m2.put(5, 0);
		}
		}
		//System.out.println("m:"+m.toString());
		//System.out.println("m2:"+m2.toString());
		
		int number1=0,number2=0;
		number1=60*(m.get(1)*10+m.get(2))+m.get(4)*10+m.get(5);
		number2=60*(m2.get(1)*10+m2.get(2))+m2.get(4)*10+m2.get(5);
		return number2-number1;
	}
}

ranko的手表（枚举）
小郑在路上
04-10 1176
（1）思路： 枚举所有t1，t2可能的分钟数（转换成分钟好算），再遍历这些枚举的可能结果，不断维护更新最大时间间距和最小时间间距，主要就是这个过程该如何枚举：见代码有注释（时有十位和个位，分有十位和个位） （2）测试数据 18:0? 2?:1? （3）代码： // 贪心可以，但是考虑的情况很多且复杂 // 24 *60 枚举可以过 // 将时分统一转换为分钟，到时候好算 // 枚举t1和t2可能的分钟数，合理的先加入到vector容器中 #include <bits/stdc++.h&.
笔面试算法--贪心和枚举（疯狂的自我检索者、chika和蜜柑、you和帆船、数位染色(重点)、ranko的手表）
0k-ok
03-10 399
#include<iostream> #include<cstdio> #include<cmath> #include<stdio.h> #include<stdlib.h> #include<vector> #include<iomanip> #include<algorithm> #include<queue> #include<stack> #include<map&g...
【笔试算法题】贪心和枚举（四个例子彻底弄懂）
indeedes的博客
04-03 2781
笔试技巧：学会根据数据范围猜知识点 一般1s时间限制的题目，时间复杂度能跑到1e8左右（python和java会少一些，所以建议大家使用c/c++做笔试题）。 n范围20以内： O(n*2^n) 状压搜索/dfs暴搜 n范围200以内： O(n^3) 三维dp n范围3000以内： O(n^2) ...
模拟、枚举、贪心（二）
zhn的博客
05-09 1009
A-Captcha Cracker 简单模拟即可 #include<bits/stdc++.h> using namespace std; int main(){ int t; cin>>t; while(t--){ string s,ans; cin>>s; for(int i=0;i<s.size();i++){ if(s[i]=='z' && s.siz.
北京信息科技大学第十三届程序设计竞赛暨ACM选拔赛题解
qq_38582001的博客
10-27 4361
北京信息科技大学第十三届程序设计竞赛暨ACM选拔赛题解A lzh的蹦床B 所谓过河C 旅行家问题1D 旅行家问题2E 小菲和Fib数列F 好玩的音乐游戏G ranko的手表 A lzh的蹦床 sky被lzh抓到了一间密室，密室里放了一排紧密相邻的蹦床 ，lzh声称自己最喜欢欣赏sky跳跃在空中的姿态，并示意他可以开始跳了。sky的跳跃方向是单向向前的，当然如果他落到一个蹦床上则会继续向前弹跳，直到sky落到了坚硬可靠的地面上，他才可以结束这一趟弹跳，lzh当然允许sky自己选择每一趟跳跃开始的蹦床。 每一
【牛客算法题】 --手套--C++
qq_53413129的博客
04-19 465
链接 思路： 这里的手套数量是对应的，但是取手套的时候并不知道对应颜色放在哪，都是混着放的。 如果正常不考虑数量的情况下，只需要把一边的所有手套拿出来，另一边选一只即可。但是这道贪心算法题需要拿出最少的手套，需要得出最优解，无疑增加了难度。 所以想要拿出最小数量，那么一边的手套量应该是：总数-最小数+1，这样才能覆盖所有的手套可能。那么另一边只需要拿出一只就可以。 当遇到0只手套这样的情况，需要把另一边的手套都取出来。无论左手还是右手，都要取出另一边是0的手套，避免取到的手套正好是这只没有另.
牛客算法题--幸运的袋子--C++
qq_53413129的博客
04-14 802
幸运的袋子
刷题-牛客算法入门
m0_65323355的博客
05-15 229
AB10 反转链表 描述 给定一个单链表的头结点pHead(该头节点是有值的，比如在下图，它的val是1)，长度为n，反转该链表后，返回新链表的表头。 数据范围： 0≤n≤1000 要求：空间复杂度O(1) ，时间复杂度O(n) 。 如当输入链表{1,2,3}时， 经反转后，原链表变为{3,2,1}，所以对应的输出为{3,2,1}。 实现1:（栈） 思路比较简单：遍历链表，将结点都存储在栈中；然后，将结点依次出栈，即得到了反转之后的链表。 需要注意的是：1.首先可以设置一个哨兵结点dummy（作用：记录头结
牛客SQL刷题 Day-07
12-14
目录 1、获取select * from employees对应的执行计划 2、将employees表的所有员工的last_name和first_name拼接起来作为Name，中间以一个空格区分 3、创建一个actor表，包含如下列信息 4、对于表actor批量插入如下...
牛客网 牛客Java高级工程师 - 高薪求职项目课vol.4.zip
01-12
软件开发设计：应用软件开发、系统软件开发、移动应用开发、网站开发C++、Java、python、web、C#等语言的项目开发与学习资料 硬件与设备：单片机、EDA、proteus、RTOS、包括计算机硬件、服务器、网络设备、存储设备...
五大基础算法——枚举，算法数据结构
04-07
五大基础算法——枚举，算法数据结构 五大常用算法
北京信息科技大学第十三届程序设计竞赛暨ACM选拔赛（重现赛）题解
qq_49593247的博客
09-19 894
题目链接: 北京信息科技大学第十三届程序设计竞赛暨ACM选拔赛（重现赛）_ACM/NOI/CSP/CCPC/ICPC算法编程高难度练习赛_牛客竞赛OJ大学ACM校赛新生赛是面向ACM/ICPC/CCPC/区域赛校队选手，巩固经典专题的编程比赛，ACM入门训练，大学ACM校队选拔比赛。https://ac.nowcoder.com/acm/contest/20278#question这套题涉及的算法并不多(除了I题需要采用容斥和莫比乌斯),其余的都是简单的算法,更重考察的就是做题的思维能力. A.lzh的
北京信息科技大学第13届程序设计大赛题解
m0_51488693的博客
09-12 286
ranko的手表 思维 大意：给定时间的格式如下，xx:xx 但是有的数字并没有给出，给定两个时间 t1,t2。求t1<t2前提下可能的时间差的最大以及最小值。 思路：看了别人的代码，也有很多 dfs 过的，比赛的时候dfs没写好，T了，然后一直在想怎么去模拟，结果到最后也没想出什么好办法。 对于 dfs 的时候大可放心去赋值，我们只需要最后去判断是否合法就好了，这样代码会很多。 另外有个更好的办法，一天24*60 也就1440分钟，我们大可放心 O(n2)O(n^2)O(n2) 的时间复杂度..
牛客-模拟、枚举、贪心 2022.11.15
Ls_attack的博客
11-15 309
之后对于每个名字的查询，从名字的第一个字母出现的第一个位置开始，二分查找之后每个字母的位置是否大于当前的位置，如果大于，更新当前位置，直至名字数组结束，说明存在子序列，否则不存在。如果二者最高位相同，则比较下一位，直到出现不同的二进制位置，那么从这一位置开始往后到二进制的最低位，存在全为一的最大值，之前的高位置都相同，异或结果为0。对于药剂的数值，按照从大到小排序，对于奶牛的区间，按照区间最小值从大到小排序，之后遍历奶牛，对于每头奶牛，遍历药剂看是否存在符合条件的药剂，记录结果即可。模拟遍历01串即可。
Java 蓝桥杯 时间转换
joreng的博客
11-26 645
目录标题题目描述解题思路代码流程图 题目描述 给定一个以秒为单位的时间t，要求用“H:M:S”的格式来表示这个时间。H表示时间，M表示分钟，而S表示秒，它们都是整数且没有前导的“0”。例如，若t=0，则应输出是“0:0:0”；若t=3661，则输出“1:1:1”。 输入 输入描述: 　　输入只有一行，是一个整数t（0<=t<=86399）。 输入样例: 0 输出 输出描述: 　　输出只有一行，是以“H:M:S”的格式所表示的时间，不包括引号。 输出样例: 0:0:0 HINT:时间限制：1.0
python可编程手表_Python手表
weixin_29199873的博客
02-10 1103
我用python和tkinter制作了一个双倒计时计时器，但是如果tkinter窗口不在前台，它就不能同时运行了。这是我的代码：import tkinter as tkimport tkinter.ttk as ttkimport timeclass app:def __init__(self):self = 0def mainGUIArea():def count_down_1():for i ...
写一个程序，输入2个整数time1和time2，表示火车的出发时间和到达时间，计算并输出旅途时间（用时多少小时多少分钟）。时间格式：0025 表示 0点25分0815 表示 8点15
m0_61134493的博客
11-08 2403
#include<iostream> using namespace std; int main() {int m,n; cin>>m>>n; cout<<(((n/100)*60+(n%100))-((m/100)*60+m%100))/60<<" hrs "<<(((n/100)*60+(n%100))-((m/100)*60+m%100))%60<<" mins"; }
NEQU练习赛
NEUQ_snowy的博客
09-20 492
在9月18日这个特殊的日子，学长们举办了一次NEUQ练习赛。 A lzh的蹦床 首先考虑贪心，容易证明每次要从最左侧且高度不为1的蹦床开始，然后维护一个支持区间加法序列，我们记成f，用f来记录每个蹦床跳过的次数，不难看出f只需要从头到尾查询一次即可，因此只需要用差分序列维护，每扫一次统计答案即可。 #include<iostream> #include<cstdio> #include<algorithm> #include<cstring>
Java循环编程常见错误与优化实践
最新发布
静水深流
06-10 44
值得注意的是，基础的静态分析诊断（如"变量未使用"）无法检测此类问题，因为循环变量。该实现完全封装了索引操作，消除了客户端代码中显式使用索引的风险。建议在代码审查时特别关注循环体内索引变量的使用一致性，并针对边界情况（如空数组、单元素数组、多元素同值数组）设计专项测试用例。），将导致严重的无限循环问题。在需要逆向遍历集合时，开发者常犯的关键错误是修改循环条件后忘记调整递增/递减操作。开发者在循环结构中常犯的一个典型错误是：虽然正确编写了循环结构，但在循环体内错误地使用常量索引（如。停止更新，引发无限循环。
牛客竞赛算法入门班怎么样
01-14
牛客竞赛算法入门班是一个针对算法竞赛初学者的培训班。它提供了系统的课程和习题，帮助学员掌握算法竞赛中常用的算法和数据结构，并提高解题能力。通过参加这个培训班，学员可以学到以下内容： 1. 算法基础知识：包括时间复杂度、空间复杂度、递归、排序算法等。 2. 数据结构：包括数组、链表、栈、队列、树、图等。 3. 常用算法：包括贪心算法、动态规划、回溯算法、分治算法等。 4. 算法竞赛技巧：包括如何优化算法、如何处理特殊情况、如何设计算法等。 5. 实战习题：提供大量的算法竞赛习题，帮助学员巩固所学知识并提高解题能力。 通过参加牛客竞赛算法入门班，学员可以系统地学习算法竞赛的基础知识和技巧，提高解题能力，并为参加算法竞赛打下坚实的基础。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值