Young Zy, [21.07.19 17:33]
> 完全自闭
> 然后我因为取余写自闭了，至少白给了8发

duang suz, [21.07.19 18:53]
[In reply to Young Zy]
< 卡了你两个小时，本来已经通过了，可是你为了优化 10x 就又多花了很多时间？...

duang suz, [21.07.19 18:56]
[In reply to Young Zy]
def resolve(n, m)
ac = 0
(1..n).each do|i|
  (1..m).each do |j|
    ac += i*j*(n % i)*(m % j)
  end
end
return ac % (10**9 + 7)
end

（也可以 Map & Sum, Kotlin 里一般这么做大概，当然这都应该看优化了的说，比如并行计算和代数化简）
我还以为是高大上算法题呢... 数学公式翻译啊... 连列数学公式都不需要自己做，这降低了好大难度档次的说...

开始看这 MathJax 的排版我还以为是逆天级别的题目... 数学 + 算法...

[In reply to Young Zy]
< 又不是位运算优化取余或者自己实现整除和取余(divmod)（
< def fmod(n, m): return (n|m)-n
< 话说那个『快速』取余是怎么定义来着...

[In reply to Young Zy]
< 是数值安全（防溢出什么的）的题？

ߓߎߏߔߜߗߙ ߌߋߎߖߘߛߟ, [21.07.19 19:12]
> 多久算出来？
> 要速度的

[In reply to Young Zy]
< 我还以为会溢出（

ߓߎߏߔߜߗߙ ߌߋߎߖߘߛߟ, [21.07.19 20:22]
> 会
> 绝对会
> 多个错误撞一起
> 看哪个先碰到

duang suz, [21.07.19 20:22]
< 等价变换啊，很多嵌入式算法都是这么解决的

我考虑了一会后想到 | What I Thought

duang suz, [21.07.19 20:23]
我走路的时候想了一会，否定了以下的脑残假设，打算过会整理一下成文，算作进步... 虽然我还是不会

（此处省略若干行）

我...

数值的我直觉比较差... 因为完全模拟做不到、一些别人都已知道的代数套用我又不会记，然后我整理的速度也比别人慢很多...

duang suz, [21.07.19 20:38]
[In reply to Young Zy]
< 🤔 我要手动展开很久... 你是怎么解的？是代数化简吗？

ߓߎߏߔߜߗߙ ߌߋߎߖߘߛߟ, [21.07.19 20:39]
> 你知道同余定理嘛

duang suz, [21.07.19 20:39]
[In reply to ߓߎߏߔߜߗߙ ߌߋߎߖߘߛߟ]
< 不知道，恐怕我得手动推...

div

Young Zy, [21.07.19 20:54]
> 官方的题解出来了，我截个图给你们
> 反正是个数学题

题解 | "Immediate" Solution

sqrt, log 和乘方函数 | Power Operators

divrem 的『图示』 | Property Definition for div & rem

• 数是什么？_{这里的数是自然数Natural Numbers} \[ \begin{eqnarray} Nat & = & \begin{cases} 0 \in{Nat} \\ x\in{Nat} \Rightarrow (x + 1)\in{Nat} \end{cases} \\ zero & = & 0 \\ succ(x\in{Nat}) & = & x +1 \\ pred(x\in{Nat}) & = & x -1 \\ pred(zero) & = & undefined \\ \forall{x}. (x+1) -1 & = & x \\ \end{eqnarray} \] 由 \( \forall{x}. (x+1) -1 = x \) 可以推出 \( \forall{x}\in{Nat}. (x-1)\in{Nat} \)
  \[ \begin{eqnarray} (0+1)\in{Nat} & \Rightarrow & ((0+1) - 1)\equiv{0} & \in{Nat} \\ \forall{(x+1)}\in{Nat} & . & ((x+1) - 1)\equiv{x} & \in{Nat} \\ pred(succ & (0)) & \equiv{0} & \in{Nat} \\ \forall{succ(x)} & . & pred(succ(x))\equiv{x} & \in{Nat} \end{eqnarray} \]
  Haskell

  
  -- data Nat = O | S Nat
  data Nat where
    O :: Nat
    S :: Nat -> Nat
  zero = O :: Nat
  succ = S :: Nat -> Nat
  pred (S x) = x
  pred O = undefined
  -- (succ . pred) = (S . \(S x) -> x) = id
  

