duangsuse::Echo
稍微 apply 了一下渐进设计，但我还是无法感知算法的灵魂
>>> hanTextFromInt(10000000)
一千
>>> hanTextFromInt(1000000000)
一十
之所以说它 dirty 是因为这种情况它会傻眼，所以递归算法里必须有修改，但我才懒得改呢…… 绝句也不需要支持
hanziFromInthanzi.kt
1 KB
我才懒得写能 pass 的版本呢（喷），这个版本
(1..100_000_000).map(::hanTextFromInt).sumBy { it.length } 算不出来，太难了，但可以用模拟只记 sum 长度列表算，而且写出正确算法以后带换下抽象数据类型就可以得到 partial info 的计算结果，那是不需要脑子的。需要脑子的是：如何把它写明白。写明白、写出灵魂永远是第一位，无论你是在写 app 抑或是算法题，但是我不会太多算法，所以，打住。
这个实现（虽然不完全）的关键词有两个：(Set)
第一个用来选择某数的最大单位，从而把输出问题化为子问题解决。
第二个则是基本的进制换算常用模式，div 的是某单位上的数位、mod 出的是余下比它小的数值，也是递归子问题。
汉字数的模式基本就是这样：
+
我不是想要教小白了解…… 以上。 #Algorithm #Kotlin
这个实现（虽然不完全）的关键词有两个：(Set)
findMaxLessEqual. (Int) divMod 第一个用来选择某数的最大单位，从而把输出问题化为子问题解决。
第二个则是基本的进制换算常用模式，div 的是某单位上的数位、mod 出的是余下比它小的数值，也是递归子问题。
汉字数的模式基本就是这样：
+ 零例：二百二十、二十一、三十一万
+ 一~九
+ (lessThan 某单位) 某单位 (equal (pred 某单位))
+
(lessThan 某单位) 某单位 零 (lessThan 某单位)
例：一千零八十二我不是想要教小白了解…… 以上。 #Algorithm #Kotlin
进步就是否定自己，这样才能变得更好，但长此以往就容易人格扭曲，变得高傲自负，甚至连亲朋好友都不放在心上。（开玩笑 😂）
我必须拿一些现在有把握的东西自我娱乐一下。
Forwarded from duangsuse::Echo
我要尝试给 debuggable 标签正名，所以必有一点是必须做的：
在这个部分插入翻转后的 DEBUGGABLE_ATTR (
就是
在这个部分插入翻转后的 DEBUGGABLE_ATTR (
0x0101000f)就是
0x0f000101
duangsuse::Echo
#reveng #recommend https://github.com/fourbrother/AXMLEditor
我们要重写的就是这个，考虑到没必要的原因，就不写 Reader/Writer 部分了 不，写，用 Kotlin multi-platform
interface ByteReader {
fun read(): Byte
fun readTo(buffer: Buffer)
fun readTo(buffer: Buffer, indices: IdxRange)
}
interface ByteWriter {
fun write(byte: Byte)
fun writeFrom(buffer: Buffer)
fun writeFrom(buffer: Buffer, indices: IdxRange)
}
interface Reader: ReadControl, DataReader
interface Writer: WriteControl, DataWriter
interface MarkReset {
fun mark() fun reset()
}
interface ReadControl: MarkReset, Closeable {
val position: Cnt; val estimate: Cnt
fun skip(n: Cnt)
}
interface WriteControl: Flushable, Colseable
interface DataReader {
fun readNat8():Nat8 fun readNat16():Nat16
fun readChar16():Char16
fun readInt8():Int8 fun readInt16():Int16
fun readInt32():Int32 fun readInt64():Int64
fun readRat32():Rat32 fun readRat64():Rat64
}
interface DataWriter {
fun writeNat8(x:Nat8) fun writeNat16(x:Nat16)
fun writeChar16(x:Char16)
fun writeInt8(x:Int8) fun writeInt16(x:Int16)
fun writeInt32(x:Int32) fun writeInt64(x:Int64)
fun writeRat32(x:Rat32) fun writeRat64(x:Rat64)
}
enum class ByteOrder {
BigEndian, LittleEndian
}
interface ByteOrdered {
var byteOrder: ByteOrder
}
interface Sized {
val size: Cnt
}
abstract class Tuple<E>(override val size: Cnt): Size {
protected abstract val items: Array<E>
operator fun get(index: Idx) = items[index]
operator fun set(index: Idx, value: E) { items[index] = value }
protected fun <T> index(idx: Idx) = object {
operator fun getValue(_p: KProperty<*>, self: Tuple<out T>) = self[idx]
operator fun setValue(_p: KProperty<*>, self: Tuple<in T>, value: T) { self[idx] = value }
}
}
fun <E> Tuple<T>.component1() = this[0]
fun <E> Tuple<T>.component2() = this[1]
fun <E> Tuple<T>.component3() = this[2]
fun <E> Tuple<T>.component4() = this[3]
inline fun <T, I, R> intBitwise(crossinline to: (T) -> I, crossinline op: I.(I) -> I, crossinline from: (I) -> R): T.(T) -> R删掉算了
= { to(this).op(to(it)).let(from) }
inline fun <T, I, R> intByteBitwise(crossinline to: (T) -> I, crossinline op: I.(Byte) -> I, crossinline from: (I) -> R): T.(Byte) -> R
= { b -> to(this).op(b).let(from) }
internal fun Int.or(byte: Byte): Int = or(byte.toInt())