public static ArrayList<BigDecimal> factors(BigDecimal query) {
if (query.equals(new BigDecimal("0"))) {
return null;
}
ArrayList<BigDecimal> factors = new ArrayList<BigDecimal>();
BigDecimal sqrt = sqrt(query);
if (sqrt.remainder(new BigDecimal("1")).equals(new BigDecimal("0"))) {
factors.add(sqrt);
}
for (float i = 1; i < sqrt.floatValue(); i++) {
// simplifying assumption
if (factors.size() > 2) {
break;
}
String m = Float.toString(i);
BigDecimal otherFactor = query.divide(new BigDecimal(m), MathContext.DECIMAL128);
if (query
.divide(new BigDecimal(m), MathContext.DECIMAL128)
.remainder(new BigDecimal(1))
.floatValue()
== 0) {
factors.add(new BigDecimal(m));
factors.add(query.divide(new BigDecimal(m)));
}
}
return factors;
}
public static Comparable<?> remainder(Comparable<?> param1, Comparable<?> param2)
throws ParseException {
if (param1 == null || param2 == null) {
return null;
}
if (param1 instanceof String) {
param1 = parse((String) param1);
}
if (param2 instanceof String) {
param2 = parse((String) param2);
}
if (param1 instanceof Number && param2 instanceof Number) {
// BigInteger type is not supported
if (param1 instanceof BigDecimal || param2 instanceof BigDecimal) {
BigDecimal b1 = getBigDecimal((Number) param1);
BigDecimal b2 = getBigDecimal((Number) param2);
return b1.remainder(b2);
}
if (param1 instanceof Double
|| param2 instanceof Double
|| param1 instanceof Float
|| param2 instanceof Float) {
return ((Number) param1).doubleValue() % ((Number) param2).doubleValue();
} else { // Long, Integer, Short, Byte
long l1 = ((Number) param1).longValue();
long l2 = ((Number) param2).longValue();
return l1 % l2;
}
} else {
throw new ParseException(
WRONG_TYPE + " (" + param1.getClass() + "%" + param2.getClass() + ")");
}
}
/**
* 数值求余处理
*
* @param num1 被除数
* @param num2 除数
* @return 余数
*/
public static BigDecimal remainder(BigDecimal num1, BigDecimal num2) {
if (null == num2 || BigDecimal.ZERO.compareTo(num2) == 0) {
return null;
}
if (null == num1 || BigDecimal.ZERO.compareTo(num1) == 0) {
return BigDecimal.ZERO;
}
return num1.remainder(num2);
}
public static double calcIncrement(double value) {
BigDecimal b = BigDecimal.valueOf(value);
BigDecimal r = b.remainder(BigDecimal.ONE);
if (r.compareTo(BigDecimal.ZERO) == 0) {
return 1;
}
double res = 1 / Math.pow(10, r.scale());
return res;
}
/** @param args fala k da jedan od zadataka ne ubija racunar */
public static void main(String[] args) {
int count = 0;
BigDecimal num = new BigDecimal(Long.MAX_VALUE).add(BigDecimal.ONE);
while (count < 10) {
if (num.remainder(new BigDecimal(5)).equals(BigDecimal.ZERO)
|| num.remainder(new BigDecimal(6))
.equals(
BigDecimal
.ZERO)) { // ako equals(bigDecimal.ZERO) vraca true, broje je djeljiv sa 6,
// ili gore sa 5
count++;
System.out.println(count + ": " + num);
}
num = num.add(BigDecimal.ONE);
}
}
/**
* Updates tick label for log scale.
*
* @param length the length of axis
*/
private void updateTickLabelForLogScale(int length) {
double min = axis.getRange().lower;
double max = axis.getRange().upper;
int digitMin = (int) Math.ceil(Math.log10(min));
int digitMax = (int) Math.ceil(Math.log10(max));
final BigDecimal MIN = new BigDecimal(new Double(min).toString());
BigDecimal tickStep = pow(10, digitMin - 1);
BigDecimal firstPosition;
if (MIN.remainder(tickStep).doubleValue() <= 0) {
firstPosition = MIN.subtract(MIN.remainder(tickStep));
} else {
firstPosition = MIN.subtract(MIN.remainder(tickStep)).add(tickStep);
}
for (int i = digitMin; i <= digitMax; i++) {
for (BigDecimal j = firstPosition;
j.doubleValue() <= pow(10, i).doubleValue();
j = j.add(tickStep)) {
if (j.doubleValue() > max) {
break;
}
if (axis.isDateEnabled()) {
Date date = new Date((long) j.doubleValue());
tickLabels.add(format(date));
} else {
tickLabels.add(format(j.doubleValue()));
}
tickLabelValues.add(j.doubleValue());
int tickLabelPosition =
(int)
((Math.log10(j.doubleValue()) - Math.log10(min))
/ (Math.log10(max) - Math.log10(min))
* length);
tickLabelPositions.add(tickLabelPosition);
}
tickStep = tickStep.multiply(pow(10, 1));
firstPosition = tickStep.add(pow(10, i));
}
}
/**
* Adds the specified dayTime duration.
*
* @param add value to be added
*/
private void add(final BigDecimal add) {
// normalized modulo: sc % 60 vs. (-sc + sc % 60 + 60 + sc) % 60
final BigDecimal sc = sec().add(add);
sec =
sc.signum() >= 0
? sc.remainder(BD60)
: sc.negate().add(sc.remainder(BD60)).add(BD60).add(sc).remainder(BD60);
final long mn = Math.max(min(), 0) + div(sc.longValue(), 60);
min = (byte) mod(mn, 60);
final long ho = Math.max(hou, 0) + div(mn, 60);
hou = (byte) mod(ho, 24);
final long da = div(ho, 24);
final long[] ymd = ymd(days().add(BigDecimal.valueOf(da)));
yea = ymd[0];
mon = (byte) ymd[1];
day = (byte) ymd[2];
}
public static void main(String[] args) throws IOException {
br = new BufferedReader(new InputStreamReader(System.in));
out = new PrintWriter(new OutputStreamWriter(System.out));
// br = new BufferedReader(new FileReader("in.txt"));
// out = new PrintWriter(new FileWriter("out.txt"));
int n = readInt();
BigDecimal bd = new BigDecimal("0").setScale(15, BigDecimal.ROUND_HALF_UP);
for (int i = 0; i < n; i++) bd = bd.add(new BigDecimal(next()));
out.println(bd.remainder(new BigDecimal("360")).toString());
out.close();
}
// ======================================================================
// [FUNC] Converts BigDecimal to a radix (No shit!)
private static String dec2rad(String str, BigDecimal rad) {
BigDecimal bd = new BigDecimal(str);
String ret = "";
int rem = 0;
bd = bd.setScale(0, BigDecimal.ROUND_DOWN);
while (bd.compareTo(BigDecimal.ZERO) > 0) {
rem = bd.remainder(rad).intValue();
if (rem >= 0 && rem <= 9) ret = (char) (rem + '0') + ret;
else if (rem >= 10) ret = (char) (rem + 'A' - 10) + ret;
bd = bd.divide(rad, 0, BigDecimal.ROUND_DOWN);
}
return ret == "" ? "0" : ret;
}
public static Timestamp decimalToTimestamp(HiveDecimal d) {
BigDecimal nanoInstant = d.bigDecimalValue().multiply(BILLION_BIG_DECIMAL);
int nanos = nanoInstant.remainder(BILLION_BIG_DECIMAL).intValue();
if (nanos < 0) {
nanos += 1000000000;
}
long seconds =
nanoInstant.subtract(new BigDecimal(nanos)).divide(BILLION_BIG_DECIMAL).longValue();
Timestamp t = new Timestamp(seconds * 1000);
t.setNanos(nanos);
return t;
}
public BigDecimal roundOffToNearestEven(final BigDecimal amount) {
BigDecimal roundedAmt;
final BigDecimal remainder = amount.remainder(new BigDecimal(2));
/*
* if reminder is less than 1, subtract reminder amount from passed
* amount else reminder is greater than 1, subtract reminder amount from
* passed amount and add 5 to result amount
*/
if (remainder.compareTo(new BigDecimal("1")) == 1)
roundedAmt = amount.subtract(remainder).add(new BigDecimal(2));
else roundedAmt = amount.subtract(remainder);
return roundedAmt;
}
/**
* Updates tick label for normal scale.
*
* @param length axis length (>0)
* @param tickStep the tick step
*/
private void updateTickLabelForLinearScale(int length, BigDecimal tickStep) {
double min = axis.getRange().lower;
double max = axis.getRange().upper;
final BigDecimal MIN = new BigDecimal(new Double(min).toString());
BigDecimal firstPosition;
/* if (min % tickStep <= 0) */
if (MIN.remainder(tickStep).doubleValue() <= 0) {
/* firstPosition = min - min % tickStep */
firstPosition = MIN.subtract(MIN.remainder(tickStep));
} else {
/* firstPosition = min - min % tickStep + tickStep */
firstPosition = MIN.subtract(MIN.remainder(tickStep)).add(tickStep);
}
// the unit time starts from 1:00
if (axis.isDateEnabled()) {
BigDecimal zeroOclock =
firstPosition.subtract(new BigDecimal(new Double(3600000).toString()));
if (MIN.compareTo(zeroOclock) == -1) {
firstPosition = zeroOclock;
}
}
for (BigDecimal b = firstPosition; b.doubleValue() <= max; b = b.add(tickStep)) {
if (axis.isDateEnabled()) {
Date date = new Date((long) b.doubleValue());
tickLabels.add(format(date));
} else {
tickLabels.add(format(b.doubleValue()));
}
tickLabelValues.add(b.doubleValue());
int tickLabelPosition = (int) ((b.doubleValue() - min) / (max - min) * length);
tickLabelPositions.add(tickLabelPosition);
}
}
private static Object doBigDecimalArithmetic(
final BigDecimal val1,
final int operation,
final BigDecimal val2,
boolean iNumber,
int returnTarget) {
switch (operation) {
case ADD:
if (iNumber) {
return narrowType(val1.add(val2, MATH_CONTEXT), returnTarget);
} else {
return val1.add(val2, MATH_CONTEXT);
}
case DIV:
if (iNumber) {
return narrowType(val1.divide(val2, MATH_CONTEXT), returnTarget);
} else {
return val1.divide(val2, MATH_CONTEXT);
}
case SUB:
if (iNumber) {
return narrowType(val1.subtract(val2, MATH_CONTEXT), returnTarget);
} else {
return val1.subtract(val2, MATH_CONTEXT);
}
case MULT:
if (iNumber) {
return narrowType(val1.multiply(val2, MATH_CONTEXT), returnTarget);
} else {
return val1.multiply(val2, MATH_CONTEXT);
}
case POWER:
if (iNumber) {
return narrowType(val1.pow(val2.intValue(), MATH_CONTEXT), returnTarget);
} else {
return val1.pow(val2.intValue(), MATH_CONTEXT);
}
case MOD:
if (iNumber) {
return narrowType(val1.remainder(val2), returnTarget);
} else {
return val1.remainder(val2);
}
case GTHAN:
return val1.compareTo(val2) == 1 ? Boolean.TRUE : Boolean.FALSE;
case GETHAN:
return val1.compareTo(val2) >= 0 ? Boolean.TRUE : Boolean.FALSE;
case LTHAN:
return val1.compareTo(val2) == -1 ? Boolean.TRUE : Boolean.FALSE;
case LETHAN:
return val1.compareTo(val2) <= 0 ? Boolean.TRUE : Boolean.FALSE;
case EQUAL:
return val1.compareTo(val2) == 0 ? Boolean.TRUE : Boolean.FALSE;
case NEQUAL:
return val1.compareTo(val2) != 0 ? Boolean.TRUE : Boolean.FALSE;
}
return null;
}
public static Number bigDecimalRemainder(BigDecimal x, BigDecimal y) {
return x.remainder(y);
}
@Override
public TimeStamp unmarshal(BigDecimal v) throws Exception {
return TimeStamp.time(
v.longValue(), v.remainder(new BigDecimal(1)).scaleByPowerOfTen(9).intValue());
}
/**
* Type converts values to other classes. For example an Integer can be converted to a Long.
*
* @param <T> Data Type.
* @param value The value to be converted.
* @param to The class to be converted to. Must be one of the Java types corresponding to the
* DataTypes.
* @return The converted value.
* @throws TypeMismatchException Thrown desired class is incompatible with the source class.
* @throws OverflowException Thrown only on narrowing value conversions, e.g from a BigInteger to
* an Integer.
*/
@Nullable
public static <T> T convert(Object value, Class<?> to)
throws TypeMismatchException, OverflowException {
final Object result;
if (value == null || value.getClass() == to) {
result = value;
} else {
final Class<?> from = value.getClass();
try {
if (from == Integer.class) { // Integer -> ...
if (to == Long.class) {
result = new Long(((Number) value).longValue());
} else if (to == BigInteger.class) {
result = BigInteger.valueOf(((Number) value).intValue());
} else if (to == Float.class) {
result = new Float(((Number) value).floatValue());
} else if (to == Double.class) {
result = new Double(((Number) value).doubleValue());
} else if (to == BigDecimal.class) {
// Use intValue() to avoid precision errors
result = new BigDecimal(((Number) value).intValue());
} else {
throw new TypeMismatchException(value.getClass(), to);
}
} else if (from == Long.class) { // Long -> ...
if (to == Integer.class) {
final long l = ((Long) value).longValue();
if (l < Integer.MIN_VALUE || l > Integer.MAX_VALUE) {
throw new OverflowException((Number) value, to);
}
result = new Integer((int) l);
} else if (to == BigInteger.class) {
result = BigInteger.valueOf(((Number) value).longValue());
} else if (to == Float.class) {
result = new Float(((Number) value).floatValue());
} else if (to == Double.class) {
result = new Double(((Number) value).doubleValue());
} else if (to == BigDecimal.class) {
// Use longValue() to avoid precision errors
result = new BigDecimal(((Number) value).longValue());
} else {
throw new TypeMismatchException(value.getClass(), to);
}
} else if (from == BigInteger.class) { // BigInteger -> ...
final BigInteger bi = (BigInteger) value;
if (to == Integer.class) {
result = new Integer(bi.intValueExact());
} else if (to == Long.class) {
result = new Long(bi.longValueExact());
} else if (to == Float.class) {
final float f1 = bi.floatValue();
if (f1 == Float.NEGATIVE_INFINITY || f1 == Float.POSITIVE_INFINITY) {
throw new OverflowException(bi, to);
}
result = new Float(f1);
} else if (to == Double.class) {
final double d = bi.doubleValue();
if (d == Double.NEGATIVE_INFINITY || d == Double.POSITIVE_INFINITY) {
throw new OverflowException(bi, to);
}
result = new Double(d);
} else if (to == BigDecimal.class) {
result = new BigDecimal(bi);
} else {
throw new TypeMismatchException(value.getClass(), to);
}
} else if (from == Float.class) { // Float -> ...
final float fl = ((Float) value).floatValue();
if (to == Integer.class) {
if (fl < Integer.MIN_VALUE || fl > Integer.MAX_VALUE | fl % 1 > 0) {
throw new OverflowException((Number) value, to);
}
result = new Integer((int) fl);
} else if (to == Long.class) {
if (fl < Long.MIN_VALUE || fl > Long.MAX_VALUE | fl % 1 > 0) {
throw new OverflowException((Number) value, to);
}
result = new Long((long) fl);
} else if (to == BigInteger.class) {
if (fl % 1 > 0) {
throw new OverflowException((Number) value, to);
}
final BigDecimal bd = BigDecimal.valueOf(fl);
result = bd.toBigInteger();
} else if (to == Double.class) {
result = new Double(((Number) value).doubleValue());
} else if (to == BigDecimal.class) {
result = BigDecimal.valueOf(fl);
} else {
throw new TypeMismatchException(value.getClass(), to);
}
} else if (from == Double.class) { // Double -> ...
final double d = ((Double) value).doubleValue();
if (to == Integer.class) {
if (d < Integer.MIN_VALUE || d > Integer.MAX_VALUE || d % 1 > 0) {
throw new OverflowException((Number) value, to);
}
result = new Integer((int) d);
} else if (to == Long.class) { // OK
if (d < Long.MIN_VALUE || d > Long.MAX_VALUE || d % 1 > 0) {
throw new OverflowException((Number) value, to);
}
result = new Long((int) d);
} else if (to == BigInteger.class) { // OK
if (d % 1 > 0) {
throw new OverflowException((Number) value, to);
}
final BigDecimal bd = BigDecimal.valueOf(d);
result = bd.toBigInteger();
} else if (to == Float.class) { // OK
if (d < -Float.MAX_VALUE || d > Float.MAX_VALUE) {
throw new OverflowException((Number) value, to);
}
result = new Float((float) d);
} else if (to == BigDecimal.class) { // OK
result = BigDecimal.valueOf(d);
} else {
throw new TypeMismatchException(value.getClass(), to);
}
} else if (from == BigDecimal.class) { // BigDecimal -> ...
final BigDecimal bd = (BigDecimal) value;
if (to == Integer.class) { // OK
result = new Integer(bd.intValueExact());
} else if (to == Long.class) { // OK
result = new Long(bd.longValueExact());
} else if (to == BigInteger.class) { // OK
// BigDecimal modulus
final BigDecimal remainder = bd.remainder(BigDecimal.ONE);
if (!remainder.equals(BigDecimal.ZERO)) {
throw new OverflowException(bd, to);
}
result = bd.toBigInteger();
} else if (to == Float.class) { // OK
if (bd.compareTo(BigDecimal_MIN_FLOAT) < 0 || bd.compareTo(BigDecimal_MAX_FLOAT) > 0) {
throw new OverflowException(bd, to);
}
result = new Float(bd.floatValue());
} else if (to == Double.class) { // OK
if (bd.compareTo(BigDecimal_MIN_DOUBLE) < 0
|| bd.compareTo(BigDecimal_MAX_DOUBLE) > 0) {
throw new OverflowException(bd, to);
}
result = new Double(bd.doubleValue());
} else {
throw new TypeMismatchException(value.getClass(), to);
}
} else {
throw new UnexpectedException("convert: " + from.getName());
}
} catch (final ArithmeticException e) {
// Thrown by intValueExact() etc.
throw new OverflowException((Number) value, to);
}
}
@SuppressWarnings("unchecked")
final T t = (T) result;
return t;
}