Problem:
カード並べ
問題
花子さんは n 枚（4 ≤ n ≤ 10）のカードを並べて遊んでいる．
それぞれのカードには 1 以上 99 以下の整数が 1 つずつ書かれている．
花子さんは，これらのカードの中から k 枚（2 ≤ k ≤ 4）を選び，
横一列に並べて整数を作ることにした．
花子さんは全部で何種類の整数を作ることができるだろうか．
例えば，1, 2, 3, 13, 21 の 5 枚のカードが与えられ，そこから 3 枚を選び整数を作ることを考える．
2, 1, 13 をこの順に並べると，整数 2113 を作ることができる．
また，21, 1, 3 をこの順に並べても，同じ整数 2113 を作ることができる．
このように，異なるカードの組み合わせから同じ整数が作られることもある．
n 枚のカードに書かれた整数が与えられたとき，
その中から k 枚を選び，横一列に並べることで作ることができる整数の個数を求めるプログラムを作成せよ．
入力
入力は複数のデータセットからなる．各データセットは以下の形式で与えられる．
各データセットは 2+n 行からなる．
1 行目にはカードの枚数 n （4 ≤ n ≤ 10）が，
2 行目にはカードを選ぶ枚数 k （2 ≤ k ≤ 4）が書かれている．
2+i 行目（1 ≤ i ≤ n）には i 枚目のカードに書かれている 1 以上 99 以下の整数が書かれている．
n, k がともに 0 のとき入力の終了を示す.データセットの数は 5 を超えない．
出力
データセットごとに，花子さんが作ることができる整数の個数を1 行に出力する．
入出力例
入力例
4
2
1
2
12
1
6
3
72
2
12
7
2
1
0
0
出力例
7
68
1つ目の入力例 において，
1, 2, 12, 1 の 4 枚のカードの中から 2 枚を選び，横一列に並べて作ることができる整数は，
11, 12, 21, 112, 121, 122, 212 の 7 個である．
上記問題文と自動審判に使われるデータは、
情報オリンピック日本委員会
が作成し公開している問題文と採点用テストデータです。

Submitted solutions:

code_snippet: #include <iostream>
#include <vector>
#include <algorithm>
#include<utility>
#include<set>
#include<deque>
#include <unordered_map>
#include<string>
#include<cmath>

using namespace std;


int main() {
	while (true) {
		int N;
		set<string>A;
		cin >> N;
		int k;
		cin >> k;
		if (N == 0 and k == 0) {
			break;
		}
		vector<int>o(N);
		int x;
		for (int i = 0; i < N; i++) {
			cin >> x;
			o[i] = x;
		}
		sort(o.begin(), o.end());

		do {
			string s = "";
			if (k == 2) {
				s += to_string(o[0]) + to_string(o[1]);
				A.insert(s);
			}
			else if (k == 3) {
				s += to_string(o[0]) + to_string(o[1]) + to_string(o[2]);
				A.insert(s);
			}
			else if (k == 4) {
				s += to_string(o[0]) + to_string(o[1]) + to_string(o[2]) + to_string(o[3]);
				A.insert(s);
			}
		} while (next_permutation(o.begin(), o.end()));

		cout << A.size() << endl;
	}
}
accuracy: 1
time_ms: 980
memory_kb: 3596
final_rank: 18

code_snippet: #include <bits/stdc++.h>
using namespace std;
typedef unsigned long long ull;
typedef long double db;
typedef long long ll;
typedef  __int128 i128;
typedef pair<int,int>P;
typedef pair<ll,ll>Pll;
mt19937 rnd(time(0));
const ll mod=998244353;
const ll inf=1<<30;
const int N=1e5+5;
bool ok=true;
int dx[8]={0,0,1,-1,1,1,-1,-1};
int dy[8]={1,-1,0,0,1,-1,1,-1};
set<int>e[N];
void solve(){
    int n,k;
    while(cin >> n >> k){
        unordered_set<string>se;
        if(n==0&&k==0) break;
        vector<string>a(n);
        int ans=0;
        for(int i=0;i<n;i++) cin >> a[i];
        sort(a.begin(),a.end());
        do{
            for(int i=0;i<=n-k;i++){
                string x;
                for(int j=i;j<=i+k-1;j++){
                    x+=a[j];
                }
                se.insert(x);
            }
        }while(next_permutation(a.begin(),a.end()));
        cout << se.size() << "\n";
    }
}
int main(){
    ios::sync_with_stdio(0);
    cin.tie(0), cout.tie(0);
    cout << fixed << setprecision(2);
    int T = 1;
    //cin >> T;
    while (T--) {
        solve();
    }
    return 0;
}
accuracy: 1
time_ms: 1000
memory_kb: 8256
final_rank: 20

code_snippet: #include <bits/stdc++.h>

using namespace std;
using ll = long long;
using ld = long double;
using pl = pair<ll, ll>;

#define rep(i, x) for (int i = 0; i < (x); ++i)
#define reps(i, pr, x) for (int i = (pr); i < (x); ++i)
#define vl vector<ll>
#define fore(i, m2) for (auto &i : m2)
#define all(X) (X).begin(), (X).end()
#define out(X) cout << (X) << endl;

template <class T> inline bool chmax(T &a, T b) {
    if (a < b) {
        a = b;
        return true;
    }
    return false;
}
template <class T> inline bool chmin(T &a, T b) {
    if (a > b) {
        a = b;
        return true;
    }
    return false;
}

const ll MOD = 1e9 + 7;
const ll INF = (1LL << 58);
const ll MAX = 1e5 + 5;

