private String bigIntToHexString(BigInteger bi) {
StringBuffer buf = new StringBuffer();
buf.append("0x");
String val = bi.toString(16);
for (int i = 0; i < ((2 * addressSize) - val.length()); i++) {
buf.append('0');
}
buf.append(val);
return buf.toString();
}
void work() {
cin = new Scanner(System.in);
int n = cin.nextInt();
BigInteger a = BigInteger.ONE;
BigInteger b = BigInteger.ONE;
n -= 1;
for (int i = 0; i < n; i++) {
BigInteger c = a.add(b);
a = b;
b = c;
}
System.out.println(b.toString());
}
public static void abcd(String str) {
BigInteger sum = BigInteger.ZERO;
StringBuffer n = new StringBuffer("");
for (int i = 0; i < str.length(); i++) {
BigInteger ab = BigInteger.valueOf(((int) str.charAt(i)) - 96);
sum = sum.add(div.pow(str.length() - i - 1).multiply(ab));
}
String s = sum.toString();
for (int i = 0; i < s.length(); i++) {
if (i % 3 == 0 && i != 0) n.insert(0, ",");
n.insert(0, s.charAt(s.length() - i - 1));
}
while (str.length() < 22) str = str + " ";
System.out.println(str + "" + n);
}
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
n = in.nextInt();
l = new BigInteger(in.next());
k = in.nextInt();
m = in.nextInt();
BigInteger w = BigInteger.TEN.pow(m);
for (int i = 0; i <= n; ++i) a[i] = new BigInteger(in.next());
for (int i = 0; i < Math.min(k, n + 1); ++i) {
t = a[0];
for (int j = 1; j <= n; ++j) {
t = t.multiply(l);
t = t.add(a[j]);
}
t = t.mod(w);
q[n][i] = t.mod(w);
int ret = 0;
c = t.toString().toCharArray();
int ll = c.length;
for (int j = 0; j < Math.min(m, ll); ++j) {
ret += (c[ll - 1 - j] - '0') * (c[ll - 1 - j] - '0');
}
System.out.println(ret);
l = l.add(BigInteger.ONE);
}
if (k > n) {
for (int i = n - 1; i >= 0; --i) {
for (int j = 0; j <= i; j++) q[i][j] = q[i + 1][j + 1].subtract(q[i + 1][j]).mod(w);
}
for (int i = 1; i <= n; ++i) q[0][i] = q[0][0];
int po = 1;
for (int i = n + 1; i < k; ++i) {
for (int j = 1; j <= n; ++j)
q[j][(po + j) % (n + 1)] =
q[j - 1][(po + j - 1) % (n + 1)].add(q[j][(po + j - 1) % (n + 1)]).mod(w);
int ret = 0;
c = q[n][(po + n) % (n + 1)].mod(w).toString().toCharArray();
int ll = c.length;
for (int j = 0; j < Math.min(m, ll); ++j) {
ret += (c[ll - 1 - j] - '0') * (c[ll - 1 - j] - '0');
}
System.out.println(ret);
l = l.add(BigInteger.ONE);
++po;
}
}
}
public String getKDigits(int N, int K) {
BigInteger ret = new BigInteger("1");
BigInteger ten = new BigInteger("10");
for (int i = 1; i <= N; i++) {
ret = ret.multiply(new BigInteger(new Integer(i).toString()));
}
System.out.println(ret);
while (ret.mod(ten).equals(BigInteger.ZERO)) ret = ret.divide(ten);
String ans = ret.toString();
if (ans.length() > K) {
ans = ans.substring(ans.length() - K, ans.length());
}
return ans;
}
public static void main(String[] args) throws IOException {
Scanner scanner = new Scanner(new BufferedInputStream(System.in));
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
while (scanner.hasNextInt()) {
int n = scanner.nextInt();
int k = scanner.nextInt();
BigInteger sum = BigInteger.ONE;
for (int i = n; i > n - k; i--) {
sum = sum.multiply(BigInteger.valueOf(i));
}
for (int i = 2; i <= k; i++) {
sum = sum.divide(BigInteger.valueOf(i));
}
System.out.println(sum.toString().length());
}
}
public static String md5(File file)
throws NoSuchAlgorithmException, FileNotFoundException, IOException {
MessageDigest md = MessageDigest.getInstance("MD5");
InputStream is = new FileInputStream(file);
byte[] buffer = new byte[8192];
int read = 0;
while ((read = is.read(buffer)) > 0) md.update(buffer, 0, read);
byte[] md5 = md.digest();
BigInteger bi = new BigInteger(1, md5);
is.close();
String hex = bi.toString(16);
while (hex.length() < 32) {
hex = "0" + hex;
} // Padding
return hex;
}
public String toString() {
String res = num.toString();
if (den.compareTo(BigInteger.ONE) != 0) res += "/" + den.toString();
return res;
}
/** @see BigInteger#toString(int) */
static String bigInteger2String(BigInteger val, int radix) {
int sign = val.sign;
int numberLength = val.numberLength;
int digits[] = val.digits;
if (sign == 0) {
return "0"; //$NON-NLS-1$
}
if (numberLength == 1) {
int highDigit = digits[numberLength - 1];
long v = highDigit & 0xFFFFFFFFL;
if (sign < 0) {
v = -v;
}
return Long.toString(v, radix);
}
if ((radix == 10) || (radix < Character.MIN_RADIX) || (radix > Character.MAX_RADIX)) {
return val.toString();
}
double bitsForRadixDigit;
bitsForRadixDigit = Math.log(radix) / Math.log(2);
int resLengthInChars =
(int) (val.abs().bitLength() / bitsForRadixDigit + ((sign < 0) ? 1 : 0)) + 1;
char result[] = new char[resLengthInChars];
int currentChar = resLengthInChars;
int resDigit;
if (radix != 16) {
int temp[] = new int[numberLength];
System.arraycopy(digits, 0, temp, 0, numberLength);
int tempLen = numberLength;
int charsPerInt = digitFitInInt[radix];
int i;
// get the maximal power of radix that fits in int
int bigRadix = bigRadices[radix - 2];
while (true) {
// divide the array of digits by bigRadix and convert remainders
// to characters collecting them in the char array
resDigit = Division.divideArrayByInt(temp, temp, tempLen, bigRadix);
int previous = currentChar;
do {
result[--currentChar] = Character.forDigit(resDigit % radix, radix);
} while (((resDigit /= radix) != 0) && (currentChar != 0));
int delta = charsPerInt - previous + currentChar;
for (i = 0; i < delta && currentChar > 0; i++) {
result[--currentChar] = '0';
}
for (i = tempLen - 1; (i > 0) && (temp[i] == 0); i--) {;
}
tempLen = i + 1;
if ((tempLen == 1) && (temp[0] == 0)) { // the quotient is 0
break;
}
}
} else {
// radix == 16
for (int i = 0; i < numberLength; i++) {
for (int j = 0; (j < 8) && (currentChar > 0); j++) {
resDigit = digits[i] >> (j << 2) & 0xf;
result[--currentChar] = Character.forDigit(resDigit, 16);
}
}
}
while (result[currentChar] == '0') {
currentChar++;
}
if (sign == -1) {
result[--currentChar] = '-';
}
return new String(result, currentChar, resLengthInChars - currentChar);
}
/** Returns a String representation of this MutableBigInteger in radix 10. */
public String toString() {
BigInteger b = new BigInteger(this, 1);
return b.toString();
}
/** This main method basically tests the different features of the Paillier encryption */
public static void test() {
Random rd = new Random();
long num = 0;
long num1 = 0;
BigInteger m = null;
BigInteger c = null;
int numberOfTests = 10;
int j = 0;
BigInteger decryption = null;
Paillier esystem = new Paillier();
PaillierPrivateKey key = KeyGen.PaillierKey(512, 122333356);
esystem.setDecryptEncrypt(key);
// let's test our algorithm by encrypting and decrypting a few instances
for (int i = 0; i < numberOfTests; i++) {
num = Math.abs(rd.nextLong());
m = BigInteger.valueOf(num);
System.out.println("number chosen : " + m.toString());
c = esystem.encrypt(m);
System.out.println("encrypted value: " + c.toString());
decryption = esystem.decrypt(c);
System.out.println("decrypted value: " + decryption.toString());
if (m.compareTo(decryption) == 0) {
System.out.println("OK");
j++;
} else System.out.println("PROBLEM");
}
System.out.println(
"out of "
+ (new Integer(numberOfTests)).toString()
+ "random encryption,# many of "
+ (new Integer(j)).toString()
+ " has passed");
// Let us check the commutative properties of the paillier encryption
System.out.println("Checking the additive properteries of the Paillier encryption");
// Obviously 1+0=1
System.out.println(
"1+0="
+ (esystem.decrypt(esystem.add(esystem.encryptone(), esystem.encryptzero())))
.toString());
// 1+1=2
System.out.println(
"1+1="
+ (esystem.decrypt(
esystem.add(esystem.encrypt(BigInteger.ONE), esystem.encrypt(BigInteger.ONE))))
.toString());
// 1+1+1=3
System.out.println(
"1+1+1="
+ (esystem.decrypt(
esystem.add(
esystem.add(
esystem.encrypt(BigInteger.ONE), esystem.encrypt(BigInteger.ONE)),
esystem.encrypt(BigInteger.ONE))))
.toString());
// 0+0=0
System.out.println(
"0+0="
+ (esystem.decrypt(
esystem.add(
esystem.encrypt(BigInteger.ZERO), esystem.encrypt(BigInteger.ZERO))))
.toString());
// 1+-1=0
System.out.println(
"1+-1="
+ (esystem.decrypt(
esystem.add(
esystem.encrypt(BigInteger.valueOf(-1).mod(key.getN())),
esystem.encrypt(BigInteger.ONE))))
.toString());
do {
num = rd.nextLong();
} while (key.inModN(BigInteger.valueOf(num)) == false);
do {
num1 = rd.nextLong();
} while (key.inModN(BigInteger.valueOf(num1)) == false);
BigInteger numplusnum1 = BigInteger.valueOf(num).add(BigInteger.valueOf(num1));
BigInteger summodnsquare = numplusnum1.mod(key.getN());
// D(E(num)+E(num1))=num+num1
System.out.println(numplusnum1.toString());
System.out.println(
summodnsquare.toString()
+ "=\n"
+ esystem
.decrypt(
esystem.add(
esystem.encrypt(BigInteger.valueOf(num)),
esystem.encrypt(BigInteger.valueOf(num1))))
.toString());
// Let us check the multiplicative properties
System.out.println("Checking the multiplicative properties");
// D(multiply(E(2),3))=6
System.out.println(
"6="
+ esystem.decrypt(
esystem.multiply(
esystem.add(esystem.encrypt(BigInteger.ONE), esystem.encrypt(BigInteger.ONE)),
3)));
}
/** Converts a binary string to a hexadecimal string */
private String bin2hex(String binary) {
BigInteger hex = new BigInteger(binary, 2);
return hex.toString(16).toUpperCase();
}
/** Converts a hexadecimal string to a binary string */
private String hex2bin(String hex) {
BigInteger bin = new BigInteger(hex.toLowerCase(), 16);
return bin.toString(2);
}
/** Converts a large integer (numeric string) to a binary string */
private String dec2bin(String decimal) {
BigInteger bin = new BigInteger(decimal);
return bin.toString(2);
}
/** Converts a binary string into a large integer (numeric string) */
private String bin2dec(String binary) {
BigInteger dec = new BigInteger(binary, 2);
return dec.toString();
}
/** convert from a particular scheme / level */
private String convertLevel(
Scheme tdtscheme,
Level tdtlevel,
String input,
Map<String, String> inputParameters,
LevelTypeList outboundlevel) {
String outboundstring;
Map<String, String> extraparams =
// new NoisyMap
(new HashMap<String, String>(inputParameters));
// get the scheme's option key, which is the name of a
// parameter whose value is matched to the option key of the
// level.
String optionkey = tdtscheme.getOptionKey();
String optionValue = extraparams.get(optionkey);
// the name of a parameter which allows the appropriate option
// to be selected
// now consider the various options within the scheme and
// level for each option element inside the level, check
// whether the pattern attribute matches as a regular
// expression
String matchingOptionKey = null;
Option matchingOption = null;
Matcher prefixMatcher = null;
for (Enumeration e = tdtlevel.enumerateOption(); e.hasMoreElements(); ) {
Option opt = (Option) e.nextElement();
if (optionValue == null || optionValue.equals(opt.getOptionKey())) {
// possible match
Matcher matcher = Pattern.compile(opt.getPattern()).matcher(input);
if (matcher.matches()) {
if (prefixMatcher != null) throw new TDTException("Multiple patterns matched");
prefixMatcher = matcher;
matchingOptionKey = opt.getOptionKey();
matchingOption = opt;
}
}
}
if (prefixMatcher == null) throw new TDTException("No patterns matched");
optionValue = matchingOptionKey;
for (Enumeration e = matchingOption.enumerateField(); e.hasMoreElements(); ) {
Field field = (Field) e.nextElement();
int seq = field.getSeq();
String strfieldname = field.getName();
int fieldlength = field.getLength();
String strfieldvalue = prefixMatcher.group(seq);
// System.out.println(" processing field " + strfieldname + " = '" + strfieldvalue + "'");
if (field.getCompaction() == null) {
// if compaction is null, treat field as an integer
if (field.getCharacterSet() != null) { // if the character set is specified
Matcher charsetmatcher =
Pattern.compile("^" + field.getCharacterSet() + "$").matcher(strfieldvalue);
if (!charsetmatcher.matches()) {
throw new TDTException(
"field "
+ strfieldname
+ " ("
+ strfieldvalue
+ ") does not conform to the allowed character set ("
+ field.getCharacterSet()
+ ") ");
}
}
BigInteger bigvalue = null;
if (tdtlevel.getType() == LevelTypeList.BINARY) { // if the input was BINARY
bigvalue = new BigInteger(strfieldvalue, 2);
extraparams.put(strfieldname, bigvalue.toString());
} else {
if (field.getDecimalMinimum() != null || field.getDecimalMaximum() != null)
bigvalue = new BigInteger(strfieldvalue);
extraparams.put(strfieldname, strfieldvalue);
}
if (field.getDecimalMinimum() != null) { // if the decimal minimum is specified
BigInteger bigmin = new BigInteger(field.getDecimalMinimum());
if (bigvalue.compareTo(bigmin)
== -1) { // throw an exception if the field value is less than the decimal minimum
throw new TDTException(
"field "
+ strfieldname
+ " ("
+ bigvalue
+ ") is less than DecimalMinimum ("
+ field.getDecimalMinimum()
+ ") allowed");
}
}
if (field.getDecimalMaximum() != null) { // if the decimal maximum is specified
BigInteger bigmax = new BigInteger(field.getDecimalMaximum());
if (bigvalue.compareTo(bigmax)
== 1) { // throw an excpetion if the field value is greater than the decimal maximum
throw new TDTException(
"field "
+ strfieldname
+ " ("
+ bigvalue
+ ") is greater than DecimalMaximum ("
+ field.getDecimalMaximum()
+ ") allowed");
}
}
// after extracting the field, it may be necessary to pad it.
padField(extraparams, field);
} else {
// compaction is specified - interpret binary as a string value using a truncated byte per
// character
CompactionMethodList compaction = field.getCompaction();
PadDirectionList padDir = field.getPadDir();
String padchar = field.getPadChar();
String s;
if (compaction == CompactionMethodList.VALUE_5)
// "5-bit"
s = bin2uppercasefive(strfieldvalue);
else if (compaction == CompactionMethodList.VALUE_4)
// 6-bit
s = bin2alphanumsix(strfieldvalue);
else if (compaction == CompactionMethodList.VALUE_3)
// 7-bit
s = bin2asciiseven(strfieldvalue);
else if (compaction == CompactionMethodList.VALUE_2)
// 8-bit
s = bin2bytestring(strfieldvalue);
else throw new Error("unsupported compaction method " + compaction);
extraparams.put(strfieldname, stripPadChar(s, padDir, padchar));
}
} // for each field;
/**
* the EXTRACT rules are performed after parsing the input, in order to determine additional
* fields that are to be derived from the fields obtained by the pattern match process
*/
int seq = 0;
for (Enumeration e = tdtlevel.enumerateRule(); e.hasMoreElements(); ) {
Rule tdtrule = (Rule) e.nextElement();
if (tdtrule.getType() == ModeList.EXTRACT) {
assert seq < tdtrule.getSeq() : "Rule out of sequence order";
seq = tdtrule.getSeq();
processRules(extraparams, tdtrule);
}
}
/**
* Now we need to consider the corresponding output level and output option. The scheme must
* remain the same, as must the value of optionkey (to select the corresponding option element
* nested within the required outbound level)
*/
Level tdtoutlevel = findLevel(tdtscheme, outboundlevel);
Option tdtoutoption = findOption(tdtoutlevel, optionValue);
/**
* the FORMAT rules are performed before formatting the output, in order to determine additional
* fields that are required for preparation of the outbound format
*/
seq = 0;
for (Enumeration e = tdtoutlevel.enumerateRule(); e.hasMoreElements(); ) {
Rule tdtrule = (Rule) e.nextElement();
if (tdtrule.getType() == ModeList.FORMAT) {
assert seq < tdtrule.getSeq() : "Rule out of sequence order";
seq = tdtrule.getSeq();
processRules(extraparams, tdtrule);
}
}
/**
* Now we need to ensure that all fields required for the outbound grammar are suitably padded
* etc. processPadding takes care of firstly padding the non-binary fields if padChar and
* padDir, length are specified then (if necessary) converting to binary and padding the binary
* representation to the left with zeros if the bit string is has fewer bits than the bitLength
* attribute specifies. N.B. TDTv1.1 will be more specific about bit-level padding rather than
* assuming that it is always to the left with the zero bit.
*/
// System.out.println(" prior to processPadding, " + extraparams);
for (Enumeration e = tdtoutoption.enumerateField(); e.hasMoreElements(); ) {
Field field = (Field) e.nextElement();
// processPadding(extraparams, field, outboundlevel, tdtoutoption);
padField(extraparams, field);
if (outboundlevel == LevelTypeList.BINARY) binaryPadding(extraparams, field);
}
/**
* Construct the output from the specified grammar (in ABNF format) together with the field
* values stored in inputparams
*/
outboundstring = buildGrammar(tdtoutoption.getGrammar(), extraparams);
// System.out.println("final extraparams = " + extraparams);
// System.out.println("returned " + outboundstring);
return outboundstring;
}
