牛客中等难度1

m0_38053538

已于 2022-03-06 18:52:55 修改

阅读量360

点赞数

文章标签：算法

于 2022-03-06 18:36:31 首次发布

本文链接：https://blog.csdn.net/m0_38053538/article/details/123314797

版权

HJ45 名字的漂亮度
描述
给出一个名字，该名字有26个字符组成，定义这个字符串的“漂亮度”是其所有字母“漂亮度”的总和。
每个字母都有一个“漂亮度”，范围在1到26之间。没有任何两个不同字母拥有相同的“漂亮度”。字母忽略大小写。
给出多个名字，计算每个名字最大可能的“漂亮度”。
本题含有多组数据。
数据范围：输入的名字长度满足 1 \le n \le 10000 \1≤n≤10000
输入描述：
整数N，后续N个名字
输出描述：
每个名称可能的最大漂亮程度
示例1
输入：
2
zhangsan
lisi
复制
输出：
192
101
import java.io.*;
import java.util.*;

public class Main{
public static void main(String[] args)throws IOException{
BufferedReader bf=new BufferedReader(new InputStreamReader(System.in));
String value;
while((value=bf.readLine())!=null){
int num=Integer.parseInt(value);
for(int index=0;index<num;index++){

//处理其中一组数据的逻辑
String name=bf.readLine();
char[] nameChars=name.toCharArray();
int[] charMaxs=new int[150];
for(int inda=0;inda<nameChars.length;inda++){
charMaxs[(int)nameChars[inda]]++;
}
Arrays.sort(charMaxs);
int max=26;
int total=0;
for(int indb=charMaxs.length-1;indb>=0;indb--){
if(charMaxs[indb]==0)
break;
total=total+charMaxs[indb]*max;
max--;
}
System.out.println(total);
}
}
}
}
HJ48 从单向链表中删除指定值的节点
描述
输入一个单向链表和一个节点的值，从单向链表中删除等于该值的节点，删除后如果链表中无节点则返回空指针。
链表的值不能重复。
构造过程，例如输入一行数据为:
6 2 1 2 3 2 5 1 4 5 7 2 2
则第一个参数6表示输入总共6个节点，第二个参数2表示头节点值为2，剩下的2个一组表示第2个节点值后面插入第1个节点值，为以下表示:
1 2 表示为
2->1
链表为2->1

3 2表示为
2->3
链表为2->3->1

5 1表示为
1->5
链表为2->3->1->5

4 5表示为
5->4
链表为2->3->1->5->4

7 2表示为
2->7
链表为2->7->3->1->5->4

最后的链表的顺序为 2 7 3 1 5 4

最后一个参数为2，表示要删掉节点为2的值
删除结点 2
则结果为 7 3 1 5 4

数据范围：链表长度满足 1 \le n \le 1000 \1≤n≤1000 ，节点中的值满足 0 \le val \le 10000 \0≤val≤10000

测试用例保证输入合法

输入描述：
输入一行，有以下4个部分：
1 输入链表结点个数
2 输入头结点的值
3 按照格式插入各个结点
4 输入要删除的结点的值
输出描述：
输出一行
输出删除结点后的序列，每个数后都要加空格
示例1
输入：
5 2 3 2 4 3 5 2 1 4 3
复制
输出：
2 5 4 1
复制
说明：
形成的链表为2->5->3->4->1
删掉节点3，返回的就是2->5->4->1
示例2
输入：
6 2 1 2 3 2 5 1 4 5 7 2 2
复制
输出：
7 3 1 5 4
复制
说明：
如题

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class Main{
public static void main(String[] args) throws IOException{
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String str1;
while((str1=br.readLine())!=null){
String[] strArray=str1.split(" ");
int n=Integer.parseInt(strArray[0]);
int head=Integer.parseInt(strArray[1]);
int[] index=new int[10000];
for (int i = 0; i < index.length; i++) {
   index[i]=10001;
           }
for (int i = 1; i < n; i++) {
               int v1=Integer.parseInt(strArray[2*i]);
               int v2=Integer.parseInt(strArray[2*i+1]);
               int next=index[v2];
               if (next<10000) {
                   index[v1]=next;
                   index[v2]=v1;
               }else {
                   index[v2]=v1;
               }
           }
int ti=head;
int delete=Integer.parseInt(strArray[2*n]);
StringBuilder resultBuilder=new StringBuilder();
while (ti<10000) {
   if (ti!=delete) {
       resultBuilder.append(ti).append(" ");
               }
   ti=index[ti];
           }
// if (resultBuilder.length()==n) {
//                System.out.println();
//            }else {
               System.out.println(resultBuilder.toString());
//            }
}
}
}
HJ57 高精度整数加法
描述
输入两个用字符串 str 表示的整数，求它们所表示的数之和。
本题含有多组样例输入。
数据范围： 1 \le len(str) \le 10000 \1≤len(str)≤10000
输入描述：
输入两个字符串。保证字符串只含有'0'~'9'字符
输出描述：
输出求和后的结果
示例1
输入：
9876543210
1234567890
复制
输出：
11111111100

