雀魂启动！

 def is_win(cards):
    if len(cards) == 2 and cards[0] == cards[1]:
        return True
    for i in range(len(cards) - 2):
        if i < len(cards)-4 and  cards[i] == cards[i + 4]:
            return False
    for i in range(len(cards) - 2):
        tmp = cards[i]
        #shunzi
        if (tmp in cards) and (tmp + 1 in cards) and (tmp + 2 in cards):
            this_cards = cards.copy()
            this_cards.remove(tmp)
            this_cards.remove(tmp + 1)
            this_cards.remove(tmp + 2)
            if is_win(this_cards):
                return True
        #kezi
        elif tmp == cards[i + 2]:
            this_cards = cards.copy()
            this_cards.remove(tmp)
            this_cards.remove(tmp)
            this_cards.remove(tmp)
            if is_win(this_cards):
                return True
    return False

def main():
    nums = list(map(int, input().split()))
    # nums = list(map(int, "1 1 1 3 4 5 5 5 5 6 7 9 9".split()))
    res = []
    for i in range(1, 10):
        cards = nums.copy()
        cards.append(i)
        cards.sort()
        if is_win(cards):
            res.append(i)

    res = ' '.join(str(x) for x in sorted(res)) if res else '0'
    print(res)

if __name__ == "__main__":
    main()

#include <bits/stdc++.h>
using namespace std;

bool F(map<int,int> M, int t){
    if(t<=0)
        return true;
    while(M[M.begin()->first]==0)
        M.erase(M.begin());
    map<int,int>::iterator it = M.begin();
    int i=it->first, cnt=it->second;
    if(t%3!=0 && cnt>=2){
        M[i] -= 2;
        if(F(M, t-2))
            return true;
        M[i] += 2;
    }
    if(cnt>=3){
        M[i] -= 3;
        if(F(M, t-3))
            return true;
        M[i] += 3;
    }
    if(cnt>0 && M[i+1]>0 && M[i+2]>0){
        M[i]--;
        M[i+1]--;
        M[i+2]--;
        if(F(M, t-3))
            return true;
        M[i]++;
        M[i+1]++;
        M[i+2]++;
    }
    return false;
}

int main(){
    map<int, int> M;
    int x;
    for(int i=0;i<13;i++){
        cin>>x;
        M[x]++;
    }
    vector<int> v;
    for(int i=1;i<10;i++){
        if(M[i]<4){
            M[i]++;
            if(F(M, 14))
                v.push_back(i);
            M[i]--;
        }
    }
    if(v.empty())
        cout<<0<<endl;
    else{
        for(int i=0;i<v.size();i++){
            if(i==v.size()-1)
                cout<<v[i]<<endl;
            else
                cout<<v[i]<<" ";
        }
    }

    return 0;
}

import java.util.*;

public class Main {

    private void sln() {
        Scanner sc = new Scanner(System.in);
        int[] state = new int[9], helpArr = new int[9];
        ArrayList<Integer> res = new ArrayList<>();
        for (int i = 0; i < 13; i++) {
            int num = sc.nextInt();
            state[num - 1]++;
        }
        for (int i = 0; i < 9; i++) {
            if (state[i] < 4) {
                int num = i + 1;
                System.arraycopy(state, 0, helpArr, 0, 9);
                helpArr[i]++;
                if (canHu(helpArr, 14, false)) res.add(num);
            }
        }
        if (res.isEmpty()) System.out.println(0);
        else {
            StringBuffer sbf = new StringBuffer();
            sbf.append(res.get(0));
            for (int i = 1; i < res.size(); i++) {
                sbf.append(" ");
                sbf.append(res.get(i));
            }
            System.out.println(sbf.toString());
        }
    }

    private boolean canHu(int[] arr, int total, boolean hasHead) {
        if (total == 0) return true;
        if (!hasHead) {
            for (int i = 0; i < 9; i++) {
                if (arr[i] >= 2) {
                    arr[i] -= 2;
                    if (canHu(arr, total - 2, true)) return true;
                    arr[i] += 2;
                }
            }
            return false;
        } else {
            for (int i = 0; i < 9; i++) {
                if (arr[i] > 0) {
                    if (arr[i] >= 3) {
                        arr[i] -= 3;
                        if (canHu(arr, total - 3, true)) return true;
                        arr[i] += 3;
                    }
                    if (i + 2 < 9 && arr[i + 1] > 0 && arr[i + 2] > 0) {
                        arr[i]--;
                        arr[i + 1]--;
                        arr[i + 2]--;
                        if (canHu(arr, total - 3, true)) return true;
                        arr[i]++;
                        arr[i + 1]++;
                        arr[i + 2]++;
                    }
                }
            }
        }
        return false;
    }

