食洗機を買った

Diary

食洗機は前から買おうと思っていたのだが、在宅勤務も長くなり、家で食事を作る機会が増えてきたので買った。導入までやったことを記しておく。まだ今日設置したところなので、食洗機買って良かったかどうかという判断はできていない。大変だったので設置できたことについての満足感はある。

続きを読む

メンデルの法則をめぐる論争について (4) - 連鎖および近年のメンデルに対する評価

Biology

関連記事一覧

前回まで3回にわたってメンデルの法則をめぐる論争について取り上げた。この話に関連してよく取り上げられる話題はもう一つある。

それは「メンデルは連鎖を見つけられたのではないか？」というものだ。

続きを読む

メンデルの法則をめぐる論争について (3) - 「データができすぎている」は解決できない

Biology

関連記事一覧

前々回、前回とメンデルの法則をめぐる法則を紹介し、前回はフィッシャーの2つの指摘のうち1つについて否定が可能という説明をした。今回はフィッシャーの指摘のもうひとつの要点である「データが理論値に一致しすぎている」について説明する。今回が本題である。

そもそも、Weldonに始まるメンデルのデータに対する疑問はこの「データが理論値に一致しすぎている」が発端である。前回取り上げた「1:1.7」問題はフィッシャーの疑念をより強めたポイントではあったが、それ単体で見れば「運が良かった」でも済ませられる程度のものであった。

続きを読む

メンデルの法則をめぐる論争について (2) - 「1:1.7問題」は解決できる

Biology

関連記事一覧

前回、メンデルの法則をめぐる論争の背景について説明し、フィッシャーの2つの指摘を紹介した。

今回はフィッシャーの指摘のうちの1つ、「F₂世代で優性型を示した個体の雑種型と不変型の分離比は2:1ではなく1.7:1として観測されるべきだがデータは2:1に近接している」という点について説明する。

続きを読む

メンデルの法則をめぐる論争について (1) - メンデルはデータを捏造したのか？フィッシャーによる2つの指摘

Biology

関連記事一覧

「メンデルのデータには捏造があるのではないか」という説は統計学の読み物や教科書にしばしば登場する。多くの場合、これはR. A. フィッシャーによる指摘として紹介される。例として『背信の科学者たち』の一節を次に引用する。

しかしながら、メンデルのデータが極めて正確であったため、一九三六年、高名な統計学者であるロナルド・Ａ・フィッシャーは、メンデルの方法を綿密に検討することにした。その結果はあまりにもうまくできすぎていた。フィッシャーは、精力的な実験の陰に何かがあったにちがいないと結論し、「すべてではないにしても、ほとんどの実験データがメンデルの期待に非常によく一致するように曲げられている」と書いている。

（ウイリアム・ブロード, ニコラス・ウェイド著, 牧野賢治訳 『背信の科学者たち　論文捏造はなぜ繰り返されるのか？』）

日本語のテキストにおける取り上げられ方は似たようなもので、メンデルにとって不利な記述であるものが目立つ。そのような状況のなか、「『メンデルが捏造』はすでに否定されているようだ」ということが数年前に少し話題となった。

ただ、結局のところ論争は終わっているのか、結論はどうなっているのかという点が当時はよく納得できなかった。結局そのときはきちんと調べなかった。この件について日本語で解説された資料があまりに少なく、かといってゆっくり英語文献を調べる気にもならなかったというのもあった。

最近また少しこの話が気になってきたので、いくつかの文献をある程度真面目に読んだ。そこで、ここまで理解したことをまとめた。長くなったので、何回かに分割して説明する。

なお結論はメンデルの法則をめぐる論争について (3) - 「データができすぎている」は解決できないに述べたが、「メンデルが捏造はすでに否定されている」とは言えないというのが現時点の感想である。

続きを読む

ABC 125反省会

C++ AtCoder

問題自体はそれほど難しくなかったが、問題が正しく読めて無くてCとDでWAを何度か出してしまった。読解力を鍛えたい。

A. Biscuit Generator

「0.5秒」のところで若干不安になったけどとりあえずこれで正解だった。

#include <bits/stdc++.h>
using namespace std;

int main(){
  int a, b, t;
  cin >> a >> b >> t;
  cout << t / a * b << endl; 
}

B. Resale

これは危なげなくクリア。

#include <bits/stdc++.h>
using namespace std;

