Search Results

Search found 1343 results on 54 pages for 'digit grouping'.

Page 18/54 | < Previous Page | 14 15 16 17 18 19 20 21 22 23 24 25  | Next Page >

• MySql Not Like Regexp?

  - by KnockKnockWhosThere

  I'm trying to find rows where the first character is not a digit. I have this: SELECT DISTINCT(action) FROM actions WHERE qkey = 140 AND action NOT REGEXP '^[:digit:]$'; But, I'm not sure how to make sure it checks just the first character...

  Read the article

• how to find out the value of textbox from asp.net to script

  - by Ramakrishna

  from my textbox, i need to get the first digit entered into that, and check whther it is 7 or 8 or 9.. using getelementbyid, how can i get this.... how can check whether first digit is 7 or 8 or 9 in the textbox

  Read the article

• Flex/bison, error: undeclared

  - by Imran

  hallo, i have a problem, the followed program gives back an error, error:: Undeclared(first use in function), why this error appears all tokens are declared, but this error comes, can anyone help me, here are the lex and yac files.thanks lex: %{ int yylinenu= 1; int yycolno= 1; %} %x STR DIGIT [0-9] ALPHA [a-zA-Z] ID {ALPHA}(_?({ALPHA}|{DIGIT}))*_? GROUPED_NUMBER ({DIGIT}{1,3})(\.{DIGIT}{3})* SIMPLE_NUMBER {DIGIT}+ NUMMER {GROUPED_NUMBER}|{SIMPLE_NUMBER} %% <INITIAL>{ [\n] {++yylinenu ; yycolno=1;} [ ]+ {yycolno=yycolno+yyleng;} [\t]+ {yycolno=yycolno+(yyleng*8);} "*" {return MAL;} "+" {return PLUS;} "-" {return MINUS;} "/" {return SLASH;} "(" {return LINKEKLAMMER;} ")" {return RECHTEKLAMMER;} "{" {return LINKEGESCHWEIFTEKLAMMER;} "}" {return RECHTEGESCHEIFTEKLAMMER;} "=" {return GLEICH;} "==" {return GLEICHVERGLEICH;} "!=" {return UNGLEICH;} "<" {return KLEINER;} ">" {return GROSSER;} "<=" {return KLEINERGLEICH;} ">=" {return GROSSERGLEICH;} "while" {return WHILE;} "if" {return IF;} "else" {return ELSE;} "printf" {return PRINTF;} ";" {return SEMIKOLON;} \/\/[^\n]* { ;} {NUMMER} {return NUMBER;} {ID} {return IDENTIFIER;} \" {BEGIN(STR);} . {;} } <STR>{ \n {++yylinenu ;yycolno=1;} ([^\"\\]|"\\t"|"\\n"|"\\r"|"\\b"|"\\\"")+ {return STRING;} \" {BEGIN(INITIAL);} } %% yywrap() { } YACC: %{ #include stdio.h> #include string.h> #include "lex.yy.c" void yyerror(char *err); int error=0,linecnt=1; %} %token IDENTIFIER NUMBER STRING COMMENT PLUS MINUS MAL SLASH LINKEKLAMMER RECHTEKLAMMER LINKEGESCHWEIFTEKLAMMER RECHTEGESCHEIFTEKLAMMER GLEICH GLEICHVERGLEICH UNGLEICH GROSSER KLEINER GROSSERGLEICH KLEINERGLEICH IF ELSE WHILE PRINTF SEMIKOLON %start Stmts %% Stmts : Stmt {puts("\t\tStmts : Stmt");} |Stmt Stmts {puts("\t\tStmts : Stmt Stmts");} ; //NEUE REGEL---------------------------------------------- Stmt : LINKEGESCHWEIFTEKLAMMER Stmts RECHTEGESCHEIFTEKLAMMER {puts("\t\tStmt : '{' Stmts '}'");} |IF LINKEKLAMMER Cond RECHTEKLAMMER Stmt {puts("\t\tStmt : '(' Cond ')' Stmt");} |IF LINKEKLAMMER Cond RECHTEKLAMMER Stmt ELSE Stmt {puts("\t\tStmt : '(' Cond ')' Stmt 'ELSE' Stmt");} |WHILE LINKEKLAMMER Cond RECHTEKLAMMER Stmt {puts("\t\tStmt : 'PRINTF' Expr ';'");} |PRINTF Expr SEMIKOLON {puts("\t\tStmt : 'PRINTF' Expr ';'");} |IDENTIFIER GLEICH Expr SEMIKOLON {puts("\t\tStmt : 'IDENTIFIER' '=' Expr ';'");} |SEMIKOLON {puts("\t\tStmt : ';'");} ;//NEUE REGEL --------------------------------------------- Cond: Expr GLEICHVERGLEICH Expr {puts("\t\tCond : '==' Expr");} |Expr UNGLEICH Expr {puts("\t\tCond : '!=' Expr");} |Expr KLEINER Expr {puts("\t\tCond : '<' Expr");} |Expr KLEINERGLEICH Expr {puts("\t\tCond : '<=' Expr");} |Expr GROSSER Expr {puts("\t\tCond : '>' Expr");} |Expr GROSSERGLEICH Expr {puts("\t\tCond : '>=' Expr");} ;//NEUE REGEL -------------------------------------------- Expr:Term {puts("\t\tExpr : Term");} |Term PLUS Expr {puts("\t\tExpr : Term '+' Expr");} |Term MINUS Expr {puts("\t\tExpr : Term '-' Expr");} ;//NEUE REGEL -------------------------------------------- Term:Factor {puts("\t\tTerm : Factor");} |Factor MAL Term {puts("\t\tTerm : Factor '*' Term");} |Factor SLASH Term {puts("\t\tTerm : Factor '/' Term");} ;//NEUE REGEL -------------------------------------------- Factor:SimpleExpr {puts("\t\tFactor : SimpleExpr");} |MINUS SimpleExpr {puts("\t\tFactor : '-' SimpleExpr");} ;//NEUE REGEL -------------------------------------------- SimpleExpr:LINKEKLAMMER Expr RECHTEKLAMMER {puts("\t\tSimpleExpr : '(' Expr ')'");} |IDENTIFIER {puts("\t\tSimpleExpr : 'IDENTIFIER'");} |NUMBER {puts("\t\tSimpleExpr : 'NUMBER'");} |STRING {puts("\t\tSimpleExpr : 'String'");} ;//ENDE ------------------------------------------------- %% void yyerror(char *msg) { error=1; printf("Line: %d , Column: %d : %s \n", yylinenu, yycolno,yytext, msg); } int main(int argc, char *argv[]) { int val; while(yylex()) { printf("\n",yytext); } return yyparse(); }

  Read the article