    public static void main(String[] args) {
        new Main().sln();
    }
}

def isHu(nums):
    """
    判断是否可以胡牌
    :param nums:
    :return:
    """
    if not nums:
        return True
    n = len(nums)
    count0 = nums.count(nums[0])
    # 没出现过雀头，且第一个数字出现的次数 >= 2,去掉雀头剩下的能不能和牌
    if n % 3 != 0 and count0 >= 2 and isHu(nums[2:]) == True:
        return True
    # 如果第一个数字出现次数 >= 3，去掉这个刻子后看剩下的能和牌
    if count0 >= 3 and isHu(nums[3:]) == True:
        return True
    # 如果存在顺子，移除顺子后剩下的能和牌
    if nums[0] + 1 in nums and nums[0] + 2 in nums:
        last_nums = nums.copy()
        last_nums.remove(nums[0])
        last_nums.remove(nums[0] + 1)
        last_nums.remove(nums[0] + 2)
        if isHu(last_nums) == True:
            return True
    # 以上条件都不满足，则不能和牌
    return False
 
def main(nums):
    """
    遍历所有可以抓到的牌看能不能胡牌
    :return:
    """
    d = {}
    for i in nums:
        d[i] = d.get(i,0) + 1
    card_list = set(range(1,10)) - {i for i,v in d.items() if v==4}
    res = []
    for i in card_list:
        if isHu(sorted(nums + [i])):  # 如果这种抽牌方式可以和牌
            res.append(i)  # 加入和牌类型列表
    res = ' '.join(str(x) for x in sorted(res)) if res else '0'
    print(res)
 
 
s = input()
nums = [int(x) for x in s.split()]
main(nums)

#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;
bool ishu(vector<int>num)
{
    if (num.empty())
        return true;
    int count0 = 0;
    for(int i=0;i<num.size();++i)
    {
        if (num[0] == num[i])
            ++count0;
        else
            break;
    }
    if (num.size() % 3 != 0 && count0 >= 2)
    {
        vector<int> newnum(num.begin() + 2, num.end());
        if (ishu(newnum))
            return true;
    }
    if (count0 >= 3)
    {
        vector<int> newnum(num.begin() + 3, num.end());
        if (ishu(newnum))
            return true;
    }
    if(count(num.begin(),num.end(),num[0]+1)>0 && count(num.begin(), num.end(), num[0] + 2)>0)
    {
        vector<int> newnum(num.begin() + 1, num.end());
        newnum.erase(find(newnum.begin(), newnum.end(), num[0] + 1));
        newnum.erase(find(newnum.begin(), newnum.end(), num[0] + 2));
        if (ishu(newnum))
            return true;
    }
    return false;
}
bool hupai(vector<int>num, int n)
{
    if (count(num.begin(), num.end(), n) == 4)
        return false;
    num.push_back(n);
    sort(num.begin(),num.end());
    return ishu(num);
}
int main()
{
    vector<int> num;
    vector<int> res;
    for (int i = 0; i < 13; ++i)
    {
        int tmp;
        cin >> tmp;
        if (tmp > 0 && tmp < 10)
            num.push_back(tmp);
        else
        {
            cout << "输入错误" << endl;
            return 0;
        }
    }
    for (int n = 1; n < 10; ++n)
    {
        if (hupai(num, n))
            res.push_back(n);
    }
    if (res.empty())
        cout << 0;
    else
        for (int i = 0; i < res.size(); ++i)
            cout << res[i]<<" ";
}

#include<iostream>
#include<map>
#include<vector>
using namespace std;
bool isHu(map<int, int> mp, int num){
    if(num<=0)return true;
    while(mp[mp.begin()->first]==0)mp.erase(mp.begin());
    map<int, int>::iterator it = mp.begin();
    if(num%3!=0 && (it->second)>=2){
        mp[it->first]-=2;
        if(isHu(mp, num-2))return true;
        mp[it->first]+=2;
    }
    if((it->second)>=3){
        mp[it->first]-=3;
        if(isHu(mp, num-3))return true;
        mp[it->first]+=3;
    }
    if((it->second)>0 && mp[(it->first)+1]>0 && mp[(it->first)+2]>0){
        mp[it->first]--;
        mp[(it->first)+1]--;
        mp[(it->first)+2]--;
        if(isHu(mp, num-3))return true;
        mp[(it->first)]++;
        mp[(it->first)+1]++;
        mp[(it->first)+2]++;
    }
    return false;
}
int main(){
    map<int, int> mp;
    int tmp;
    for(int i=0;i<13;i++){
        cin>>tmp;
        mp[tmp]++;
    }
    vector<int> ans;
    for(int i=1;i<10;i++){
        if(mp[i]<4){
            ++mp[i];
            if(isHu(mp, 14))
                ans.push_back(i);
            --mp[i];
        }
    }
    if(ans.empty())cout<<0<<endl;
    else{
        for(int i:ans)cout<<i<<' ';
    }
    
    return 0;
}