输入两个字符串表示的整数，对其进行相加运算
字符串中只有字符0-9，即正整数加法运算
字符串长度：1<=n<=100001<=n<=100001<=n<=10000
方法一：遍历相加
具体做法：
从两个字符串末尾开始往前遍历每个字符，直到遍历到两个字符串的下标都为0. 将遍历到的字符串转化为数字，如果其中一个字符串已经过了首部，则直接数字记为0.
然后将两个数字与进位变量相加，取余数放入现在这位，整除10作为进位，初始进位变量为0。最后结束之后如果进位变量还有1，则添加在后面。
最后将其逆序并转成字符串输出即可。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32   import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        while (scan.hasNext()) {
            String s1 = scan.next();
            String s2 = scan.next(); //输入两个数
            String res = add(s1, s2); //输出
            System.out.println(res);
        }
    }

    private static String add(String s1, String s2) { //两个字符串整数相加
        StringBuilder res = new StringBuilder();
        int n = s1.length() - 1;
        int m = s2.length() - 1;
        int carry = 0; //进位
        while (n >= 0 || m >= 0) { //从两个人字符串最后一位开始相加
            char c1 = n >= 0 ? s1.charAt(n--) : '0'; //没有了就用0代替
            char c2 = m >= 0 ? s2.charAt(m--) : '0';
            int sum = (c1 - '0') + (c2 - '0') + carry; //两个数子与进位相加
            res.append(sum % 10); //余数添加进结果
            carry = sum / 10;  //进位
        }

        if (carry == 1) { //最后的进位
            res.append(carry);
        }
        return res.reverse().toString(); //反转后转成字符串
    }
}
复杂度分析：
时间复杂度：O(n)O(n)O(n)，其中nnn为较长字符串的长度，遍历最多是较长的字符串长度
空间复杂度：O(n)O(n)O(n)，保留运算结果的StringBuilder的长度最多为n+1n+1n+1

HJ59 找出字符串中第一个只出现一次的字符
找出字符串中第一个只出现一次的字符
数据范围：输入的字符串长度满足 1 \le n \le 1000 \1≤n≤1000
输入描述：
输入几个非空字符串
输出描述：
输出第一个只出现一次的字符，如果不存在输出-1
示例1
输入：
asdfasdfo
aabb
复制
输出：
o
-1

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class Main {
public static void main(String[] args) throws IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String input;
while ((input = br.readLine()) != null) {
for (int i = 0; i < input.length(); i++) {
char c = input.charAt(i);
if (input.indexOf(c) == input.lastIndexOf(c)) {
System.out.println(c);
break;
}
if (i == input.length() - 1) {
System.out.println(-1);
}
}
}
}
}
.
一个 DNA 序列由 A/C/G/T 四个字母的排列组合组成。 G 和 C 的比例（定义为 GC-Ratio ）是序列中 G 和 C 两个字母的总的出现次数除以总的字母数目（也就是序列长度）。在基因工程中，这个比例非常重要。因为高的 GC-Ratio 可能是基因的起始点。
给定一个很长的 DNA 序列，以及限定的子串长度 N ，请帮助研究人员在给出的 DNA 序列中从左往右找出 GC-Ratio 最高且长度为 N 的第一个子串。
DNA序列为 ACGT 的子串有: ACG , CG , CGT 等等，但是没有 AGT ， CT 等等

