結果

問題 No.81 すべて足すだけの簡単なお仕事です。
ユーザー alpha_virginisalpha_virginis
提出日時 2016-09-02 14:56:49
言語 C++14
(gcc 13.2.0 + boost 1.83.0)
結果
WA  
(最新)
AC  
(最初)
実行時間 -
コード長 4,707 bytes
コンパイル時間 717 ms
コンパイル使用メモリ 75,260 KB
実行使用メモリ 4,384 KB
最終ジャッジ日時 2023-08-21 13:24:40
合計ジャッジ時間 1,941 ms
ジャッジサーバーID
（参考情報） 		judge12 / judge13
このコードへのチャレンジ
（要ログイン）

テストケース

テストケース表示
入力 結果 実行時間
実行使用メモリ
testcase_00 AC 2 ms
4,376 KB
testcase_01 AC 1 ms
4,376 KB
testcase_02 AC 1 ms
4,380 KB
testcase_03 AC 1 ms
4,376 KB
testcase_04 AC 2 ms
4,380 KB
testcase_05 AC 2 ms
4,376 KB
testcase_06 AC 2 ms
4,376 KB
testcase_07 AC 2 ms
4,380 KB
testcase_08 AC 1 ms
4,380 KB
testcase_09 AC 2 ms
4,380 KB
testcase_10 WA -
testcase_11 AC 2 ms
4,376 KB
testcase_12 AC 1 ms
4,376 KB
testcase_13 AC 1 ms
4,376 KB
testcase_14 AC 2 ms
4,376 KB
testcase_15 AC 2 ms
4,376 KB
testcase_16 AC 2 ms
4,376 KB
testcase_17 WA -
testcase_18 AC 1 ms
4,380 KB
testcase_19 AC 2 ms
4,384 KB
testcase_20 AC 2 ms
4,376 KB
testcase_21 AC 2 ms
4,376 KB
testcase_22 AC 1 ms
4,376 KB
testcase_23 AC 1 ms
4,376 KB
testcase_24 AC 2 ms
4,376 KB
testcase_25 WA -
testcase_26 WA -
testcase_27 WA -
testcase_28 AC 2 ms
4,380 KB
testcase_29 AC 1 ms
4,380 KB
権限があれば一括ダウンロードができます

ソースコード

diff # 

#include <cstdio>
#include <iostream>

#include <cstdint>
#include <string>
#include <tuple>
#include <algorithm>