# 小包最近迷上了一款叫做雀魂的麻将游戏，但是这个游戏规则太复杂，小包玩了几个月了还是输多赢少。
# 于是生气的小包根据游戏简化了一下规则发明了一种新的麻将，只留下一种花色，并且去除了一些特殊和牌方式（例如七对子等），具体的规则如下：
#     总共有36张牌，每张牌是1~9。每个数字4张牌。
#     你手里有其中的14张牌，如果这14张牌满足如下条件，即算作和牌
#     14张牌中有2张相同数字的牌，称为雀头。
#     除去上述2张牌，剩下12张牌可以组成4个顺子或刻子。顺子的意思是递增的连续3个数字牌（例如234,567等），刻子的意思是相同数字的3个数字牌（例如111,777）
# 例如：
# 1 1 1 2 2 2 6 6 6 7 7 7 9 9 可以组成1,2,6,7的4个刻子和9的雀头，可以和牌
# 1 1 1 1 2 2 3 3 5 6 7 7 8 9 用1做雀头，组123,123,567,789的四个顺子，可以和牌
# 1 1 1 2 2 2 3 3 3 5 6 7 7 9 无论用1 2 3 7哪个做雀头，都无法组成和牌的条件。
# 现在，小包从36张牌中抽取了13张牌，他想知道在剩下的23张牌中，再取一张牌，取到哪几种数字牌可以和牌。
# 原理：如果该手牌胡牌，那么每个数字必然是，雀头、刻子、顺子的成员，
# 递归算法 ： 从最小的数字开始尝试，如果把其当成雀头成员，该数字划掉两个，并看余下的数字能否划空
# 如果是刻子成员，该数字划掉三个，并查看余下数字能否划空
# 如果是顺子成员，划掉该值
# a, a + 1, a + 2，并查看余下数字能否划空
# 如果上述三种尝试都无法划空数组，说明存在数字无法是
# 雀头、刻子、顺子的成员，
#将一个数字牌补入13个牌之中，判断是否和牌，是则输出，不是则下一个数字牌

def IShepai(str):
    lenth=str.__len__()
    if lenth == 0:
        return True
    count1=str.count(str[0])

    if lenth%3!=0 and count1>=2 and IShepai(str[2:])==True:
        return True
    if  count1 >= 3 and IShepai(str[3:])==True:
            return True
    if str[0] + 1 in str and str[0] + 2 in str:
        str1 = str[1:]
        str1.remove(str[0]+1)
        str1.remove(str[0]+2)
        if IShepai(str1) == True:
            return True
    return False
if __name__ == '__main__':
    a=input().split(" ")
    a=[int(x) for x in a]

    for i in range(1,10):
        al=sorted(a + [i])
        if al.count(i)>4:
            continue
        else:
            if IShepai(al) == True:
                print(i,end=" ")
    print()

#include<bits/stdc++.h>
using namespace std;
bool dfs(vector<int>map,int size,bool k){
    if(size==0){
        return true;
    }
    bool a = false,b = false,c = false;
    for(int i = 1;i<10;i++){
        if(!k&&map[i]>=2){
            map[i]-=2;
            a = dfs(map,size-2,true);
            map[i]+=2;
        }
        if(map[i]>=3){
            map[i]-=3;
            b = dfs(map,size-3,k);
            map[i]+=3; 
        }
        if(i<=7&&map[i]>0&&map[i+1]>0&&map[i+2]>0){
            --map[i];--map[i+1];--map[i+2];
            c = dfs(map,size-3,k);
            ++map[i];++map[i+1];++map[i+2];
        }
    }
    return a||b||c;
}
int main(){
    vector<int>map(10);
    int k;
    while(cin>>k){
        map[k]++;
    }
    for(int i = 0;i<10;i++){
        if(map[i]+1<=4){
            ++map[i];
            if(dfs(map,14,false)){
                cout<<i<<' ';
            }
            --map[i];
        }
    }
    return 0;
}

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Scanner;