数据范围：字符串长度满足 1 \le n \le 1000 \1≤n≤1000 ，输入的字符串只包含 A/C/G/T 字母
输入描述：
输入一个string型基因序列，和int型子串的长度
输出描述：
找出GC比例最高的子串,如果有多个则输出第一个的子串
示例1
输入：
ACGT
2
复制
输出：
CG
复制
说明：
ACGT长度为2的子串有AC,CG,GT3个，其中AC和GT2个的GC-Ratio都为0.5，CG为1，故输出CG
示例2
输入：
AACTGTGCACGACCTGA
5
复制
输出：
GCACG
复制
说明：
虽然CGACC的GC-Ratio也是最高，但它是从左往右找到的GC-Ratio最高的第2个子串，所以只能输出GCACG。

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.IOException;

public class Main{
public static void main(String[] args) throws IOException{
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String str;
while((str = br.readLine()) != null) {
int len = Integer.parseInt(br.readLine());
char[] c = str.toCharArray();

int max = 0;
int start = 0;
for(int i = 0; i < c.length - len; i++) {
int count = 0;
for(int j = 0; j < len; j++) {
if(c[i + j] == 'G' || c[i + j] == 'C')
count ++;
}
if(count > max) {
start = i;
max = count;
}
}

StringBuilder builder = new StringBuilder();
for(int i = start; i < start + len; i++) {
builder.append(c[i]);
}
System.out.println(builder.toString());
}
}
}
MP3 Player因为屏幕较小，显示歌曲列表的时候每屏只能显示几首歌曲，用户要通过上下键才能浏览所有的歌曲。为了简化处理，假设每屏只能显示4首歌曲，光标初始的位置为第1首歌。

现在要实现通过上下键控制光标移动来浏览歌曲列表，控制逻辑如下：

歌曲总数<=4的时候，不需要翻页，只是挪动光标位置。

光标在第一首歌曲上时，按Up键光标挪到最后一首歌曲；光标在最后一首歌曲时，按Down键光标挪到第一首歌曲。

其他情况下用户按Up键，光标挪到上一首歌曲；用户按Down键，光标挪到下一首歌曲。

2. 歌曲总数大于4的时候（以一共有10首歌为例）：

特殊翻页：屏幕显示的是第一页（即显示第1 – 4首）时，光标在第一首歌曲上，用户按Up键后，屏幕要显示最后一页（即显示第7-10首歌），同时光标放到最后一首歌上。同样的，屏幕显示最后一页时，光标在最后一首歌曲上，用户按Down键，屏幕要显示第一页，光标挪到第一首歌上。

一般翻页：屏幕显示的不是第一页时，光标在当前屏幕显示的第一首歌曲时，用户按Up键后，屏幕从当前歌曲的上一首开始显示，光标也挪到上一首歌曲。光标当前屏幕的最后一首歌时的Down键处理也类似。

其他情况，不用翻页，只是挪动光标就行。

数据范围：本题含有多组输入数据，数据组数1 \le t \le5 \1≤t≤5 ，命令长度1\le s\le 100\1≤s≤100 ，歌曲数量1\le n \le 150\1≤n≤150
进阶：时间复杂度：O(n)\O(n) ，空间复杂度：O(n)\O(n)
输入描述：
输入说明：
1 输入歌曲数量
2 输入命令 U或者D

本题含有多组输入数据！

输出描述：
输出说明
1 输出当前列表
2 输出当前选中歌曲

示例1
输入：
10
UUUU
复制
输出：
7 8 9 10
7

HJ65 查找两个字符串a,b中的最长公共子串
描述
查找两个字符串a,b中的最长公共子串。若有多个，输出在较短串中最先出现的那个。
注：子串的定义：将一个字符串删去前缀和后缀（也可以不删）形成的字符串。请和“子序列”的概念分开！