• 加法是什么？ \[ add(a, b) = \begin{cases} b, & a = zero \\ add(pred(a), succ(b)), & otherwise \end{cases} \] In other words，把 \(a\) 的每个 \(succ\) 转移到 \(b\) 上 \[ \begin{eqnarray} add(succ(x), & b) & = & add(x, succ(b)) \\ add(zero, & b) & = & b \end{eqnarray} \]
  Haskell

  
  add :: (Nat, Nat) -> Nat
  add (a, b)
    | a == zero = b
    | otherwise = add (pred a, succ b)
  
  add' :: (Nat, Nat) -> Nat
  add' (S x, b) = add' (x, S b)
  add' O b = b
  

• 减法是什么？ \[ sub(b, a) = \begin{cases} b, & a = zero \\ zero, & b = a = zero \\ undefined, & b = zero \\ sub(pred(b), pred(a)), & otherwise \end{cases} \] 换句话说，把每个 \(pred\) 转移到 \(b\) 上 \[ \begin{eqnarray} sub(b, & zero) & = & b \\ sub(succ(b'), & succ(a')) & = & sub(b', a') \\ sub(zero, & zero) & = & zero\\ sub(zero, & a) & = & undefined \end{eqnarray} \]
  Haskell

  
  sub :: (Nat, Nat) -> Nat
  sub (b, a)
    | b == O & a /= O = undefined -- 负数不是自然数
    | a == O = b
    | otherwise = sub (pred b, pred a)
  
  sub' :: (Nat, Nat) -> Nat
  sub (b, O) = b
  sub (O, S _) = undefined
  sub (S b', S a') = sub (b', a')
  