/**
 *
 * https://www.nowcoder.com/question/next?pid=16516564&qid=362290&tid=28447145
 * 题设：总共有36张牌，每张牌是1~9。每个数字4张牌。
 * 你手里有其中的14张牌，如果这14张牌满足如下条件，即算作和牌,和牌条件如下：
 *  (1)14张牌中有2张相同数字的牌，称为雀头。
 *  (2)除去上述2张牌，剩下12张牌可以组成4个顺子或刻子。
 *      顺子的意思是：递增的连续3个数字牌（例如234,567等）；
 *      刻子的意思是：相同数字的3个数字牌（例如111,777）
 * 输入：已有的13张牌
 * 输出：可以使14张牌成为和牌的最后一张（如果有多种可能，按从小到大的顺序输出）
 *
 * 分析：由小到大添加可能的牌（如果原来牌组已经有了4张该种牌那肯定就不可能了）。
 * 难点是判定14张牌是否是和牌：
 *      第一步选择两张数字相同的，作为雀头；
 *      剩下的牌作为顺子的部分还是刻子部分？(从小到打遍历)
 *          如果除去雀头，一个数字有1或2张：那么这两张肯定作为刻子；
 *          如果除去雀头，一个数字有3张：那么这三张都是刻子或者都是顺子；
 *              假设该数字是顺子，直接划掉
 *              假设该数字是刻子，就划掉a,a+1,a+2
 *          如果除去雀头，一个数字有4张：那么肯定有1张作为刻子，其余三张都是刻子或者都是顺子；
 *              先划掉刻子的那张,     a,a+1,a+2
 *              剩下三张依照上述内容继续处理！
 * 分析到这里，不难看出采用回溯法可以解决。
 *  回溯除了本身是一种暴力实用的算法，还能有效帮助我们理解值传递和引用传递的区别！
 * tips:Java数组如何转化为集合？https://www.cnblogs.com/kangkaii/p/8427739.html
 * 个人喜欢new一个list，然后调用Collections.addAll(list,arr);
 * Arrays.asList()里面不能传数组引用竟然！！！必须要传数组的具体内容！
 *
 */
public class Main {
    private static int[] count= new int[9];
    //由小到大存放可以使牌胡的最后一张(要有可能才行)
    private static ArrayList<Integer> getRes(Integer[] data){
        //存储可行解
        ArrayList<Integer> res=new ArrayList<>();
        //统计1~9出现的次数,count[i]统计的是i+1的次数。i从0~8
        for (Integer e : data) {
            count[e-1]++;
        }
        for (int i = 1; i <= 9; i++) {
            //1.visit
            if(count[i-1]<4){
                count[i-1]++;//说明该张牌可以被插入
            }else {
                continue;
            }
            //2.operate：after copying
            int[] countCp = Arrays.copyOf(count, count.length);
            if( canFindQueTou(countCp) ){
                res.add(i);
            }
            //3.backTrack
            count[i-1]--;
        }
        return res;
    }
    //找雀头
    private static boolean canFindQueTou(int[] count){
        int cnt=0;//记录删掉的牌
        for (int integer = 1; integer <= 9; integer++) {
            if(count[integer-1]>=2){//找到可以作为雀头的integer
                //1.visit
                count[integer-1]-=2;
                //2.operation
                cnt+=2;
                int[] countCp = Arrays.copyOf(count, count.length);
                if(canGoOn(countCp)){//&&后面也能正常进行
                    return true;
                }
                //3.backTrack
                count[integer-1]+=2;
            }
        }
        return false;
    }
    //给其它牌配顺子或者刻子！
    private static boolean canGoOn(int[] count) {
        for (int i = 1; i <= 7; i++) {
            if(count[i-1]==1||count[i-1]==2){//如果该牌只有1张或者两张，必然作为刻子
                if(count[i]>=count[i-1]&&count[i+1]>=count[i-1]){
                    count[i]-=count[i-1];
                    count[i+1]-=count[i-1];
                    count[i-1]-=count[i-1];
                    continue;
                }
                return false;
            }
            if(count[i-1]==3){//如果该牌有3张,作为顺子是当前可行step;3张都作为刻子看情况
                //能做刻子就做刻子,否则才做顺子？这种策略真的不会出错吗？
                //有没有做顺子可以做刻子不行的情况？
                //111 222 333 顺刻都行
                //111 2222 3333 顺子：2222 3333  刻子: 2 3
                if(count[i]>=count[i-1]&&count[i+1]>=count[i-1]){//3张都可以作为刻子的情形
                    count[i]-=count[i-1];
                    count[i+1]-=count[i-1];
                    count[i-1]-=count[i-1];
                    continue;
                }else {//作为顺子
                    count[i-1]-=count[i-1];
                    continue;
                }
//                return false;
            }
            if(count[i-1]==4){//如果该牌有4张,1张作为刻子
                if(count[i]>=1&&count[i+1]>=1){
                    count[i]-=1;
                    count[i+1]-=1;
                    count[i-1]-=1;
                    i--;//继续当前牌的判断，退役到上头该牌有3张的那种情况了
                    continue;
                }
                return false;
            }
        }
        return (count[7]==0||count[7]==3)&&(count[8]==0||count[8]==3);
    }


    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        while (sc.hasNext()) { //分隔符：换行||空格
            Integer[] data=new Integer[13];
            for (int i = 0; i < 13; i++) {
                data[i]=Integer.parseInt(sc.next());
            }
            ArrayList<Integer> res = getRes(data);
            if(res.size()==0){
                System.out.print(res.size());
            }else {
                for (int i = 0; i < res.size(); i++) {
                    System.out.print(res.get(i)+((i!=res.size()-1)?" ":""));
                }
            }
        }
    }
}