本题含有多组输入数据！
数据范围：字符串长度1\le s \le300 \1≤s≤300 ，1\le t\le 5\1≤t≤5
进阶：时间复杂度：O(n^3)\O(n
3
) ，空间复杂度：O(n)\O(n)
输入描述：
输入两个字符串

输出描述：
返回重复出现的字符
示例1
输入：
abcdefghijklmnop
abcsafjklmnopqrstuvw
复制
输出：
jklmnop

import java.io.*;
import java.util.*;
public class Main{
public static void main(String[] args) throws Exception{
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String str;
while((str = br.readLine())!=null){
String ss = br.readLine();
if(str.length()<ss.length()){
System.out.println(res(str,ss));
}else{
System.out.println(res(ss,str));
}
}
}
public static String res(String s,String c){
char[] ch1 = s.toCharArray();
char[] ch2 = c.toCharArray();
int[][] ins = new int[ch1.length + 1][ch2.length + 1];
int max = 0;
int start = 0;
for (int i = 0; i < ch1.length; i++) {
for (int j = 0; j < ch2.length; j++) {
if(ch1[i]==ch2[j]){
ins[i+1][j+1] = ins[i][j]+1;
if(ins[i+1][j+1]>max){
max = ins[i+1][j+1];
start = i-max;
}
}
}
}
return s.substring(start+1,start+max+1);
}
}
HJ55 挑7
描述
输出小于等于 n 的与 7 有关数字的个数，包括 7 的倍数，还有包含 7 的数字（如 17 ，27 ，37 ... 70 ，71 ，72 ，73...）的个数（一组测试用例里可能有多组数据，请注意处理）

数据范围： 1 \le n \le 30000 \1≤n≤30000

本题有多组输入
输入描述：
多组输入每组输入 1 个正整数 n 。( n 不大于 30000 )

输出描述：
不大于n的与7有关的数字个数，例如输入20，与7有关的数字包括7,14,17.

示例1
输入：
20
10
复制
输出：
3
1
挑7
就两种 1 能整除, 则对7取余==0,
2 不能整除,则转化成字符串,看里面是否包含7
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 sum=0;
for(int i = 1;i<=n;i++){
if(i%7==0){
sum++;
}else{
String s = String.valueOf(i);
if(s.contains("7")){
sum++;
}
}
}
System.out.println(sum);
}
}
}
HJ66 配置文件恢复
描述
有6条配置命令，它们执行的结果分别是：
命   令   执   行
reset   reset what
reset board   board fault
board add   where to add
board delete   no board at all
reboot backplane   impossible
backplane abort   install first
he he   unknown command
注意：he he不是命令。
为了简化输入，方便用户，以“最短唯一匹配原则”匹配（注：需从首字母开始进行匹配）：
1、若只输入一字串，则只匹配一个关键字的命令行。例如输入：r，根据该规则，匹配命令reset，执行结果为：reset what；输入：res，根据该规则，匹配命令reset，执行结果为：reset what；
2、若只输入一字串，但匹配命令有两个关键字，则匹配失败。例如输入：reb，可以找到命令reboot backpalne，但是该命令有两个关键词，所有匹配失败，执行结果为：unknown command
3、若输入两字串，则先匹配第一关键字，如果有匹配，继续匹配第二关键字，如果仍不唯一，匹配失败。
例如输入：r b，找到匹配命令reset board 和 reboot backplane，执行结果为：unknown command。
例如输入：b a，无法确定是命令board add还是backplane abort，匹配失败。
4、若输入两字串，则先匹配第一关键字，如果有匹配，继续匹配第二关键字，如果唯一，匹配成功。例如输入：bo a，确定是命令board add，匹配成功。
5、若输入两字串，第一关键字匹配成功，则匹配第二关键字，若无匹配，失败。例如输入：b addr，无法匹配到相应的命令，所以执行结果为：unknow command。
6、若匹配失败，打印“unknown command”
注意：有多组输入。
数据范围：数据组数：1\le t\le 800\1≤t≤800 ，字符串长度1\le s\le 20\1≤s≤20
进阶：时间复杂度：O(n)\O(n) ，空间复杂度：O(n)\O(n)
输入描述：
多行字符串，每行字符串一条命令
输出描述：
执行结果，每条命令输出一行
示例1
输入：
reset
reset board
board add
board delet
reboot backplane
backplane abort
复制
输出：
reset what
board fault
where to add
no board at all
impossible
install first

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.IOException;