• C++: Simplifying my program to convert numbers to from one base to another.

  - by Spin City

  Hello, I'm taking a beginner C++ course. I received an assignment telling me to write a program that converts an arbitrary number from any base between binary and hex to another base between binary and hex. I was asked to use separate functions to convert to and from base 10. It was to help us get used to using arrays. (We already covered passing by reference previously in class.) I already turned this in, but I'm pretty sure this wasn't how I was meant to do it: #include <iostream> #include <conio.h> #include <cstring> #include <cmath> using std::cout; using std::cin; using std::endl; int to_dec(char value[], int starting_base); char* from_dec(int value, int ending_base); int main() { char value[30]; int starting_base; int ending_base; cout << "This program converts from one base to another, so long as the bases are" << endl << "between 2 and 16." << endl << endl; input_numbers: cout << "Enter the number, then starting base, then ending base:" << endl; cin >> value >> starting_base >> ending_base; if (starting_base < 2 || starting_base > 16 || ending_base < 2 || ending_base > 16) { cout << "Invalid base(s). "; goto input_numbers; } for (int i=0; value[i]; i++) value[i] = toupper(value[i]); cout << "Base " << ending_base << ": " << from_dec(to_dec(value, starting_base), ending_base) << endl << "Press any key to exit."; getch(); return 0; } int to_dec(char value[], int starting_base) { char hex[16] = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'}; long int return_value = 0; unsigned short int digit = 0; for (short int pos = strlen(value)-1; pos > -1; pos--) { for (int i=0; i<starting_base; i++) { if (hex[i] == value[pos]) { return_value+=i*pow((float)starting_base, digit++); break; } } } return return_value; } char* from_dec(int value, int ending_base) { char hex[16] = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'}; char *return_value = (char *)malloc(30); unsigned short int digit = (int)ceil(log10((double)(value+1))/log10((double)ending_base)); return_value[digit] = 0; for (; value != 0; value/=ending_base) return_value[--digit] = hex[value%ending_base]; return return_value; } I'm pretty sure this is more advanced than it was meant to be. How do you think I was supposed to do it? I'm essentially looking for two kinds of answers: Examples of what a simple solution like the one my teacher probably expected would be. Suggestions on how to improve the code.

  Read the article

• How to optimize dynamic programming?

  - by Chan

  Problem A number is called lucky if the sum of its digits, as well as the sum of the squares of its digits is a prime number. How many numbers between A and B are lucky? Input: The first line contains the number of test cases T. Each of the next T lines contains two integers, A and B. Output: Output T lines, one for each case containing the required answer for the corresponding case. Constraints: 1 <= T <= 10000 1 <= A <= B <= 10^18 Sample Input: 2 1 20 120 130 Sample Output: 4 1 Explanation: For the first case, the lucky numbers are 11, 12, 14, 16. For the second case, the only lucky number is 120. The problem is quite simple if we use brute force, however the running time is so critical that my program failed most test cases. My current idea is to use dynamic programming by storing the previous sum in a temporary array, so for example: sum_digits(10) = 1 -> sum_digits(11) = sum_digits(10) + 1 The same idea is applied for sum square but with counter equals to odd numbers. Unfortunately, it still failed 9 of 10 test cases which makes me think there must be a better way to solve it. Any idea would be greatly appreciated. #include <iostream> #include <vector> #include <string> #include <algorithm> #include <unordered_map> #include <unordered_set> #include <cmath> #include <cassert> #include <bitset> using namespace std; bool prime_table[1540] = { 0, 0, 1, 1, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0 }; unsigned num_digits(long long i) { return i > 0 ? (long) log10 ((double) i) + 1 : 1; } void get_sum_and_sum_square_digits(long long n, int& sum, int& sum_square) { sum = 0; sum_square = 0; int digit; while (n) { digit = n % 10; sum += digit; sum_square += digit * digit; n /= 10; } } void init_digits(long long n, long long previous_sum[], const int size = 18) { int current_no_digits = num_digits(n); int digit; for (int i = 0; i < current_no_digits; ++i) { digit = n % 10; previous_sum[i] = digit; n /= 10; } for (int i = current_no_digits; i <= size; ++i) { previous_sum[i] = 0; } } void display_previous(long long previous[]) { for (int i = 0; i < 18; ++i) { cout << previous[i] << ","; } } int count_lucky_number(long long A, long long B) { long long n = A; long long end = B; int sum = 0; int sum_square = 0; int lucky_counter = 0; get_sum_and_sum_square_digits(n, sum, sum_square); long long sum_counter = sum; long long sum_square_counter = sum_square; if (prime_table[sum_counter] && prime_table[sum_square_counter]) { lucky_counter++; } long long previous_sum[19] = {1}; init_digits(n, previous_sum); while (n < end) { n++; if (n % 100000000000000000 == 0) { previous_sum[17]++; sum_counter = previous_sum[17] + previous_sum[18]; sum_square_counter = previous_sum[17] * previous_sum[17] + previous_sum[18] * previous_sum[18]; previous_sum[16] = 0; previous_sum[15] = 0; previous_sum[14] = 0; previous_sum[13] = 0; previous_sum[12] = 0; previous_sum[11] = 0; previous_sum[10] = 0; previous_sum[9] = 0; previous_sum[8] = 0; previous_sum[7] = 0; previous_sum[6] = 0; previous_sum[5] = 0; previous_sum[4] = 0; previous_sum[3] = 0; previous_sum[2] = 0; previous_sum[1] = 0; previous_sum[0] = 0; } else if (n % 10000000000000000 == 0) { previous_sum[16]++; sum_counter = previous_sum[16] + previous_sum[17] + previous_sum[18]; sum_square_counter = previous_sum[16] * previous_sum[16] + previous_sum[17] * previous_sum[17] + previous_sum[18] * previous_sum[18]; previous_sum[15] = 0; previous_sum[14] = 0; previous_sum[13] = 0; previous_sum[12] = 0; previous_sum[11] = 0; previous_sum[10] = 0; previous_sum[9] = 0; previous_sum[8] = 0; previous_sum[7] = 0; previous_sum[6] = 0; previous_sum[5] = 0; previous_sum[4] = 0; previous_sum[3] = 0; previous_sum[2] = 0; previous_sum[1] = 0; previous_sum[0] = 0; } else if (n % 1000000000000000 == 0) { previous_sum[15]++; sum_counter = previous_sum[15] + previous_sum[16] + previous_sum[17] + previous_sum[18]; sum_square_counter = previous_sum[15] * previous_sum[15] + previous_sum[16] * previous_sum[16] + previous_sum[17] * previous_sum[17] + previous_sum[18] * previous_sum[18]; previous_sum[14] = 0; previous_sum[13] = 0; previous_sum[12] = 0; previous_sum[11] = 0; previous_sum[10] = 0; previous_sum[9] = 0; previous_sum[8] = 0; previous_sum[7] = 0; previous_sum[6] = 0; previous_sum[5] = 0; previous_sum[4] = 0; previous_sum[3] = 0; previous_sum[2] = 0; previous_sum[1] = 0; previous_sum[0] = 0; } else if (n % 100000000000000 == 0) { previous_sum[14]++; sum_counter = previous_sum[14] + previous_sum[15] + previous_sum[16] + previous_sum[17] + previous_sum[18]; sum_square_counter = previous_sum[14] * previous_sum[14] + previous_sum[15] * previous_sum[15] + previous_sum[16] * previous_sum[16] + previous_sum[17] * previous_sum[17] + previous_sum[18] * previous_sum[18]; previous_sum[13] = 0; previous_sum[12] = 0; previous_sum[11] = 0; previous_sum[10] = 0; previous_sum[9] = 0; previous_sum[8] = 0; previous_sum[7] = 0; previous_sum[6] = 0; previous_sum[5] = 0; previous_sum[4] = 0; previous_sum[3] = 0; previous_sum[2] = 0; previous_sum[1] = 0; previous_sum[0] = 0; } else if (n % 10000000000000 == 0) { previous_sum[13]++; sum_counter = previous_sum[13] + previous_sum[14] + previous_sum[15] + previous_sum[16] + previous_sum[17] + previous_sum[18]; sum_square_counter = previous_sum[13] * previous_sum[13] + previous_sum[14] * previous_sum[14] + previous_sum[15] * previous_sum[15] + previous_sum[16] * previous_sum[16] + previous_sum[17] * previous_sum[17] + previous_sum[18] * previous_sum[18]; previous_sum[12] = 0; previous_sum[11] = 0; previous_sum[10] = 0; previous_sum[9] = 0; previous_sum[8] = 0; previous_sum[7] = 0; previous_sum[6] = 0; previous_sum[5] = 0; previous_sum[4] = 0; previous_sum[3] = 0; previous_sum[2] = 0; previous_sum[1] = 0; previous_sum[0] = 0; } else if (n % 1000000000000 == 0) { previous_sum[12]++; sum_counter = previous_sum[12] + previous_sum[13] + previous_sum[14] + previous_sum[15] + previous_sum[16] + previous_sum[17] + previous_sum[18]; sum_square_counter = previous_sum[12] * previous_sum[12] + previous_sum[13] * previous_sum[13] + previous_sum[14] * previous_sum[14] + previous_sum[15] * previous_sum[15] + previous_sum[16] * previous_sum[16] + previous_sum[17] * previous_sum[17] + previous_sum[18] * previous_sum[18]; previous_sum[11] = 0; previous_sum[10] = 0; previous_sum[9] = 0; previous_sum[8] = 0; previous_sum[7] = 0; previous_sum[6] = 0; previous_sum[5] = 0; previous_sum[4] = 0; previous_sum[3] = 0; previous_sum[2] = 0; previous_sum[1] = 0; previous_sum[0] = 0; } else if (n % 100000000000 == 0) { previous_sum[11]++; sum_counter = previous_sum[11] + previous_sum[12] + previous_sum[13] + previous_sum[14] + previous_sum[15] + previous_sum[16] + previous_sum[17] + previous_sum[18]; sum_square_counter = previous_sum[11] * previous_sum[11] + previous_sum[12] * previous_sum[12] + previous_sum[13] * previous_sum[13] + previous_sum[14] * previous_sum[14] + previous_sum[15] * previous_sum[15] + previous_sum[16] * previous_sum[16] + previous_sum[17] * previous_sum[17] + previous_sum[18] * previous_sum[18]; previous_sum[10] = 0; previous_sum[9] = 0; previous_sum[8] = 0; previous_sum[7] = 0; previous_sum[6] = 0; previous_sum[5] = 0; previous_sum[4] = 0; previous_sum[3] = 0; previous_sum[2] = 0; previous_sum[1] = 0; previous_sum[0] = 0; } else if (n % 10000000000 == 0) { previous_sum[10]++; sum_counter = previous_sum[10] + previous_sum[11] + previous_sum[12] + previous_sum[13] + previous_sum[14] + previous_sum[15] + previous_sum[16] + previous_sum[17] + previous_sum[18]; sum_square_counter = previous_sum[10] * previous_sum[10] + previous_sum[11] * previous_sum[11] + previous_sum[12] * previous_sum[12] + previous_sum[13] * previous_sum[13] + previous_sum[14] * previous_sum[14] + previous_sum[15] * previous_sum[15] + previous_sum[16] * previous_sum[16] + previous_sum[17] * previous_sum[17] + previous_sum[18] * previous_sum[18]; previous_sum[9] = 0; previous_sum[8] = 0; previous_sum[7] = 0; previous_sum[6] = 0; previous_sum[5] = 0; previous_sum[4] = 0; previous_sum[3] = 0; previous_sum[2] = 0; previous_sum[1] = 0; previous_sum[0] = 0; } else if (n % 1000000000 == 0) { previous_sum[9]++; sum_counter = previous_sum[9] + previous_sum[10] + previous_sum[11] + previous_sum[12] + previous_sum[13] + previous_sum[14] + previous_sum[15] + previous_sum[16] + previous_sum[17] + previous_sum[18]; sum_square_counter = previous_sum[9] * previous_sum[9] + previous_sum[10] * previous_sum[10] + previous_sum[11] * previous_sum[11] + previous_sum[12] * previous_sum[12] + previous_sum[13] * previous_sum[13] + previous_sum[14] * previous_sum[14] + previous_sum[15] * previous_sum[15] + previous_sum[16] * previous_sum[16] + previous_sum[17] * previous_sum[17] + previous_sum[18] * previous_sum[18]; previous_sum[8] = 0; previous_sum[7] = 0; previous_sum[6] = 0; previous_sum[5] = 0; previous_sum[4] = 0; previous_sum[3] = 0; previous_sum[2] = 0; previous_sum[1] = 0; previous_sum[0] = 0; } else if (n % 100000000 == 0) { previous_sum[8]++; sum_counter = previous_sum[8] + previous_sum[9] + previous_sum[10] + previous_sum[11] + previous_sum[12] + previous_sum[13] + previous_sum[14] + previous_sum[15] + previous_sum[16] + previous_sum[17] + previous_sum[18]; sum_square_counter = previous_sum[8] * previous_sum[8] + previous_sum[9] * previous_sum[9] + previous_sum[10] * previous_sum[10] + previous_sum[11] * previous_sum[11] + previous_sum[12] * previous_sum[12] + previous_sum[13] * previous_sum[13] + previous_sum[14] * previous_sum[14] + previous_sum[15] * previous_sum[15] + previous_sum[16] * previous_sum[16] + previous_sum[17] * previous_sum[17] + previous_sum[18] * previous_sum[18]; previous_sum[7] = 0; previous_sum[6] = 0; previous_sum[5] = 0; previous_sum[4] = 0; previous_sum[3] = 0; previous_sum[2] = 0; previous_sum[1] = 0; previous_sum[0] = 0; } else if (n % 10000000 == 0) { previous_sum[7]++; sum_counter = previous_sum[7] + previous_sum[8] + previous_sum[9] + previous_sum[10] + previous_sum[11] + previous_sum[12] + previous_sum[13] + previous_sum[14] + previous_sum[15] + previous_sum[16] + previous_sum[17] + previous_sum[18]; sum_square_counter = previous_sum[7] * previous_sum[7] + previous_sum[8] * previous_sum[8] + previous_sum[9] * previous_sum[9] + previous_sum[10] * previous_sum[10] + previous_sum[11] * previous_sum[11] + previous_sum[12] * previous_sum[12] + previous_sum[13] * previous_sum[13] + previous_sum[14] * previous_sum[14] + previous_sum[15] * previous_sum[15] + previous_sum[16] * previous_sum[16] + previous_sum[17] * previous_sum[17] + previous_sum[18] * previous_sum[18]; previous_sum[6] = 0; previous_sum[5] = 0; previous_sum[4] = 0; previous_sum[3] = 0; previous_sum[2] = 0; previous_sum[1] = 0; previous_sum[0] = 0; } else if (n % 1000000 == 0) { previous_sum[6]++; sum_counter = previous_sum[6] + previous_sum[7] + previous_sum[8] + previous_sum[9] + previous_sum[10] + previous_sum[11] + previous_sum[12] + previous_sum[13] + previous_sum[14] + previous_sum[15] + previous_sum[16] + previous_sum[17] + previous_sum[18]; sum_square_counter = previous_sum[6] * previous_sum[6] + previous_sum[7] * previous_sum[7] + previous_sum[8] * previous_sum[8] + previous_sum[9] * previous_sum[9] + previous_sum[10] * previous_sum[10] + previous_sum[11] * previous_sum[11] + previous_sum[12] * previous_sum[12] + previous_sum[13] * previous_sum[13] + previous_sum[14] * previous_sum[14] + previous_sum[15] * previous_sum[15] + previous_sum[16] * previous_sum[16] + previous_sum[17] * previous_sum[17] + previous_sum[18] * previous_sum[18]; previous_sum[5] = 0; previous_sum[4] = 0; previous_sum[3] = 0; previous_sum[2] = 0; previous_sum[1] = 0; previous_sum[0] = 0; } else if (n % 100000 == 0) { previous_sum[5]++; sum_counter = previous_sum[5] + previous_sum[6] + previous_sum[7] + previous_sum[8] + previous_sum[9] + previous_sum[10] + previous_sum[11] + previous_sum[12] + previous_sum[13] + previous_sum[14] + previous_sum[15] + previous_sum[16] + previous_sum[17] + previous_sum[18]; sum_square_counter = previous_sum[5] * previous_sum[5] + previous_sum[6] * previous_sum[6] + previous_sum[7] * previous_sum[7] + previous_sum[8] * previous_sum[8] + previous_sum[9] * previous_sum[9] + previous_sum[10] * previous_sum[10] + previous_sum[11] * previous_sum[11] + previous_sum[12] * previous_sum[12] + previous_sum[13] * previous_sum[13] + previous_sum[14] * previous_sum[14] + previous_sum[15] * previous_sum[15] + previous_sum[16] * previous_sum[16] + previous_sum[17] * previous_sum[17] + previous_sum[18] * previous_sum[18]; previous_sum[4] = 0; previous_sum[3] = 0; previous_sum[2] = 0; previous_sum[1] = 0; previous_sum[0] = 0; } else if (n % 10000 == 0) { previous_sum[4]++; sum_counter = previous_sum[4] + previous_sum[5] + previous_sum[6] + previous_sum[7] + previous_sum[8] + previous_sum[9] + previous_sum[10] + previous_sum[11] + previous_sum[12] + previous_sum[13] + previous_sum[14] + previous_sum[15] + previous_sum[16] + previous_sum[17] + previous_sum[18]; sum_square_counter = previous_sum[4] * previous_sum[4] + previous_sum[5] * previous_sum[5] + previous_sum[6] * previous_sum[6] + previous_sum[7] * previous_sum[7] + previous_sum[8] * previous_sum[8] + previous_sum[9] * previous_sum[9] + previous_sum[12] * previous_sum[12] + previous_sum[13] * previous_sum[13] + previous_sum[14] * previous_sum[14] + previous_sum[15] * previous_sum[15] + previous_sum[16] * previous_sum[16] + previous_sum[17] * previous_sum[17] + previous_sum[18] * previous_sum[18]; previous_sum[3] = 0; previous_sum[2] = 0; previous_sum[1] = 0; previous_sum[0] = 0; } else if (n % 1000 == 0) { previous_sum[3]++; sum_counter = previous_sum[3] + previous_sum[4] + previous_sum[5] + previous_sum[6] + previous_sum[7] + previous_sum[8] + previous_sum[9] + previous_sum[10] + previous_sum[11] + previous_sum[12] + previous_sum[13] + previous_sum[14] + previous_sum[15] + previous_sum[16] + previous_sum[17] + previous_sum[18]; sum_square_counter = previous_sum[3] * previous_sum[3] + previous_sum[4] * previous_sum[4] + previous_sum[5] * previous_sum[5] + previous_sum[6] * previous_sum[6] + previous_sum[7] * previous_sum[7] + previous_sum[8] * previous_sum[8] + previous_sum[9] * previous_sum[9] + previous_sum[10] * previous_sum[10] + previous_sum[11] * previous_sum[11] + previous_sum[12] * previous_sum[12] + previous_sum[13] * previous_sum[13] + previous_sum[14] * previous_sum[14] + previous_sum[15] * previous_sum[15] + previous_sum[16] * previous_sum[16] + previous_sum[17] * previous_sum[17] + previous_sum[18] * previous_sum[18]; previous_sum[2] = 0; previous_sum[1] = 0; previous_sum[0] = 0; } else if (n % 100 == 0) { previous_sum[2]++; sum_counter = previous_sum[2] + previous_sum[3] + previous_sum[4] + previous_sum[5] + previous_sum[6] + previous_sum[7] + previous_sum[8] + previous_sum[9] + previous_sum[10] + previous_sum[11] + previous_sum[12] + previous_sum[13] + previous_sum[14] + previous_sum[15] + previous_sum[16] + previous_sum[17] + previous_sum[18]; sum_square_counter = previous_sum[2] * previous_sum[2] + previous_sum[3] * previous_sum[3] + previous_sum[4] * previous_sum[4] + previous_sum[5] * previous_sum[5] + previous_sum[6] * previous_sum[6] + previous_sum[7] * previous_sum[7] + previous_sum[8] * previous_sum[8] + previous_sum[9] * previous_sum[9] + previous_sum[10] * previous_sum[10] + previous_sum[11] * previous_sum[11] + previous_sum[12] * previous_sum[12] + previous_sum[13] * previous_sum[13] + previous_sum[14] * previous_sum[14] + previous_sum[15] * previous_sum[15] + previous_sum[16] * previous_sum[16] + previous_sum[17] * previous_sum[17] + previous_sum[18] * previous_sum[18]; previous_sum[1] = 0; previous_sum[0] = 0; } else if (n % 10 == 0) { previous_sum[1]++; sum_counter = previous_sum[1] + previous_sum[2] + previous_sum[3] + previous_sum[4] + previous_sum[5] + previous_sum[6] + previous_sum[7] + previous_sum[8] + previous_sum[9] + previous_sum[10] + previous_sum[11] + previous_sum[12] + previous_sum[13] + previous_sum[14] + previous_sum[15] + previous_sum[16] + previous_sum[17] + previous_sum[18]; sum_square_counter = previous_sum[1] * previous_sum[1] + previous_sum[2] * previous_sum[2] + previous_sum[3] * previous_sum[3] + previous_sum[4] * previous_sum[4] + previous_sum[5] * previous_sum[5] + previous_sum[6] * previous_sum[6] + previous_sum[7] * previous_sum[7] + previous_sum[8] * previous_sum[8] + previous_sum[9] * previous_sum[9] + previous_sum[10] * previous_sum[10] + previous_sum[11] * previous_sum[11] + previous_sum[12] * previous_sum[12] + previous_sum[13] * previous_sum[13] + previous_sum[14] * previous_sum[14] + previous_sum[15] * previous_sum[15] + previous_sum[16] * previous_sum[16] + previous_sum[17] * previous_sum[17] + previous_sum[18] * previous_sum[18]; previous_sum[0] = 0; } else { sum_counter++; sum_square_counter += ((n - 1) % 10) * 2 + 1; } // get_sum_and_sum_square_digits(n, sum, sum_square); // assert(sum == sum_counter && sum_square == sum_square_counter); if (prime_table[sum_counter] && prime_table[sum_square_counter]) { lucky_counter++; } } return lucky_counter; } void inout_lucky_numbers() { int n; cin >> n; long long a; long long b; while (n--) { cin >> a >> b; cout << count_lucky_number(a, b) << endl; } } int main() { inout_lucky_numbers(); return 0; }

  Read the article

• HSSFS Part 2.1 - Parsing @@VERSION

  - by Most Valuable Yak (Rob Volk)

  For Part 2 of the Handy SQL Server Function Series I decided to tackle parsing useful information from the @@VERSION function, because I am an idiot.  It turns out I was confused about CHARINDEX() vs. PATINDEX() and it pretty much invalidated my original solution.  All is not lost though, this mistake turned out to be informative for me, and hopefully for you. Referring back to the "Version" view in the prelude I started with the following query to extract the version number: SELECT DISTINCT SQLVersion, SUBSTRING(VersionString,PATINDEX('%-%',VersionString)+2, 12) VerNum FROM VERSION I used PATINDEX() to find the first hyphen "-" character in the string, since the version number appears 2 positions after it, and got these results: SQLVersion VerNum ----------- ------------ 2000 8.00.2055 (I 2005 9.00.3080.00 2005 9.00.4053.00 2008 10.50.1600.1 As you can see it was good enough for most of the values, but not for the SQL 2000 @@VERSION.  You'll notice it has only 3 version sections/octets where the others have 4, and the SUBSTRING() grabbed the non-numeric characters after.  To properly parse the version number will require a non-fixed value for the 3rd parameter of SUBSTRING(), which is the number of characters to extract. The best value is the position of the first space to occur after the version number (VN), the trick is to figure out how to find it.  Here's where my confusion about PATINDEX() came about.  The CHARINDEX() function has a handy optional 3rd parameter: CHARINDEX (expression1 ,expression2 [ ,start_location ] ) While PATINDEX(): PATINDEX ('%pattern%',expression ) Does not.  I had expected to use PATINDEX() to start searching for a space AFTER the position of the VN, but it doesn't work that way.  Since there are plenty of spaces before the VN, I thought I'd try PATINDEX() on another character that doesn't appear before, and tried "(": SELECT SQLVersion, SUBSTRING(VersionString,PATINDEX('%-%',VersionString)+2, PATINDEX('%(%',VersionString)) FROM VERSION Unfortunately this messes up the length calculation and yields: SQLVersion VerNum ----------- --------------------------- 2000 8.00.2055 (Intel X86) Dec 16 2008 19:4 2005 9.00.3080.00 (Intel X86) Sep 6 2009 01: 2005 9.00.4053.00 (Intel X86) May 26 2009 14: 2008 10.50.1600.1 (Intel X86) Apr 2008 10.50.1600.1 (X64) Apr 2 20 Yuck.  The problem is that PATINDEX() returns position, and SUBSTRING() needs length, so I have to subtract the VN starting position: SELECT SQLVersion, SUBSTRING(VersionString,PATINDEX('%-%',VersionString)+2, PATINDEX('%(%',VersionString)-PATINDEX('%-%',VersionString)) VerNum FROM VERSION And the results are: SQLVersion VerNum ----------- -------------------------------------------------------- 2000 8.00.2055 (I 2005 9.00.4053.00 (I Msg 537, Level 16, State 2, Line 1 Invalid length parameter passed to the LEFT or SUBSTRING function. Ummmm, whoops.  Turns out SQL Server 2008 R2 includes "(RTM)" before the VN, and that causes the length to turn negative. So now that that blew up, I started to think about matching digit and dot (.) patterns.  Sadly, a quick look at the first set of results will quickly scuttle that idea, since different versions have different digit patterns and lengths. At this point (which took far longer than I wanted) I decided to cut my losses and redo the query using CHARINDEX(), which I'll cover in Part 2.2.  So to do a little post-mortem on this technique: PATINDEX() doesn't have the flexibility to match the digit pattern of the version number; PATINDEX() doesn't have a "start" parameter like CHARINDEX(), that allows us to skip over parts of the string; The SUBSTRING() expression is getting pretty complicated for this relatively simple task! This doesn't mean that PATINDEX() isn't useful, it's just not a good fit for this particular problem.  I'll include a version in the next post that extracts the version number properly. UPDATE: Sorry if you saw the unformatted version of this earlier, I'm on a quest to find blog software that ACTUALLY WORKS.

  Read the article

• Using stdint.h and ANSI printf?

  - by nn

  Hi, I'm writing a bignum library, and I want to use efficient data types to represent the digits. Particularly integer for the digit, and long (if strictly double the size of the integer) for intermediate representations when adding and multiplying. I will be using some C99 functionality, but trying to conform to ANSI C. Currently I have the following in my bignum library: #include <stdint.h> #if defined(__LP64__) || defined(__amd64) || defined(__x86_64) || defined(__amd64__) || defined(__amd64__) || defined(_LP64) typedef uint64_t u_w; typedef uint32_t u_hw; #define BIGNUM_DIGITS 2048 #define U_HW_BITS 16 #define U_W_BITS 32 #define U_HW_MAX UINT32_MAX #define U_HW_MIN UINT32_MIN #define U_W_MAX UINT64_MAX #define U_W_MIN UINT64_MIN #else typedef uint32_t u_w; typedef uint16_t u_hw; #define BIGNUM_DIGITS 4096 #define U_HW_BITS 16 #define U_W_BITS 32 #define U_HW_MAX UINT16_MAX #define U_HW_MIN UINT16_MIN #define U_W_MAX UINT32_MAX #define U_W_MIN UINT32_MIN #endif typedef struct bn { int sign; int n_digits; // #digits should exclude carry (digits = limbs) int carry; u_hw tab[BIGNUM_DIGITS]; } bn; As I haven't written a procedure to write the bignum in decimal, I have to analyze the intermediate array and printf the values of each digit. However I don't know which conversion specifier to use with printf. Preferably I would like to write to the terminal the digit encoded in hexadecimal. The underlying issue is, that I want two data types, one that is twice as long as the other, and further use them with printf using standard conversion specifiers. It would be ideal if int is 32bits and long is 64bits but I don't know how to guarantee this using a preprocessor, and when it comes time to use functions such as printf that solely rely on the standard types I no longer know what to use.

  Read the article

• Improving the performance of XSL

  - by Rachel

  I am using the below XSL 2.0 code to find the ids of the text nodes that contains the list of indices that i give as input. the code works perfectly but in terms for performance it is taking a long time for huge files. Even for huge files if the index values are small then the result is quick in few ms. I am using saxon9he Java processor to execute the XSL. <xsl:variable name="insert-data" as="element(data)*"> <xsl:for-each-group select="doc($insert-file)/insert-data/data" group-by="xsd:integer(@index)"> <xsl:sort select="current-grouping-key()"/> <data index="{current-grouping-key()}" text-id="{generate-id( $main-root/descendant::text()[ sum((preceding::text(), .)/string-length(.)) ge current-grouping-key() ][1] )}"> <xsl:copy-of select="current-group()/node()"/> </data> </xsl:for-each-group> </xsl:variable> In the above solution if the index value is too huge say 270962 then the time taken for the XSL to execute is 83427ms. In huge files if the index value is huge say 4605415, 4605431 it takes several minutes to execute. Seems the computation of the variable "insert-data" takes time though it is a global variable and computed only once. Should the XSL be addessed or the processor? How can i improve the performance of the XSL.

  Read the article

• authentication question (security code generation logic)

  - by Stick it to THE MAN

  I have a security number generator device, small enough to go on a key-ring, which has a six digit LCD display and a button. After I have entered my account name and password on an online form, I press the button on the security device and enter the security code number which is displayed. I get a different number every time I press the button and the number generator has a serial number on the back which I had to input during the account set-up procedure. I would like to incorporate similar functionality in my website. As far as I understand, these are the main components: Generate a unique N digit aplha-numeric sequence during registration and assign to user (permanently) Allow user to generate an N (or M?) digit aplha-numeric sequence remotely For now, I dont care about the hardware side, I am only interested in knowing how I may choose a suitable algorithm that will allow the user to generate an N (or M?) long aplha-numeric sequence - presumably, using his unique ID as a seed Identify the user from the number generated in step 2 (which decryption method is the most robust to do this?) I have the following questions: Have I identified all the steps required in such an authentication system?, if not please point out what I have missed and why it is important What are the most robust encryption/decryption algorithms I can use for steps 1 through 3 (preferably using 64bits)?

  Read the article

• question about LSD radix sort

  - by davit-datuashvili

  hello i have following code public class LSD{ public static int R=1<<8; public static int bytesword=4; public static void radixLSD(int a[],int l,int r){ int aux[]=new int[a.length]; for (int d=bytesword-1;d>=0;d--){ int i, j; int count[]=new int[R+1]; for ( j=0;j<R;j++) count[j]=0; for (i=l;i<=r;i++) count[digit(a[i],d)+1]++; for (j=1;j<R;j++) count[j]+=count[j-1]; for (i=l;i<=r;i++) aux[count[digit(a[i],d)]++]=a[i]; for (i=l;i<=r;i++) a[i]=aux[i-1]; } } public static void main(String[]args){ int a[]=new int[]{3,6,5,7,4,8,9}; radixLSD(a,0,a.length-1); for (int i=0;i<a.length;i++){ System.out.println(a[i]); } } public static int digit(int n,int d){ return (n>>d)&1; } } but it show me mistake java.lang.ArrayIndexOutOfBoundsException: -1 at LSD.radixLSD(LSD.java:19) at LSD.main(LSD.java:29) please help me

  Read the article

• Code Golf: Find the possible ways on a numpad

  - by ikar

  I was bored today at school and so I tried to amuse myself using my calculator and a "game" I've invented which isn't really a game but keeps the boringness away. Also some time has passed since the last real code-golf here, so I decided to create this one. Imagine a simplified numpad like you know it from your phone (I'll leave the 0 out for this code-golf as it kinda destroys all the fun) 1 2 3 4 5 6 7 8 9 Now the rules of the game were always: At the end every digit must have been visited exactly once You can start at any digit you want You can always move one digit up, down, left or right. You can't move diagonally! There a quite a lot of possible ways (or not; I haven't found out yet), here some trivial examples: > > v v < < > > | The output of the golf-program should look something like the above, I'll try to explain: Symbols: Go right < Go left ^ Go up v Go down | End of the way Example solutions: (Program output can either be the numbers pressed in the right order from beginning point to end, or an (ASCII) picture like above) 147852369 569874123 523698741 So if we speak out the example above it would be: Start at 1, move right to 2, move right to 3, go down to 6, go left to 5, go left to 4, go down to 7, go right to 8 then go right to 9 and we are finished! Now there are many different ways possible: You could as well start at 5 and go around it in a circle. So the task would be: Write a program that can compute (using brute-force or whatever) the possible solutions for the numpad problem described above. (Friendly rethorical question with smiley removed because it made some people think that this is homework)

  Read the article

• Coding style in .NET: whether to refactor into new method or not?

  - by Dione

  Hi As you aware, in .NET code-behind style, we already use a lot of function to accommodate those _Click function, _SelectedIndexChanged function etc etc. In our team there are some developer that make a function in the middle of .NET function, for example: public void Button_Click(object sender, EventArgs e) {     some logic here..     some logic there..     DoSomething();     DoSomethingThere();     another logic here..     DoOtherSomething(); } private void DoSomething() { } private void DoSomethingThere() { } private void DoOtherSomething() { } public void DropDown_SelectedIndexChanged() { } public void OtherButton_Click() { } and the function listed above is only used once in that function and not used anywhere else in the page, or called from other part of the solution. They said it make the code more tidier by grouping them and extract them into additional sub-function. I can understand if the sub-function is use over and over again in the code, but if it is only use once, then I think it is not really a good idea to extract them into sub-function, as the code getting bigger and bigger, when you look into the page and trying to understand the logic or to debug by skimming through line by line, it will make you confused by jumping from main function to the sub-function then to main function and to sub-function again. I know this kind of grouping by method is better when you writing old ASP or Cold fusion style, but I am not sure if this kind of style is better for .NET or not. Question is: which is better when you developing .NET, is grouping similar logic into a sub-method better (although they only use once), or just put them together inside main function and add //explanation here on the start of the logic is better? Hope my question is clear enough. Thanks.

  Read the article

• expected identifier or '(' before '{' token in Flex

  - by user1829177

  I am trying to use Flex to parse 'C' source code. Unfortunately I am getting the error "expected identifier or '(' before '{' token" on lines 1,12,13,14... . Any ideas why? %{ %} digit [0-9] letter [a-zA-Z] number (digit)+ id (letter|_)(letter|digit|_)* integer (int) character (char) comma [,] %% {integer} {return INT;} {character} {return CHAR;} {number} {return NUM;} {id} {return IDENTIFIER;} {comma} {return ',';} [-+*/] {return *yytext;} . {} %% main() { yylex(); } The corresponding flex file is as shown below: %{ #include <ctype.h> #include <stdio.h> #include "myhead.h" #include "mini.l" #define YYSTYPE double # undef fprintf %} %token INT %token CHAR %token IDENTIFIER %token NUM %token ',' %left '+' '-' %left '*' '/' %right UMINUS %% lines:lines expr '\n' {printf("%g\n",$2);} |lines '\n' |D | ; expr :expr '*' expr {$$=$1*$3;} |expr '/' expr {$$=$1/$3;} |expr '+' expr {$$=$1+$3;} |expr '-' expr {$$=$1+$3;} |'(' expr ')' {$$=$2;} |'-' expr %prec UMINUS {$$=-$2;} |IDENTIFIER {} |NUM {} ; T :INT {} |CHAR {} ; L :L ',' IDENTIFIER {} |IDENTIFIER {} ; D :T L {printf("T is %g, L is %g",$1,$2);} ; %% /*void yyerror (char *s) { fprintf (stderr, "%s\n", s); } */ I am compiling the generated code using the command: gcc my_file.c -ly

  Read the article

• Large invoice database structure and rendering

  - by user132624

  Our client has a MS SQL database that has 1 million customer invoice records in it. Using the database, our client wants its customers to be able to log into a frontend web site and then be able to view, modify and download their company’s invoices. Given the size of the database and the large number of customers who may log into the web site at any time, we are concerned about data base engine performance and web page invoice rendering performance. The 1 million invoice database is for just 90 days sales, so we will remove invoices over 90 days old from the database. Most of the invoices have multiple line items. We can easily convert our invoices into various data formats so for example it is easy for us to convert to and from SQL to XML with related schema and XSLT. Any data conversion would be done on another server so as not to burden the web interface server. We have tentatively decided to run the web site on a .NET Framework IIS web server using MS SQL on MS Azure. How would you suggest we structure our database for best performance? For example, should we put all the invoices of all customers located within the same 5 digit or 6 digit zip codes into the same table? Or could we set up a separate home directory for each customer on IIS and place each customer’s invoices in each customer’s home directory in XML format? And secondly what would you suggest would be the best method to render customer invoices on a web page and allow customers to modify for best performance? The ADO.net XML Data Set looks intriguing to us as a method, but we have never used it.

  Read the article

• Handling extremely large numbers in a language which can't?

  - by Mallow

  I'm trying to think about how I would go about doing calculations on extremely large numbers (to infinitum - intergers no floats) if the language construct is incapable of handling numbers larger than a certain value. I am sure I am not the first nor the last to ask this question but the search terms I am using aren't giving me an algorithm to handle those situations. Rather most suggestions offer a language change or variable change, or talk about things that seem irrelevant to my search. So I need a little guideance. I would sketch out an algorithm like this: Determine the max length of the integer variable for the language. If a number is more than half the length of the max length of the variable split it in an array. (give a little play room) Array order [0] = the numbers most to the right [n-max] = numbers most to the left Ex. Num: 29392023 Array[0]:23, Array[1]: 20, array[2]: 39, array[3]:29 Since I established half the length of the variable as the mark off point I can then calculate the ones, tenths, hundredths, etc. Place via the halfway mark so that if a variable max length was 10 digits from 0 to 9999999999 then I know that by halfing that to five digits give me some play room. So if I add or multiply I can have a variable checker function that see that the sixth digit (from the right) of array[0] is the same place as the first digit (from the right) of array[1]. Dividing and subtracting have their own issues which I haven't thought about yet. I would like to know about the best implementations of supporting larger numbers than the program can.

  Read the article

• Rails time stamps on images in CSS

  - by brad

  Just posted this on Stack but realized it may be more appropriate here: So Rails time stamping is great. I'm using it to add expires headers to all files that end in the 10 digit timestamp. Most of my images however are referenced in my CSS. Has anyone come across any method that allows for timestamps to be added to CSS referenced images, or some funky re-write rule that achieves this? I'd love for ALL images in my site, both inline and in css to have this timestamp so I can tell the browser to cache them, but refresh any time the file itself changes. I couldn't find anything on the net regarding this and I can't believe this isn't a more frequently discussed topic. I don't think my setup will matter because the actual expiring will hopefully happen the same way, based on the 10 digit timestamp, but I'm using apache to serve all static content if that matters

  Read the article

• Excel 2010 started changing my numbers

  - by Going Crazy

  If I type in a 16 digit number (format: number, no decimals) it changes the number on me. Example: 1234567812345678 changes the view to 1234567812345670. If I type it in as a general format it changes the numbers above so it displays 1.23457E+15 but if you click on the cell, the display shows the last digit as a 0 instead of an 8 once again. I opened the file on a different computer and same issue now with it. I have changed the auto correcting and auto formating all to no avail. Help!

  Read the article

• How to select all ActiveX objects in an area using a mouse in Excel?

  - by enderland

  Because of this problem with ActiveX objects changing size, I am not grouping my ActiveX objects in my Excel worksheet. Grouping them causes my solution hack to not work which is quite annoying. However, I often times want to be able to essentially use the mouse and select a region and then select all ActiveX objects contained in the region. This would also be useful for easily selecting objects to group them initially. Basically: Use mouse to select area Automatically select all ActiveX components in region I'm fine with a VBA solution if needed. How can I do this?

  Read the article

• Can't remove Enter_Frame and stop TimerEvent

  - by Hwang

  I wanted to remove an ENTER_FRAME object and stopping an TimerEvent when I click on a button, and rerun ENTER_FRAME and TimerEvent when I click on another button. I've tried removeAddEventListener and stop() for the time, but I won't work. Any idea whats the problem here? package{ import flash.display.MovieClip; import flash.display.DisplayObject; import flash.events.Event; import flash.events.TimerEvent; import flash.utils.Timer; public class clockFunction extends MovieClip { private var clock:clockMC=new clockMC(); private var countdownTimer:Timer; //seconds private var secTop1=clock.second.top1.digit; private var secTop2=clock.second.top2.digit; private var secBot1=clock.second.bot1.digit; private var secBot2=clock.second.bot2.digit; private var seconds:Number; private var minutes:Number; private var hours:Number; private var days:Number; public function clockFunction():void { decrease(); addChild(clock); } private function decrease():void { countdownTimer=new Timer(1000); //Adding an event listener to the timer object countdownTimer.addEventListener(TimerEvent.TIMER,updateTime); //Initializing timer object //countdownTimer.start(); } private function updateTime(event:TimerEvent):void { decreasTimerFunction(); clock.second.play(); if (seconds==1) { clock.minute.play(); } if ((minutes==1)&&(seconds==1)) { clock.hour.play(); } if ((hours==1)&&(minutes==1)&&(seconds==1)) { clock.day.play(); } } //Setting it back to its correct time so it won't have number changing in between of flipping issues. private function detect(event:Event):void { //seconds var sec1=seconds; var sec2=seconds-1; if (sec1<10) { sec1="0"+sec1; } if (sec2<10) { sec2="0"+sec2; } if (sec1==00) { sec2=59; } secTop1.text=sec1; secTop2.text=sec2; secBot1.text=sec1; secBot2.text=sec2; } public function startTime():void { addEventListener(Event.ENTER_FRAME,detect); countdownTimer.start(); trace("start"); } public function stopTime():void { countdownTimer.stop(); removeEventListener(Event.ENTER_FRAME,detect); trace("stop"); } private function decreasTimerFunction():void { //Create a date object for Christmas Morning var endTime:Date=new Date(2010,3,26,20,0,0); //Current date object var now:Date=new Date(); // Set the difference between the two date and times in milliseconds var timeDiff:Number=endTime.getTime()-now.getTime(); seconds=Math.floor(timeDiff/1000); minutes=Math.floor(seconds/60); hours=Math.floor(minutes/60); days=Math.floor(hours/24); // Set the remainder of the division vars above hours%=24; minutes%=60; seconds%=60; } } }

  Read the article

• C#/.NET Little Wonders: The Joy of Anonymous Types

  - by James Michael Hare

  Once again, in this series of posts I look at the parts of the .NET Framework that may seem trivial, but can help improve your code by making it easier to write and maintain. The index of all my past little wonders posts can be found here. In the .NET 3 Framework, Microsoft introduced the concept of anonymous types, which provide a way to create a quick, compiler-generated types at the point of instantiation.  These may seem trivial, but are very handy for concisely creating lightweight, strongly-typed objects containing only read-only properties that can be used within a given scope. Creating an Anonymous Type In short, an anonymous type is a reference type that derives directly from object and is defined by its set of properties base on their names, number, types, and order given at initialization.  In addition to just holding these properties, it is also given appropriate overridden implementations for Equals() and GetHashCode() that take into account all of the properties to correctly perform property comparisons and hashing.  Also overridden is an implementation of ToString() which makes it easy to display the contents of an anonymous type instance in a fairly concise manner. To construct an anonymous type instance, you use basically the same initialization syntax as with a regular type.  So, for example, if we wanted to create an anonymous type to represent a particular point, we could do this: 1: var point = new { X = 13, Y = 7 }; Note the similarity between anonymous type initialization and regular initialization.  The main difference is that the compiler generates the type name and the properties (as readonly) based on the names and order provided, and inferring their types from the expressions they are assigned to. It is key to remember that all of those factors (number, names, types, order of properties) determine the anonymous type.  This is important, because while these two instances share the same anonymous type: 1: // same names, types, and order 2: var point1 = new { X = 13, Y = 7 }; 3: var point2 = new { X = 5, Y = 0 }; These similar ones do not: 1: var point3 = new { Y = 3, X = 5 }; // different order 2: var point4 = new { X = 3, Y = 5.0 }; // different type for Y 3: var point5 = new {MyX = 3, MyY = 5 }; // different names 4: var point6 = new { X = 1, Y = 2, Z = 3 }; // different count Limitations on Property Initialization Expressions The expression for a property in an anonymous type initialization cannot be null (though it can evaluate to null) or an anonymous function.  For example, the following are illegal: 1: // Null can't be used directly. Null reference of what type? 2: var cantUseNull = new { Value = null }; 3:  4: // Anonymous methods cannot be used. 5: var cantUseAnonymousFxn = new { Value = () => Console.WriteLine(“Can’t.”) }; Note that the restriction on null is just that you can’t use it directly as the expression, because otherwise how would it be able to determine the type?  You can, however, use it indirectly assigning a null expression such as a typed variable with the value null, or by casting null to a specific type: 1: string str = null; 2: var fineIndirectly = new { Value = str }; 3: var fineCast = new { Value = (string)null }; All of the examples above name the properties explicitly, but you can also implicitly name properties if they are being set from a property, field, or variable.  In these cases, when a field, property, or variable is used alone, and you don’t specify a property name assigned to it, the new property will have the same name.  For example: 1: int variable = 42; 2:  3: // creates two properties named varriable and Now 4: var implicitProperties = new { variable, DateTime.Now }; Is the same type as: 1: var explicitProperties = new { variable = variable, Now = DateTime.Now }; But this only works if you are using an existing field, variable, or property directly as the expression.  If you use a more complex expression then the name cannot be inferred: 1: // can't infer the name variable from variable * 2, must name explicitly 2: var wontWork = new { variable * 2, DateTime.Now }; In the example above, since we typed variable * 2, it is no longer just a variable and thus we would have to assign the property a name explicitly. ToString() on Anonymous Types One of the more trivial overrides that an anonymous type provides you is a ToString() method that prints the value of the anonymous type instance in much the same format as it was initialized (except actual values instead of expressions as appropriate of course). For example, if you had: 1: var point = new { X = 13, Y = 42 }; And then print it out: 1: Console.WriteLine(point.ToString()); You will get: 1: { X = 13, Y = 42 } While this isn’t necessarily the most stunning feature of anonymous types, it can be handy for debugging or logging values in a fairly easy to read format. Comparing Anonymous Type Instances Because anonymous types automatically create appropriate overrides of Equals() and GetHashCode() based on the underlying properties, we can reliably compare two instances or get hash codes.  For example, if we had the following 3 points: 1: var point1 = new { X = 1, Y = 2 }; 2: var point2 = new { X = 1, Y = 2 }; 3: var point3 = new { Y = 2, X = 1 }; If we compare point1 and point2 we’ll see that Equals() returns true because they overridden version of Equals() sees that the types are the same (same number, names, types, and order of properties) and that the values are the same.   In addition, because all equal objects should have the same hash code, we’ll see that the hash codes evaluate to the same as well: 1: // true, same type, same values 2: Console.WriteLine(point1.Equals(point2)); 3:  4: // true, equal anonymous type instances always have same hash code 5: Console.WriteLine(point1.GetHashCode() == point2.GetHashCode()); However, if we compare point2 and point3 we get false.  Even though the names, types, and values of the properties are the same, the order is not, thus they are two different types and cannot be compared (and thus return false).  And, since they are not equal objects (even though they have the same value) there is a good chance their hash codes are different as well (though not guaranteed): 1: // false, different types 2: Console.WriteLine(point2.Equals(point3)); 3:  4: // quite possibly false (was false on my machine) 5: Console.WriteLine(point2.GetHashCode() == point3.GetHashCode()); Using Anonymous Types Now that we’ve created instances of anonymous types, let’s actually use them.  The property names (whether implicit or explicit) are used to access the individual properties of the anonymous type.  The main thing, once again, to keep in mind is that the properties are readonly, so you cannot assign the properties a new value (note: this does not mean that instances referred to by a property are immutable – for more information check out C#/.NET Fundamentals: Returning Data Immutably in a Mutable World). Thus, if we have the following anonymous type instance: 1: var point = new { X = 13, Y = 42 }; We can get the properties as you’d expect: 1: Console.WriteLine(“The point is: ({0},{1})”, point.X, point.Y); But we cannot alter the property values: 1: // compiler error, properties are readonly 2: point.X = 99; Further, since the anonymous type name is only known by the compiler, there is no easy way to pass anonymous type instances outside of a given scope.  The only real choices are to pass them as object or dynamic.  But really that is not the intention of using anonymous types.  If you find yourself needing to pass an anonymous type outside of a given scope, you should really consider making a POCO (Plain Old CLR Type – i.e. a class that contains just properties to hold data with little/no business logic) instead. Given that, why use them at all?  Couldn’t you always just create a POCO to represent every anonymous type you needed?  Sure you could, but then you might litter your solution with many small POCO classes that have very localized uses. It turns out this is the key to when to use anonymous types to your advantage: when you just need a lightweight type in a local context to store intermediate results, consider an anonymous type – but when that result is more long-lived and used outside of the current scope, consider a POCO instead. So what do we mean by intermediate results in a local context?  Well, a classic example would be filtering down results from a LINQ expression.  For example, let’s say we had a List<Transaction>, where Transaction is defined something like: 1: public class Transaction 2: { 3: public string UserId { get; set; } 4: public DateTime At { get; set; } 5: public decimal Amount { get; set; } 6: // … 7: } And let’s say we had this data in our List<Transaction>: 1: var transactions = new List<Transaction> 2: { 3: new Transaction { UserId = "Jim", At = DateTime.Now, Amount = 2200.00m }, 4: new Transaction { UserId = "Jim", At = DateTime.Now, Amount = -1100.00m }, 5: new Transaction { UserId = "Jim", At = DateTime.Now.AddDays(-1), Amount = 900.00m }, 6: new Transaction { UserId = "John", At = DateTime.Now.AddDays(-2), Amount = 300.00m }, 7: new Transaction { UserId = "John", At = DateTime.Now, Amount = -10.00m }, 8: new Transaction { UserId = "Jane", At = DateTime.Now, Amount = 200.00m }, 9: new Transaction { UserId = "Jane", At = DateTime.Now, Amount = -50.00m }, 10: new Transaction { UserId = "Jaime", At = DateTime.Now.AddDays(-3), Amount = -100.00m }, 11: new Transaction { UserId = "Jaime", At = DateTime.Now.AddDays(-3), Amount = 300.00m }, 12: }; So let’s say we wanted to get the transactions for each day for each user.  That is, for each day we’d want to see the transactions each user performed.  We could do this very simply with a nice LINQ expression, without the need of creating any POCOs: 1: // group the transactions based on an anonymous type with properties UserId and Date: 2: byUserAndDay = transactions 3: .GroupBy(tx => new { tx.UserId, tx.At.Date }) 4: .OrderBy(grp => grp.Key.Date) 5: .ThenBy(grp => grp.Key.UserId); Now, those of you who have attempted to use custom classes as a grouping type before (such as GroupBy(), Distinct(), etc.) may have discovered the hard way that LINQ gets a lot of its speed by utilizing not on Equals(), but also GetHashCode() on the type you are grouping by.  Thus, when you use custom types for these purposes, you generally end up having to write custom Equals() and GetHashCode() implementations or you won’t get the results you were expecting (the default implementations of Equals() and GetHashCode() are reference equality and reference identity based respectively). As we said before, it turns out that anonymous types already do these critical overrides for you.  This makes them even more convenient to use!  Instead of creating a small POCO to handle this grouping, and then having to implement a custom Equals() and GetHashCode() every time, we can just take advantage of the fact that anonymous types automatically override these methods with appropriate implementations that take into account the values of all of the properties. Now, we can look at our results: 1: foreach (var group in byUserAndDay) 2: { 3: // the group’s Key is an instance of our anonymous type 4: Console.WriteLine("{0} on {1:MM/dd/yyyy} did:", group.Key.UserId, group.Key.Date); 5:  6: // each grouping contains a sequence of the items. 7: foreach (var tx in group) 8: { 9: Console.WriteLine("\t{0}", tx.Amount); 10: } 11: } And see: 1: Jaime on 06/18/2012 did: 2: -100.00 3: 300.00 4:  5: John on 06/19/2012 did: 6: 300.00 7:  8: Jim on 06/20/2012 did: 9: 900.00 10:  11: Jane on 06/21/2012 did: 12: 200.00 13: -50.00 14:  15: Jim on 06/21/2012 did: 16: 2200.00 17: -1100.00 18:  19: John on 06/21/2012 did: 20: -10.00 Again, sure we could have just built a POCO to do this, given it an appropriate Equals() and GetHashCode() method, but that would have bloated our code with so many extra lines and been more difficult to maintain if the properties change.  Summary Anonymous types are one of those Little Wonders of the .NET language that are perfect at exactly that time when you need a temporary type to hold a set of properties together for an intermediate result.  While they are not very useful beyond the scope in which they are defined, they are excellent in LINQ expressions as a way to create and us intermediary values for further expressions and analysis. Anonymous types are defined by the compiler based on the number, type, names, and order of properties created, and they automatically implement appropriate Equals() and GetHashCode() overrides (as well as ToString()) which makes them ideal for LINQ expressions where you need to create a set of properties to group, evaluate, etc. Technorati Tags: C#,CSharp,.NET,Little Wonders,Anonymous Types,LINQ

  Read the article

• WPF Binding to DataRow Columns

  - by Trindaz

  Hi, I've taken some sample code from http://sweux.com/blogs/smoura/index.php/wpf/2009/06/15/wpf-toolkit-datagrid-part-iv-templatecolumns-and-row-grouping/ that provides grouping of data in a WPF DataGrid. I'm modifying the example to use a DataTable instead of a Collection of entities. My problem is in translating a binding declaration {Binding Parent.IsExpanded}, which works fine where Parent is a reference to an entity that has the IsExpanded attribute, to something that will work for my weakly typed DataTable, where Parent is the name of a column and references another DataRow in the same DataTable. I've tried declarations like {Binding Parent.Items[IsExpanded]} and {Binding Parent("IsExpanded")} but none of these seem to work. How can I create a binding to the IsExpanded column of the DataRow Parent in my DataTable? Thanks in advance, Dave

  Read the article

• Convert a Julian Date to Regular Calendar Date

  - by Mark Acosta

  How do I convert a 7-digit julian date into a format like MM/dd/yyy?

  Read the article

• This antlr example is not working properly

  - by Aftershock

  Hi, This ANTLR example does not parse input "1;" . Can you explain why? It parses "11;". grammar test; options {//language = 'CSharp2'; //language = 'Java'; output=AST; } expr : mexpr (PLUS^ mexpr)* SEMI! ; mexpr : atom (STAR^ atom)* ; atom: INT ; //class csharpTestLexer extends Lexer; WS : (' ' | '\t' | '\n' | '\r') { $channel = HIDDEN; } ; LPAREN: '(' ; RPAREN: ')' ; STAR: '*' ; PLUS: '+' ; SEMI: ';' ; protected DIGIT : '0'..'9' ; INT : (DIGIT)+ ;

  Read the article

• In PHP how do I complete a regex that returns only what was grouped

  - by maestrojed

  I want to perform a regex using grouping. I am only interested in the grouping, its all I want returned. Is this possible? $haystack = '<a href="/foo.php">Go To Foo</a>'; $needle = '/href="(.*)">/'; preg_match($needle,$haystack,$matches); print_r($matches); //Outputs //Array ( [0] => href="/foo.php"> [1] => /foo.php ) //I want: //Array ( [0] => /foo.php )

  Read the article

• URL BNF search part does not make sense

  - by Asaf Mesika

  Hi, While implementing a Java regular expression for URL based on the URL BNF published by W3C, I've failed to understand the search part. As quoted: httpaddress h t t p : / / hostport [ / path ] [ ? search ] search xalphas [ + search ] xalphas xalpha [ xalphas ] xalpha alpha | digit | safe | extra | escape alpha a | b | c | d | e | f | g | h | i | j | k | l | m | n | o | p | q | r | s | t | u | v | w | x | y | z | A | B | C | D | E | F | G | H | I | J | K | L | M | N | O | P | Q | R | digit 0 |1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 safe $ | - | _ | @ | . | & | + | - extra ! | * | " | ' | ( | ) | , Search claims it is xalphas seperated by a plus sign. xalphas can contain plus signs by it self, as claimed by safe. Thus according to my understanding , it should be: search xalphas Where am I wrong here?

  Read the article

< Previous Page | 14 15 16 17 18 19 20 21 22 23 24 25  | Next Page >