from collections import Counter

def options(s, m):
    c = Counter(s)
    k = ''.join(sorted(c.keys()))
    if m == 0: return [i for i in map(str, range(1, 10)) if i not in k or c[i] < 4]
    elif m == 1: return [i * 2 for i in k if c[i] >= 2]
    else: return [i * 3 for i in k if c[i] >= 3] + \
                 [k[i: i + 3] for i in range(len(k) - 2) if 
                  int(k[i]) + 2 == int(k[i + 1]) + 1 == int(k[i + 2])]

def strip(s, o):
    for i in o: s = s.replace(i, '', 1)
    return s

def dfs(s):
    if not s: return True
    for i in options(s, 2):
        if dfs(strip(s, i)): return True
    return False

s, l = input().replace(' ', ''), []
for i in options(s, 0):
    for j in options(s + i, 1):
        if dfs(strip(s + i, j)):
            l.append(i)
            break
print(' '.join(l) if l else 0)

import java.util.*;

public class Main {

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);

        int[] arr = new int[9];
        for(int i = 0; i<13; i++){
            int a = in.nextInt();
            arr[a-1]++;
        }
        
        for(int i = 0; i<9; i++){
            if(arr[i] == 4){
                continue;
            }
            arr[i]++;
            for(int j = 0; j<9; j++){
                if(arr[j] < 2){
                    continue;
                }
                arr[j] -= 2;
                if(hasTriples(arr)){
                    System.out.print(i+1);
                    System.out.print(" ");
                }
                arr[j] += 2;
            }
            arr[i]--;
        }
    }

    public static boolean hasTriples(int[] arr){
        int sum = Arrays.stream(arr).sum();
        if(sum == 0){
            return true;
        }
        boolean flag = false;
        for(int i = 0; i<9; i++){
            if(arr[i]>=3){
                arr[i] -= 3;
                flag = hasTriples(arr) || flag;
                arr[i] += 3;
            }
            if(i<7 && arr[i]>0 && arr[i+1]>0 && arr[i+2]>0){
                arr[i]--; arr[i+1]--; arr[i+2]--;
                flag = hasTriples(arr) || flag;
                arr[i]++; arr[i+1]++; arr[i+2]++;
            }
        }
        return flag;
    } 

}

import java.util.Scanner;

// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int[] c = new int[10];
        while (in.hasNextInt()) c[in.nextInt()]++;
        boolean f = false;  
        for (int i = 1; i <= 9; ++i) {
            if (c[i] == 4) continue;
            c[i]++;
            if (check(c)) {
                System.out.print(i + " ");
                f = true;
            }
            c[i]--;
        }
        if (!f) System.out.println(0);
    }

    public static boolean check(int[] c) {
        for (int i = 1; i <= 9; ++i) {
            if (c[i] >= 2) {
                int[] cc = new int[10];
                System.arraycopy(c, 0, cc, 0, 10);
                cc[i] -= 2;
                if (op(cc)) return true;
            }
        }
        return false;
    }

    public static boolean op(int[] c) {
        int cnt = 0;
        for (int i = 1; i <= 9; ++i) {
            if (c[i] < 0) return false;
            if (c[i] >= 3) {
                cnt++;
                c[i] -= 3;
            }
            while (c[i] > 0) {
                if (i >= 8) return false;
                c[i]--;
                c[i + 1]--;
                c[i + 2]--;
                cnt++;
            }
        }
        return cnt == 4;
    }
}