输入：
hello nowcoder
输出：
8
最后一个单词为nowcoder，长度为8
import java.util.*;
public class Main{
public static void main(String[] args){
Scanner sc=new Scanner(System.in);
String s=sc.nextLine();
String[] strs=s.split(" ");
int m=strs[strs.length-1].length();
System.out.println(m);
}
}输入：
ABCabc
A
输出：
2
import java.util.*;
public class Main{
public static void main(String[] args){
Scanner sc=new Scanner(System.in);
String str=sc.nextLine().toLowerCase();
String s=sc.nextLine().toLowerCase();
System.out.println(str.length()-str.replaceAll(s,"").length());
}
}明明生成了NN个1到500之间的随机整数。请你删去其中重复的数字，即相同的数字只保留一个，把其余相同的数去掉，然后再把这些数从小到大排序，按照排好的顺序输出。
数据范围：1≤n≤1000 ，输入的数字大小满足 1≤val≤500
输入：
3
2
2
1
输出：
1
2
说明：
输入解释：
第一个数字是3，也即这个小样例的N=3，说明用计算机生成了3个1到500之间的随机整数，接下来每行一个随机数字，共3行，也即这3个随机数字为：
2
2
1
所以样例的输出为：
1
2
import java.util.*;
public class Main{
public static void main(String[] args){
Scanner sc=new Scanner(System.in);
int n=sc.nextInt();
TreeSet set=new TreeSet();
for(int i=0;i<n;i++){
set.add(sc.nextInt());
}
Iterator iterator=set.iterator();
while(iterator.hasNext()){
System.out.println(iterator.next());
}
}
}•输入一个字符串，请按长度为8拆分每个输入字符串并进行输出；
•长度不是8整数倍的字符串请在后面补数字0，空字符串不处理。
输入：
abc
输出：
abc00000
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();
StringBuilder sb = new StringBuilder();//牢记字符串缓冲区的建立语法
sb.append(str);//字符串缓冲区的加入
int size = str.length();
int addZero = 8 - size%8;//addzero的可能值包括8
while((addZero > 0)&&(addZero<8)){//注意边界调节，避免addzero=8
sb.append("0");//使用‘’或“”都可
addZero--;
}
String str1 = sb.toString();
while(str1.length()>0){
System.out.println(str1.substring(0,8));
str1 = str1.substring(8);
}
}
}
}输入：
0xAA
输出：
170
import java.util.Scanner;
public class Main{
public static void main(String[] args){
Scanner scanner = new Scanner(System.in);
while(scanner.hasNext()){
String str = scanner.nextLine();
System.out.println(Integer.valueOf(str.substring(2),16));
}
}
}功能:输入一个正整数，按照从小到大的顺序输出它的所有质因子（重复的也要列举）（如180的质因子为2 2 3 3 5 ）
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
long num = scanner.nextLong();
long k = (long) Math.sqrt(num);
for (long i = 2; i <= k; i++) {
while (num % i == 0) {
System.out.print(i + " ");
num /= i;
}
}
System.out.println(num == 1 ? "": num+" ");
}
}写出一个程序，接受一个正浮点数值，输出该数值的近似整数值。如果小数点后数值大于等于 0.5 ,向上取整；小于 0.5 ，则向下取整。
import java.util.Scanner;
public class Main{
public static void main(String[] args){
Scanner in = new Scanner(System.in);
//输入参数
double a = in.nextDouble();
//取整数部分
int b = (int)a;
//判断
if((a - b) >= 0.5){
b=(int)(a + 0.5);
}
System.out.println(b);
}
}数据表记录包含表索引index和数值value（int范围的正整数），请对表索引相同的记录进行合并，即将相同索引的数值进行求和运算，输出按照index值升序进行输出。
输入：
4
0 1
0 2
1 2
3 4
输出：
0 3
1 2
3 4
import java.util.*;
public class Main {
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
int next = sc.nextInt();
TreeMap<Integer,Integer> map = new TreeMap<>();
for (int i = 0; i < next; i++) {
int key = sc.nextInt();
int value = sc.nextInt();
if (map.containsKey(key)){
map.put(key,map.get(key)+value);
}else {
map.put(key,value);
}
}
for (Map.Entry<Integer, Integer> entry : map.entrySet()) {
System.out.println(entry.getKey()+" "+entry.getValue());
}
}
}输入一个 int 型整数，按照从右向左的阅读顺序，返回一个不含重复数字的新的整数。
保证输入的整数最后一位不是 0 。
输入：
9876673
输出：
37689
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int num = scanner.nextInt();
char[] chars= (num+"").toCharArray();
String str ="";
for(int i= chars.length-1; i>= 0;i--){
if(!str.contains(chars[i]+"")){
str +=chars[i];
}
}
System.out.println(str);
}
}编写一个函数，计算字符串中含有的不同字符的个数。字符在 ASCII 码范围内( 0~127 ，包括 0 和 127 )，换行表示结束符，不算在字符里。不在范围内的不作统计。多个相同的字符只计算一次
例如，对于字符串 abaca 而言，有 a、b、c 三种不同的字符，因此输出 3 。
import java.util.*;
public class Main {
public static void main(String[] args){
Scanner sc =new Scanner(System.in);
HashSet<Character> set = new HashSet<>();
String s = sc.nextLine();
char[] charArray = s.toCharArray();
for(char c : charArray){
set.add(c);
}
System.out.println(set.size());
}
}输入一个整数，将这个整数以字符串的形式逆序输出
程序不考虑负数的情况，若数字含有0，则逆序形式也含有0，如输入为100，则输出为001
import java.util.*;
public class Main{
public static void main(String[] args){
Scanner in=new Scanner(System.in);
String str=in.nextLine();
StringBuilder rs=new StringBuilder(str);
rs.reverse();
System.out.println(rs);
}
}HJ12 字符串反转
输入：
abcd
输出：
dcba
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
while(scanner.hasNext()){
String str= scanner.nextLine();
//将字符串变成char数组再倒序输出
char[] chars= str.toCharArray();
for(int i=chars.length-1;i>=0;i--){
System.out.print(chars[i]);
}
}
}
}将一个英文语句以单词为单位逆序排放。例如“I am a boy”，逆序排放后为“boy a am I”
所有单词之间用一个空格隔开，语句中除了英文字母外，不再包含其他字符
import java.util.*;
public class Main{
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
Stack<String> words = new Stack<>();
for (String word : scanner.nextLine().split(" ")) {
words.add(word);
}
while(!words.isEmpty()){
System.out.print(words.pop()+" ");
}
}
}给定 n 个字符串，请对 n 个字符串按照字典序排列。
import java.util.*;
public class Main{
public static void main(String[] args){
Scanner sc=new Scanner(System.in);
int n=sc.nextInt();
String[] str=new String[n];
for(int i=0;i<n;i++){
str[i]=sc.next();
}
Arrays.sort(str);
for(int i=0;i<n;i++){
System.out.println(str[i]);
}
}
}输入：
5
输出：
2
import java.util.*;
public class Main{
public static void main(String[] args){
Scanner sc=new Scanner(System.in);
int n=sc.nextInt();
System.out.println(countOne(n));
}
private static int countOne(int n){
return n==0?0:n%2+countOne(n/2);
}
}开发一个坐标计算工具， A表示向左移动，D表示向右移动，W表示向上移动，S表示向下移动。从（0,0）点开始移动，从输入字符串里面读取一些坐标，并将最终输入结果输出到输出文件里面。
输入：
合法坐标为A(或者D或者W或者S) + 数字（两位以内）
坐标之间以;分隔。
非法坐标点需要进行丢弃。如AA10; A1A;
下面是一个简单的例子 如：
A10;S20;W10;D30;X;A1A;B10A11;;A10;
处理过程：
起点（0,0）
A10 = （-10,0）
S20 = (-10,-20)
W10 = (-10,-10)
D30 = (20,-10)
x = 无效
A1A = 无效
B10A11 = 无效
一个空 不影响
A10 = (10,-10)
结果 （10， -10）
import java.util.*;
public class Main {
public static void main(String[] args){
Scanner sc=new Scanner(System.in);
Map<Character,Integer> map=new HashMap<>();
String regex="[ADWS]\\d{1}\\d?";
String[] str=sc.nextLine().split(";");
int x=0,y=0;
for(int i=0;i<str.length;i++){
if(str[i].matches(regex)){
map.put(str[i].charAt(0),map.getOrDefault(str[i].charAt(0),0)+Integer.valueOf(str[i].substring(1)));
}
}
x=x-map.get('A')+map.get('D');
y=y-map.get('S')+map.get('W');
System.out.println(x+","+y);
map.clear();
sc.close();
}
}密码要求:
1.长度超过8位
2.包括大小写字母.数字.其它符号,以上四种至少三种
3.不能有长度大于2的不含公共元素的子串重复 （注：其他符号不含空格或换行）
数据范围：输入的字符串长度满足 1≤n≤100
输入：
021Abc9000
021Abc9Abc1
021ABC9000
021$bc9000
输出：
OK
NG
NG
OK
import java.util.*;
import java.util.regex.*;
public class Main {
public static void main(String[] args){
Scanner sc=new Scanner(System.in);
while(sc.hasNext()){
String str=sc.nextLine();
if(str.length()<=8){
System.out.println("NG");
continue;
}
if(getString(str,0,3)){
System.out.println("NG");
continue;
}
if(getMatch(str)){
System.out.println("NG");
continue;
}
System.out.println("OK");
}
}
static boolean getString(String str,int l,int r){
if(r>=str.length()){
return false;
}
if(str.substring(r).contains(str.substring(l,r))){
return true;
}
return getString(str,l+1,r+1);
}
static boolean getMatch(String str){
int count = 0;
Pattern pat=Pattern.compile("[A-Z]");
if(pat.matcher(str).find()){
count++;
}
Pattern pat1=Pattern.compile("[a-z]");
if(pat1.matcher(str).find()){
count++;
}
Pattern pat2=Pattern.compile("[0-9]");
if(pat2.matcher(str).find()){
count++;
}
Pattern pat3=Pattern.compile("[^A-Za-z0-9]");
if(pat3.matcher(str).find()){
count++;
}
if(count>=3){
return false;
}
return true;
}
}现在有一种密码变换算法。
九键手机键盘上的数字与字母的对应： 1--1， abc--2, def--3, ghi--4, jkl--5, mno--6, pqrs--7, tuv--8 wxyz--9, 0--0，把密码中出现的小写字母都变成九键键盘对应的数字，如：a 变成 2，x 变成 9.
而密码中出现的大写字母则变成小写之后往后移一位，如：X ，先变成小写，再往后移一位，变成了 y ，例外：Z 往后移是 a 。
数字和其它的符号都不做变换。
数据范围： 输入的字符串长度满足 1 \le n \le 100 \1≤n≤100
输入：
YUANzhi1987
输出：
zvbo9441987
import java.util.*;
public class Main {
public static void main(String[] args){
HashMap<String,Integer> map=new HashMap<>();
map.put("abc",2);
map.put("def",3);
map.put("ghi",4);
map.put("jkl",5);
map.put("mno",6);
map.put("pqrs",7);
map.put("tuv",8);
map.put("wxyz",9);
Scanner sc=new Scanner(System.in);
String str=sc.nextLine();
for(char c : str.toCharArray()){
if(c>='A'&&c<='Z'){
if((c+32)=='z'){
System.out.print('a');
}else{
System.out.print((char)(c+33));
}
}else if(c>='a'&&c<='z'){
final Character cF=c;
String key=map.keySet().stream().filter(o->o.contains(cF.toString())).findAny().get();
System.out.print(map.get(key));
}else{
System.out.print(c);
}
}
}
}某商店规定：三个空汽水瓶可以换一瓶汽水，允许向老板借空汽水瓶（但是必须要归还）。
小张手上有n个空汽水瓶，她想知道自己最多可以喝到多少瓶汽水。
数据范围：输入的正整数满足1≤n≤100
思路：想要换最多的汽水，就要厚脸皮，每两个空瓶向老板借一瓶汽水，喝完之后拿三个空瓶再换一瓶还给老板；相当于自己每两个空瓶可以换到一瓶汽水
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();
if(n==0){
break;
}
System.out.println((int)n/2);
}
}
}实现删除字符串中出现次数最少的字符，若出现次数最少的字符有多个，则把出现次数最少的字符都删除。输出删除这些单词后的字符串，字符串中其它字符保持原来的顺序。
数据范围：输入的字符串长度满足 1≤n≤20 ，保证输入的字符串中仅出现小写字母
输入：
aabcddd
输出：
aaddd
import java.util.*;
public class Main {
public static void main(String[] args){
Scanner sc=new Scanner(System.in);
while(sc.hasNextLine()){
String str=sc.nextLine();
Map<Character,Integer> map=new HashMap<>();
for(char c:str.toCharArray()){
map.put(c,map.getOrDefault(c,0)+1);
}
Integer min=Integer.MAX_VALUE;
for(Integer times:map.values()){
min=Math.min(min,times);
}
StringBuilder res=new StringBuilder();
for(char c:str.toCharArray()){
if(map.get(c)!=min){
res.append(c);
}
}
System.out.println(res);
}
}
}编写一个程序，将输入字符串中的字符按如下规则排序。
规则 1 ：英文字母从 A 到 Z 排列，不区分大小写。
如，输入： Type 输出： epTy
规则 2 ：同一个英文字母的大小写同时存在时，按照输入顺序排列。
如，输入： BabA 输出： aABb
规则 3 ：非英文字母的其它字符保持原来的位置。
如，输入： By?e 输出： Be?y
数据范围：输入的字符串长度满足 1≤n≤1000
输入：
A Famous Saying: Much Ado About Nothing (2012/8).
输出：
A aaAAbc dFgghh: iimM nNn oooos Sttuuuy (2012/8).
import java.util.*;
public class Main{
public static void main(String[] args){
Scanner sc=new Scanner(System.in);
String str=sc.nextLine();
String res=sort(str);
System.out.println(res);
}
static String sort(String str){
List<Character> letters=new ArrayList<>();
for(char ch:str.toCharArray()){
if(Character.isLetter(ch)){
letters.add(ch);
}
}
letters.sort(new Comparator<Character>(){
public int compare(Character o1,Character o2){
return Character.toLowerCase(o1)-Character.toLowerCase(o2);
}
});
StringBuilder res=new StringBuilder();
for(int i=0,j=0;i<str.length();i++){
if(Character.isLetter(str.charAt(i))){
res.append(letters.get(j++));
}else{
res.append(str.charAt(i));
}
}
return res.toString();
}
}输入只有一行。 先输入字典中单词的个数n，再输入n个单词作为字典单词。 然后输入一个单词x 最后后输入一个整数k
第一行输出查找到x的兄弟单词的个数m 第二行输出查找到的按照字典顺序排序后的第k个兄弟单词，没有符合第k个的话则不用输出。
输入：
3 abc bca cab abc 1
输出：
2
bca
import java.util.*;
public class Main {
public static void main(String[] args){
Scanner sc=new Scanner(System.in);
String[] ss=sc.nextLine().split(" ");
int n=Integer.valueOf(ss[0]);
String target=ss[ss.length-2];
int k=Integer.valueOf(ss[ss.length-1]);
List<String> list=new ArrayList<>();
for(int i=1;i<=n;i++){
if(isMatch(target,ss[i])){
list.add(ss[i]);
}
}
System.out.println(list.size());
if(list.size()>=k){
Collections.sort(list);
System.out.println(list.get(k-1));
}
}
public static Boolean isMatch(String t,String s){
if(s.length()!=t.length()||s.equals(t)){
return false;
}
char[] ts=t.toCharArray();
char[] ss=s.toCharArray();
Arrays.sort(ts);
Arrays.sort(ss);
return new String(ts).equals(new String(ss));
}
}对输入的字符串进行加解密，并输出。
加密方法为：
当内容是英文字母时则用该英文字母的后一个字母替换，同时字母变换大小写,如字母a时则替换为B；字母Z时则替换为a；
当内容是数字时则把该数字加1，如0替换1，1替换2，9替换0；
其他字符不做变化。
解密方法为加密的逆过程。
数据范围：输入的两个字符串长度满足 1≤n≤1000 ，保证输入的字符串都是只由大小写字母或者数字组成
输入：
abcdefg
BCDEFGH
输出：
BCDEFGH
abcdefg
import java.util.*;
public class Main {
public static void main(String[] args){
Scanner sc=new Scanner(System.in);
while(sc.hasNext()){
System.out.println(encode(sc.nextLine()));
System.out.println(decode(sc.nextLine()));
}
sc.close();
}
private static String encode(String str){
StringBuilder sb=new StringBuilder();
for(char s:str.toCharArray()){
if(s>='a'&&s<'z'){
sb.append((char)(s-'a'+'A'+1));
}else if(s=='z'){
sb.append('A');
}else if(s>='A'&&s<'Z'){
sb.append((char)(s-'A'+'a'+1));
}else if(s=='Z'){
sb.append('a');
}else if(s>='0'&&s<'9'){
sb.append((char)(s+1));
}else if(s=='9'){
sb.append('0');
}
}
return sb.toString();
}
private static String decode(String str){
StringBuilder sb=new StringBuilder();
for(char s:str.toCharArray()){
if(s>'a'&&s<='z'){
sb.append((char)(s-'a'+'A'-1));
}else if(s=='a'){
sb.append('Z');
}else if(s>'A'&&s<='Z'){
sb.append((char)(s-'A'+'a'-1));
}else if(s=='A'){
sb.append('z');
}else if(s>'0'&&s<='9'){
sb.append((char)(s-1));
}else if(s=='0'){
sb.append('9');
}
}
return sb.toString();
}
}对字符串中的所有单词进行倒排。
说明：
1、构成单词的字符只有26个大写或小写英文字母；
2、非构成单词的字符均视为单词间隔符；
3、要求倒排后的单词间隔符以一个空格表示；如果原字符串中相邻单词间有多个间隔符时，倒排转换后也只允许出现一个空格间隔符；
4、每个单词最长20个字母；
输入：
$bo*y gi!r#l
输出：
l r gi y bo
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();
String[] strs=str.split("[^a-zA-Z]");
Stack<String> stack = new Stack<>();
for(int i=0;i<strs.length;i++){
stack.push(strs[i]);
}
while(!stack.isEmpty()){
System.out.print(stack.pop()+" ");
}
}
}
}即最长回文子串
输入：
ABBA
输出：
4
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();
int max=0;
for(int i=0;i<str.length();i++){
max=Math.max(max,longestPanlindrome(str,i,i));
max=Math.max(max,longestPanlindrome(str,i,i+1));
}
System.out.println(max);
}
}
public static int longestPanlindrome(String str,int i,int j){
int len=0;
while(i>=0&&j<str.length()&&str.charAt(i)==str.charAt(j)){
len=j-i+1;
i--;
j++;
}
return len;
}
}输入 1 输入IP地址 2 输入10进制型的IP地址
输出 1 输出转换成10进制的IP地址 2 输出转换后的IP地址
输入：
10.0.3.193
167969729
输出：
167773121
10.3.3.193
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();
System.out.println(convert(str));
}
}
public static String convert(String str){
if(str.contains(".")){
String[] strs=str.split("\\.");
long res=0;
for(int i=0;i<4;i++){
res=res*256+Integer.valueOf(strs[i]);
}
return res+"";
}else{
String res="";
Long ipv4=Long.parseLong(str);
for(int i=0;i<4;i++){
res=ipv4%256+"."+res;
ipv4/=256;
}
return res.substring(0,res.length()-1);
}
}
}Lily上课时使用字母数字图片教小朋友们学习英语单词，每次都需要把这些图片按照大小（ASCII码值从小到大）排列收好。请大家给Lily帮忙，通过代码解决。
Lily使用的图片使用字符"A"到"Z"、"a"到"z"、"0"到"9"表示。
输入：
Ihave1nose2hands10fingers
输出：
0112Iaadeeefghhinnnorsssv
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();
char[] chars=str.toCharArray();
Arrays.sort(chars);
for(int i=0;i<chars.length;i++){
System.out.print(chars[i]);
}
}
}
}蛇形矩阵是由1开始的自然数依次排列成的一个矩阵上三角形。
例如，当输入5时，应该输出的三角形为：
1 3 6 10 15
2 5 9 14
4 8 13
7 12
11
输入：
4
输出：
1 3 6 10
2 5 9
4 8
7
import java.util.*;
public class Main {
public static void main(String[] args){
Scanner sc=new Scanner(System.in);
int n=sc.nextInt();
printTriangle(n);
}
public static void printTriangle(int n){
int y=1,yCount=1;
for(int i=1;i<=n;i++){
int x=y;
int xCount=i+1;
for(int j=1;j<=n-i+1;j++){
System.out.print(x+" ");
x+=xCount++;
}
System.out.println("");
y+=yCount++;
}
}
}有一种兔子，从出生后第3个月起每个月都生一只兔子，小兔子长到第三个月后每个月又生一只兔子。
例子：假设一只兔子第3个月出生，那么它第5个月开始会每个月生一只兔子。
假如兔子都不死，问第n个月的兔子总数为多少？
数据范围：输入满足1≤n≤31
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();
System.out.println(count(n));
}
}
public static int count(int n){
if(n<3){
return 1;
}
return count(n-1)+count(n-2);
}
}假设一个球从任意高度自由落下，每次落地后反跳回原高度的一半; 再落下, 求它在第5次落地时，共经历多少米?第5次反弹多高？
数据范围：输入的小球初始高度满足 1≤n≤1000 ，且保证是一个整数
输入：
1
输出：
2.875
0.03125
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();
double temp=n;
double sum=0;
for(int i=0;i<5;i++){
sum+=temp*2;
temp/=2;
}
sum-=n;
System.out.printf("%.6f\n",sum);
System.out.printf("%.6f",temp);
}
}
}输入一行字符，分别统计出包含英文字母、空格、数字和其它字符的个数。
数据范围：输入的字符串长度满足1≤n≤1000
输入：
1qazxsw23 edcvfr45tgbn hy67uj m,ki89ol.\\/;p0-=\\][
输出：
26
3
10
12
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();
int charnum=0;
int blank=0;
int num=0;
int other=0;
for(char ch:str.toCharArray()){
if(Character.isLetter(ch)){
charnum++;
}else if(Character.isSpace(ch)){
blank++;
}else if(ch>='0'&&ch<='9'){
num++;
}else{
other++;
}
}
System.out.println(charnum);
System.out.println(blank);
System.out.println(num);
System.out.println(other);
}
}
} private static String Maxstr(String str[]) {
int index=0;
for(int i=1;i<=str.length-1;i++) {
if(str[i].length()>str[index].length()) {
index=i;
}
}
return str[index];
}给定两个整数 n 和 k，返回范围 [1, n] 中所有可能的 k 个数的组合。
你可以按 任何顺序 返回答案。
class Solution {
public List<List<Integer>> combine(int n, int k) {
LinkedList<Integer> nums=new LinkedList<Integer>();
for(int i=1;i<k+1;++i)
nums.add(i);
nums.add(n+1);
List<List<Integer>> output=new ArrayList<List<Integer>>();
int j=0;
while(j<k){
output.add(new LinkedList(nums.subList(0,k)));
j=0;
while((j<k)&&(nums.get(j+1)==nums.get(j)+1))
nums.set(j,j++ + 1);
nums.set(j,nums.get(j)+1);
}
return output;
}
}