• 乘法是什么？ \[ a \times{b} = \overbrace{a + a + \cdots + a}^{b} \] \[ times(a, b, n=0) = \begin{cases} n, & a = 0 \\ times(pred(a), b, add(b, n)), & otherwise \end{cases} \]
  Haskell

  
  times :: (Nat, Nat) -> Nat
  times a b = times' a b O
    where
      times' O _ n = n
      times' (S a') b n = times' a' b (add (b, n))
  
  times' :: (Nat, Nat) -> Nat
  times' a b = foldl (\ac, x -> add (x, ac)) 0 (take b (repeat a))
  
  foldn :: (Nat -> Nat -> Nat) -> Nat -> (Nat -> Nat)
  foldn f v O = v
  foldn f v x = let (S x') = x in foldn f (f v x) x'
  
  times'' = foldn (curry add) O
  

• 求幂（乘方）是什么？ 写累了，说起来，其实即便有交换律存在，顺序（主语和宾语）很重要，可惜我级别太低无力维护了。
  \[ a^b = \overbrace{a \times a \times \cdots \times a}^{b} \]
  Haskell

  
  power a b = foldn ((curry times) a) (S O) b
  

• 除法是什么？_{\(b\) 里面有几个 \(a\)} \[ div(b, a, n=0) = \begin{cases} div(sub(b, a), a, succ(n)), & gt(b, a) \lor a \equiv b \\ n, & otherwise \end{cases} \]
  Haskell

  
  div :: (Nat, Nat) -> Nat
  div (b, a) = div' (b, a, O)
    where div' (b, a, n)
      | eq(b, a) or gt(b, a) = div(sub(b, a), a, succ(n))
      | otherwise = n
  

• 取余法是什么？_{神奇海螺：为啥不用 divrem 呢？} \[ rem(b, a, n=0) = \begin{cases} rem(rem(b, a), a, succ(n)), & gt(b, a) \lor a \equiv b \\ b, & otherwise \end{cases} \] 从取余数也可以推出一个简单的性质：当除数大于被除数，余数等于被除数、商等于零 \[ \neg{gt(b, a)} \Rightarrow rem(b, a) \equiv{b} \land div(b, a) \equiv{0} \] \[ b < a \Rightarrow rem(b, a) \equiv{b} \land div(b, a) \equiv{0} \] 所以取余操作符的性质等式才能成立： \[ \forall{b a}. a\times{\llcorner\frac{b}{a}\lrcorner} + rem(b, a) = b \]
  Haskell

  
  rem :: (Nat, Nat) -> Nat
  rem (b, a) = rem' (b, a, O)
    where rem' (b, a, n)
      | eq(b, a) or gt(b, a) = rem(sub(b, a), a, succ(n))
      | otherwise = b
  
  divrem :: (Nat, Nat) -> (Nat, Nat)
  divrem (b, a) = rem' (b, a, (O, O))
    where divrem' (b, a, (dn, rn))
      | eq(b, a) or gt(b, a) = divrem(sub(b, a), a, (succ(n), O))
      | otherwise = (dn, b)
  

• 比较法是什么？_{包含相等性和『小于』lessThan} \[ eq(a, b) = \begin{cases} true, & a = b = 0 \\ eq(pred(a), pred(b)), & a \ne{0} \land b \neq{0} \\ false, & otherwise \end{cases} \] \[ gt(b, a) = \begin{cases} true, & a = 0 \land b \neq{0} \\ false, & b = 0 \land a \neq{0} \\ false, & a = b = 0 \\ gt(pred(b), pred(a)), & otherwise \end{cases} \] \[ lessThan(a, b) = gt(b, a) \]
  Haskell

  
  eq :: (Nat, Nat) -> Bool
  eq (O, O) = True
  eq (S a', S b') = eq (a', b')
  eq (_, _) = False
  
  gt :: (Nat, Nat) -> Bool
  gt (O, S _) = False
  gt (S _, O) = True
  gt (O, O) = False
  gt (S b', S a') = gt (b', a')
  
  lessThan :: Nat -> Nat -> Bool
  lessThan = flip (curry gt)
  

• 被除数是什么？_{最后一问，实在没有力气写了，我相信我是这个问题写的最仔细的人了可能} \[ \underbrace{ \overbrace{a + a + \cdots + a}^{\frac{b}{a}} + \overbrace{c}^{b-a\times\frac{b}{a}} }_{b} \] 然后你可能要问了，那 \( b-a\times\frac{b}{a} \) 不是可以 约分嘛，这不 \(c \equiv{b-b} \equiv{0}\) \[ \underbrace{ \overbrace{a + a + \cdots + a}^{\frac{b}{a}} }_{b} \]
  所以算 \(c\) 要整除（Haskell 里 b `div` a 是整除 (/) b a 是实除）
  （虽然引入小数后除不尽就不可能了 \[ \underbrace{ \overbrace{a + a + \cdots + a}^{\llcorner\frac{b}{a}\lrcorner} + \overbrace{c}^{b-a\times\llcorner\frac{b}{a}\lrcorner} }_{b} \] 定义是递归的，所以不好理解 （应该说这是对 \( \frac{b}{a}\) 的定义，可是 \(\llcorner \frac{b}{a}\lrcorner\) 实际应该被… 认为是先除法再取整的操作，而不是取整和除法定义的 结合，这是『模式』化可能造成的一个混淆）
  Haskell

  
  {- 不好意思，我已经不知道如何使用 Haskell 表达它了 -}
  Integral :: * -> Constraint
  div :: Integral a => a -> a -> a
  (/) :: Fractional a => a -> a -> a
  instance Integral Int -- Defined in ‘GHC.Real’
  

• 如何和普通的数字进行转换？_{不过 Nat 和 Int 并不是同构的}
  请读者自己开动脑筋，用 Haskell 完成 fromInt 和 toInt 函数的定义

从等式分析（变换）看 sum （求和公式） | The \( \sum{} \) Operator

for i in range(1, 11): print(str(i) + " " + str(len(list(range(1, 101, i)))))

完了 | Aborted