Seven Segment Display ZOJ - 3962

A seven segment display, or seven segment indicator, is a form of electronic display device for displaying decimal numerals that is an alternative to the more complex dot matrix displays. Seven segment displays are widely used in digital clocks, electronic meters, basic calculators, and other electronic devices that display numerical information.

Edward, a student in Marjar University, is studying the course "Logic and Computer Design Fundamentals" this semester. He bought an eight-digit seven segment display component to make a hexadecimal counter for his course project.

In order to display a hexadecimal number, the seven segment display component needs to consume some electrical energy. The total energy cost for display a hexadecimal number on the component is the sum of the energy cost for displaying each digit of the number. Edward found the following table on the Internet, which describes the energy cost for display each kind of digit.

Digit Energy Cost (units/s) 0 6 1 2 2 5 3 5 4 4 5 5 6 6 7 3

Digit Energy Cost (units/s) 8 7 9 6 A 6 B 5 C 4 D 5 E 5 F 4

For example, in order to display the hexadecimal number "5A8BEF67" on the component for one second, 5 + 6 + 7 + 5 + 5 + 4 + 6 + 3 = 41 units of energy will be consumed.

Edward's hexadecimal counter works as follows:

• The counter will only work for n seconds. After n seconds the counter will stop displaying.
• At the beginning of the 1st second, the counter will begin to display a previously configured eight-digit hexadecimal number m.
• At the end of the i-th second (1 ≤ i < n), the number displayed will be increased by 1. If the number displayed will be larger than the hexadecimal number "FFFFFFFF" after increasing, the counter will set the number to 0 and continue displaying.

Given n and m, Edward is interested in the total units of energy consumed by the seven segment display component. Can you help him by working out this problem?

Input

There are multiple test cases. The first line of input contains an integer T (1 ≤ T ≤ 10⁵), indicating the number of test cases. For each test case:

The first and only line contains an integer n (1 ≤ n ≤ 10⁹) and a capitalized eight-digit hexadecimal number m (00000000 ≤ m ≤ FFFFFFFF), their meanings are described above.

We kindly remind you that this problem contains large I/O file, so it's recommended to use a faster I/O method. For example, you can use scanf/printf instead of cin/cout in C++.

Output

For each test case output one line, indicating the total units of energy consumed by the eight-digit seven segment display component.

Sample Input

3
5 89ABCDEF
3 FFFFFFFF
7 00000000

Sample Output

208
124
327

Hint

For the first test case, the counter will display 5 hexadecimal numbers (89ABCDEF, 89ABCDF0, 89ABCDF1, 89ABCDF2, 89ABCDF3) in 5 seconds. The total units of energy cost is (7 + 6 + 6 + 5 + 4 + 5 + 5 + 4) + (7 + 6 + 6 + 5 + 4 + 5 + 4 + 6) + (7 + 6 + 6 + 5 + 4 + 5 + 4 + 2) + (7 + 6 + 6 + 5 + 4 + 5 + 4 + 5) + (7 + 6 + 6 + 5 + 4 + 5 + 4 + 5) = 208.

For the second test case, the counter will display 3 hexadecimal numbers (FFFFFFFF, 00000000, 00000001) in 3 seconds. The total units of energy cost is (4 + 4 + 4 + 4 + 4 + 4 + 4 + 4) + (6 + 6 + 6 + 6 + 6 + 6 + 6 + 6) + (6 + 6 + 6 + 6 + 6 + 6 + 6 + 2) = 124.

#include<cstdio>
#include<iostream>
#include<cstring>
#include<algorithm>
#include<vector>
typedef long long ll;
using namespace std;

const int maxn=1e5+10;
const ll mod=0x100000000;
char st[10];
/*
妈的，做了两天
这个状态，真的很难想
一个是要pos,这是必须的，还有就是一个状态压缩的量，
因为我们不可能遍历所有的状态，那样的话，我们不就是暴力了，所以我们要压缩，
把值划分到不同的状态里面，这样的话，我们才可以利用上记忆话搜索，要不然你记忆了
只能等到下一次用，再说，那直接这个样例也会爆掉的，所以我们可以把前缀和当做一个
状态，这样的话，我们才可以利用上记忆化搜索
还有就是数字，我们想的是把数字自己写出来，最后传递一个字符串，
但是这样会很麻烦，不如利用一个solve()，直接转换成bit[],这样多么
高度集成，实在是收获颇多 
*/

ll cost[16]={6,2,5,5,4,5,6,3,7,6,6,5,4,5,5,4};
ll dp[10][100];

int bit[10];
ll dfs(int pos,int sum,int limit){//id代表我这个地方最高填什么,limit,pos，三要素 
	//printf("pos:%d sum:%d\n",pos,sum);
	if(pos==-1)
		return sum;
	if(!limit&&dp[pos][sum]!=-1) return dp[pos][sum];
	int up=limit?bit[pos]:15;//原字符串的限制作用体现在这 
	ll ans=0;
	for(int i=0;i<=up;i++){
		 ans+=dfs(pos-1,sum+cost[i],limit&&(i==up));		
	}
	if(!limit)
	   dp[pos][sum]=ans;
	return ans;
}

ll solve(ll num){
	if(num<0) return 0;
	int cnt=0;
	memset(bit,0,sizeof(bit));
	while(num){
		bit[cnt++]=num%16;
		num/=16;
	}
	return dfs(7,0,1);
}

int get_int(char ch){
	if(ch>='0'&&ch<='9') return ch-'0';
	return ch-'A'+10;
}
ll get_int(char* str){
	ll sum=0;
	for(int i=0;i<8;i++){
		sum=sum*16+get_int(str[i]);
	}
	return sum;
}

int main(){
//	freopen("123.txt","w",stdout);
	memset(dp,-1,sizeof(dp));
	int n;
	scanf("%d",&n);
	for(int i=1;i<=n;i++){
		int num;
		scanf("%d %s",&num,st);
		ll l=get_int(st);
		ll r=l+num-1;
		if(r>=mod){
			r%=mod;
			printf("%lld\n",solve((ll)0xffffffff)-solve(l-1)+solve(r));
		}
		else{
			printf("%lld\n",solve(r)-solve(l-1));
		}
	}
	return 0;
}