package step1;
import java.util.*;
public class Main {
public static void main(String[] args) {
// -- write your code here --
//声明Scanner类的实例对象in
Scanner in = new Scanner(System.in);
String str1 = in.nextLine();
String str2 = in.nextLine();
String[] strarr1 = str1.substring(str1.indexOf("[") + 1,str1.indexOf("]")).split(",");
String[] strarr2 = str2.substring(str2.indexOf("[") + 1,str2.indexOf("]")).split(",");
int arr1[] = new int[strarr1.length];
int arr2[] = new int[strarr2.length];
//获取数据:分别输入两个数组arr1和arr2
int i;
for(i=0;i<arr1.length;i++){
String num = strarr1[i].trim();
arr1[i] = Integer.parseInt(num);
}
for(i=0;i<arr2.length;i++){
String num = strarr2[i].trim();
arr2[i] = Integer.parseInt(num);
}
//声明Solution类的实例对象
Solution solution = new Solution();
//调用Solution类的方法equalityOfArrays判断两个数组是否相等并输出结果
boolean res = solution.equalityOfArrays(arr1,arr2);
if(res) System.out.println("The arrays arr1 and arr2 are equal.");
else System.out.println("The arrays arr1 and arr2 are not equal.");
//关闭输入流对象
in.close();
}
}
package step2;
import java.util.*;
class Solution {
/**
* @param str: 非空字符串
* @return 按照字典序的降序排列的字符串
*/
public String handle(String str) {
// --write your code here--
char[] arr = str.toCharArray();
Character[] arr2 = new Character[arr.length];
for(int i=0;i<arr.length;i++){
arr2[i] = arr[i];
}
Arrays.sort(arr2,new Comparator<Character>(){
public int compare(Character o1,Character o2){
return o2 - o1;
}
});
return Arrays.toString(arr2);
}
}
public class Main {
public static void main(String[] args) {
// --write your code here--
//声明Scanner类的实例对象in
Scanner in = new Scanner(System.in);
//输入一行字符串
String str = in.nextLine();
//声明Solution类的实例对象
Solution solution = new Solution();
//调用Solution类的handle方法,并输出结果
String res = solution.handle(str);
System.out.print(res);
//关闭输入流对象
in.close();
}
}
package step3;
public class Student implements Comparable {
private String name;
private int score;
public Student(String name, int score) {
this.name = name;
this.score = score;
}
public String getName() {
return this.name;
}
public int getScore() {
return this.score;
}
@Override
public int compareTo(Object s) {
// --write your code here--
Student stu =(Student)s;
if(this.score>stu.score){
return -1;
}
else if(this.score<stu.score){
return 1;
}
else{
return this.getName().compareTo(stu.getName());
}
}
@Override
public String toString() {
return this.name + " " + this.score;
}
}
package step3;
import java.util.*;
public class Main {
public static void main(String[] args) {
// --write your code here
//创建Scanner类的实例对象in
Scanner in = new Scanner(System.in);
List<Student> list = new ArrayList<>();
// 读取数据并存入List集合
while(in.hasNextLine()){
String str = in.nextLine();
String[] strarr = str.trim().split(" ");
String name = strarr[0];
int score = Integer.parseInt(strarr[1]);
list.add(new Student(name,score));
}
//排序:成绩从高到低,成绩相等时安装姓名字典序
Collections.sort(list);
//输出排序后的结果
for(Student student:list){
System.out.println(student);
}
//关闭输入流对象in
in.close();
}
}
package step4;
import java.util.*;
import java.io.*;
/**
* 最大的k个数。
*/
public class Main {
public static void main(String[] args) throws Exception {
//使用File类读入目录"src/step4/"下的文件"0.in"
File file = new File("src/step4/0.in");
//声明Scanner类的实例对象in, 从File类的对象中读入多行数据
Scanner in = new Scanner(file);
//循环读入多组数据
while (in.hasNextLine()) {
// 读入一组数据,解析数据,存入数组
String str = in.nextLine();
String kk = in.nextLine();
int k = Integer.parseInt(kk);
String[] nums = str.substring(str.indexOf("[")+1,str.indexOf("]")).trim().split(", ");
Integer arr[] = new Integer[nums.length];
int i;
for(i=0;i<nums.length;i++){
arr[i] = Integer.parseInt(nums[i]);
}
Arrays.sort(arr,Comparator.reverseOrder());
//输出最大的k个数
System.out.print("[");
for(i=0;i<k;i++){
if(i==k-1){
System.out.print(arr[i]);
}
else {System.out.print(arr[i]+", ");}
}
System.out.println("]");
}
in.close();
}
}
package step5;
import java.util.Scanner;
import java.util.*;
import java.io.*;
public class Main {
public static void main(String[] args) throws Exception {
//使用File类读入目录"src/step5/"下的文件"0.in"
File file = new File("src/step5/0.in");
//声明Scanner类的实例对象in, 从File类的对象中读入多行数据
Scanner in = new Scanner(file);
//循环读入多组数据
while (in.hasNextLine()) {
// 读入一组数据,解析数据,存入数组
String str = in.nextLine();
String nums[] = str.substring(str.indexOf("[")+1, str.indexOf("]")).trim().split(", ");
int n = Integer.parseInt(nums[0]);
int key = Integer.parseInt(nums[1]);
int[] arr = new int[nums.length-2];
for(int i=0;i<nums.length-2;i++){
arr[i] = Integer.parseInt(nums[i+2]);
}
// 调用折半查找函数
bs(arr,key);
}
//关闭输入流
in.close();
}
/**
* 折半查找函数bs:在数组arr中查找关键字key。
* 输出关键字key在数组中的索引值和查找次数。
* 如果数组中找不到关键字key,则输出Not Found
*/
public static void bs(int[] arr, int key) {
int s=0,e=arr.length-1;
int mid,count=0;
while(s<=e){
mid = s+(e-s)/2;
count++;
if(key == arr[mid]){
System.out.println(mid + " " + count);
return;
}else if(key>arr[mid]){
s = mid + 1;
}
else if(key < arr[mid]){
e = mid - 1;
}
}
if(s>e)
System.out.println("Not Found");
}
}
package step6;
import java.util.*;
public class Main {
public static void main(String[] args) {
//创建Scanner类的实例对象
Scanner sc = new Scanner(System.in);
//读入n a b c
int n =sc.nextInt();
int a =sc.nextInt();
int b =sc.nextInt();
int c =sc.nextInt();
//创建Solution类的实例对象
Solution solution = new Solution();
//调用Solution类的fun方法,统计[a, b]内c出现的次数并输出
System.out.println(solution.fun(n,a,b,c));
//关闭输入流对象
sc.close();
}
}
class Solution {
/**
* 由n构建字符串,在构建的字符串的[a, b]区间内统计c出现的次数并返回。
*/
public int fun(int n, int a, int b, int c) {
StringBuilder sb = new StringBuilder();
for(int i=0;i<=n;i++){
sb.append(i);
}
String str = sb.toString();
String re = sb.substring(a,b+1);
int cnt = 0;
for(int i=0;i<re.length();i++){
if(Integer.parseInt(re.charAt(i)+"")==c)
cnt++;
}
System.out.print(str.length()+" ");
return cnt;
}
}
package step7;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
//创建Scanner类的实例对象sc
Scanner sc = new Scanner(System.in);
//读入一行仅由字母和*组成的字符串c
String c = sc.nextLine();
//h定位到字符串c第一个字母,p定位到字符串c的最后一个字母
int h = 0,p = c.length() - 1;
//调用函数fun完成*的删除
fun(c, h, p);
//关闭输入流对象
sc.close();
}
/**
* 功能 :删除字符串中间位置的*
* 参数c:传入的字符串
* 参数h:字符串第一个字符的索引
* 参数p:字符串最后一个字符的索引
*/
private static void fun(String c, int h, int p) {
//************** code begin **************//
char[] str = new char[c.length()];
while(c.charAt(h)=='*'){
str[h++] = '*';
}
while(c.charAt(p)=='*'){
p--;
}
int k = h;
for(int i=h;i<=p;i++){
if(c.charAt(i)!='*')
str[k++] = c.charAt(i);
}
for(int i=p+1;i<c.length();i++)
{
str[k++] = '*';
}
System.out.print(new String(str));
// ************** code end ****************//
}
}
package step8;
import java.util.*;
import java.io.*;
public class Solution {
public static void main(String[] args) {
int b;
byte[] s = new byte[1024];
try {
b = System.in.read(s);
} catch (IOException e) {
System.out.println(e.toString());
}
// 请在此添加代码
/*************** Begin **************/
//创建Solution类的实例对象
Solution solution = new Solution();
//调用Solution类的extractNum方法,返回一个集合对象。
List<Character> list = solution.extractNum(s);
//将集合中存储的数字打印出来
int flag= 0;
for(int i=0;i<list.size();i++){
if(list.get(i).equals('0')){
if(flag!=0){
System.out.print(list.get(i));
}
}
else{
System.out.print(list.get(i));
flag = 1;
}
}
/*************** End ***************/
}
// 函数extractNum:选出str指向的字符串中的数字
// 参数:str-指向字符串
public List<Character> extractNum(byte[] str) {
// 请在此添加代码,实现函数extractNum
/*************** Begin **************/
List<Character> list = new ArrayList<>();
for(int i=0;i<str.length;i++){
if(Character.isDigit(str[i])){
list.add((char)str[i]);
}
}
return list;
/*************** End ***************/
}
}
package step9;
import java.util.*;
/**
* 输入: source = "abcde", target = "cdeab"
* 输出: true
*/
class Solution {
public boolean rotateString(String s, String target) {
//在下面编写代码
//************************Begin**********************//
return s.length() == target.length() && (s + s).contains(target);
//*************************End***********************//
}
}
public class Main {
public static void main(String[] args) {
//在下面编写代码
//************************Begin**********************//
//声明Scanner类实例对象cin
Scanner cin = new Scanner(System.in);
//输入源字符串source
String source = cin.next();
//输入目标字符串target
String target = cin.next();
//创建Solution类实例对象
Solution solution = new Solution();
//调用Solution类的方法rotateString,判断target是否可以由source旋转得到。
//如果可以,输出true;否则输出false
System.out.println(solution.rotateString(source,target));
//*************************End***********************//
cin.close();
}
}
package step10;
import java.util.*;
import java.math.*;
class Solution {
public int isPrefixOfWord(String sentence, String searchWord) {
/***********************Begin**************************/
String words[] = sentence.trim().split(" ");
for(int i=0;i<words.length;i++)
{
boolean flag = words[i].startsWith(searchWord);
if(flag==true)
{
return i+1;
}
}
return -1;
/*************************End**************************/
}
}
package step10;
import java.util.*;
import java.math.*;
import java.io.*;
public class Main {
public static void main(String[] args) throws Exception {
//读入目录src/step10下面的文件0.in
File file = new File("src/step10/0.in");
//声明Scanner类的实例对象cin,从文件0.in中读入数据进行处理。
Scanner cin = new Scanner(file);
while(cin.hasNextLine()){
String sentence = cin.nextLine();
String searchWord = cin.nextLine();
//声明Solution类的实例对象,并调用Solution类的方法isPrefixOfWord,返回结果并打印。
Solution solution = new Solution();
System.out.println(solution.isPrefixOfWord(sentence,searchWord));
}
cin.close(); //关闭输入流对象
}
}
package step11;
import java.util.*;
public class Solution {
//统计数组元素之和并返回
public int getSum(int arr[]) {
//******Begin*******//
Set<Integer> set = new HashSet<>();
for(int x:arr){
set.add(x);
}
int sum = 0;
Iterator<Integer> it = set.iterator();
while(it.hasNext()){
sum += it.next();
}
return sum;
//******End*******//
}
}
package step11;
import java.io.*;
import java.util.*;
public class Main {
public static void main(String[] args) throws Exception {
//读入src/step11/下的文件0.in,创建File类的实例对象file
File file = new File("src/step11/0.in");
//根据File类的实例对象file,创建Scanner类的实例对象in
Scanner in = new Scanner(file);
//循环读入多行
while (in.hasNextLine()) {
// 读取一行数据并处理
String str = in.nextLine();
String[] m = str.substring(str.indexOf("[")+1,str.indexOf("]")).trim().split(", ");
int[] cin = new int[m.length];
int i;
for(i=0;i<m.length;i++){
cin[i] = Integer.parseInt(m[i]);
}
//创建Solution类的实例对象
Solution solution = new Solution();
//调用Solution类的方法getSum,传入参数,获取返回值
int n = solution.getSum(cin);
//输出返回结果
System.out.println(n);
}
in.close(); //关闭输入流
}
}
package step12;
import java.util.*;
public class Solution {
/**
* @param arr: Any int array, and not an empty array
* @return Non-repetitive and ordered arrays
*/
public Integer[] deDuplicationAndSort(Integer[] arr) {
// write your code here
Set<Integer> set = new HashSet<>();
for(int x:arr){
set.add(x);
}
Integer[] ans = new Integer[set.size()];
Iterator it = set.iterator();
int i=0;
while(it.hasNext()){
ans[i++] = (Integer)it.next();
}
Arrays.sort(ans);
return ans;
}
}
package step12;
import java.io.*;
import java.util.*;
public class Main {
public static void main(String[] args) throws Exception {
//使用File类读入目录"src/step12/"下的文件"0.in"
File file = new File("src/step12/0.in");
//声明Scanner类的实例对象in, 从File类的对象中读入多行数据
Scanner in = new Scanner(file);
//循环读入多行数据
while (in.hasNextLine()) {
// 读入一行数据,解析数据,存入数组
String str = in.nextLine();
String[] arr = str.substring(str.indexOf("[")+1,str.indexOf("]")).trim().split(", ");
Integer[] nums = new Integer[arr.length];
for(int i=0;i<arr.length;i++){
nums[i] = Integer.parseInt(arr[i]);
}
//声明Solution类的实例对象solution
Solution solution = new Solution();
//调用Solution类的方法deDuplicationAndSort
Integer[] an = solution.deDuplicationAndSort(nums);
//按照指定格式[1, 2, 3, 4]这种形式打印去除重复元素并排序后的数据
System.out.print("[");
for(int i=0;i<an.length;i++){
if(i!=an.length-1){
System.out.print(an[i]+", ");
}
else System.out.print(an[i]);
}
System.out.println("]");
}
in.close(); //关闭输入流
}
}
package step13;
import java.util.*;
import java.io.*;
import java.math.*;
public class Main {
public static void main(String[] args) {
//在下面编写代码
//**************Begin**************//
//创建Scanner类实例对象cin
Scanner cin = new Scanner(System.in);
//输入整数n
int n = cin.nextInt();
//创建数组nums
int nums[] = new int[n];
//输入n个整数,存入数组nums
for(int i=0;i<n;i++){
nums[i] = cin.nextInt();
}
int[] arr = new int[1000];
//统计只出现一次的元素之和并打印
for(int i=0;i<n;i++){
arr[nums[i]]++;
}
int sum = 0;
for(int i=0;i<1000;i++){
if(arr[i]==1)
sum += i;
}
System.out.print(sum);
//关闭输入流对象
cin.close();
//***************End***************//
}
}
package step14;
import java.util.*;
class Solution {
/**
* 求两个数组的交集。
*/
Set<Integer> jointSet(int[] nums1, int[] nums2) {
//write your coder here
//********************Begiin*****************//
Arrays.sort(nums1);
Arrays.sort(nums2);
int i=0,j;
for(j=1;j<nums1.length;j++){
if(nums1[i] != nums1[j]){
i++;
nums1[i] = nums1[j];
}
}
int len1 = i+1;
i=0;
for(j=1;j<nums2.length;j++){
if(nums2[i] != nums2[j]){
i++;
nums2[i] = nums2[j];
}
}
int len2 = i+1;
Set<Integer> list = new TreeSet<>();
int m=0,k=0;
while(m<len1 && k<len2)
{
if(nums1[m]==nums2[k])
{
list.add(nums1[m]);
m++;k++;
}
else if(nums1[m]<nums2[k]) m++;
else k++;
}
return list;
//*********************End******************//
}
}
public class Main {
public static void main(String[] args) {
//write your coder here
//********************Begiin*****************//
//定义Scanner类的实例对象cin
Scanner cin = new Scanner(System.in);
//输入n和n个整数
int n;
n = cin.nextInt();
int[] arr1 = new int[n];
for(int i=0;i<n;i++)
{
arr1[i] = cin.nextInt();
}
//输入k和k个整数
int k;
k = cin.nextInt();
int[] arr2 = new int[k];
for(int i=0;i<k;i++)
{
arr2[i] = cin.nextInt();
}
//定义Solution类的实例对象
Solution sol = new Solution();
//调用Solution类的方法jointSet方法求两个数组的交集
Set<Integer> set = sol.jointSet(arr1,arr2);
//输出交集的大小
System.out.println(set.size());
//输出交集的元素
if(set.size()==0)
{
System.out.println("null");
}
else{
for(int x:set)
{
System.out.print(x+" ");
}
}
//*********************End******************//
//关闭输入流对象cicn
cin.close();
}
}
10-09
572
12-27
828