public class Main{
public static void main(String[] args) throws IOException{
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String str = "";
StringBuilder sb = new StringBuilder();
//str1是参考命令
String[] str1 = {"reset","reset board","board add","board delete","reboot backplane","backplane abort"};
Out:
while((str=br.readLine())!=null){
String[] str2 = str.split(" "); //将输入的字符串分开成数组
if(str2.length==1){
String cmd = str1[0];
for(int i=0; i<str2[0].length(); i++){
if(str2[0].charAt(i) != cmd.charAt(i)){
sb.append("unknown command").append("\n");
continue Out;
}
}
sb.append("reset what").append("\n");
}else if(str2.length==2){
if(str2[0].charAt(0) == 'r'){
if((str2[0].equals("r") && str2[1].equals("b")) || (str2[0].equals("re") && str2[1].equals("b"))){
sb.append("unknown command").append("\n");
}else if(str2[0].length()<6 && str2[1].length()<6 && str2[0].charAt(2)=='s' && str2[1].charAt(0)=='b'){
sb.append("board fault").append("\n");
}else if(str2[0].length()<7 && str2[1].length()<10 && str2[0].charAt(2)=='b' && str2[1].charAt(1)=='a'){
sb.append("impossible").append("\n");
}else{
sb.append("unknown command").append("\n");
}
}else if(str2[0].charAt(0) == 'b'){
if(str2[0].equals("b") && str2[1].equals("a")){
sb.append("unknown command").append("\n");
}else if(str2[1].charAt(0)=='d'){
sb.append("no board at all").append("\n");
}else if(str2[0].charAt(1)=='o' && str2[1].charAt(0)=='a'){
sb.append("where to add").append("\n");
}else if(str2[0].charAt(1)=='a' && str2[1].charAt(0)=='a'){
sb.append("install first").append("\n");
}else{
sb.append("unknown command").append("\n");
}
}else if(str2[0].charAt(0) == 'h'){
sb.append("unknown command").append("\n");
}
}
}
sb.deleteCharAt(sb.length()-1);
System.out.println(sb.toString());
}
}

HJ67 24点游戏算法
描述
给出4个1-10的数字，通过加减乘除运算，得到数字为24就算胜利,除法指实数除法运算,运算符仅允许出现在两个数字之间,本题对数字选取顺序无要求，但每个数字仅允许使用一次，且需考虑括号运算
此题允许数字重复，如3 3 4 4为合法输入，此输入一共有两个3，但是每个数字只允许使用一次，则运算过程中两个3都被选取并进行对应的计算操作。
输入描述：
读入4个[1,10]的整数，数字允许重复，测试用例保证无异常数字。
输出描述：
对于每组案例，输出一行表示能否得到24点，能输出true，不能输出false
示例1
输入：
7 2 1 10
复制
输出：
true

import java.io.*;
public class Main {
public static void main(String[] args) throws Exception {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String str;
while((str = br.readLine()) != null) {
String[] numstrs = str.split(" ");
int[] nums = new int[4];
nums[0] = Integer.parseInt(numstrs[0]);
nums[1] = Integer.parseInt(numstrs[1]);
nums[2] = Integer.parseInt(numstrs[2]);
nums[3] = Integer.parseInt(numstrs[3]);
boolean flag = false;
for(int i = 0; i < 4; i++) {
if(is24(nums, 1 << i, nums[i])) {
flag = true;
break;
}
}
System.out.println(flag);
}

}
private static boolean is24(int[] nums, int stu, int val) {
if(val == 24) return true;
else if (stu == 7) return false;
for(int i = 0; i < 4; i++) {
int temp = 1 << i;
if ((temp & stu) == 0) {
temp |= stu;
if(is24(nums, temp, val + nums[i])
||is24(nums, temp, val - nums[i])
||is24(nums, temp, val * nums[i])
||(val % nums[i] == 0 && is24(nums, temp, val + nums[i])))
return true;
}
}
return false;
}
}
HJ69 矩阵乘法
描述
如果A是个x行y列的矩阵，B是个y行z列的矩阵，把A和B相乘，其结果将是另一个x行z列的矩阵C。这个矩阵的每个元素是由下面的公式决定的