int main(){
  int n;
  cin >> n;
  vector<int> v(n);
  vector<int> c(n);
  
  for (int i = 0; i < n; i++) {
    cin >> v.at(i);
  }
  for (int i = 0; i < n; i++) {
    cin >> c.at(i);
  }
  int ans = 0;
  for (int i = 0; i < n; i++) {
    if (v.at(i) > c.at(i)) ans += v.at(i) - c.at(i);
  }
  cout << ans << endl;
}

C. GCD on Blackboard

gcd(a, b, c) = gcd(gcd(a, b), c)なので、順番に見ていってOK。

任意の数に変更できるというのは数を除外するのと同じなので「次の数を使わないパターン」がこれまでの最大ケースより大きいかどうかを順次比較しつつ結果を更新していけばよい。

最初手間取ったので、もうちょっとコードを綺麗にできそうな気もする。

#include <bits/stdc++.h>
using namespace std;
using ll = long long;

ll gcd(ll a, ll b) {
  ll tmp = 0;
  while (b != 0) {
    if (b < a) {
      swap(a, b);
    }
    b = b % a;
  }
  return a;
}

int main(){
  ll N;
  cin >> N;
  vector<ll> A(N);
  for (int i = 0; i < N; i++) {
    cin >> A.at(i);
  }

  if (A.size() == 2) {
    cout << max(A.at(0), A.at(1)) << endl;
  } else {
    ll a = A.at(0);
    ll b = A.at(1);
    ll c = A.at(2);
    ll gcd_max = 0;
    ll gcd_all = gcd(a, b);
    if (gcd(a, c) > gcd(b, c)) {
      gcd_max = gcd(a, c);
    } else {
      gcd_max = gcd(b, c);
    }
    for (int i = 2; i < N; i++) {
      ll c = A.at(i);
      gcd_max = gcd(gcd_max, c) > gcd_all ? gcd(gcd_max, c) : gcd_all;
      gcd_all = gcd(gcd_all, c);
    }
    cout << gcd_max << endl;
  }
}

D. Flipping Signs

Cより簡単だった気がする。実際正解者数もCよりかなり多かった様子。

最初、最後の1個だけ見るのかと思ってWAを2回ほど出してしまった。

操作はいくらでもできるので、負数が偶数個なら全部正整数にできるし、奇数個ならどれか1つが負数になる。

したがって、負数をカウントして偶数なら絶対値の和が答えになり、奇数個なら絶対値の和から絶対値が最小の値の2倍を引けば答えになる。

#include <bits/stdc++.h>
using namespace std;
using ll = long long;

int main(){
  ll N;
  cin >> N;
  vector<ll> A(N);
  for (ll i = 0; i < N; i++) {
    cin >> A.at(i);
  }

  ll ans = 0; // 絶対値の合計
  for (ll i = 0; i < N; i++){
    ans += abs(A.at(i));
  }

  int minus_cnt = 0; // 負数の数を数える
  for (ll i = 0; i < N; i++) {
    if (A.at(i) < 0) minus_cnt++;
  }
  
  if (minus_cnt % 2 != 0) { // 負数が奇数個ならどれか一つ-が残るので、絶対値が一番小さいものを負にする
    ll min = abs(A.at(0));
    for (ll i = 1; i < N; i++) {
      if (abs(A.at(i)) < min) min = abs(A.at(i));
    }
    ans -= abs(min) * 2;
  }
  
  cout << ans << endl;
}

Tenka1 Programmer Beginner Contest 2019反省会

AtCoder Python C++

Cまで届かなかった。前日飲みすぎてダルかったので今後は酒を控えたい所存。

A. On the Way

Pythonでやった。

A, B, C = [int(i) for i in input().split()]

min_n = min(A, B)
max_n = max(A, B)

if min_n < C and max_n > C:
  print("Yes")
else:
  print("No")

B. *e**** ********e* *e****e* ****e**

文字列走査するならC++かなと思ってC++でやった。

#include <bits/stdc++.h>
using namespace std;
int main(void){
  int N, K;
  string S;
  cin >> N >> S >> K;
  char target;
  target = S.at(K-1);
  for (int i = 0; i < S.size(); i++) {
    if (S.at(i) == target) {
      cout << target;
    } else {
      cout << '*';
    }
  }
  cout << endl;
}

C. Stones

（分割してカウントするんだよな…）と思ってこういうの書いてしまっていた。

N = int(input())
S = input().strip()