namespace Num {
  template<size_t size>
  struct Integer {
    Integer() {
      for(size_t i = 0; i < size; ++i) v[i] = 0ULL;
      flag = 1;
    }
    uint64_t v[size];
    int flag;
    Integer<size>& operator = (const Integer<size>& y) {
      for(size_t i = 0; i < size; ++i) {
        v[i] = y.v[i];
      }
      flag = y.flag;
      return *this;
    }
    bool isZero() {
      for(size_t i = 0; i < size; ++i) {
        if( v[i] != 0ULL ) return false;
      }
      return true;
    }
    Integer<size>& setMinus() {
      flag = -1;
      return *this;
    }
    Integer<size>& setPlus() {
      flag = 1;
      return *this;
    }
  };
  template<size_t size>
  int abscmp(const Integer<size>& x, const Integer<size>& y) {
    for(size_t i = size - 1; i < size; --i) {
      if( x.v[i] < y.v[i] ) return -1;
      if( x.v[i] > y.v[i] ) return 1;
    }
    return 0;
  }
  template<size_t size>
  Integer<size>& fix(Integer<size>& x) {
    for(size_t i = 0; i < size - 1; ++i) {
      x.v[i+1] += x.v[i] / 0x100000000ULL;
      x.v[i]   %= 0x100000000ULL;
    }
    x.v[size-1] %= 0x100000000ULL;
    return x;
  }
  template<size_t size>
  Integer<size> add(Integer<size>& x, const Integer<size>& y) {
    for(size_t i = 0; i < size; ++i) {
      x.v[i] += y.v[i];
    }
    return fix(x);
  }
  template<size_t size>
  Integer<size> sub(Integer<size>& x, const Integer<size>& y) {
    x.v[0] += (1ULL << 32);
    for(size_t i = 1; i < size; ++i) x.v[i] += (1ULL << 32) - 1;
    for(size_t i = 0; i < size; ++i) {
      x.v[i] -= y.v[i];
    }
    return fix(x);
  }
  template<size_t size>
  Integer<size>& operator += (Integer<size>& x, const Integer<size>& y) {
    if( x.flag == y.flag ) {
      return x = add(x, y);
    }
    else {
      if( abscmp(x, y) >= 0 ) {
        if( x.flag > 0 ) {
          return x = sub(x, y).setPlus();
        }
        else {
          return x = sub(x, y).setMinus();
        }
      }
      else {
        Integer<size> y2 = y;
        if( y2.flag > 0 ) {
          return x = sub(y2, x).setPlus();
        }
        else {
          return x = sub(y2, x).setMinus();
        }
      }
    }
  }
  template<size_t size>
  Integer<size>& operator += (Integer<size>& x, uint32_t y) {
    x.v[0] += y;
    return fix(x);
  }
  template<size_t size>
  Integer<size>& operator *= (Integer<size>& x, uint32_t y) {
    for(size_t i = 0; i < size; ++i) {
      x.v[i] *= (uint64_t)y;
    }
    return fix(x);
  }
  template<size_t size>
  std::tuple<Integer<size>, uint64_t> div(const Integer<size>& x, uint32_t y) {
    Integer<size> z = x;
    uint64_t t = 0;
    for(size_t i = size - 1; i < size; --i) {
      z.v[i] += (t << 32);
      t = z.v[i] % (uint64_t)y;
      z.v[i] /= (uint64_t) y;
    }
    return std::make_tuple(z, t);
  }
  template<size_t size>
  std::string toString(const Integer<size>& x) {
    Integer<size> y = x;
    std::string str;
    while( not y.isZero() ) {
      auto pq = div(y, 10);
      str += std::get<1>(pq) + '0';
      y = std::get<0>(pq);
    }
    if( y.flag < 0 ) str += '-';
    std::reverse(str.begin(), str.end());
    return str;
  }
  template<size_t size>
  Integer<size> strToInteger(std::string str) {
    Integer<size> x;
    for(int i = 0; i < (int)str.size(); ++i) {
      if( i == 0 and str[i] == '-' ) {
        x.flag = -1;
        continue;
      }
      x *= 10;
      x += str[i] - '0';
    }
    return x;
  }
};

std::string encode(std::string str) {
  int p = -1;
  for(int i = 0; i < (int)str.size(); ++i) {
    if( str[i] == '.' ) {
      p = i;
    }
  }
  if( p == -1 ) {
    str += ".0000000000";
  }
  else {
    while( (int)str.size() <= p + 10 ) {
      str += '0';
    }
  }
  std::string res;
  for(int i = 0; i < (int)str.size(); ++i) {
    if( str[i] != '.' ) res += str[i];
  }
  return res;
}

std::string decode(std::string str) {
  std::string res;
  for(int i = 0; i < (int)str.size(); ++i) {
    if( i + 10 == (int)str.size() ) res += '.';
    res.push_back(str[i]);
  }
  return res;
}

int main() {
  int n;
  std::cin >> n;
  Num::Integer<8> x;
  for(int i = 0; i < n; ++i) {
    std::string str;
    std::cin >> str;
    Num::Integer<8> y = Num::strToInteger<8>(encode(str));
    x += y;
  }
  std::string res = Num::toString(x);
  std::cout << decode(res) << std::endl;

  // std::string str;
  // std::cin >> str;
  // Num::Integer<8> x = Num::strToInteger<8>(encode(str));
  // std::cin >> str;
  // Num::Integer<8> y = Num::strToInteger<8>(encode(str));
  // x += y;
  // std::string res = toString(x);
  // std::cout << res << std::endl;
  
  return 0;
}
0