矩阵的大小不超过100*100
输入描述：
输入包含多组数据，每组数据包含：
第一行包含一个正整数x，代表第一个矩阵的行数
第二行包含一个正整数y，代表第一个矩阵的列数和第二个矩阵的行数
第三行包含一个正整数z，代表第二个矩阵的列数
之后x行，每行y个整数，代表第一个矩阵的值
之后y行，每行z个整数，代表第二个矩阵的值
输出描述：
对于每组输入数据，输出x行，每行z个整数，代表两个矩阵相乘的结果
示例1
输入：
2
3
2
1 2 3
3 2 1
1 2
2 1
3 3
复制
输出：
14 13
10 11
复制
说明：
1 2 3
3 2 1
乘以
1 2
2 1
3 3
等于
14 13
10 11
示例2
输入：
2
2
2
1 1
1 1
1 1
1 1
16
8
7
17 19 16 19 14 1 14 9
7 2 7 9 16 14 16 12
13 3 3 17 5 9 8 16
1 14 16 10 13 13 14 1
13 13 15 4 7 2 6 16
16 15 5 5 15 13 1 11
11 5 0 16 14 7 7 15
0 16 4 7 16 6 0 15
2 14 11 2 17 17 5 12
8 13 11 10 1 17 10 8
15 16 17 15 7 8 13 14
5 19 11 3 11 14 5 4
9 16 13 11 15 18 0 3
15 3 19 9 5 14 12 3
9 8 7 11 18 19 14 18
12 19 9 1 0 18 17 10
5 18 16 19 6 12 5
1 17 1 5 9 16 3
14 16 4 0 19 3 6
11 9 15 18 11 17 13
5 5 19 3 16 1 12
12 13 19 1 10 5 18
19 18 6 18 19 12 3
15 11 6 5 10 17 19
复制
输出：
2 2
2 2
1020 1490 1063 1100 1376 1219 884
966 1035 1015 715 1112 772 920
822 948 888 816 831 920 863
855 1099 828 578 1160 717 724
745 1076 644 595 930 838 688
635 1051 970 600 880 811 846
748 879 952 772 864 872 878
526 722 645 335 763 688 748
764 996 868 362 1026 681 897
836 1125 785 637 940 849 775
1082 1476 996 968 1301 1183 953
609 987 717 401 894 657 662
700 1083 1022 527 1016 746 875
909 1162 905 722 1055 708 720
1126 1296 1240 824 1304 1031 1196
905 1342 766 715 1028 956 749

import java.io.*;public class Main {
public static void main(String[] args) throws IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String str = null;
while ((str = br.readLine()) != null) {
if (str.equals("")) continue;
int x = Integer.parseInt(str);
int y = Integer.parseInt(br.readLine());
int z = Integer.parseInt(br.readLine());
int[][] matrix1 = new int[x][y];
int[][] matrix2 = new int[y][z];
for (int i = 0; i < x; i++) {
String[] params = br.readLine().split(" ");
for (int j = 0; j < y; j++) {
matrix1[i][j] = Integer.parseInt(params[j]);
}
}
for (int i = 0; i < y; i++) {
String[] params = br.readLine().split(" ");
for (int j = 0; j < z; j++) {
matrix2[i][j] = Integer.parseInt(params[j]);
}
}
StringBuilder ans = new StringBuilder();
for (int i = 0; i < x; i++) {
for (int j = 0; j < z; j++) {
int temp = 0;
for (int k = 0; k < y; k++) {
temp += matrix1[i][k] * matrix2[k][j];
}
ans.append(temp).append(" ");
}
ans.deleteCharAt(ans.length()-1).append("\n");
}
System.out.print(ans.toString());
}
}
}