笔试题 字符集合、删数

[编程题] 字符集合

输入一个字符串，求出该字符串包含的字符集合

输入描述:
每组数据输入一个字符串，字符串最大长度为100，且只包含字母，不可能为空串，区分大小写。

输出描述:
每组数据一行，按字符串原有的字符顺序，输出字符集合，即重复出现并靠后的字母不输出。

输入例子:
abcqweracb

输出例子:
abcqwer

使用linkedhashset 可以按照插入的顺序保存 并进行输出。treeset会按照某种顺序排序，hashset保存顺序不固定。
我之前写过道类似的题 使用treeset解决的 其实就是一个去重排序问题
华为笔试三题 汽水瓶/明明的随机数/进制转换

import java.util.LinkedHashSet;
import java.util.Scanner;
import java.util.Set;
public class Main {     
     public static void main(String[] args){
            Scanner in = new Scanner(System.in);
            while(in.hasNext()){
                char[] c = in.next().toCharArray();
                StringBuffer sb = new StringBuffer();
                Set<Character> set = new LinkedHashSet<Character>();
                for(int i = 0;i<c.length;i++){
                    set.add(c[i]);
                }
                for(Character cc:set)
                    System.out.print(cc);
                 System.out.println();
            }
        }
}

[编程题]删数

有一个数组a[N]顺序存放0~N-1，要求每隔两个数删掉一个数，到末尾时循环至开头继续进行，求最后一个被删掉的数的原始下标位置。以8个数(N=7)为例:｛0，1，2，3，4，5，6，7｝，0->1->2(删除)->3->4->5(删除)->6->7->0(删除),如此循环直到最后一个数被删除。
输入描述:
每组数据为一行一个整数n(小于等于1000)，为数组成员数,如果大于1000，则对a[999]进行计算。
输出描述:
一行输出最后一个被删掉的数的原始下标位置。
输入例子:
8
输出例子:
6
查到的非常好的代码。。思路太清晰了。。为什么自己就想不到？

public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        while (sc.hasNext()) {
            int n = sc.nextInt();
            if (n > 1000) {
                n = 999;
            }
            List<Integer> list = new ArrayList<Integer>();
            for (int i = 0; i < n; i++) {
                list.add(i);
            }
            int i = 0;
            while (list.size() > 1) {
                i = (i + 2) % list.size();
                list.remove(i);
            }
            System.out.println(list.get(0));
        }
    }

使用循环链表的方法

import java.util.*;
public class test2025 {
    
    
    
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        while(sc.hasNext()){
            int n=sc.nextInt();
            Node temp=new Node();
            temp.index=0;
            Node root=temp;
            //构建链表
            for(int i=1;i<n;i++){
                Node node=new Node();
                node.index=i;
                temp.next=node;
                temp=node;
            }
            //循环链表
            temp.next=root;
            temp=root;
            while(temp!=null){
                Node p=temp.next;
                Node removeNode=p.next;
                Node child=removeNode.next;
                //删除
                p.next=child;
                if(p==child){
                    //此时只剩下最后一个节点
                    System.out.println(p.index);
                    break;
                }
                temp=child;
            }
        }
    }



}
class Node{
    public int index;
    public Node next;
}

类似约瑟夫环，猴子选大王，还有一种数学方法，目前没太理解，先记录一下

 public static void main(String[] args) {
         Scanner sc=new Scanner(System.in);
         while(sc.hasNext()){
             int n=sc.nextInt();
             int index=0;
             if(n!=1){
                 for(int i=2;i<=n;i++){
                     index=(index+3)%i;
                 }
             }else{
                 index=1;
             }
             System.out.println(index);
         }
     }