/*明明想在学校中请一些同学一起做一项问卷调查,为了实验的客观性,
他先用计算机生成了N个1到1000之间的随机整数(N≤1000),对于其中重复的数字,
只保留一个,把其余相同的数去掉,不同的数对应着不同的学生的学号。然后再把
这些数从小到大排序,按照排好的顺序去找同学做调查。请你协助明明完成“去重”与“排序”的工作。*/
import java.util.Scanner;
import java.util.TreeSet;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
while(sc.hasNext()){
int num = sc.nextInt();
TreeSet<Integer> set = new TreeSet<Integer>();
for(int i = 0 ; i < num ;i++){
int curr = sc.nextInt();
set.add(curr);
}
for(Integer i : set){
System.out.println(i);
}
}
}
}
/*求两个数的最小公倍数*/
import java.util.Scanner;
public class Main {
public static int getResult(int m ,int n){
if(m<n){
int temp=m;
m=n;
n=temp;
}
int k;
while(n!=0){
k=m%n;
m=n;
n=k;
}
return m;
}
public static void main(String[] args) {
Scanner reader = new Scanner(System.in);
while(reader.hasNext()){
int m = reader.nextInt();
int n = reader.nextInt();
System.out.println(m*n/getResult(m, n));
}
}
}
/*
计算一个数字的立方根,不使用库函数
详细描述:
•接口说明
原型:
public static double getCubeRoot(double input)
输入:double 待求解参数
返回值:double 输入参数的立方根
*/
import java.util.*;
public class Main
{
// 使用二分查找算法
public static double getCubeRoot(double input)
{
double min = 0;
double max = input;
double mid = 0;
// 注意,这里的精度要提高一点,否则某些测试用例无法通过
while ((max - min) > 0.001)
{
mid = (max + min) / 2;
if (mid * mid * mid > input)
max = mid;
else if (mid * mid * mid < input)
min = mid;
else
return mid;
}
return max;
}
public static void main(String[] args)
{
Scanner sc = new Scanner(System.in);
while (sc.hasNext())
{
double input = sc.nextDouble();
double result = getCubeRoot(input);
System.out.printf("%.1f\n", result);
}
sc.close();
}
}
/*
将一个字符串str的内容颠倒过来,并输出。str的长度不超过100个字符。 如:输入“I am a student”,输出“tneduts a ma I”。
*/
import java.util.*;
public class Main{
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
while(sc.hasNext()){
String str = sc.nextLine();//next()是遇到空格;nextLine()是遇到回车
StringBuilder sb = new StringBuilder(str);
System.out.println(sb.reverse().toString());
}}}
/*
从输入任意个整型数,统计其中的负数个数并求所有非负数的平均值
*/
import java.util.*;
public class Main{
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
int count1 = 0;
int count2 = 0;
float sum = 0;
while(in.hasNext()){
int n = in.nextInt();
if(n<0){
count1++;
}else{
count2++;
sum+=n;
}
}
float average = sum/count2;
System.out.println(count1);
System.out.printf("%.1f\n",average);
}
}
/*
连续输入字符串(输出次数为N,字符串长度小于100),请按长度为8拆分每个字符串后输出到新的字符串数组,
长度不是8整数倍的字符串请在后面补数字0,空字符串不处理。
*/
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner scanner=new Scanner(System.in);
while(scanner.hasNextLine()){
String s=scanner.nextLine();
split(s);
}
}
public static void split(String s){
while(s.length()>=8){
System.out.println(s.substring(0, 8));
s=s.substring(8);
}
if(s.length()<8&&s.length()>0){
s=s+"00000000";
System.out.println(s.substring(0, 8));
}
}
}
/*
Redraiment是走梅花桩的高手。Redraiment总是起点不限,从前到后,往高的桩子走,但走的步数最多,不知道为什么?你能替Redraiment研究他最多走的步数吗?
样例输入
6
2 5 1 5 4 5
样例输出
3
提示
Example:
6个点的高度各为 2 5 1 5 4 5
如从第1格开始走,最多为3步, 2 4 5
从第2格开始走,最多只有1步,5
而从第3格开始走最多有3步,1 4 5
从第5格开始走最多有2步,4 5
所以这个结果是3。
*/
#include<iostream>
#include<vector>
#include<cmath>
using namespace std;
int main(){
int n;
while(cin>>n){
vector<int> data(n,0);
vector<int> dp(n,1);
int result=0;
for(int i=0;i<n;i++){
cin>>data[i];
for(int j=0;j<i;j++){
if(data[i]>data[j])
dp[i]=max(dp[i],dp[j]+1);
}
result=max(result,dp[i]);
}
cout<<result<<endl;
}
return 0;
}
/*写出一个程序,接受一个十六进制的数值字符串,输出该数值的十进制字符串。(多组同时输入 )*/
import java.lang.Math;
import java.util.Scanner;
public class Main{
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
while(sc.hasNext()){
String str = sc.nextLine();
System.out.println(fun(str.substring(2)));
}
}
public static int fun(String s){
int n=0;
int count= 0;
int temp = 0;
char ch;
while(count<s.length())
{
ch = s.charAt(s.length()-count-1);
if(ch>='0'&&ch<='9'){
temp = ch-'0';
}else if(ch>='A'&&ch<='Z'){
temp = ch-'A'+10;
}else if(ch>='a'&&ch<='z'){
temp = ch-'a'+10;
}else{
break;
}
n += temp*Math.pow(16,count);
count++;
}
return n;
}
}
/*功能:输入一个正整数,按照从小到大的顺序输出它的所有质数的因子(如180的质数因子为2 2 3 3 5 )
最后一个数后面也要有空格
详细描述:
函数接口说明:
public String getResult(long ulDataInput)
输入参数:
long ulDataInput:输入的正整数
返回值:
String*/
import java.util.*;
public class Main
{
public static void main(String [] args)
{
Scanner sc=new Scanner(System.in);
long params=sc.nextLong();
if(params<2)
{
sc.close();
return ;
}
String result =getResult(params);
System.out.println(result);
sc.close();
}
public static String getResult(long ulDataInput)
{
StringBuilder str=new StringBuilder();
int index=2;
while(index<=ulDataInput)
{
if(ulDataInput%index==0){
if(index==ulDataInput){
str.append(index).append(" ");
break;
}else{
str.append(index).append(" ");
ulDataInput=ulDataInput/index;
}
}else
{
index++;
}
}
return str.toString();
}
}
/*
写出一个程序,接受一个正浮点数值,输出该数值的近似整数值。如果小数点后数值大于等于5,向上取整;小于5,则向下取整
*/
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner scanner=new Scanner(System.in);
double d=scanner.nextDouble();
System.out.println(getReturn(d));
}
public static int getReturn(double d) {
int i=(int)d;
return (d-i)>=0.5?i+1:i;
}
}
/*数据表记录包含表索引和数值,请对表索引相同的记录进行合并,即将相同索引的数值进行求和运算,输出按照key值升序进行输出*/
import java.util.Iterator;
import java.util.Map;
import java.util.Scanner;
import java.util.TreeMap;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
while (sc.hasNext()) {
Map<Integer, Integer> map = new TreeMap<Integer, Integer>();
int n = sc.nextInt();
for (int i = 0; i < n; i++) {
int s=sc.nextInt();
int value=sc.nextInt();
if (map.containsKey(s)) {
map.put(s, map.get(s) + value);
} else
map.put(s, value);
}
for (Integer key : map.keySet()) {
System.out.println(key + " " + map.get(key));
}
}
}
}
/*输入一个int型整数,按照从右向左的阅读顺序,返回一个不含重复数字的新的整数*/
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
@SuppressWarnings("resource")
Scanner scanner=new Scanner(System.in);
while(scanner.hasNext()){
String s=scanner.nextLine();
int len=s.length();
int []arr1=new int[10];
for(int i=len-1;i>=0;i--){
if(arr1[s.charAt(i)-48]==0){
System.out.print(s.charAt(i)-48);
arr1[s.charAt(i)-48]++;
}
}
}
}
}
/*编写一个函数,计算字符串中含有的不同字符的个数。字符在ACSII码范围内(0~127)。不在范围内的不作统计*/
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner scanner=new Scanner(System.in);
while(scanner.hasNext()){
String s=scanner.nextLine();
int len=getLen(s);
System.out.println(len);
}
}
public static int getLen(String s) {
int[] arr=new int[128];
for(int i=0;i<s.length();i++){
arr[s.charAt(i)]=1;
}
int len=0;
for (int i = 0; i < arr.length; i++) {
if(arr[i]==1){
len++;
}
}
return len;
}
}
/*输入一个整数,将这个整数以字符串的形式逆序输出
程序不考虑负数的情况,若数字含有0,则逆序形式也含有0,如输入为100,则输出为001
*/
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
int n = new Scanner(System.in).nextInt();
System.out.println(reverse(n));
}
private static String reverse(int n){
String str = String.valueOf(n);
StringBuffer sb = new StringBuffer();
for(int i=str.length()-1;i>=0;i--){
sb.append(str.charAt(i));
}
return sb.toString();
}
}
/*
对字符中的
各个英文字符(大小写分开统计),数字,空格进行统计,并按照统计个数由多到少输出,如果统计的个数相同,则按照ASII码由小到大排序输出 。如果有其他字符,则对这些字符不用进行统计。
*/
#include <iostream>
#include <string>
#include <algorithm>
using namespace std;
int main()
{
string st;
while (getline(cin, st))
{
int a[128] = {0}, i, j, b[128] = {0};
for (i = 0; i < st.length(); ++i)
{
a[st[i]]++;
b[st[i]]++;
}
sort(a, a + 128);
sort(st.begin(), st.end());
for (i = 127; i >= 0; --i)
{
if (a[i] == 0)break;
for (j = 0; j < st.length(); ++j)
{
if (b[st[j]] == a[i])
{
cout << st[j];
b[st[j]] = 0;
break;
}
}
}
cout << endl;
}
return 0;
}
/*
输入整型数组和排序标识,对其元素按照升序或降序进行排序
接口说明
原型:
void sortIntegerArray(Integer[] pIntegerArray, int iSortFlag);
输入参数:
Integer[] pIntegerArray:整型数组
int iSortFlag:排序标识:0表示按升序,1表示按降序
输出参数:
无
返回值:
void
*/
#include <iostream>
#include <algorithm>
using namespace std;
int main(void)
{
int n;
while ( cin >> n )
{
int A[n], i = n-1, tag;
for (i = 0; i < n; i++)
cin >> A[i];
cin >> tag;
sort(A, A+n);
if (tag == 1)
reverse(A, A+n);
for (i = 0; i < n-1; i++)
cout << A[i] << ' ';
cout << A[n-1] << endl;
}
}
/*
功能:等差数列 2,5,8,11,14。。。。
输入:正整数N >0
输出:求等差数列前N项和
返回:转换成功返回 0 ,非法输入与异常返回-1
*/
//等差数列求和公式:Sn=a1*n+n*(n-1)*d/2
import java.util.*;
public class Main{
public static void main(String[] args){
Scanner in = new Scanner(System.in);
while(in.hasNext()){
int n = in.nextInt();
if(n<1){
System.out.println(-1);
}else{
System.out.println((2*n+3*n*(n-1)/2));
}
}
in.close();
}
}
/*
自守数是指一个数的平方的尾数等于该数自身的自然数。例如:25^2 = 625,76^2 = 5776,9376^2 = 87909376。请求出n以内的自守数的个数
接口说明
/*
功能: 求出n以内的自守数的个数
输入参数:
int n
返回值:
n以内自守数的数量。
*/
#include <iostream>
#include <string>
using namespace std;
//转换成字符串 查找,利用现成的库函数 =-=
int main()
{
long n;
while(cin>>n){
int ans = 2;// 0, 1也是
for(long i = 3; i<=n; i++){
long n2 = i*i;
string s1 = to_string(i);
string s2 = to_string(n2);
int pos = s2.size()- s1.size();
if(s2.find(s1,pos) != -1)
ans++;
}
cout<<ans<<endl;
}
return 0;
}
他先用计算机生成了N个1到1000之间的随机整数(N≤1000),对于其中重复的数字,
只保留一个,把其余相同的数去掉,不同的数对应着不同的学生的学号。然后再把
这些数从小到大排序,按照排好的顺序去找同学做调查。请你协助明明完成“去重”与“排序”的工作。*/
import java.util.Scanner;
import java.util.TreeSet;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
while(sc.hasNext()){
int num = sc.nextInt();
TreeSet<Integer> set = new TreeSet<Integer>();
for(int i = 0 ; i < num ;i++){
int curr = sc.nextInt();
set.add(curr);
}
for(Integer i : set){
System.out.println(i);
}
}
}
}
/*求两个数的最小公倍数*/
import java.util.Scanner;
public class Main {
public static int getResult(int m ,int n){
if(m<n){
int temp=m;
m=n;
n=temp;
}
int k;
while(n!=0){
k=m%n;
m=n;
n=k;
}
return m;
}
public static void main(String[] args) {
Scanner reader = new Scanner(System.in);
while(reader.hasNext()){
int m = reader.nextInt();
int n = reader.nextInt();
System.out.println(m*n/getResult(m, n));
}
}
}
/*
计算一个数字的立方根,不使用库函数
详细描述:
•接口说明
原型:
public static double getCubeRoot(double input)
输入:double 待求解参数
返回值:double 输入参数的立方根
*/
import java.util.*;
public class Main
{
// 使用二分查找算法
public static double getCubeRoot(double input)
{
double min = 0;
double max = input;
double mid = 0;
// 注意,这里的精度要提高一点,否则某些测试用例无法通过
while ((max - min) > 0.001)
{
mid = (max + min) / 2;
if (mid * mid * mid > input)
max = mid;
else if (mid * mid * mid < input)
min = mid;
else
return mid;
}
return max;
}
public static void main(String[] args)
{
Scanner sc = new Scanner(System.in);
while (sc.hasNext())
{
double input = sc.nextDouble();
double result = getCubeRoot(input);
System.out.printf("%.1f\n", result);
}
sc.close();
}
}
/*
将一个字符串str的内容颠倒过来,并输出。str的长度不超过100个字符。 如:输入“I am a student”,输出“tneduts a ma I”。
*/
import java.util.*;
public class Main{
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
while(sc.hasNext()){
String str = sc.nextLine();//next()是遇到空格;nextLine()是遇到回车
StringBuilder sb = new StringBuilder(str);
System.out.println(sb.reverse().toString());
}}}
/*
从输入任意个整型数,统计其中的负数个数并求所有非负数的平均值
*/
import java.util.*;
public class Main{
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
int count1 = 0;
int count2 = 0;
float sum = 0;
while(in.hasNext()){
int n = in.nextInt();
if(n<0){
count1++;
}else{
count2++;
sum+=n;
}
}
float average = sum/count2;
System.out.println(count1);
System.out.printf("%.1f\n",average);
}
}
/*
连续输入字符串(输出次数为N,字符串长度小于100),请按长度为8拆分每个字符串后输出到新的字符串数组,
长度不是8整数倍的字符串请在后面补数字0,空字符串不处理。
*/
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner scanner=new Scanner(System.in);
while(scanner.hasNextLine()){
String s=scanner.nextLine();
split(s);
}
}
public static void split(String s){
while(s.length()>=8){
System.out.println(s.substring(0, 8));
s=s.substring(8);
}
if(s.length()<8&&s.length()>0){
s=s+"00000000";
System.out.println(s.substring(0, 8));
}
}
}
/*
Redraiment是走梅花桩的高手。Redraiment总是起点不限,从前到后,往高的桩子走,但走的步数最多,不知道为什么?你能替Redraiment研究他最多走的步数吗?
样例输入
6
2 5 1 5 4 5
样例输出
3
提示
Example:
6个点的高度各为 2 5 1 5 4 5
如从第1格开始走,最多为3步, 2 4 5
从第2格开始走,最多只有1步,5
而从第3格开始走最多有3步,1 4 5
从第5格开始走最多有2步,4 5
所以这个结果是3。
*/
#include<iostream>
#include<vector>
#include<cmath>
using namespace std;
int main(){
int n;
while(cin>>n){
vector<int> data(n,0);
vector<int> dp(n,1);
int result=0;
for(int i=0;i<n;i++){
cin>>data[i];
for(int j=0;j<i;j++){
if(data[i]>data[j])
dp[i]=max(dp[i],dp[j]+1);
}
result=max(result,dp[i]);
}
cout<<result<<endl;
}
return 0;
}
/*写出一个程序,接受一个十六进制的数值字符串,输出该数值的十进制字符串。(多组同时输入 )*/
import java.lang.Math;
import java.util.Scanner;
public class Main{
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
while(sc.hasNext()){
String str = sc.nextLine();
System.out.println(fun(str.substring(2)));
}
}
public static int fun(String s){
int n=0;
int count= 0;
int temp = 0;
char ch;
while(count<s.length())
{
ch = s.charAt(s.length()-count-1);
if(ch>='0'&&ch<='9'){
temp = ch-'0';
}else if(ch>='A'&&ch<='Z'){
temp = ch-'A'+10;
}else if(ch>='a'&&ch<='z'){
temp = ch-'a'+10;
}else{
break;
}
n += temp*Math.pow(16,count);
count++;
}
return n;
}
}
/*功能:输入一个正整数,按照从小到大的顺序输出它的所有质数的因子(如180的质数因子为2 2 3 3 5 )
最后一个数后面也要有空格
详细描述:
函数接口说明:
public String getResult(long ulDataInput)
输入参数:
long ulDataInput:输入的正整数
返回值:
String*/
import java.util.*;
public class Main
{
public static void main(String [] args)
{
Scanner sc=new Scanner(System.in);
long params=sc.nextLong();
if(params<2)
{
sc.close();
return ;
}
String result =getResult(params);
System.out.println(result);
sc.close();
}
public static String getResult(long ulDataInput)
{
StringBuilder str=new StringBuilder();
int index=2;
while(index<=ulDataInput)
{
if(ulDataInput%index==0){
if(index==ulDataInput){
str.append(index).append(" ");
break;
}else{
str.append(index).append(" ");
ulDataInput=ulDataInput/index;
}
}else
{
index++;
}
}
return str.toString();
}
}
/*
写出一个程序,接受一个正浮点数值,输出该数值的近似整数值。如果小数点后数值大于等于5,向上取整;小于5,则向下取整
*/
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner scanner=new Scanner(System.in);
double d=scanner.nextDouble();
System.out.println(getReturn(d));
}
public static int getReturn(double d) {
int i=(int)d;
return (d-i)>=0.5?i+1:i;
}
}
/*数据表记录包含表索引和数值,请对表索引相同的记录进行合并,即将相同索引的数值进行求和运算,输出按照key值升序进行输出*/
import java.util.Iterator;
import java.util.Map;
import java.util.Scanner;
import java.util.TreeMap;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
while (sc.hasNext()) {
Map<Integer, Integer> map = new TreeMap<Integer, Integer>();
int n = sc.nextInt();
for (int i = 0; i < n; i++) {
int s=sc.nextInt();
int value=sc.nextInt();
if (map.containsKey(s)) {
map.put(s, map.get(s) + value);
} else
map.put(s, value);
}
for (Integer key : map.keySet()) {
System.out.println(key + " " + map.get(key));
}
}
}
}
/*输入一个int型整数,按照从右向左的阅读顺序,返回一个不含重复数字的新的整数*/
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
@SuppressWarnings("resource")
Scanner scanner=new Scanner(System.in);
while(scanner.hasNext()){
String s=scanner.nextLine();
int len=s.length();
int []arr1=new int[10];
for(int i=len-1;i>=0;i--){
if(arr1[s.charAt(i)-48]==0){
System.out.print(s.charAt(i)-48);
arr1[s.charAt(i)-48]++;
}
}
}
}
}
/*编写一个函数,计算字符串中含有的不同字符的个数。字符在ACSII码范围内(0~127)。不在范围内的不作统计*/
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner scanner=new Scanner(System.in);
while(scanner.hasNext()){
String s=scanner.nextLine();
int len=getLen(s);
System.out.println(len);
}
}
public static int getLen(String s) {
int[] arr=new int[128];
for(int i=0;i<s.length();i++){
arr[s.charAt(i)]=1;
}
int len=0;
for (int i = 0; i < arr.length; i++) {
if(arr[i]==1){
len++;
}
}
return len;
}
}
/*输入一个整数,将这个整数以字符串的形式逆序输出
程序不考虑负数的情况,若数字含有0,则逆序形式也含有0,如输入为100,则输出为001
*/
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
int n = new Scanner(System.in).nextInt();
System.out.println(reverse(n));
}
private static String reverse(int n){
String str = String.valueOf(n);
StringBuffer sb = new StringBuffer();
for(int i=str.length()-1;i>=0;i--){
sb.append(str.charAt(i));
}
return sb.toString();
}
}
/*
对字符中的
各个英文字符(大小写分开统计),数字,空格进行统计,并按照统计个数由多到少输出,如果统计的个数相同,则按照ASII码由小到大排序输出 。如果有其他字符,则对这些字符不用进行统计。
*/
#include <iostream>
#include <string>
#include <algorithm>
using namespace std;
int main()
{
string st;
while (getline(cin, st))
{
int a[128] = {0}, i, j, b[128] = {0};
for (i = 0; i < st.length(); ++i)
{
a[st[i]]++;
b[st[i]]++;
}
sort(a, a + 128);
sort(st.begin(), st.end());
for (i = 127; i >= 0; --i)
{
if (a[i] == 0)break;
for (j = 0; j < st.length(); ++j)
{
if (b[st[j]] == a[i])
{
cout << st[j];
b[st[j]] = 0;
break;
}
}
}
cout << endl;
}
return 0;
}
/*
输入整型数组和排序标识,对其元素按照升序或降序进行排序
接口说明
原型:
void sortIntegerArray(Integer[] pIntegerArray, int iSortFlag);
输入参数:
Integer[] pIntegerArray:整型数组
int iSortFlag:排序标识:0表示按升序,1表示按降序
输出参数:
无
返回值:
void
*/
#include <iostream>
#include <algorithm>
using namespace std;
int main(void)
{
int n;
while ( cin >> n )
{
int A[n], i = n-1, tag;
for (i = 0; i < n; i++)
cin >> A[i];
cin >> tag;
sort(A, A+n);
if (tag == 1)
reverse(A, A+n);
for (i = 0; i < n-1; i++)
cout << A[i] << ' ';
cout << A[n-1] << endl;
}
}
/*
功能:等差数列 2,5,8,11,14。。。。
输入:正整数N >0
输出:求等差数列前N项和
返回:转换成功返回 0 ,非法输入与异常返回-1
*/
//等差数列求和公式:Sn=a1*n+n*(n-1)*d/2
import java.util.*;
public class Main{
public static void main(String[] args){
Scanner in = new Scanner(System.in);
while(in.hasNext()){
int n = in.nextInt();
if(n<1){
System.out.println(-1);
}else{
System.out.println((2*n+3*n*(n-1)/2));
}
}
in.close();
}
}
/*
自守数是指一个数的平方的尾数等于该数自身的自然数。例如:25^2 = 625,76^2 = 5776,9376^2 = 87909376。请求出n以内的自守数的个数
接口说明
/*
功能: 求出n以内的自守数的个数
输入参数:
int n
返回值:
n以内自守数的数量。
*/
#include <iostream>
#include <string>
using namespace std;
//转换成字符串 查找,利用现成的库函数 =-=
int main()
{
long n;
while(cin>>n){
int ans = 2;// 0, 1也是
for(long i = 3; i<=n; i++){
long n2 = i*i;
string s1 = to_string(i);
string s2 = to_string(n2);
int pos = s2.size()- s1.size();
if(s2.find(s1,pos) != -1)
ans++;
}
cout<<ans<<endl;
}
return 0;
}