Três perguntas sobre uma certa programação Kewang (Java) -string, set, array
A primeira pergunta:
Descrição do título
Encontre o primeiro caractere que aparece apenas uma vez na string
Descrição da entrada:
Insira várias strings não vazias
Descrição da
saída : produza o primeiro caractere que aparece apenas uma vez, se não existir, saída -1
Exemplo 1
Enter
asdfasdfo
aabb
copy
o
-1
import java.util.*;
public class Main{
public static void main(String[]args){
Scanner input=new Scanner(System.in);
ArrayList<String>list=new ArrayList<>();
while(input.hasNext()){
list.add(input.nextLine());
}
for(String str:list){
Map<Character,Integer>map=new HashMap<>();
for(int i=0;i<str.length();++i){
char x=str.charAt(i);
if(!map.containsKey(x)){
map.put(x,1);
}else{
map.put(x,map.get(x)+1);
}
}
boolean flag=false;
for(int i=0;i<str.length();++i){
char x=str.charAt(i);
if(map.get(x)==1){
System.out.println(x);
flag=true;
break;
}
}
if(!flag){
System.out.println(-1);
}
}
}
}
A ideia básica: Use HashMap para mapear um a um, adicione um ao número encontrado e entre no Mapa se ele não for encontrado.No final, você só precisa encontrar o número um no Mapa.
Por que escolher o HashMap?
Porque a complexidade de tempo de adição, exclusão, verificação e modificação de HashMap é O (1).
A segunda pergunta:
Descrição do título
Insira n inteiros e produza o menor k.
A pluralidade de títulos de conjuntos de amostras de entrada, usando o ciclo de leitura, como o processamento while (cin >>), etc.
Descrição da entrada:
a primeira linha da entrada dois inteiros n e k
da segunda linha de entrada uma
saída de matriz de inteiros Descrição :
Saída de uma matriz de inteiro classificado pequeno a grande
Exemplo 1
Entrada
5 2
1 3 5 7 2
Saída
1 2
import java.util.*;
public class Main{
public static void main(String[]args){
Scanner input=new Scanner(System.in);
while(input.hasNext()){
int n=input.nextInt();
int k=input.nextInt();
PriorityQueue<Integer>queue=new PriorityQueue<>(
new Comparator<Integer>(){
public int compare(Integer o1,Integer o2){
return o2-o1;
}
}
);
for(int i=0;i<n;++i){
int x=input.nextInt();
if(i<k){
queue.offer(x);
}else{
if(x<queue.peek()){
queue.poll();
queue.offer(x);
}
}
}
ArrayList<Integer>list=new ArrayList<>();
for(int x:queue){
list.add(x);
}
Collections.sort(list);
for(int x:list){
System.out.print(x+" ");
}
System.out.println();
}
}
}
A ideia básica: crie um grande heap raiz, primeiro insira os valores K e, em seguida, o topo do heap deve ser o maior, então você só precisa comparar o elemento superior com o elemento após K, o elemento superior do heap será fora do heap e, em seguida, o elemento atual será adicionado ao heap. No final, há apenas K menores elementos restantes no heap e, então, apenas a saída classificada é usada.
Nota: O PriorityQueue na coleção é um pequeno heap raiz por padrão, portanto, o comparador precisa ser reescrito.
Pergunta 3:
Descrição do título
Insira dois inteiros representados por cadeias de caracteres e encontre a soma dos números que eles representam.
O comprimento da string não excede 10.000.
Esta questão contém vários conjuntos de entrada de amostra.
Descrição da entrada:
Insira duas strings. Certifique-se de que a string contém apenas '0' ~ '9' caracteres.
Descrição da
saída : exibe o resultado da soma.
Exemplo 1
entrada
9876543210
1234567890 e
saída
11111111100
import java.util.*;
public class Main{
public static void main(String[]args){
Scanner input=new Scanner(System.in);
ArrayList<String>list=new ArrayList<>();
while(input.hasNext()){
String str1=input.next();
StringBuilder s1=new StringBuilder();
s1.append(str1);
String str2=input.next();
StringBuilder s2=new StringBuilder();
s2.append(str2);
StringBuilder end=new StringBuilder();
while(s1.length()<s2.length()){
s1.insert(0,'0');
}
while(s1.length()>s2.length()){
s2.insert(0,'0');
}
int c=0;
for(int i=s1.length()-1;i>=0;i--){
char x=s1.charAt(i);
char y=s2.charAt(i);
int re=(x-'0')+(y-'0')+c;
if(re<10){
end.insert(0,re);
c=0;
}else{
end.insert(0,re%10);
c=1;
if(i==0){
end.insert(0,c);
}
}
}
System.out.println(end.toString());
}
}
}
A ideia básica:
como o comprimento da string de entrada pode ser muito longo, o comprimento do número do tipo Long não é muito longo, portanto, é excluído fazer a conversão por Integer.valueOf e então calculá-lo. Não tem como? Não! Na verdade, é muito simples: você só precisa contar a corda de trás para a frente, uma a uma, mas deve considerar se há um transporte. Conecte um bit para cada bit de cálculo para obter o resultado final.
Anime-se todos os dias, venham juntos! ! ! ! ! ! ! ! ! ! !
Ao mesmo tempo, existem melhores práticas, bem-vindo para discutir.