def stone_cnt(idx):
  return S[:idx].count("#") + S[idx:].count(".")

left = 0
right = len(S)

ans = min([stone_cnt(i) for i in range(N+1)])
  
print(ans)

O(N²)なのでもちろんTLEだ。「境界を動かしたらカウントがどうなるか」に注目すればO(N)で解けるというのは冷静に考えれば分かりそうだったのに、冷静ではなかった。酒を飲んではいけない。

C++版の回答。

#include <bits/stdc++.h>
using namespace std;
int main(void){
  int N;
  string S;
  cin >> N >> S;
  int lb = 0;
  int rw = count(S.begin(), S.end(), '.');
  int ans = lb + rw;
  for (int i = 0; i < N; i++) {
    if (S.at(i) == '.') {
      rw--;
    } else {
      lb++;
    }
    ans = min(ans, lb + rw);
  }
  cout << ans << endl;
}

Python版の回答。

# coding: utf-8

N = int(input())
S = input().rstrip('#')

lb = 0
rw = S.count('.')
ans = lb + rw

for i in range(len(S)):
  if S[i] == '.':
    rw -= 1
  else:
    lb += 1
  ans = min(ans, rw + lb)

print(ans)

D. Three Colors

解説だけ読んでもよく分からなくて、他の人の回答を見てやっと理解できた。

Python版。TLEになる。他の人の回答を見ると少し最適化すれば通るっぽい。

ちなみにAtCoderのPyPyにはNumPyが無いっぽいので、そのままPyPy3に切り替えるという手は使えない。NumPy外してPyPy使ってみたりもしたけど私の能力ではやっぱりTLEだった。

import numpy as np
import math

MOD = 998244353

N = int(input())
a = np.array([int(input()) for _ in range(N)])

S = sum(a)

dp1 = np.zeros((N + 1, S + 1))
dp1[0, 0] = 1
dp2 = np.zeros((N + 1, S + 1))
dp2[0, 0] = 1

for i, x in enumerate(a):
  ## 長さを計算する色をcとして、cの長さに対する組み合わせを数える
  dp1[i+1, :]  += dp1[i, :] * 2 % MOD  # c以外に塗り分ける場合（各2通り追加）
  dp1[i+1, x:] += dp1[i, :-x]   % MOD  # cに塗る場合（xずらしたところに1通り追加）
  ## 2色だけを使う組み合わせを数える
  dp2[i+1, :]  += dp2[i, :]     % MOD  # cではないいずれか1色に塗る場合（各1通り）
  dp2[i+1, x:] += dp2[i, :-x]   % MOD  # cに塗る場合
  