int main() {

    ll n, k;
    while (true) {

        cin >> n >> k;
        if (n == 0 && k == 0) break;
        vl a(n);
        rep(i, n) { cin >> a[i]; }
        sort(all(a));
        set<ll> st;
        do {
            string nm = "";
            rep(i, k) { nm += to_string(a[i]); }
            st.insert(stoll(nm));

        } while (next_permutation(all(a)));

        out(st.size());
    }
}
accuracy: 1
time_ms: 880
memory_kb: 3608
final_rank: 15

code_snippet: #include<iostream>
#include<vector>
#include<string>
#include<iomanip>
#include<queue>
#include<map>
#include<algorithm>
#include<set>
using namespace std;

int64_t power(int y) {
	int ans = 1;
	for (int i = 0; i < y; i++) {
		ans *= 10;
	}
	return ans;
}

void solve(int n, int k) {
	vector<int64_t> vec1(n);
	vector<int> vec2(n);
	for (int i = 0; i < n; i++) {
		int64_t x;
		cin >> x;
		vec1.at(i) = x;
		string y = to_string(x);
		vec2.at(i) = y.size();
	}

	vector<int> parm(n);
	for (int i = 0; i < n; i++) {
		parm.at(i) = i;
	}
	set<int> S;
	do {
		int64_t a = 0;
		int count = 0;
		for (int i = 0; i < k; i++) {
			int y = parm.at(i);
			int64_t p = vec1.at(y);
			a += (p * power(count));
			count += vec2.at(y);
		}
		S.insert(a);
	} while (next_permutation(parm.begin(), parm.end()));
	int ans = S.size();
	cout << ans << endl;
}

int main() {
	int n, k;
	cin >> n >> k;
	while (n != 0 || k != 0) {
		solve(n, k);
		cin >> n >> k;
	}
}
accuracy: 1
time_ms: 240
memory_kb: 3308
final_rank: 9

code_snippet: //templateなのだ！
#include <bits/stdc++.h>
#define int long long
#define double long double
#define rep(i, l, r) for (int i=(int)(l); i<(int)(r); i++)
#define repd(i,l,r) for (int i=(int)(l); i>=r; i--)
#define all(a) (a).begin(), (a).end()
#define BS(v, k) (binary_search(all(v),(k)))
#define LBS(v, k) (lower_bound(all(v),(k))-v.begin())
#define UBS(v, k) (upper_bound(all(v),(k))-v.begin())
using namespace std;
using vec=vector<int>;
using mat=vector<vec>;
using graph=vector<vector<pair<int, int> > >;
#define cinvec(v) \
    rep(bakatan,0,(int)v.size()) cin>>v[bakatan];
#define coutvec(v) \
    rep(bakatan,0,(int)v.size()) cout<<v[bakatan]<<' '; cout<<endl;
#define coutvecl(v) \
    rep(bakatan,0,(int)v.size()) cout<<v[bakatan]<<endl;
#pragma GCC target("avx")
#pragma GCC optimize("O3")
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
const int INT_INF=(1ll<<31)-1;
const int INF=1e17;
const int mod1=998244353ll;
const int mod2=1e9+7;
//数学系関数なのだ！
int GCD(int a, int b) {
    if (a<0) a=abs(a); 
    if (b<0) b=abs(b);
    if (a<b) swap(a,b);
    if (b==0) return a;
    else return GCD(b,a%b);
}
int LCM(int a, int b) {
    return (a/GCD(a,b))*b;
}
int Pow(int a, int b) {
    int Ans=1;
    rep(i,0,b) Ans*=a;
    return Ans;
}
int Powmod (int a, int b, int m) {
    int Ans=1, p=a;
    rep(i, 0, 63) {
        if ((b&(1ll<<i))!=0) {Ans*=p; Ans%=m;}
        p*=p; p%=m;
    }
    return Ans;
}
int extGCD(int a, int b, int &x, int &y) {
    if (a<b) return extGCD(b, a, y, x);
    if (b==0) {x=1,y=0; return a;}
    int d=extGCD(b,a%b,y,x); y-=a/b*x;
    return d;
} 
void Euclid(int a, int b, int c, int &x, int &y) {
    int d=extGCD(a,b,x,y); x*=c/d, y*=c/d;
}
int Digit(int N) {
    int Ans=0;
    while (N>0) {N/=10; Ans++;}
    return Ans;
}
int DigitSum(int N) {
    int Ans=0;
    while (N>0) {Ans+=N%10; N/=10;}
    return Ans;
}
int MOD(int a, int m) {
    return (a%m+m)%m;
}
int CRT(int b1, int m1, int b2, int m2) {
    int p, q; int d=extGCD(m1, m2, p, q);
    if ((b2-b1)%d!=0) return -1;
    return MOD(b1+m1*((b2-b1)/d*p%(m2/d)), m1*m2/d);
}
void primefac(int N,vec &p,vec &e) {
    for (int i=2;i*i<=N;i++) {
        int cnt=0; while (N%i==0) {N/=i; cnt++;}
        if (cnt>0) {p.push_back(i); e.push_back(cnt);}
    }
    if (N!=1) {p.push_back(N); e.push_back(1);}
    return;
}
void getprime(int N, vector<int> &prime) {
    vector<bool> flag(N+1, true);
    for (int i=2; i*i<=N; i++) {
        if (flag[i]) {for (int j=2; i*j<=N; j++) flag[i*j]=false;}
    }
    rep(i, 2, N+1) {if (flag[i]) prime.push_back(i);}
    return;
}
// sum_{i=0}^{N-1} floor((A*i+B)/M)
int floorsum(int N,int M,int A,int B) {
    if (N==0) return 0;
    int Ans=0;
    if (A>=M) Ans+=N*(N-1)*(A/M)/2,A%=M;
    if (B>=M) Ans+=N*(B/M),B%=M;
    int Y=(A*N+B)/M,X=Y*M-B;
    if (A==0||Y==0) return Ans;
    Ans+=(N-(X+A-1)/A)*Y+floorsum(Y,A,M,(A-X%A)%A);
    return Ans;
}
//n以下の正整数のうちnと互いに素なものの個数...O(sqrt(N))
int Euler(int n) {
    int Ans=n; vec p; //素因数
    for (int i=2;i*i<=n;i++) {
        if (n%i==0) {
            p.push_back(i);
            while (n%i==0) {n/=i;}
        }
    }
    if (n!=1) p.push_back(n);
    rep(i,0,(int)p.size()) Ans=Ans/p[i]*(p[i]-1);
    return Ans;
}
vec fact,fact_inv,inv;
void init_nCk(int SIZE,int mod) {
    fact.resize(SIZE+5); fact_inv.resize(SIZE+5); inv.resize(SIZE+5);
    fact[0]=fact[1]=1; fact_inv[0]=fact_inv[1]=1; inv[1]=1;
    rep(i,2,SIZE+5) {
        fact[i]=fact[i-1]*i%mod;
        inv[i]=mod-inv[mod%i]*(mod/i)%mod;
        fact_inv[i]=fact_inv[i-1]*inv[i]%mod;
    }
}
int nCk(int n,int k,int mod) {
    if (n<k||n<0||k<0) return -1;
    return fact[n]*(fact_inv[k]*fact_inv[n-k]%mod)%mod;
}
//データ構造なのだ！
/* unionfindの説明なのだ！
unionfind():大きさ0で宣言...O(1)
unionfind(N):大きさNで宣言...O(1)
init(N):大きさNで初期化
root(v):頂点vの根..O(1)
unite(u,v):頂点uを含む集合と頂点vを含む集合を統合
same(u,v):頂点uとvが同じ集合に属するか判定
*/
class UnionFind {
    public:
    vector<int> par, siz;
    UnionFind() {init(0);}
    UnionFind(int N) {init(N);}
    void init(int N) {par.resize(N,-1); siz.resize(N,1);}
    int root(int pos) { //posの根を返す関数
        if (par[pos]==-1) return pos;
        else return par[pos]=root(par[pos]);
    }
    void unite(int u, int v) { //要素uとvを統合する関数
        int RootU=root(u), RootV=root(v);
        if (RootU==RootV) return;
        if (siz[RootU]<siz[RootV]) {par[RootU]=RootV; siz[RootV]+=siz[RootU];}
        else {par[RootV]= RootU; siz[RootU]+=siz[RootV];}
    }
    bool same(int u, int v) { //要素uとvが同じグループに属するか判定する関数
        if (root(u)==root(v)) return true;
        else return false;
    }
};
/* セグメント木の説明なのだ！
・宣言 : N=配列の大きさ, fx=モノイドXの二項演算, ex=fx(a,e)=fx(e,a)=aとなる単位元e
・set(i,x):i番目をxとおく（後でbuild()が必要）...O(logN)
・build():セグメント木を再構築する...O(1)
・update(i,x):i番目をxに変更する...O(logN)
・query(l,r):fx(A[l],A[l+1],...A[r-1])を求める...O(logN)
・find_right, find_left:セグメント木上での二分探索（必要に応じて）...0(logN)
*/
template <typename X> 
struct SegmentTree{
    using FX=function<X(X,X)>;
    vector<X> dat; //各ノードの値
    int siz; //葉の数
    FX fx; //二項演算
    const X ex; //単位元
    SegmentTree(int N,FX fx_,X ex_):siz(),fx(fx_),ex(ex_),dat() {
        siz=1; while (siz<N) siz*=2;
        dat.resize(2*siz-1); rep(i,0,2*siz-1) dat[i]=ex;
    }
    void set(int i,X x) { dat[i+siz-1] = x;}
    void build() {
        for (int i=siz-2; i>=0; i--) dat[i]=fx(dat[2*i+1], dat[2*i+2]);
    }
    void update(int pos,X x) {
        pos+=siz-1; dat[pos] = x;
        while (pos>0) {pos=(pos-1)/2; dat[pos]=fx(dat[pos*2+1], dat[pos*2+2]);}
    }
    X query(int a,int b) {return query_sub(a,b,0,0,siz);} //範囲は[a, b)
    X query_sub(int a,int b,int k,int l,int r) {
        if (r<=a||b<=l) return ex;
        if (a<=l&&r<=b) return dat[k];
        X left=query_sub(a,b,k*2+1,l,(l+r)/2);
        X right=query_sub(a,b,k*2+2,(l+r)/2,r);
        return fx(left, right);
    }
};
//セグ木の二項演算
int Fx(int x1, int x2) {return min(x1,x2);}
int Fx2(int x1,int x2) {return max(x1,x2);}
/*遅延評価セグメント木の説明なのだ！
SegTreeLazy(n,fx,fa,fm,ex,em):要素数n,二項演算fx,fa,fm,単位元ex,emのセグ木を構築...O(logn)
set(i,x)→build():i番目の値をxになおす...set:O(1),build:O(logn)
update(a,b,x):[a,b)の値をxに変更...O(logn)
query(a,b):[a,b)に対応するなんらかの値を返す...O(logn)
*/
template<typename X,typename M> 
struct SegTreeLazy {
    using FX=function<X(X,X)>; FX fx; //セグ木のデータに関する演算
    using FA=function<X(X,M)>; FA fa;//遅延評価を作用させる演算
    using FM=function<M(M,M)>; FM fm; //遅延評価に関する演算
    int n;
    const X ex; const M em; //集合X,Mに関する単位元
    vector<X> dat;
    vector<M> lazy;
    SegTreeLazy(int n_,FX fx_,FA fa_,FM fm_,X ex_,M em_)
    :n(),fx(fx_),fa(fa_),fm(fm_),ex(ex_),em(em_),dat(n_*4,ex),lazy(n_*4,em) {
        n=1; while (n_>n) n*=2;
    }
    void set(int i,X x) {dat[i+n-1]=x;}
    void build() {
        for (int k=n-2;k>=0;k--) dat[k]=fx(dat[2*k+1],dat[2*k+2]);
    }
    void eval(int k) {
        if (lazy[k]==em) return;
        if (k<n-1) {
            lazy[2*k+1]=fm(lazy[2*k+1],lazy[k]);
            lazy[2*k+2]=fm(lazy[2*k+2],lazy[k]);
        }
        dat[k]=fa(dat[k],lazy[k]);
        lazy[k]=em;
    }
    void update(int a,int b,M x,int k,int l,int r) {
        eval(k);
        if (a<=l&&r<=b) {
            lazy[k]=fm(lazy[k],x); eval(k);
        }
        else if (a<r&&l<b) {
            update(a,b,x,2*k+1,l,(l+r)/2);
            update(a,b,x,2*k+2,(l+r)/2,r);
            dat[k]=fx(dat[2*k+1],dat[2*k+2]);
        }
    }
    void update(int a,int b,M x) {update(a,b,x,0,0,n);}
    X query_sub(int a,int b,int k,int l,int r) {
        eval(k);
        if (r<=a||b<=l) return ex;
        if (a<=l&&r<=b) return dat[k];
        else {
            X left=query_sub(a,b,2*k+1,l,(l+r)/2);
            X right=query_sub(a,b,2*k+2,(l+r)/2,r);
            return fx(left,right);
        }
    }
    X query(int a,int b) {return query_sub(a,b,0,0,n);}
};
//遅延セグ木の二項演算
int fx(int a,int b) {return min(a,b);}
int fa(int a,int b) {return b;}
int fm(int a,int b) {return b;}
/* BITの説明なのだ！
宣言:N=配列の大きさ
add(l,r,x):[l,r)にxを加算する
query(l,r):[l,r)の和を返す
＊内部では1-indexになっていることに注意
*/
template <typename T>
struct BIT {
    int N; vector<T> bit[2];
    BIT(int n) {init(n);}
    private:
    void init(int n) {
        N=n+1; rep(i,0,2) bit[i].assign(N,0);
    }
    void add_sub(int p,int i,T x) {
        for (int idx=i; idx<N; idx+=(idx&-idx)) bit[p][idx]+=x;
    }
    T sum_sub(int p,int i) {
        T s(0);
        for (int idx=i; idx>0; idx-=(idx&-idx)) s+=bit[p][idx];
        return s;
    }
    T sum(int i) {return sum_sub(0,i)+sum_sub(1,i)*i;}
    public:
    void add(int l,int r,T x) {
        l++; r++;
        add_sub(0,l,-x*(l-1)); add_sub(0,r,x*(r-1));
        add_sub(1,l,x); add_sub(1,r,-x);
    }
    T query(int l,int r) {l++; r++; return sum(r-1)-sum(l-1);}
};
/* RollingHashの説明なのだ！
宣言:Sに関するHash値を計算する
query(l,r):[l,r)のHash値を計算する
*/
struct RollingHash{
    int Mod=(1ll<<61)-1,Modsub=(1ll<<31)-1;
    int RollingHash_MOD(int x) { 
        int res=(x>>61)+(x&Mod);
        if (res>=Mod) res-=Mod;
        return res;
    }
    int Mul(int a,int b) {
        int tmp=(a&Modsub)*(b>>31)+(b&Modsub)*(a>>31);
        int res=(a>>31)*(b>>31)*2+(tmp>>30)+((tmp&((1ll<<30)-1))<<31)+(a&Modsub)*(b&Modsub);
        return RollingHash_MOD(res);
    }
    string S; int siz,Base=RollingHash_MOD(rand());
    vec Hash, Power;
    RollingHash(string T):S(T),siz((int)T.size()) {
        Hash.resize(siz+1); Power.resize(siz+1); Hash[0]=0; Power[0]=1;
        rep(i,1,siz+1) Hash[i]=RollingHash_MOD(Mul(Base,Hash[i-1])+(S[i-1]-'a')+1);
        rep(i,1,siz+1) Power[i]=Mul(Power[i-1],Base);
    }
    int query(int l, int r) {
        return RollingHash_MOD(Hash[r]+Mod-Mul(Hash[l],Power[r-l]));
    }
};
//グラフアルゴリズムなのだ！
void BFS(int start, mat G, vec &dist) {
    int N=(int)G.size(); 
    dist.assign(N,-1); dist[start]=0;
    queue<int> Q; Q.push(start);
    while (!Q.empty()) {
        int pos=Q.front(); Q.pop();
        rep(i,0,(int)G[pos].size()) {
            if (dist[G[pos][i]]==-1) {
                dist[G[pos][i]]=dist[pos]+1; Q.push(G[pos][i]);
            }
        }
    }
    return;
}
void Dijkstra(int start, graph G, vector<int> &dist) {
    int N=(int)G.size(); 
    dist.resize(N); rep(i,0,N) dist[i]=INF;
    priority_queue<pair<int, int>, vector<pair<int, int> >, greater<pair<int, int> > > Q;
    vector<bool> flag(N, false);
    dist[start]=0; Q.push(make_pair(0,start));
    while (!Q.empty()) {
        int pos=Q.top().second; Q.pop();
        if (flag[pos]) continue;
        flag[pos]=true;
        rep(i,0,(int)G[pos].size()) {
            if (dist[G[pos][i].first]>dist[pos]+G[pos][i].second) {
                dist[G[pos][i].first]=dist[pos]+G[pos][i].second;
                Q.push(make_pair(dist[G[pos][i].first], G[pos][i].first));
            }
        }
    }
}
int Path2(int s, int t, graph G, vector<int> &route) {
    int N=(int)G.size(), pos=t; 
    vector<int> dist(N); Dijkstra(s, G, dist);
    while (true) {
        route.push_back(pos);
        if (pos==s) break;
        rep(i,0,(int)G[pos].size()) {
            if (dist[G[pos][i].first]+G[pos][i].second==dist[pos]) {
                pos=G[pos][i].first; break;
            }
        }
    }
    reverse(all(route));
    return dist[t];
}
//トポロジカルソート
vec topo_sort(mat G) { //BFS
    int N=(int)G.size(); vec Ans,ind(N);
    rep(i,0,N) {
        rep(j,0,(int)G[i].size()) ind[G[i][j]]++;
    }
    queue<int> Q;
    rep(i,0,N) {
        if (ind[i]==0) Q.push(i);
    }
    while (!Q.empty()) {
        int pos=Q.front(); Q.pop();
        Ans.push_back(pos);
        rep(i,0,(int)G[pos].size()) {
            ind[G[pos][i]]--;
            if (ind[G[pos][i]]==0) Q.push(G[pos][i]);
        }
    }
    return Ans;
}
/*最大フローの説明なのだ！
宣言:N=グラフの大きさ
add(a,b,c):aからbをつなぐ大きさcの辺を追加する(0-index、有向辺)
max_flow(s,t):sからtへの最大フローを求める
*/
struct MaxFlow_Edge {int to,cap,rev;};
class MaxFlow {
    public:
    int N; vector<bool> flag; vector<vector<MaxFlow_Edge> > G;
    MaxFlow(int n):N(n),flag(n),G(n) {}
    void add(int a,int b,int c) {
        MaxFlow_Edge tmp1={b,c,(int)G[b].size()};
        MaxFlow_Edge tmp2={a,0,(int)G[a].size()};
        G[a].push_back(tmp1); G[b].push_back(tmp2);
    }
    int dfs(int pos,int goal,int MinFlow) {
        if (pos==goal) return MinFlow;
        flag[pos]=true;
        rep(i,0,(int)G[pos].size()) {
            if (G[pos][i].cap==0) continue;
            if (flag[G[pos][i].to]) continue;
            int Flow=dfs(G[pos][i].to,goal,min(MinFlow,G[pos][i].cap));
            if (Flow>0) {
                G[pos][i].cap-=Flow; 
                G[G[pos][i].to][G[pos][i].rev].cap+=Flow;
                return Flow;
            }
        }
        return 0;
    }
    int max_flow(int s,int t) {
        int Ans=0;
        while (true) {
            rep(i,0,N) flag[i]=false;
            int Flow=dfs(s,t,INF);
            if (Flow==0) break;
            Ans+=Flow;
        }
        return Ans;
    }
};
/*LCAの説明なのだ！
LCA(mat G,int root):根がrootの木Gで前処理を行う...O(NlogN)
query(u,v):頂点uとvの最小共通祖先を求める...O((logN)^2)
*/
struct LCA{
    mat par; //par[k][v]:頂点vの2^k先の親
    vec dist;
    LCA(const mat &G,int root=0) {init(G,root);}
    void init(const mat &G,int root=0) {
        int N=(int)G.size(),cnt=0;
        while ((1<<cnt)<N) cnt++;
        par.assign(cnt,vec(N,-1));
        dist.assign(N,-1);
        dfs(G,root,-1,0);
        rep(k,0,cnt-1) {
            rep(v,0,N) {
                if (par[k][v]<0) par[k+1][v]=-1;
                else par[k+1][v]=par[k][par[k][v]];
            }
        }
    }
    void dfs(const mat &G,int v,int p,int d) {
        par[0][v]=p; dist[v]=d;
        rep(i,0,(int)G[v].size()) {
            if (G[v][i]!=p) dfs(G,G[v][i],v,d+1);
        }
    }
    int query(int u,int v) {
        if (dist[u]<dist[v]) swap(u,v);
        int cnt=(int)par.size();
        rep(k,0,cnt) {
            if ((dist[u]-dist[v])>>k&1) u=par[k][u];
        }
        if (u==v) return u;
        for (int k=cnt-1;k>=0;k--) {
            if (par[k][u]!=par[k][v]) {u=par[k][u]; v=par[k][v];}
        }
        return par[0][u];
    }
};
//便利関数なのだ！
template <typename T>
void chmax(T &a, const T b) {
    if (a<b) a=b;
}
template <typename T>
void chmin(T &a, const T b) {
    if (a>b) a=b;
}
int swap_count(vec A) { //i<j,A[i]>A[j]を満たす(i,j)を数える...O(NlogN)
    int N=(int)A.size();
    //まず座圧
    set<int> T; rep(i,0,N) T.insert(A[i]);
    vec t; while (!T.empty()) {t.push_back(*begin(T)); T.erase(*begin(T));}
    vec P(N); rep(i,0,N) P[i]=LBS(t,A[i]);
    //最大がN-1になったから転倒数を求める
    BIT<int> S(N);
    int Ans=0;
    rep(i,0,N) {
        Ans+=i-S.query(0,P[i]);
        S.add(P[i],P[i]+1,1);
    }
    return Ans;
}
template <typename T>
T Sum(vector<T> A) {
    T Ans=0;
    rep(i,0,(int)A.size()) Ans+=A[i];
    return Ans;
}
template<typename T>
T Min(vector<T> A) {
    T Ans=A[0];
    rep(i,1,(int)A.size()) chmin(Ans,A[i]);
    return Ans;
}
template<typename T>
T Max(vector<T> A) {
    T Ans=A[0];
    rep(i,1,(int)A.size()) chmax(Ans,A[i]);
    return Ans;
}

signed main() {
    cin.tie(nullptr);
    ios::sync_with_stdio(false);
    //init_nCk(2*1e6+9,mod2);
    cout<<fixed<<setprecision(15);
    srand(time(NULL));
    while (true) {
    int N,K; cin>>N>>K;
    if (N==0&&K==0) return 0;
    vector<string> S(N); cinvec(S);
    vec P(N); rep(i,0,N) P[i]=i;
    set<string> Ans;
    do {
        string s="";
        rep(i,0,K) s+=S[P[i]];
        Ans.insert(s);
    }while (next_permutation(all(P)));
    cout<<(int)Ans.size()<<endl;
    }
}
accuracy: 1
time_ms: 900
memory_kb: 3648
final_rank: 16

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

int main()
{
    int n, k;
    while (cin >> n >> k)
    {
        if (n == 0 && k == 0)
            break;
        vector<string> card(n);
        for (int i = 0; i < n; i++)
        {
            cin >> card.at(i);
        }
        set<string> number;
        sort(card.begin(), card.end());
        do
        {
            string newcard = "";
            for (int i = 0; i < k; i++)
                newcard += card.at(i);
            number.insert(newcard);
        } while (next_permutation(card.begin(), card.end()));
        cout << number.size() << endl;
    }
}
accuracy: 1
time_ms: 310
memory_kb: 3528
final_rank: 10

code_snippet: #include<bits/stdc++.h>
using namespace std;
void solve(bool& flag)
{
	int n, k;
	cin >> n >> k;
	if (n == 0 && k == 0)
	{
		flag = true;
		return;
	}
	vector<string>numbers(n);
	vector<int>indexs(n);
	for (int a = 0; a < n; a++)
	{
		string num;
		cin >> num;
		numbers.at(a) = num;
		indexs.at(a) = a;
	}
	set<string>MixedNumbers;
	do
	{
		string mixedNumber;
		for (int a = 0; a < k; a++)
		{
			mixedNumber += numbers.at(indexs.at(a));
		}
		MixedNumbers.insert(mixedNumber);
	} 
	while (next_permutation(indexs.begin(), indexs.end()));
	cout << MixedNumbers.size() << endl;
}
int main()
{
	bool flag = false;
	while (!flag)
		solve(flag);
}
accuracy: 1
time_ms: 860
memory_kb: 3348
final_rank: 14

code_snippet: #include <bits/stdc++.h>
using namespace std;
const long long MOD1 = 1000000007;
const long long MOD2 = 998244353;
typedef long long ll;
typedef pair<long long, long long> P;
const long long INF = 1e17;
const ll MOD = MOD1;
template <typename T>
void input_arr(vector<T>& A, ll N) {
    for (ll i = 0; i < N; i++) {
        cin >> A[i];
    }
}
template <typename T, typename Q>
void input_arr(vector<pair<T, Q>>& A, ll N) {
    for (ll i = 0; i < N; i++) {
        cin >> A[i].first >> A[i].second;
    }
}
template <typename T>
ll elements(vector<T>& A) {
    sort(A.begin(), A.end());
    ll ans = 1;
    for (ll i = 1; i < A.size(); i++) {
        if (A[i] != A[i - 1]) ans++;
    }
    return ans;
}
int main() {
    ll N, K; cin >> N >> K;
    while (!(N==0 && K==0)) {
        vector<ll>A(N); input_arr(A, N);
        sort(A.begin(),A.end());
        vector<ll>S;
        do {
            ll num = A[0];
            for (ll i = 1; i < K; i++) {
                num *= 10;
                if (A[i] >= 10) num *= 10;
                num += A[i];
            }
            S.push_back(num);
        }while(next_permutation(A.begin(),A.end()));
        cout << elements(S) << endl;
        cin >> N >> K;
    }
}
accuracy: 1
time_ms: 60
memory_kb: 28148
final_rank: 19

