Quicksum
Time Limit: 2000/1000 MS (Java/Others) Memory Limit: 32768/32768 K (Java/Others)
Total Submission(s): 492 Accepted Submission(s): 408
Problem Description
A checksum is an algorithm that scans a packet of data and returns a single number. The idea is that if the packet is changed, the checksum will also change, so checksums are often used for detecting transmission errors, validating document contents, and in many other situations where it is necessary to detect undesirable changes in data.
For this problem, you will implement a checksum algorithm called Quicksum. A Quicksum packet allows only uppercase letters and spaces. It always begins and ends with an uppercase letter. Otherwise, spaces and letters can occur in any combination, including consecutive spaces.
A Quicksum is the sum of the products of each character's position in the packet times the character's value. A space has a value of zero, while letters have a value equal to their position in the alphabet. So, A=1, B=2, etc., through Z=26. Here are example Quicksum calculations for the packets "ACM" and "MID CENTRAL":
ACM: 1*1 + 2*3 + 3*13 = 46MID CENTRAL: 1*13 + 2*9 + 3*4 + 4*0 + 5*3 + 6*5 + 7*14 + 8*20 + 9*18 + 10*1 + 11*12 = 650
For this problem, you will implement a checksum algorithm called Quicksum. A Quicksum packet allows only uppercase letters and spaces. It always begins and ends with an uppercase letter. Otherwise, spaces and letters can occur in any combination, including consecutive spaces.
A Quicksum is the sum of the products of each character's position in the packet times the character's value. A space has a value of zero, while letters have a value equal to their position in the alphabet. So, A=1, B=2, etc., through Z=26. Here are example Quicksum calculations for the packets "ACM" and "MID CENTRAL":
ACM: 1*1 + 2*3 + 3*13 = 46MID CENTRAL: 1*13 + 2*9 + 3*4 + 4*0 + 5*3 + 6*5 + 7*14 + 8*20 + 9*18 + 10*1 + 11*12 = 650
Input
The input consists of one or more packets followed by a line containing only # that signals the end of the input. Each packet is on a line by itself, does not begin or end with a space, and contains from 1 to 255 characters.
Output
For each packet, output its Quicksum on a separate line in the output.
Sample Input
ACM MID CENTRAL REGIONAL PROGRAMMING CONTEST ACN A C M ABC BBC #
Sample Output
46 650 4690 49 75 14 15
#include <iostream>#include <cstdio>#include <cstring>int main()
{
char str[260]; int ans = 0; while( gets(str) && str[0] != '#' )
{
ans = 0; int len = strlen(str); for( int i = 0; i < len; i++ ) { if( str[i] == ' ' ) continue; else ans += ( str[i] - 64 ) * ( i + 1 );
} std::cout << ans << std::endl; } return 0;
}]]>
Time Limit: 4000/2000 MS (Java/Others) Memory Limit: 32768/32768 K (Java/Others)
Total Submission(s): 252 Accepted Submission(s): 125
Problem Description
In a factory, there are N workers to finish two types of tasks (A and B). Each type has N tasks. Each task of type A needs xi time to finish, and each task of type B needs yj time to finish, now, you, as the boss of the factory, need to make an assignment, which makes sure that every worker could get two tasks, one in type A and one in type B, and, what's more, every worker should have task to work with and every task has to be assigned. However, you need to pay extra money to workers who work over the standard working hours, according to the company's rule. The calculation method is described as follow: if someone’ working hour t is more than the standard working hour T, you should pay t-T to him. As a thrifty boss, you want know the minimum total of overtime pay.
Input
There are multiple test cases, in each test case there are 3 lines. First line there are two positive Integers, N (N<=1000) and T (T<=1000), indicating N workers, N task-A and N task-B, standard working hour T. Each of the next two lines has N positive Integers; the first line indicates the needed time for task A1, A2…An (Ai<=1000), and the second line is for B1, B2…Bn (Bi<=1000).
Output
For each test case output the minimum Overtime wages by an integer in one line.
Sample Input
2 5 4 2 3 5
Sample Output
4
//綆鍗曡椽蹇?/span>#include <iostream>#include <cstdio>#include <algorithm>const int maxn = 1000 + 5;using namespace std;bool cmp( int a, int b ){ return a > b;}int main(){ int a[maxn], b[maxn]; int n, t, ans = 0; while( cin >> n >> t ) { ans = 0; for( int i = 0; i < n; i++ ) cin >> a[i]; for( int i = 0; i < n; i++ ) cin >> b[i]; sort( a, a + n ); sort( b, b + n, cmp ); for( int i = 0; i < n; i++ ) if( a[i] + b[i] > t ) ans += a[i] + b[i] - t; cout << ans << endl; } return 0;}]]>
//鎵捐寰嬶紝姣?涓暟寰幆涓嬈?/span>#include <iostream>#include <cstdio>using namespace std;int main(){ long long a, b; int ans[5]; while(cin >> a >> b) { if( b == 0 ) { cout << "1" << endl; continue; } else if( a == 0 ) { cout << "0" << endl; continue; } ans[1] = a % 10; ans[2] = (ans[1] * a ) % 10; ans[3] = (ans[2] * a ) % 10; ans[4] = (ans[3] * a ) % 10; int tmp = b % 4; if( tmp == 0 ) tmp = 4; cout << ans[tmp] << endl; } return 0;}]]>
/************************************************************* 璁＄畻 2004^X鐨勫洜瀛愬拰 s(2004^X) mod M, M=29 s(2004^X)%29 鍥犲瓙鍜?nbsp;s鏄Н鎬у嚱鏁?鍗?nbsp;錛歡cd(a,b)=1==> s(a*b)= s(a)*s(b) 2004^X=4^X * 3^X *167^X s(2004^X)= s(2^(2X))* s(3^X) * s(167^X) 濡傛灉 p鏄礌鏁?nbsp;==> s(p^X)=1+p+p^2+
+p^X = (p^(X+1)-1) /(p-1) s(2004^X)=錛?^(2X+1)-1錛? (3^(X+1)-1)/2 *(167^(X+1)-1)/166 167%29=22 s(2004^X)=錛?^(2X+1)-1錛? (3^(X+1)-1)/2 *(22^(X+1)-1)/21 (a*b)/c %M= a%M* b%M * inv(c) c*inv(c)=1 %M 妯′負(fù)1鐨勬墍鏈夋暟 inv錛坈錛変負(fù)鏈灝忓彲浠ヨc鏁撮櫎鐨?br /> inv(2)=15, inv(21)=18 2*15=1 mod 29, 18*21=1 mod 29 s(2004^X)=錛?^(2X+1)-1錛? (3^(X+1)-1)/2 *(22^(X+1)-1)/21 =錛?^(2X+1)-1錛? (3^(X+1)-1)*15 *(22^(X+1)-1)*18***************************************************************///hdu 1452#include <iostream>#include <cstdio>#include <cmath>using namespace std;int _pow( int a, int n ){ int b = 1; while( n > 1 ) if( n % 2 == 0 ) { a = ( a * a ) % 29; n /= 2; } else { b = b * a % 29; n--; } return a * b % 29;}int main(){ int X; int a, b, c; while( cin >> X, X ) { a = _pow( 2, 2 * X + 1 ); b = _pow( 3, ( X + 1 ) ); c = _pow( 22, ( X + 1 ) ); cout << ( a - 1 ) * ( b - 1 ) * 15 * ( c - 1 ) * 18 % 29 << endl; } return 0;}]]>
#include <iostream>#include <cstdio>using namespace std;int main(){ double len; double tmp; int ans; while( cin >> len, len ) { tmp = 0; ans = 1; while( ans++ ) { tmp += 1 / ( ans * 1.0 ); if( tmp >= len ) { cout << ans - 1 << " card(s)" << endl; break; } } } return 0;}]]>
/**********************************N % MI = MI - a鍥犱負(fù) a < MI鍘熷紡絳変環(huán)浜?nbsp;(N + a) % MI = 0鎵浠ユ棰樹負(fù)姹?nbsp;M0 鍒?nbsp;MI 鐨勬渶灝忓叕鍊嶆暟(娉ㄦ剰綺懼害闂,鐢╛_int64)***********************************/#include <iostream>#include <cstdio>using namespace std;__int64 gcd( __int64 a, __int64 b ){ if( b == 0 ) return a; return gcd( b, a % b );}__int64 lcm( __int64 a, __int64 b ){ return a * b / gcd( a, b );}int main(){ int n, k; int tmp; __int64 ans; while( cin >> n >> k, n || k ) { ans = 1; for( int i = 0; i < n; i++ ) { cin >> tmp; ans = lcm( ans, tmp ); } cout << ans - k << endl; } return 0;}]]>
n寰堝皬鐨勬椂鍊欙紝鏂壒鐏靛叕寮忕殑鍙栧煎凡緇忓崄鍒嗗噯紜?/p>
榪欏氨鏄錛屽浜庤凍澶熷ぇ鐨勬暣鏁?em>n錛岃繖涓や釜鏁頒簰涓鴻繎浼煎箋傛洿鍔犵簿紜湴錛?img border="0" alt="" src="http://www.shnenglu.com/images/cppblog_com/vontroy/2.png" width="194" height="65" />
Big Number
Time Limit: 20000/10000 MS (Java/Others) Memory Limit: 65536/32768 K (Java/Others)
Total Submission(s): 8759 Accepted Submission(s): 3879
Problem Description
In many applications very large integers numbers are required. Some of these applications are using keys for secure transmission of data, encryption, etc. In this problem you are given a number, you have to determine the number of digits in the factorial of the number.
Input
Input consists of several lines of integer numbers. The first line contains an integer n, which is the number of cases to be tested, followed by n lines, one integer 1 ≤ n ≤ 107 on each line.
Output
The output contains the number of digits in the factorial of the integers appearing in the input.
Sample Input
2 10 20
Sample Output
7 19
//log10(n!)=(0.5*log(2*PI*n)+n*log(n)-n)/log(10)#include <iostream>#include <cstdio>#include <cmath>const double PI = 3.1415926;int main(){ int n; int tmp; while( ~scanf("%d", &n ) ) { for( int i = 0; i < n; i++ ) { scanf("%d", &tmp); double cnt = 1; cnt += (0.5 * log( 2 * PI * tmp ) + tmp * log( tmp ) - tmp ) / log(10); printf("%d\n", (int)(cnt)); } } return 0;}]]>
import java.util.*;import java.math.*;public class Main{ public static void main( String args[] ) { Scanner in = new Scanner( System.in ); int cnt = 0; BigInteger fib1, fib2; BigInteger fla1, fla2; while( in.hasNext() ) { fib1 = BigInteger.valueOf(1); fib2 = BigInteger.valueOf(2); fla1 = in.nextBigInteger(); fla2 = in.nextBigInteger(); if( fla1.equals(BigInteger.valueOf(0)) && fla2.equals(BigInteger.valueOf(0))) break; cnt = 0; while( true ) { if( fib1.compareTo(fla1) >= 0 && fib1.compareTo(fla2) <= 0 ) cnt++; if( fib2.compareTo(fla1) >= 0 && fib2.compareTo(fla2) <= 0 ) cnt++; if( fib1.compareTo(fla2) > 0 || fib2.compareTo(fla2) > 0 ) break; fib1 = fib1.add(fib2); fib2 = fib2.add(fib1); } System.out.println( cnt ); } }}]]>
using namespace std;
int bin[2500];
int find(int x)
{return x==bin[x]?x:find(bin[x]);}
void merge(int x,int y)
{
x=find(x);
y=find(y);
if(x!=y) bin[x]=y;
}
int main()
{
int a[11] = {9, 3, 12, 6, 5, 10, 11, 13, 14, 7, 15}, m, n, i, j, map[50][50], total;
char c;
while(scanf("%d %d", &m, &n), m != -1 || n != -1){
getchar();
for(i = 0; i < m; ++i){
for(j = 0; j < n; ++j){
scanf("%c", &c);
map[i][j] = c - 65;
}
getchar();
}
for(i = 0; i < m * n; ++i) bin[i] = i;
for(i = 0; i < m; ++i)
for(j = 0; j < n; ++j){
if(i + 1 < m && a[map[i][j]] & 0x04 && a[map[i + 1][j]] & 0x01)
merge(i * n + j, i * n + n + j);
if(j + 1 < n && a[map[i][j]] & 0x02 && a[map[i][j + 1]] & 0x08)
merge(i * n + j, i * n + j + 1);
}
for(total = 0, i = 0; i < m * n; ++i)
if(i == bin[i]) ++total;
printf("%d\n", total);
}
return 0;
}
]]>
#include <cstdio>
#include <cmath>
const int maxn = 10;
using namespace std;
bool escape;
char map[maxn][maxn];
int dir[4][2] = {{-1,0}, {1,0}, {0,-1}, {0,1}};
int n, m, t;
int si, sj, di, dj;
void dfs( int x, int y, int cnt )
{
if( escape ) return;
if( x == di && y == dj && cnt == t )
{
escape = 1;
return;
}
int temp = t - cnt - ( fabs(di - x) + fabs(dj - y ) );
if( temp < 0 || temp % 2 != 0 ) return;//濂囧伓鍓灊
if( x <= 0 || y <= 0 || x > n || y > m ) return;
for( int i = 0; i < 4; i++ )
{
if( map[x+dir[i][0]][y+dir[i][1]] != 'X')
{
map[x+dir[i][0]][y+dir[i][1]] = 'X';
dfs(x+dir[i][0], y+dir[i][1], cnt+1);
map[x+dir[i][0]][y+dir[i][1]] = '.';
}
}
}
int main()
{
while( cin >> n >> m >> t, m || n || t )
{
int wall = 0;
escape = 0;
for ( int i = 1; i <= n; i++ )
for ( int j = 1; j <= m; j++ )
{
cin >> map[i][j];
if( map[i][j] == 'D')
{
di = i;
dj = j;
}
else if ( map[i][j] == 'S' )
{
si = i;
sj = j;
}
else if ( map[i][j] == 'X' )
wall ++ ;
}
if( m * n - wall <= t )
{
printf("NO\n");
continue;
}
else
{
map[si][sj] = 'X';
dfs( si, sj, 0 );
printf("%s\n", escape ? "YES" : "NO" );
}
}
return 0;
}
]]>