Question

我有

+----+
| id |
+----+
|  2 |
|  3 |
|  5 |
|  7 |
| 11 |
| 13 |
| 17 |
| 19 |
| 23 |
| 29 |
| 31 |
| 37 |
| 41 |
| 43 |
| 47 |
| 53 |
| 59 |
| 61 |
| 67 |
| 71 |
| 73 |
| 79 |
| 83 |
| 89 |
| 97 |
+----+
25 rows in set (0.00 sec)

但这是一个垃圾功能。帮助

let f = x => x % 4 === 0 ? 0 : 4 - x % 4永远不会消极。

这是一种真理表，或者某种东西。

我试图在这里找到一些相关性，但它已经很晚了，我不认为我的大脑正常工作。 ZZZ

我在x x % 4 4 - (x % 4) f(x) 0 0 4 0 1 1 3 3 2 2 2 2 3 3 1 1 4 0 4 0 5 1 3 3 6 2 2 2 7 3 1 1 8 0 4 0 9 1 3 3列中看到的是一种反向模数，其输出周期为032103210 ...而不是01230123 ......

我感觉某些f(x)或Math.max与Math.min结合使用可能有所帮助......那里可能还有一个Math.abs ...

你能帮我写一下x * -1，这样它就不会那么糟糕吗？

Answer 1

我以为你不想使用modulo。那么这是你的代码。

var f = x => 2 * (x & 2 ? ~x & 1 : x & 1) + (x & 1)

x   x % 4    4 - (x % 4)       f(x)
0     0         4               0
1     1         3               3
2     2         2               2
3     3         1               1
4     0         4               0
5     1         3               3
6     2         2               2
7     3         1               1
8     0         4               0
9     1         3               3

说明：我只需回忆一下真相表的旧时代，这有助于我解决这个问题。所以现在我们有输入和输出。由于我们在模4中工作，我们只对最后两位感兴趣。

 Input    Output
0 : 0 0    0 0
1 : 0 1    1 1
2 : 1 0    1 0
3 : 1 1    0 1

因此，如果我们看一下，输出2 ^ 1数字是输入2 ^ 0和2 ^ 1的XOR，因此2 * (x & 2 ? ~x & 1 : x & 1)和输出2 ^ 0数字实际上输入2 ^ 0数字。这是(x & 1)因此...... var f = x => 2 * (x & 2 ? ~x & 1 : x & 1) + (x & 1)

注意：（foo XOR bar = foo ? !bar : bar）

                                 u       v
                        y        z       z       w
   x       x & 2   ?    ~x       y & 1   x & 1   2 * z  w + v  f(x)
-- ------  ------  ---  -------  ------  ------  -----  -----  ----
0  0000    0000    F    -0001    0001    0000    0      0      0
1  0001    0000    F    -0010    0000    0001    2      3      3
2  0010    0010    T    -0011    0001    0000    2      2      2
3  0011    0010    T    -0100    0000    0001    0      1      1
4  0100    0000    F    -0101    0001    0000    0      0      0
5  0101    0000    F    -0110    0000    0001    2      3      3
7  0110    0010    T    -0111    0001    0000    2      2      2
8  0111    0010    T    -1000    0000    0001    0      1      1
9  1000    0000    F    -1001    0001    0000    0      0      0

Answer 2

这样的事情肯定会做：

(4 - (x % 4)) % 4

这是更多的事实：

x   x % 4     4 - (x % 4)     (4 - (x % 4)) % 4
0   0         4               0
1   1         3               3
2   2         2               2
3   3         1               1
4   0         4               0
5   1         3               3
6   2         2               2
7   3         1               1
8   0         4               0
9   1         3               3

Answer 3

提前减少use of bitwise operators {/ 3}}：

f(x) = -x & 3

Truths™表

x       x       -x       3    -x&3    -x&3
-    ----    -----    ----    ----    ----
0    0000     0000    0011    0000       0
1    0001    -0001    0011    0011       3
2    0010    -0010    0011    0010       2
3    0011    -0011    0011    0001       1
4    0100    -0100    0011    0000       0
5    0101    -0101    0011    0011       3
6    0110    -0110    0011    0010       2
7    0111    -0111    0011    0001       1
8    1000    -1000    0011    0000       0
9    1001    -1001    0011    0011       3

＆＃13;

var i, 
    f = x => -x & 3;

for (i = 0; i < 20; i++) {
    console.log(i, f(i));
}

＆＃13;

.as-console-wrapper { max-height: 100% !important; top: 0; }

＆＃13;

具有负值和负偏移量3的原始解决方案然后以模数再次添加相同的偏移量。

f(x) = (-x - 3) % 4 + 3

＆＃13;

var i, 
    f = x => (-x - 3) % 4 + 3;

for (i = 0; i < 20; i++) {
    console.log(i, f(i));
}

＆＃13;

.as-console-wrapper { max-height: 100% !important; top: 0; }

＆＃13;

如何简化模运算？

3 个答案: