旧键盘 (20)

import java.util.Scanner;
public class Main {
	public static void main(String[] args) {
		Scanner in = new Scanner(System.in);
		String a = in.next();
		String b = in.next();
		StringBuilder sb = new StringBuilder();
		int i = 0,j = 0;
		int[] arr = new int[26+10+1];
		while(i<a.length()){
			if(j<b.length()){
				if(a.charAt(i)!=b.charAt(j)){
					int index = index(a.charAt(i));
					if(arr[index]++==0)
						sb.append(Character.toUpperCase(a.charAt(i)));
				}else{
					j++;
				}
			}else{
				int index = index(a.charAt(i));
				if(arr[index]++==0)
					sb.append(Character.toUpperCase(a.charAt(i)));
			}
			i++;
		}
		System.out.println(sb.toString());
	}
	
	private static int index(char c){
		if(c=='_')
			return 0;
		if(c>='a'&&c<='z')
			return c-'a'+1;
		if(c>='A'&&c<='Z')
			return c-'A'+1;
		if(c>='0'&&c<='9')
			return 26+c-'0'+1;
		return -1;
	}
}

#include<iostream>
#include<string>
using namespace std;

int main()
{
    string s1,s2;
    cin>>s1>>s2;
    bool hash[256] = {false};
    int len_1 = s1.length(),len_2 = s2.length();

    for(int i=0;i<len_2;++i)
    {
        s2[i] = towupper(s2[i]);
        hash[s2[i]]=true;
    }
    for(int i=0;i<len_1;++i)
    {
        s1[i] = towupper(s1[i]);
        if(hash[s1[i]]==false)
            cout<<s1[i];
        hash[s1[i]]=true;
    }

    return 0;
}

#include<stdio.h>
#include<string.h>
#include <ctype.h>
int main (){//the shorter,the better.
    char s1[80],s2[80],i,h[123] = {0};
    for(;~scanf("%s%s",s1,s2);){
        for(i=0;i<strlen(s2);h[toupper(s2[i++])]=1);
        for(i=0;i<strlen(s1);h[toupper(s1[i])]?:putchar(toupper(s1[i])),h[toupper(s1[i++])]=1);
    }
}

import java.util.Scanner;
import java.util.ArrayList;
public class Main{
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        while(sc.hasNext()){
            char[] ch = sc.nextLine().toCharArray();
            String str = sc.nextLine();
            ArrayList<Character> lt = new ArrayList<>();
            for(int i=0;i<ch.length;i++){
                String c = String.valueOf(ch[i]);
                if(!str.contains(c)){
                    if(ch[i]>='a' && ch[i]<='z'){
                        ch[i]=(char)(ch[i]-32);
                    }
                    if(!lt.contains(ch[i])){
                        lt.add(ch[i]);
                    }
                }
            }
            for(Character cc : lt){
                System.out.print(cc);
            }
        }
    }
}

#include <cstdio>
#include <cstring>

int main()
{
    int A[128],k=0,B[80];
    char x='x';
    int num=0;
    memset(A,-1,sizeof(A));
    while(x!='\n'){ //读入第一行字符串，使读到的字符对应位置的A[128]置零
        scanf("%c",&x);
        B[num++] = x;   //B中装入第一个字符串
        k = (int)x;
        A[k]++;
        if(A[k]!=-1)
            A[k] = 0;
    }
    B[num-1] = '\0';
    x='r';    
    for(int i=0;x!='\n';i++){   //读入第二行字符串，使对应位置的A[128]加一
        scanf("%c",&x);
        k = (int)x;
        A[k]++;
    }
    for(int i=0;B[i]!='\0';i++){     //输出，注意大小写的问题
        int sb = B[i];
        if(A[sb]==0){
            if(sb>=97 && sb<=122){
                printf("%c",sb-32);
                A[sb-32] = 1;
            }
            else
                printf("%c",sb);
            A[sb] = 1;
        }
    }
    return 0;
}

	



	简单说两句，思路大概是这样的，建立一个大小为128的数组A，将其中全部值置为-1,"memset(A,-1,sizeof(A))".



	接着读入第一行字符串，使用B[80]将其存储，同时使A中对应的ascii值进行加一操作，并最后置为0。



	再然后读入第二行字符串，使其每个字符对应的ascii值对应A的位置，并将对应的A[i]进行加一操作。



	最后输出，以B（即第一行字符串）作为被循环字符串，每个字符的ascii值对应数组A，将为0



	的值输出即可。



	



	很惭愧，一点微小的贡献。

import java.util.*;

/**
 * 旧键盘
 * 题目描述
 * 旧键盘上坏了几个键，于是在敲一段文字的时候，对应的字符就不会出现。现在给出应该输入的
 * 一段文字、以及实际被输入的文字，请你列出肯定坏掉的那些键。
 * 输入描述:
 * 输入在2行中分别给出应该输入的文字、以及实际被输入的文字。每段文字是不超过80个字符的串，
 * 由字母A-Z（包括大、小写）、数字0-9、以及下划线“_”（代表空格）组成。题目保证2个字符串均非空。
 * 输出描述:
 * 按照发现顺序，在一行中输出坏掉的键。其中英文字母只输出大写，每个坏键只输出一次。题目保证至少有1个坏键。
 * 输入例子:
 * 7_This_is_a_test
 * _hs_s_a_es
 * 输出例子:
 * 7TI
 *
 * @author shijiacheng
 * @date 2018/2/1
 */
public class B1019OldKeyboard {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String old = sc.next();
        String result = sc.next();

        Map<Character, Integer> mapResult = new HashMap<>();
        Map<Character, Integer> mapOld = new HashMap<>();

        char[] charsResult = result.toUpperCase().toCharArray();
        char[] charsOld = old.toUpperCase().toCharArray();

        for (int i = 0; i < charsResult.length; i++) {
            if (!mapResult.containsKey(charsResult[i])) {
                mapResult.put(charsResult[i], i);
            }
        }
        List<Character> list = new ArrayList<>();
        for (int i = 0; i < charsOld.length; i++) {
            if (!mapResult.containsKey(charsOld[i])) {
                if (!mapOld.containsKey(charsOld[i])) {
                    mapOld.put(charsOld[i], i);
                    list.add(charsOld[i]);
                }
            }
        }
        for (int i = 0; i < list.size(); i++) {
            System.out.print(list.get(i));
        }
    }
}

a,b=raw_input(),raw_input()
c=[i.upper() for i in a if i not in b]

print "".join( sorted( list(set(c)),key=c.index ) )

	import java.util.Scanner;



	 



	public class Main {



	 



	    public static void main(String[] args) {



	        Scanner scanner = new Scanner(System.in);



	        String begin = scanner.nextLine().toUpperCase();



	        String end = scanner.nextLine().toUpperCase();



	        StringBuilder result = newStringBuilder();



	        for(inti = 0; i < begin.length(); i++) {



	            if(end.indexOf(begin.charAt(i)) == -1&& result.toString().indexOf(begin.charAt(i)) == -1) {



	                result.append(begin.charAt(i));



	            }



	        }



	        System.out.println(result);



	    }



	}

#include <iostream>
#include <cstring>
using namespace std;

int main(){
    char a[90],b[90];
    int hashtable[128]={0};                       //ASCII码个数为128
    cin>>a;cin>>b;
    int len1=strlen(a);
    int len2=strlen(b);
    for(int i=0;i<len1;i++){
        char c1,c2;int j;
        for(j=0;j<len2;j++){
            c1=a[i];c2=b[j];
            if(c1>='a'&&c1<='z') c1=c1-'a'+'A';    //转化小写为大写
            if(c2>='a'&&c2<='z') c2=c2-'a'+'A';
            if(c1==c2) break;
        }
        if(j==len2&&hashtable[c1]==0){             //在第二个字符串中没有出现c1，且c1没有被输出过
            printf("%c",c1);
            hashtable[c1]=1;
        }
    }
    return 0;
}

	

import java.util.Scanner;
import java.util.Set;
import java.util.TreeSet;
/**
 * 
 * @author MSK
 * 改题不能使用TreeSet保存，因为TreeSet虽然是有序不重复的，但是题目要求有序（按照发现顺序）输出
 * TreeSet在再次发现已有元素，会影响原数据的位置。所以不能使用,使用字符串保存。
 */
public class OldKey_19 {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		String t = sc.next().toUpperCase();
		String f = sc.next().toUpperCase();
		int len = t.length();
		int  j = 0;
		String c = "";
		boolean flag = true;
		for ( int i = 0; i < len; i++){	
			if(j < f.length()){
				if(t.charAt(i) != f.charAt(j)){
					if(flag){
						flag = false;
						c = t.substring(i, i+1);
					}else if(c.indexOf(t.charAt(i)) < 0){
						c = c+t.charAt(i);
					}
				}else
					j++;						
			}else if(c.indexOf(t.charAt(i)) < 0){
				c = c+t.charAt(i);
			}
		}	
			System.out.print(c);

	}
}

为什么会段错误-.-

#include <stdio.h>
#include <ctype.h>
int main(){
 char A[81],B[123] = {0}, ch, i = 0, tag = 1;
 gets(A);
 while (A[i] != '\0'){
  tag = ((ch = getchar()) == '\n' ? 0 : 1);
  while ((tag && toupper(A[i]) != toupper(ch)) || !tag && A[i] != '\0'){
   if (B[toupper(A[i])]++ == 0)
   printf("%c", toupper(A[i]));
   i++;
  }
  i++;
 }
 return 0;
}

	#include<iostream>



	#include<ctype.h>



	#include<string.h>



	using namespace std;



	//PAT乙级真题旧键盘 (20)



	intmain()



	{



	    charInput[82],FactInput[82],WrongInput[82];



	    cin>>Input>>FactInput;



	    inti=0,j=0,m=0,n=0;



	    intisExist;



	    intlength = strlen(Input);



	    intFactLength = strlen(FactInput);



	    for(i=0;i<length;i++){



	            //is the equal



	            if((Input[i]==FactInput[j]) && (j<FactLength))



	                j++;



	            else{



	                isExist = 0;



	                //is the lower



	                if(islower(Input[i]))



	                    Input[i] = Input[i]-32;



	                //is the WrongInput



	                for(m=0;m<n;m++){



	                    if(Input[i]==WrongInput[m])



	                        isExist = 1;



	                }



	                //is not in the WrongInput



	                if(isExist == 0)



	                    WrongInput[n++]=Input[i];



	            }



	    }



	    for(i=0;i<n;i++)



	        cout<<WrongInput[i];



	    return0;



	}

import java.util.*;

public class Main{
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        String strExce = in.nextLine();
        String strActual = in.nextLine();
        funcPrint(strExce,strActual);
    }

    /**
     * 输出
     * @param strExce 7_This_is_a_test
     * @param strActual _hs_s_a_es
     */
    public static void funcPrint(String strExce,String strActual){
        Set<Character> set = new HashSet<>();
        //1、将坏键盘输出的数据放入set中
        //因题例中输出结果均为大写，调用toUpperCase()存入
        for (Character ch : strActual.toUpperCase().toCharArray()) {
            set.add(ch);
        }

        Set<Character> hasPrint = new HashSet<>();

        //2、遍历好键盘输入的数据，得出有问题的键
        for (Character ch : strExce.toUpperCase().toCharArray()) {
            //3、用hasPrint排除已经出现过的键
            if (!set.contains(ch) && !hasPrint.contains(ch)){
                System.out.print(ch);
                hasPrint.add(ch);
            }
        }
    }
}