code_snippet: #include<bits/stdc++.h>
using namespace std;
typedef long long ll;

signed main() {
    while(true) {
        int n, k; cin >> n >> k;
        if(n == 0 && k == 0) return 0;
        vector<string> a(n);
        for(int i=0; i<n; i++) cin >> a[i];
        sort(a.begin(), a.end());
        unordered_set<string> result;
        do {
            string test = "";
            for(int i=0; i<k; i++) test += a[i];
            result.insert(test);
        } while(next_permutation(a.begin(), a.end()));
        cout << result.size() << endl;
    }
}
accuracy: 1
time_ms: 160
memory_kb: 3640
final_rank: 8

code_snippet: #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define ve(i) vector<i>
#define pa(i, j) pair<i, j>
#define qu(i) queue<i>
#define tu(i, j, k) tuple<i, j, k>
#define ma(i, j) map<i, j>
#define st(i) stack<i>
#define fop(i, n) for(int i=0; i<n; ++i)
#define fom(i, n) for(int i=n-1; i<=0; --i)
#define bgen(i) i.begin(),i.end()

void chmin(int& a, int& b){if(a > b)a = b;}
void chmax(int& a, int& b){if(a < b)a = b;}

const ve(int) DX = {-1, 0, 1, 0};
const ve(int) DY = {0, 1, 0, -1};

int main() {
  while(1){
    int n, k;
    cin >> n >> k;
    if(n == 0 && k == 0)return 0;
    int jump = 1;
    fop(i, n-k) jump *= (i+1);
    --jump;
    ve(int) num(n);
    fop(i, n) cin >> num[i];
    sort(bgen(num));
    
    set<string> numb;
    do{
      fop(i, jump)continue;
      string s;
      fop(i, k) s += to_string(num[i]);
      numb.insert(s);
    }while(next_permutation(bgen(num)));

    cout << numb.size() << endl;
  }
}
accuracy: 1
time_ms: 910
memory_kb: 3712
final_rank: 17

code_snippet: #include<algorithm>
#include<iostream>
#include<vector>
#include<set>

int calc(std::vector<std::string> card, int K){
    std::sort(card.begin(), card.end());
    std::set<std::string> st;
    do{
        std::string s="";
        for(int i=0; i<K; ++i) s += card[i];
        st.insert(s);
    }while(std::next_permutation(card.begin(), card.end()));
    return st.size();
}

int main(){
    int N,K;
    while(std::cin >> N >> K, N || K){
        std::vector<std::string> card(N);
        for(int n=0; n<N; ++n) std::cin >> card[n];
        std::cout << calc(card, K) << std::endl;
    }
    return 0;
}
accuracy: 1
time_ms: 760
memory_kb: 3412
final_rank: 13

code_snippet: #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
using namespace std;
using ll = long long;
using P = pair<int, int>;

int main() {
    int n, k;
    while(cin >> n >> k) {
        if (n == 0) break;
        vector<int> card(n);
        rep(i, n) {
            cin >> card[i];
        }
        
        sort(card.begin(), card.end());
        set<int> ans;
        int sum;
        do {
            sum = 0;
            rep(i, k) {
                if (card[i] < 10) {
                    sum = 10 * sum + card[i];
                } else {
                    sum = 100 * sum + card[i];
                }
            }
            ans.insert(sum);
        } while (next_permutation(card.begin(), card.end()));

        cout << ans.size() << endl;
        
    } 
    return 0;
}
accuracy: 1
time_ms: 50
memory_kb: 3224
final_rank: 4

code_snippet: #include <algorithm>
#include <iostream>
#include <queue>
#include <set>
#include <vector>
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
using namespace std;

int main() {
  int n, k;
  while (true) {
    cin >> n >> k;
    if (n == 0 && k == 0) return 0;
    vector<string> a(n);
    rep(i, n) cin >> a[i];
    sort(a.begin(), a.end());

    set<string> s;
    do {
      string ans;
      rep(i, k) ans += a[i];
      s.insert(ans);
    } while (next_permutation(a.begin(), a.end()));

    cout << s.size() << endl;
  }
  return 0;
}
accuracy: 1
time_ms: 750
memory_kb: 3268
final_rank: 12

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

#define rep(i,n) for(int i=0; i<(n); ++i)
using ll = long long;
using P = pair<int, int>;

int main() {
  vector<int> ans;
  while (true) {
    int n, k;
    cin >> n >> k;
    if (n == 0 && k == 0) break;
    vector<string> c(n);
    rep(i,n) cin >> c[i];

    set<string> num;
    sort(c.begin(), c.end());
    do {
      string tmp;
      rep(i,k) {
	tmp += c[i];
      }
      num.insert(tmp);
    } while (next_permutation(c.begin(), c.end()));
    ans.push_back(num.size());
  }

  rep(i,ans.size()) cout << ans[i] << endl;
  return 0;
}
accuracy: 1
time_ms: 740
memory_kb: 3424
final_rank: 11

code_snippet: #include<bits/stdc++.h>
#define rep(i,n) for(int i=0;i<n;i++)
using namespace std;
typedef long long ll;

int main(){
    ios::sync_with_stdio(false);
    cin.tie(0);   

    int n,k;

    
    while(cin >> n >> k){
        if(!n && !k) break;

        int card[n];
        rep(i,n) cin >> card[i];

        sort( card, card + n );

        int ans = 0;
        map<int,int> memo;
        do{
            int temp = 0;
            rep(i,k){
                temp *= 10;
                if(card[i]>9) temp *= 10;
                temp += card[i];
            }
            if(memo[temp] == 0) ans++;
            memo[temp] = 1;
        }while(next_permutation( card, card + n ));

        cout << ans << endl;
    }

    return 0;
}
accuracy: 1
time_ms: 100
memory_kb: 3236
final_rank: 7

code_snippet: #include <bits/stdc++.h>
#define ll long long
#define rep(i,n) for(ll (i)=0;(i)<(n);++(i))
using namespace std;

int main(){
    while(true){
    ll n,k;
    cin>>n>>k;
    if(n==0&&k==0)return 0;
    vector<ll> a(n);
    rep(i,n)cin>>a[i];
    sort(a.begin(),a.end());
    set<string> ans;
    if(k==2){
        rep(i,n){
            rep(j,n){
                if(i==j)continue;
                string v;
                v+=to_string(a[i])+to_string(a[j]);
                ans.insert(v);
            }
        }
    }else if(k==3){
        rep(i,n){
            rep(j,n){
                if(i==j)continue;
                rep(l,n){
                    if(i==l || j==l)continue;
                    string v;
                    v+=to_string(a[i])+to_string(a[j])+to_string(a[l]);
                    ans.insert(v);
                }
            }
        }
    }else if(k==4){
        rep(i,n){
            rep(j,n){
                if(i==j)continue;
                rep(l,n){
                    if(i==l || j==l)continue;
                    rep(m,n){
                        if(i==m || j==m || l==m)continue;
                        string v;
                        v+=to_string(a[i])+to_string(a[j])+to_string(a[l])+to_string(a[m]);
                        ans.insert(v);
                    }
                }
            }
        }
    }
    cout<<ans.size()<<endl;
    }
}
accuracy: 1
time_ms: 10
memory_kb: 3432
final_rank: 1

code_snippet: #include <algorithm>
#include <iostream>
#include <map>
#include <vector>

using namespace std;

typedef long long ll;
typedef pair<ll, ll> P;

#define MOD 1000000007
#define REP(i, N) for (int i = 0; i < N; ++i)
#define REP1(i, N) for (int i = 1; i <= N; ++i)
#define RREP(i, N) for (int i = N - 1; i >= 0; --i)
#define ALL(a) a.begin(), a.end()

int main() {
  int n, k;
  while (cin >> n >> k) {
    if (n == 0 && k == 0) break;
    vector<int> card;
    REP(i, n) {
      int c;
      cin >> c;
      card.push_back(c);
    }
    sort(ALL(card));
    map<int, int> mp;
    do {
      int num = 0;
      REP(i, k) {
        if (i == 0) {
          num += card[i];
        } else {
          int d = 0;
          int tmp = card[i];
          while (0 < tmp) {
            tmp /= 10;
            d++;
          }
          REP(j, d) num *= 10;
          num += card[i];
        }
      }
      mp[num]++;
    } while (next_permutation(ALL(card)));
    cout << mp.size() << endl;
  }
  return 0;
}
accuracy: 1
time_ms: 60
memory_kb: 3168
final_rank: 6

code_snippet: // TLE
#include <algorithm>
#include <iostream>
#include <map>
#include <vector>

using namespace std;

typedef long long ll;
typedef pair<ll, ll> P;

#define MOD 1000000007
#define REP(i, N) for (int i = 0; i < N; ++i)
#define REP1(i, N) for (int i = 1; i <= N; ++i)
#define RREP(i, N) for (int i = N - 1; i >= 0; --i)
#define ALL(a) a.begin(), a.end()

int main() {
  int n, k;
  while (cin >> n >> k) {
    if (n == 0 && k == 0) break;
    vector<int> card;
    REP(i, n) {
      int c;
      cin >> c;
      card.push_back(c);
    }
    sort(ALL(card));
    map<int, int> mp;
    do {
      int num = 0;
      REP(i, k) {
        if (i == 0) {
          num += card[i];
        } else {
          int d = 0;
          int tmp = card[i];
          while (0 < tmp) {
            tmp /= 10;
            d++;
          }
          REP(j, d) num *= 10;
          num += card[i];
        }
      }
      mp[num]++;
    } while (next_permutation(ALL(card)));
    cout << mp.size() << endl;
  }
  return 0;
}
accuracy: 1
time_ms: 60
memory_kb: 3156
final_rank: 5

code_snippet: #include <iostream>
#include <algorithm>
#include <vector>
#include <set>

using namespace std;

int main() {
	int n, k; 
	while (cin >> n >> k, n + k) {
		vector<int> card(n);
		for (int i = 0; i < n; ++i) cin >> card[i];
		sort(card.begin(), card.end());
		set<int> cnt;
		do {
			int tmp = 0;
			for (int i = 0; i < k; ++i)
				tmp = tmp * (card[i] >= 10 ? 100 : 10) + card[i];
			cnt.insert(tmp);
		} while (next_permutation(card.begin(), card.end()));
		cout << cnt.size() << endl;
	}

	return 0;
}
accuracy: 1
time_ms: 50
memory_kb: 3196
final_rank: 3

code_snippet: #include <iostream>
#include <algorithm>
#include <vector>
#include <set>

using namespace std;

int digit(int x) {
	int dig = 0;
	while (x / 10) x /= 10, dig++;
	return dig;
}

int main() {
	int n, k; 
	while (cin >> n >> k, n + k) {
		vector<int> card(n);
		for (int i = 0; i < n; ++i) cin >> card[i];
		sort(card.begin(), card.end());
		set<int> cnt;
		do {
			int tmp = 0;
			for (int i = 0; i < k; ++i)
				tmp = tmp * (card[i] >= 10 ? 100 : 10) + card[i];
			cnt.insert(tmp);
		} while (next_permutation(card.begin(), card.end()));
		cout << cnt.size() << endl;
	}

	return 0;
}
accuracy: 1
time_ms: 50
memory_kb: 3188
final_rank: 2