# 全塗り分けパターン
pat = 3 ** N % MOD
# 最大の色の値が S/2 以上のパターン（三角形ができない）
s1  = 3 * sum(dp1[N, math.ceil(S / 2):]) % MOD
# 最大の色の値が S/2 に等しいパターン（重複している）
s2  = 3 * dp2[N, S // 2] % MOD if S % 2 == 0 else 0

print(int(pat - s1 + s2) % MOD)

C++版。これは通る。通るが、結構ハマりどころがあったので（%が負数を返すパターンへの対処とか多次元配列の合計のとり方とか）もう少し練習しないと本番の時間内では実装できない感じがある。

#include <bits/stdc++.h>
using namespace std;
using ll = long long;

const ll MOD = 998244353;

ll mod(ll n, ll m) {
  ll res = n % m;
  if (res < 0) res += m;
  return res;
}

ll modpow(ll a, ll n, ll mod) {
    ll res = 1;
    while (n > 0) {
        if (n & 1) res = res * a % mod;
        a = a * a % mod;
        n >>= 1;
    }
    return res;
}


int main(void){
  ll N;
  cin >> N;
  vector<ll> a(N);
  for (int i = 0; i < N; i++) {
    cin >> a.at(i);
  }
  ll S = accumulate(a.begin(), a.end(), 0);
  
  vector<vector<ll>> dp1(N+1, vector<ll>(S+1, 0));
  vector<vector<ll>> dp2(N+1, vector<ll>(S+1, 0));
  dp1.at(0).at(0) = 1;
  dp2.at(0).at(0) = 1;
  
  for (int i = 0; i < N; i++) {
    for (int j = 0; j < S; j++) {
      dp1.at(i+1).at(j) += dp1.at(i).at(j) * 2 % MOD;
      dp2.at(i+1).at(j) += dp2.at(i).at(j) % MOD;
    }
    for (int j = a.at(i); j < S+1; j++) {
      dp1.at(i+1).at(j) += dp1.at(i).at(j-a.at(i)) % MOD;
      dp2.at(i+1).at(j) += dp2.at(i).at(j-a.at(i)) % MOD;
    }
  }
  
  ll pat;
  pat = modpow(3, N, MOD);
  ll s1 = 0;
  ll s2 = 0;

  if (S % 2 == 0) {
    for (int i = S/2; i < S+1; i++) {
      s1 += 3 * dp1.at(N).at(i);
      s1 %= MOD;
    }
    s2 = 3 * dp2.at(N).at(S / 2);
  } else {
    for (int i = S/2+1; i < S+1; i++) {
      s1 += 3 * dp1.at(N).at(i);
      s1 %= MOD;
    }
  }
  cout << mod(pat - s1 + s2, MOD) << endl;
}

ABC 124反省会

C++ AtCoder

初4完。でも今回正解者多かったし少し簡単だったかも…？

A. Buttons

A==Bの場合だけ気をつける。

#include <bits/stdc++.h>
using namespace std;

int main(){
  int A, B;
  cin >> A >> B;
  int m = max(A, B);
  cout << (A == B ? m + m : m + m - 1) << endl;
}

B. Great Ocean View

最大の山の高さを保持しつつ、比較していけば良い。

#include <bits/stdc++.h>
using namespace std;

int main(){
  int N;
  cin >> N;
  int h;
  cin >> h;
  int hmax = h;
  int cnt = 1;
  for (int i = 1; i < N; i++) {
    cin >> h;
    if (h >= hmax){
      hmax = h;
      cnt++;
    };
  }
  cout << cnt << endl;
}

C. Coloring Colorfully

一つ前と色が違えばカウントを増やす。

#include <bits/stdc++.h>
using namespace std;

int main(){
  string S;
  cin >> S;
  int pre = S.at(0) - '0';
  int cnt = 0;
  int cur;
  for (int i = 1; i < S.size(); i++) {
    cur = S.at(i) - '0';
    if (pre == cur) {
      cnt++;
    };
    pre = !pre;
  }
  cout << cnt << endl;
}

D. Handstand

例えば入力例2は次のように見ることができる。

  • 1が3個
  • 0が1個
  • 1が1個
  • 0が1個
  • 1が1個
  • 0が1個
  • 1が2個
  • 0が2個
  • 1が2個

このような集計をした上で、各1からk*2+1個分先までの区間の「個数」が最大になる場合を探せば良い。もし文字列Sが0から始まったら、最初に「1が0個」があるとみなせば良い。これなら計算量はO(S.size())程度なので余裕で間に合う。

#include <bits/stdc++.h>
using namespace std;

int main(){
  int N, K;
  cin >> N >> K;
  string S;
  cin >> S;
  vector<int> arr(N, 0);
  int idx = 0;
  char pre = '1';
  if (S.at(0) == '0') { // 0スタートだった
    idx++;
    arr.at(0) = 0; // 1が0個あることにする
    pre = '0';
  }
  for (int i = 0; i < N; i++) {
    if (pre == S.at(i)) {
      arr.at(idx)++;
    } else {
      idx++;
      arr.at(idx)++;
    }
    pre = S.at(i);    
  }
  
  int max_lensum = 0;
  for (int i = 0; i < idx+1; i = i+2) {
    int lensum = accumulate(arr.begin()+i, arr.begin() + min(i+2*K+1, idx+1), 0);
    if (lensum > max_lensum) max_lensum = lensum;
    if (i+2*K+1 > idx) break;
  }
  cout << max_lensum << endl;
}

ABC 123反省会

C++ Python AtCoder

今回はAとBはスッと解けたもののCでハマってしまった。

A. Five Antennas

条件よく読んでなくて総当たりしてしまった。

a = [int(input()) for _ in range(5)]
k = int(input())
flag = True

for i in range(5):
  for j in range(5):
    if abs(a[i] - a[j]) > k:
      flag = False
      break

if flag:
  print('Yay!')
else:
  print(':(')

C++でやり直し。これでよかったですね。

#include <bits/stdc++.h>
using namespace std;
int main(){
  int a, b, c, d, e, k;
  cin >> a >> b >> c >> d >> e >> k;
  cout << (e - a <= k ? "Yay!" : ":(") << endl;
}

B. Five Dishes

Python

import math

t = [int(input()) for _ in range(5)]

min1 = map(lambda x: x % 10, t)
min1 = min([10 if i == 0 else i for i in min1])

print(sum(map(lambda x: math.ceil(x) * 10, [i/10 for i in t])) - (10 - min1))

C++

#include <bits/stdc++.h>
using namespace std;
int main(void){
  int min_1 = 10;
  int sum = 0;
  int t;
  for (int i = 0; i < 5; i++) {
    cin >> t;
    if (t % 10 != 0 && t % 10 < min_1) min_1 = t % 10;
    sum += int(ceil(t / 10.0) * 10);
  }
  cout << sum - 10 + min_1 << endl;
}

C. Five Transportations

ここで時間切れになってしまった。

1つの都市が空になるまでの時間を積み重ねていこうと思ったんだけど、これが良くなかった。最終的に解ける方法ではあったのだけれど、細かい部分にバグが入り込みやすくてWA連発してしまった。テストケースをもう少しうまく組み立てられればなんとかなったかもしれない。

N = int(input())
abcde = [int(input()) for _ in range(5)]

time = 0
n = N # 次の都市でまだ残っている人数
last = 0 # 最後の1回で移動する人数

for i in range(5):
  time += n // abcde[i]
  if n % abcde[i] > 0:
    time += 1

  last = n % abcde[i]
  if last == 0:
    last = abcde[i]

  if i < 4: 
    n = last + max((N-last) - (time-i-1) * abcde[i+1], 0)
  
print(time)

まあ実際にはこれでよかったんだけど…。

Python

import math

N = int(input())
a = [int(input()) for _ in range(5)]

print(math.ceil(N / min(a)) + 4)

C++

#include <bits/stdc++.h>
using namespace std;
using ll = long long;

int main(){
  ll N;
  cin >> N;
  vector<ll> max_n(5);
  for (int i = 0; i < 5; i++) {
    cin >> max_n.at(i);
  }
  ll min;
  min = *min_element(max_n.begin(), max_n.end());
  cout << setprecision(16) << ceil(N / double(min)) + 4 << endl;
}

D. Cake 123

解答見て素直な方法をやってみたらギリTLEになってしまった（提出 #4867478 - AtCoder Beginner Contest 123）。

x, y, z, k = [int(i) for i in input().split()]

a = [int(i) for i in input().split()]
b = [int(i) for i in input().split()]
c = [int(i) for i in input().split()]

ab = [ai + bi for ai in a for bi in b]
ab.sort(reverse=True)
ab = ab[:k]

abc = [abi + ci for abi in ab for ci in c]
abc.sort(reverse = True)

for i in range(len(abc)):
  if i < k:
    print(abc[i])
  else:
    break

ところが全く同じコードをPyPy3で提出したところACになった（提出 #4868185 - AtCoder Beginner Contest 123）。ループの少ない例ではあまり時間が短縮されないようだった（むしろ長くなる例もあった）が、ループが多いとかなりの時間短縮が見込めるようだ。ギリギリTLEになるときはとりあえずPyPy3にしてみるというのはアリかもしれない。互換性がどの程度なのかよく調べてないけど…。

ちなみにC++なら相当余裕があった。

#include <bits/stdc++.h>
using namespace std;

#define REP(i, n) for(int i = 0; i < (int)(n); i++)

using lli = long long int;

int main(){
  int x, y, z, k;
  cin >> x >> y >> z >> k;
  vector<lli> a(x);
  vector<lli> b(y);
  vector<lli> c(z);
  
  REP(i, x) cin >> a.at(i);
  REP(j, y) cin >> b.at(j);
  REP(k, z) cin >> c.at(k);
  
  vector<lli> ab(x*y);
  int idx = 0;
  REP(i, x) {
    REP(j, y) {
      ab.at(idx) = a.at(i) + b.at(j);
      idx++;
    }
  }
  
  sort(ab.rbegin(), ab.rend());
  
  vector<lli> abc(k*z);
  idx = 0;
  REP(i, min(x*y, k)) {
    REP(j, z) {
      abc.at(idx) = ab.at(i) + c.at(j);
      idx++;
    }
  }
  
  sort(abc.rbegin(), abc.rend());
  REP(i, k) {
    cout << abc.at(i) << endl;
  }
}