Datasets:
filename stringlengths 25 120 | content stringlengths 30 1.63M | extension stringclasses 15
values | source stringclasses 5
values | license stringclasses 3
values | quality_tier stringclasses 4
values | sha256 stringlengths 64 64 | byte_size int64 40 1.64M | total_lines int64 2 56.6k | cjk_ratio float64 0 1 | has_cjk bool 1
class |
|---|---|---|---|---|---|---|---|---|---|---|
000000_mulan__00000_MulanRevive__mulan-rework__确认语法说明完整.ul | using re
源数据 = open("文档/语法说明.md", 'rt', encoding="utf-8")
匹配 = re.search(3"`" + "\n(.*)\n" + 3"`", 源数据.read(), re.DOTALL)
文档各行 = 匹配 ? 匹配.group(1).split("\n") : []
文档规则 = []
for 行 in 文档各行 {
if re.match("^\s*$", 行) {
continue
}
字段 = 行.split(" : ")
if #字段 > 1 {
成分全文 = 字段[-1]
}
字段 = 行.split("| ")
if #字段 > 1 {
成分全文 = 字段[-1]
}
注释匹配 = re.match("(.*)\/\/.*", 成分全文)
if 注释匹配 {
成分全文 = 注释匹配.group(1)
}
文档规则.append(成分全文.strip()) // 去掉首尾空格
}
println("文档规则数: `#文档规则`")
源数据 = open("木兰/分析器/语法分析器.py", 'rt', encoding="utf-8")
代码各行 = 源数据.read().split("\n")
源数据.close()
代码规则 = []
for 行 in 代码各行 {
// 末个 .* 为优先级参数部分
匹配 = re.match("\s*@分析器母机.语法规则\(语法\..+\.成分\((.*)\).*\)\s*", 行)
if 匹配 {
代码规则文本 = ""
各成分 = list(map(成分 -> 成分.replace("语法.", ""), 匹配.group(1).split(', ')))
此规则 = " ".join(各成分)
代码规则.append(此规则)
}
}
println("代码规则数: `#代码规则`")
println("代码有而文档无:\n" +
"\n".join(list(filter(规则 -> !文档规则.__contains__(规则), 代码规则))))
println("文档有而代码无:\n" +
"\n".join(list(filter(规则 -> !代码规则.__contains__(规则), 文档规则))))
| .ul | mulan | MIT | A | 9b01ee9c34532b67a81a42be136b6b04ae880662df4b4f6b283baba738cd6111 | 1,530 | 53 | 0.454369 | true |
000001_mulan__00001_MulanRevive__mulan-rework__善后.ul | try {} finally {}
/*
逆向里代码如下，出现的问题就是语法为try_stmt : TRY block final_stmt时try_stmt处理就会把handlers设置成block，其实就是语法出错了
因为要保持与原语言一致，所以我们的程序也不能增加实现，比如在加上try_stmt函数中如果len(p)为2时handlers设置为[]这样就可以正确处理
@pg_.production('try_stmt : TRY block catch_stmts')
def try_stmt(self, p):
return ast.Try(body=(p[1]),
handlers=(p[(-1)]),
orelse=[],
finalbody=[],
lineno=(self.getlineno(p)),
col_offset=(self.getcolno(p)))
@pg_.production('try_stmt : TRY block catch_stmts final_stmt')
@pg_.production('try_stmt : TRY block final_stmt')
def try_stmt_with_final(self, p):
try_stmt = self.try_stmt(p[:-1])
try_stmt.finalbody = p[(-1)]
return try_stmt
当前执行时会 报类型错误: expected some sort of excepthandler, but got <_ast.Pass object at 0x...> 错误
*/ | .ul | mulan | MIT | B | 82db27ecade8089024fb737d3227e6732303511cba2ffcc77db4891f70a532d5 | 1,018 | 21 | 0.195358 | true |
000002_mulan__00002_MulanRevive__mulan-rework__空匿名函数.ul | b = () -> 2
print(b())
/*
如出错将 /木兰/分析器/语法分析器.py `def lambda形参(self, 片段):` L762
if len(片段) == 2: # L775
# return self.形参列表()
return 语法树.新节点(语法.形参列表, 参数=[], 片段=片段)
*/ | .ul | mulan | MIT | A | 6017caa864a2e00cdc6869c0596ea088459d02fac6bee8aaf3672b3fbe1bd9b3 | 281 | 8 | 0.482759 | true |
000003_mulan__00003_MulanRevive__mulan-rework__顺便处理各表达式前缀.ul | try a,b=c {}
/*
原语言报错如下：
try a,b=c {}
ValueError: expression must have Store context but has Load instead
讲一下这句报错要表达的意思，
try a,b=c {} 的语法树如下：
Module(body=[With(items=[withitem(context_expr=Name(id='c', ctx=Load(), lineno=1, col_offset=9),
ptional_vars=Tuple(elts=[Name(id='a', ctx=Load(), lineno=1, col_offset=5), Name(id='b', ctx=Load(),
lineno=1, col_offset=7)], ctx=Store(), lineno=1, col_offset=5))], body=[Pass( lineno=1, col_offset=11)],
lineno=1, col_offset=1)])
上面的报错是说，ptional_vars属性中elts列表中需要ctx为Store但是当前为Load,所以报错。
*/ | .ul | mulan | MIT | B | 6294aee44704ca9903eb0d3bc06273edc7d8478a026de48567e6890cd56784cd | 641 | 13 | 0.153846 | true |
000004_mulan__00004_MulanRevive__mulan-rework__字符串.ul | /* 测试 */
a = '测试'
str(time_diff) | .ul | mulan | MIT | B | e34465d382811d417d0ba09caf8a281e4ea82666ba27a8dd35d51b0ec120dd03 | 40 | 3 | 0.25 | true |
000005_mulan__00005_MulanRevive__mulan-rework__ExtSlice_待解决.ul |
/*
下方注释的代码当前木兰语法分析报错：
文件 "测试/unittest/源码生成/木兰到Python\ExtSlice.ul", 第1行, 第4列, 没认出这个词 ","
a[1?, 2]
*/
/*
a[1, 2]
a[1, 2, 3]
a[1, 2, 3, 4]
*/
| .ul | mulan | MIT | A | 8f457f7f277dd1b7ec26949d4467c2a25fa6adcbade11a4de1221c09541a4733 | 219 | 12 | 0.58209 | true |
000006_mulan__00006_MulanRevive__mulan-rework__ImportFrom_待解决.ul | // using b in .. // 此语句当前的木兰语法分析报错：
/*
文件 "测试/unittest/源码生成/木兰到Python\ImportFrom.ul", 第4行, 第12列, 没认出这个词 ".."
using b in ?..
*/
| .ul | mulan | MIT | A | 4c3d1e84ef26d1a50c69ec42de4312a4600f7cff62db33942521ffb34d79d5e2 | 201 | 5 | 0.461538 | true |
000007_mulan__00007_MulanRevive__mulan-rework__signature.ul | /*
原始木兰不能执行该测试用例：
$ C:\ulang-0.2.2.exe --dump-python .\源码生成\函数\变长指名参数.ul
SyntaxError: File ".\源码生成\函数\变长指名参数.ul", line 1:8, unexpected token "*"
func a(**kwargs) {
^
*/
func a(**kwargs) {
print(kwargs)
}
func b(*args) {
print(args)
}
a(k1="v1", k2="v2")
b(3, 4)
a(**{a: 1, b: 2})
b(*(3, 4))
| .ul | mulan | MIT | B | 9b44aa443007f2c0fb4cbd18129b50629fd6f9dce88bbd282dae3de637c71c66 | 386 | 21 | 0.24359 | true |
000008_mulan__00008_MulanRevive__mulan-rework__冒泡.ul |
func 冒泡(数列) {
换过 = true
while 换过 {
换过 = false
for i in range(0, len(数列) - 1) {
前项 = 数列[i]
后项 = 数列[i + 1]
if (前项 > 后项) {
数列[i], 数列[i + 1] = tuple(后项, 前项)
换过 = true
}
}
}
}
打乱数列 = [5, 2, 1, 8, 4]
冒泡(打乱数列)
println(打乱数列) | .ul | mulan | MIT | A | 0b6325b4c92a3c9fc3a80bdd7cc41e15c7a58a9241ca99ab71236c81a50835f5 | 371 | 18 | 0.470588 | true |
000009_mulan__00009_MulanRevive__mulan-rework__插入.ul |
func 插入排序(数列) {
for i in range(1, len(数列)) {
挑出 = 数列[i]
位置 = i - 1
while ((位置 >= 0) and (数列[位置] > 挑出)) {
数列[位置 + 1] = 数列[位置]
位置 -= 1
}
数列[位置 + 1] = 挑出
}
}
乱序数列 = [5, 2, 1, 8, 4]
插入排序(乱序数列)
println(乱序数列) | .ul | mulan | MIT | A | 5bad0c12f56579c4783d83fc7033e8e885eb55c89e43f36969eeae0bff3dd80d | 347 | 15 | 0.606742 | true |
000010_mulan__00010_MulanRevive__mulan-rework__猜数字.ul | using sys, cmd
using randrange in random
type 猜数字 : cmd.Cmd {
{
intro, prompt = tuple('我想了个 100 之内的数，猜猜是几？', '请猜吧: ')
想的 = randrange(1000) / 10
}
func $default(行) {
try {
数 = int(行)
}
catch 例外 : ValueError {
println(行 + ' 不是数，请再试')
return
}
$比较(数)
}
func $比较(数) {
if (数 == $想的) {
println('中了!')
sys.exit()
}
println((数 > $想的) ? '太大了!' : '太小了!')
}
}
猜数字().cmdloop() | .ul | mulan | MIT | B | 1afe37b738e35900239e53241ac164d45a860d0d0641605f4e19cb5261a793a8 | 567 | 30 | 0.282927 | true |
000011_mulan__00011_MulanRevive__mulan-rework__文件.ul | f = open('测试/函数/API/测试.txt', 'rt')
内容 = f.read()
f.close()
print(内容) | .ul | mulan | MIT | B | 4851f094663ab9146a279ec3b71e6839af16ae616c59daeb7ad057c1354c820a | 88 | 4 | 0.25641 | true |
000012_mulan__00012_MulanRevive__mulan-rework__map.ul | func 平方(n) {
return n*n
}
print(list(map(平方, [1,2,3]))) | .ul | mulan | MIT | B | b3b31667176a336f3a91cda3e854b03f6cb45dc63caf25089ad91420e5e81dfa | 67 | 4 | 0.137931 | true |
000013_mulan__00013_MulanRevive__mulan-rework__匿名函数.ul | print(list(filter(func (n) { return n>0 }, [1,-1])))
print(list(filter(n -> n>0, [1,-1])))
print(list(filter(n -> {
平方 = n*n
return 平方>5
}, [1,3])))
print(list(filter(
边长 -> { 面积 = 边长 * 边长; return 面积 > 5 },
[1,3]
)))
print(list(map(
func (边长) { 面积 = 边长 * 边长; return 面积 },
[1, 2]
)))
print(func (长, 宽) {
面积 = 长 * 宽;
return 面积
}(3, 4))
type 形状 {
{}
}
print(func (边长) : 形状 {
return 形状()
}(1) != nil)
a = () -> 3
print(a())
正方形面积 = (边长:int) -> 边长*边长
print(正方形面积(2))
print(list(filter((n:int) -> n>0, [1,-1])))
体积 = (长:int, 宽:int, 高:int) -> 长*宽*高
print(体积(2, 3, 4))
长方体体积 = (长, 宽, 高) -> 长*宽*高
print(长方体体积(3, 4, 5))
长方形面积 = (宽, 高:int) -> 宽*高
print(长方形面积(2, 3))
三角形面积 = (底:int, 高=3) -> 底*高/2
print(三角形面积(3, 4))
print(三角形面积(4)) | .ul | mulan | MIT | A | 15ec0f49a4b7d8737deb83796200ec9edd1574c619e3297ef3b46004235bc455 | 967 | 38 | 0.340237 | true |
000014_mulan__00014_MulanRevive__mulan-rework__指定返回类型.ul | type Person {
{
name = "小白"
}
func $__init__(name) {
self.name = name
}
}
func shout(id): Person {
return Person(id)
}
print(shout("Mulan1").name) | .ul | mulan | MIT | C | c03fec8ed0d616c46b2c7e87b1dd51c9c36662e36bfb04621b5057529619325c | 189 | 15 | 0.022222 | true |
000015_mulan__00015_MulanRevive__mulan-rework__若干形参.ul | func 若干形参(...) {
for 参数 : ... {
print(typeof(参数))
}
}
type Test {
{}
}
若干形参(1, 2.3, '3', Test())
func 回复(...) {
print(...)
}
回复(1, 2, 3)
单个若干参数 = (...) -> typeof(...)
print(单个若干参数('string'))
多个若干参数 = (...) -> max(...)
print(多个若干参数(3, 1, 2))
func 求和(...){
和值 = 0
for 值 in ... {
和值 += 值
}
return 和值
}
print(求和(2, 2, 3))
若干形参 = (a, b=3, ...) -> a*b*求和(...)
print(若干形参(1, 2, 3, 4))
func 哈(...) {
__varargs__ = tuple('ha', 'ha')
print(...)
}
哈(2, 3, 3, 3)
| .ul | mulan | MIT | A | a86e9b94e01811b42b62184ac56c35791cd15a6df1bf6bcfaa91eef143179120 | 635 | 32 | 0.351648 | true |
000016_mulan__00016_MulanRevive__mulan-rework__过滤.ul | func a() {
func 大数(n) {
return n>5
}
return 大数
}
print(list(filter(a(), [1,10]))) | .ul | mulan | MIT | B | 03337ab509ff662ea36de5d3e7c27be01bc9a54f5302f8c0655dd2b614bdf95e | 109 | 7 | 0.093023 | true |
000017_mulan__00017_MulanRevive__mulan-rework__返回多值.ul | func echo() {
return 1, 2
}
多值 = echo()
print(多值[0])
print(多值[1]) | .ul | mulan | MIT | B | 00e57b8ad867dcb6d5f2131f1f9307ab4ec7c518f53a6fe4bcc4b8d4dd5980a0 | 81 | 6 | 0.176471 | true |
000018_mulan__00018_MulanRevive__mulan-rework__双引号.ul | print("ok")
print("\n")
print("\t")
print("\\\")
print("\"")
print("\\\"+"n")
func print2(a, b) {
print(a)
}
print2("a","b")
源数据文件 = open("测试/字符串/空行.txt", 'rt', -1, "utf-8")
内容 = 源数据文件.read()
源数据文件.close()
print(内容 == "\n")
源数据文件 = open("测试/字符串/制表符.txt", 'rt', -1, "utf-8")
内容 = 源数据文件.read()
源数据文件.close()
print(内容 == "\t")
print(2"c")
| .ul | mulan | MIT | A | a8b11983794e6e841e157616cc4923875c880fc9dc400721de98b033d30ae5b1 | 446 | 19 | 0.30814 | true |
000019_mulan__00019_MulanRevive__mulan-rework__相关方法.ul | print("你好".find('好'))
for 字 in "hi" {
print(字)
}
using re
print(re.findall('\bfish', 'fish 1fish'))
| .ul | mulan | MIT | B | f18e1c624c7ef0ce603da2cfa7e5a552811a02462a8142155974e5d453b96064 | 112 | 6 | 0.083333 | true |
000020_mulan__00020_MulanRevive__mulan-rework__四百药.ul | using re
源数据 = open("测试/实用/中医/四百药.txt", 'rt', encoding="utf-8")
所有行 = 源数据.read().split("\n")
源数据.close()
药名 = []
for 行 in 所有行 {
匹配 = re.match("\d+\.(.*)[（\s]", 行)
if 匹配 {
药名.append(匹配.group(1))
continue
}
匹配 = re.match("\d+\.(.*)$", 行)
if 匹配 {
药名.append(匹配.group(1))
}
}
去重 = set(药名)
println(药名)
println(len(去重))
| .ul | mulan | MIT | A | b2a69349f7b31277703995150acd7ad2e4167ad0ebc8d4e4169808e5e61f73e8 | 451 | 25 | 0.313953 | true |
000021_mulan__00021_MulanRevive__mulan-rework__分词.ul | using jieba
词表 = jieba.cut("谁也不用奇怪也别问为什么呀")
for 词 in 词表 {
println(词)
} | .ul | mulan | MIT | A | 35a9390ce539e60f1a2dede0a0ddc5c9ea31eb4aca3842083ac61f0088e34034 | 113 | 6 | 0.387755 | true |
000022_mulan__00022_MulanRevive__mulan-rework__取形声字.ul | using 字典 in chinese_characters_words
using * in chinese_regular_expression.规律
using json, re
常用字数据 = open('测试/实用/字/常用字拆字.json', 'r', encoding="utf-8")
拆字 = json.load(常用字数据)
常用字数据.close()
func 字音(字) {
信息 = 字典.查单字(字)
return 信息 ? 信息['拼音'] : nil
}
func 去音调(拼音) {
拼音 = re.sub(某字('āáǎà').表达(), 'a', 拼音)
拼音 = re.sub(某字('ōóǒò').表达(), 'o', 拼音)
拼音 = re.sub(某字('īíǐì').表达(), 'i', 拼音)
拼音 = re.sub(某字('ēéěè').表达(), 'e', 拼音)
拼音 = re.sub(某字('ūúǔù').表达(), 'u', 拼音)
return 拼音
}
func 近音(字) {
信息 = 字典.查单字(字)
return 信息 ? 去音调(信息['拼音']) : nil
}
func 取部件(字) {
return 字典.的结构(字)['部分']
}
func 任一(全集) { return any(全集) }
func 取形声字(所有字) {
return list(
filter(
字 -> 任一(
map(
部件 -> 字音(部件) == 字音(字) or 近音(部件) == 近音(字),
取部件(字)
)),
所有字)
)
}
// 1390 字，737 音
// 485 形声字，258 音调相同，229 不同。待做：哪2个重复？
所有形声字 = 取形声字(拆字)
println(#所有形声字) | .ul | mulan | MIT | A | b0fe16cc58a41e5cdf658f4d158b4d40637ef5aa6a729209bc3cef21770d11af | 1,306 | 49 | 0.476744 | true |
000023_mulan__00023_MulanRevive__mulan-rework__常用字拆分.ul | using 为常用字 in 测试.实用.通用.库_常用字
using json
// 不包含常用字, 比如"广"
// ⻖和⻏分别为左/右耳朵旁
// 形近码异问题: 辶⻌不同!
一笔 = "乚"
二笔 = "刂冫匚𠆢亠⺆勹亻辶⻌廴冖讠⻖⻏"
三笔 = "氵彡丬口囗扌忄饣彳宀艹纟犭彐"
四笔 = "灬歹𤣩𠃜龵⺼攵"
五笔 = "疒𢀖矢衤钅⺲皿覀缶耒糸𧾷癶"
常用部首 = 一笔 + 二笔 + 三笔 + 四笔 + 五笔
// 数据中, 部首 礻为"示"
// 数据来源：http://git.chise.org/gitweb/?p=chise/ids.git;a=blob_plain;f=IDS-UCS-Basic.txt;hb=HEAD
源数据 = open("测试/实用/字/IDS-UCS-Basic.txt", 'rt', encoding="utf-8")
所有行 = 源数据.read().split("\n")
源数据.close()
带部首的字 = {:}
拆字 = {:}
无法拆的字 = []
for 行 in 所有行 {
字段 = 行.split("\t")
// 暂时只考察两部分构成的字
continue if len(字段) != 3
字 = 字段[1]
信息 = 字段[2]
if 为常用字(字) and 字 != 信息 {
字型 = 信息[0]
部分 = []
都为常用字 = true
for i in 1..<len(信息) {
if !为常用字(信息[i]) {
if 常用部首.find(信息[i]) >= 0 {
部首 = 信息[i]
if 带部首的字.get(部首) {
带部首的字[部首].append(字)
} else {
带部首的字[部首] = [字]
}
} else {
都为常用字 = false
无法拆的字.append(字)
break
}
}
部分.append(信息[i])
}
拆字[字] = {"字型": 字型, "部分": 部分} if 都为常用字
}
}
常用字数据 = open('测试/实用/字/常用字拆字.json', 'w', encoding="utf-8")
json.dump(拆字, 常用字数据, ensure_ascii=false, indent = 4)
常用字数据.close()
print(str(len(无法拆的字)) + "".join(无法拆的字))
/*
for 部首 in 带部首的字 {
println(部首 + " -> " + str(带部首的字[部首]))
}
for 部首 in 常用部首 {
if !带部首的字.get(部首) {
print(部首)
}
}*/ | .ul | mulan | MIT | A | 40c3b8b3d154c6a7cd580f8dcf952f1a0c0046cc82079d1107e60b5621558b37 | 2,032 | 67 | 0.511346 | true |
000024_mulan__00024_MulanRevive__mulan-rework__扩展拆字游戏.ul | using json
部分1 = "又寸土工斤木白旦各莫十分丁户少合青鸟包羊月古"
部分2 = "亻讠木又火口目⺼扌日氵𧾷宀艹广门辶"
// 待加：广门辶
// 待定: 纟钅
常用字数据 = open('测试/实用/字/常用字拆字.json', 'r', encoding="utf-8")
拆字 = json.load(常用字数据)
常用字数据.close()
func 搜索偏旁(偏旁) {
字数 = 0
所有字 = []
for 字 in 拆字 {
字型, 部分 = 拆字[字]['字型'], 拆字[字]['部分']
if 部分[0] == 偏旁 or 部分[1] == 偏旁 {
字数 += 1
所有字.append(字)
}
}
println(str(字数) + " " + 偏旁 + " -> " + "".join(所有字))
}
// 字型: ⿱⿰⿸⿵⿴
func 取字(包含偏旁, 排除偏旁) {
带偏旁的字 = {:}
for 字 in 拆字 {
字型, 部分 = 拆字[字]['字型'], 拆字[字]['部分']
for 偏旁 in 包含偏旁 {
try {
偏旁位置 = 部分.index(偏旁)
} catch e : ValueError {
continue
}
if 偏旁位置 >= 0 {
部首位置 = 1 - 偏旁位置
}
部首 = 部分[部首位置]
// continue if 排除偏旁.find(部首) >= 0
if 带偏旁的字.get(部首) {
带偏旁的字[部首].append(字)
} else {
带偏旁的字[部首] = [字]
}
}
}
return 带偏旁的字
}
带偏旁的字 = 取字(部分2, 部分1)
/*for 偏旁 in 带偏旁的字 {
println(偏旁 + ": " + str(带偏旁的字[偏旁])) if len(带偏旁的字[偏旁]) > 2
}*/
for 偏旁 in 部分2 {
搜索偏旁(偏旁)
}
| .ul | mulan | MIT | A | c1a09dfcc55730f291ec611878de5cd7a9eafcf713f8194b14602ca8106b74e3 | 1,570 | 59 | 0.599562 | true |
000025_mulan__00025_MulanRevive__mulan-rework__凑十法.ul | 拆分 = {
2 : [[1, 1]],
3 : [[1, 2]],
4 : [[1, 3], [2, 2]],
5 : [[1, 4], [2, 3]],
6 : [[1, 5], [2, 4], [3, 3]],
7 : [[1, 6], [2, 5], [3, 4]],
8 : [[1, 7], [2, 6], [3, 5], [4, 4]],
9 : [[1, 8], [2, 7], [3, 6], [4, 5]],
10 : [[1, 9], [2, 8], [3, 7], [4, 6], [5, 5]]
}
func 取剩余(整体, 部分) {
for 两部分 in 拆分[整体] {
if 两部分[0] == 部分 {
return 两部分[1]
} elif 两部分[1] == 部分 {
return 两部分[0]
}
}
}
func 凑十法求和(基数, 被拆数) {
凑数 = 取剩余(10, 基数)
拆得数 = 取剩余(被拆数, 凑数)
return "1`拆得数`"
}
println(凑十法求和(9, 7)) | .ul | mulan | MIT | A | 4b9944f0c757bf4ae8e02a990803d22af2a17d55aeb8238f6a5b4922bf2e3838 | 663 | 29 | 0.607143 | true |
000026_mulan__00026_MulanRevive__mulan-rework__聊天演示.ul | /*
#!/usr/bin/env python
#
# Copyright 2009 Facebook
#
# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
"""Simplified chat demo for websockets.
Authentication, error handling, etc are left as an exercise for the reader :)
"""
在原始 tornado 源码库例程基础上改为木兰实现
*/
using logging
using tornado.escape
using tornado.ioloop
using tornado.options
using tornado.web
using tornado.websocket
using os.path
using uuid
using define, options in tornado.options
// type 为语言关键词, 因而不可以作为函数形参的关键词
func 定义(名称 : str, 默认=nil, 类型=nil, 帮助=nil) {
define(名称, 默认, 类型, 帮助)
}
定义("port", 默认=8888, 帮助="在此端口运行服务", 类型=int)
type 应用 : tornado.web.Application {
func $应用 {
相应处置 = [tuple("/", 主页面),
tuple("/chatsocket", 聊天渠道)]
// 不支持 **
super.__init__(相应处置,
cookie_secret="__TODO: 生成随机内容",
template_path=os.path.join(os.path.dirname(__file__), "templates"),
static_path=os.path.join(os.path.dirname(__file__), "static"),
xsrf_cookies=true
)
}
}
type 主页面 : tornado.web.RequestHandler {
func $get {
$render("index.html", messages=聊天渠道.历史)
}
}
type 聊天渠道 : tornado.websocket.WebSocketHandler {
{
接收端 = set()
历史 = []
历史长度 = 200
}
func $get_compression_options {
// Non-None enables compression with default options.
return {:}
}
func $open {
聊天渠道.接收端.add($)
}
func $on_close {
聊天渠道.接收端.remove($)
}
func 更新历史(消息) {
// 必须指定类
聊天渠道.历史.append(消息)
if len(聊天渠道.历史) > 聊天渠道.历史长度 {
聊天渠道.历史 = 聊天渠道.历史[-聊天渠道.历史长度 :]
}
}
func 广播(消息) {
logging.info("发到%d个接收端", len(聊天渠道.接收端))
for 某接收端 in 聊天渠道.接收端 {
try {
某接收端.write_message(消息)
} catch e {
logging.error("发送消息出错", exc_info=True)
}
}
}
func $on_message(内容) {
logging.info("收到消息: %r", 内容)
parsed = tornado.escape.json_decode(内容)
消息 = {"id": str(uuid.uuid4()), "body": parsed["body"]}
消息["html"] = tornado.escape.to_basestring(
$render_string("message.html", message=消息)
)
聊天渠道.更新历史(消息)
聊天渠道.广播(消息)
}
}
func 中 {
tornado.options.parse_command_line()
app = 应用()
app.listen(options.port)
tornado.ioloop.IOLoop.current().start()
}
if __name__ == "__main__" {
中()
}
| .ul | mulan | MIT | B | f28f5ef8bb511b1fed2ab55b15d352b1b843de88fc56367a59687394d1c9c9b2 | 3,233 | 124 | 0.157059 | true |
000027_mulan__00027_MulanRevive__mulan-rework__简单.ul | using SimpleHTTPRequestHandler in http.server
using socketserver
端口 = 8080
try 服务=socketserver.TCPServer(tuple("", 端口), SimpleHTTPRequestHandler) {
println("请访问：http://localhost:8080/")
服务.serve_forever()
}
/* 参考: https://www.afternerd.com/blog/python-http-server/ */
| .ul | mulan | MIT | B | fdee63b71cf6b2bfc57569766adeffa9bc7c4298894e6a12444238f114d694e1 | 307 | 11 | 0.071066 | true |
000028_mulan__00028_MulanRevive__mulan-rework__中.ul | using * in 测试.实用.棋.井字.棋盘
using * in 测试.实用.棋.井字.棋局
格数 = 3
棋盘 = 棋盘图样(格数)
状况 = 棋盘状况(格数)
loop {
状况.落子(棋盘.鼠标位置所在格()) if 棋盘.取事件() == 棋盘事件.鼠标按键
棋盘.画棋盘()
棋盘.画棋子(状况.所有子)
if 状况.结束() {
棋盘.宣布结果(状况.取结语())
}
棋盘.更新()
}
| .ul | mulan | MIT | A | 2bf69e34c4da3dabde448df5dfd4fd04ebc6d39f3b724c0981efddad83d0387e | 414 | 16 | 0.813559 | true |
000029_mulan__00029_MulanRevive__mulan-rework__棋局.ul | using Enum in enum
using 相等 in 测试.实用.通用.测试相关
using * in 测试.实用.棋.井字.模型
/* 不依赖 pygame, 易于测试 */
赢了 = 3
结语 = {
状态.X胜: "X 赢了!",
状态.O胜: "O 赢了!",
状态.平局: "平了!"
}
type 步 {
func $步(横, 纵, 棋手) {
$横, $纵, $棋手 = 横, 纵, 棋手
}
func $棋手为X {
return $棋手 == 棋手.X
}
operator == (另一子) {
return $横 == 另一子.横 and $纵 == 另一子.纵 and $棋手 == 另一子.棋手
}
func __repr__(self) {
return "(`$棋手`: (`$横`, `$纵`))"
}
}
type 棋盘状况 {
func $棋盘状况(格数) {
$格数 = 格数
$所有子 = []
$进行状态 = 状态.对弈
$当前棋手 = 棋手.X
}
func $落子(所在格) {
横格, 纵格 = 所在格[0], 所在格[1]
可落子 = $进行状态 == 状态.对弈 and $在棋盘内(横格, 纵格) and !$位置已占(横格, 纵格)
if 可落子 {
$所有子.append(步(横格, 纵格, $当前棋手))
if $已赢() {
$进行状态 = $当前棋手 == 棋手.X ? 状态.X胜 : 状态.O胜
} elif len($所有子) == 9 {
$进行状态 = 状态.平局
} else {
$当前棋手 = $当前棋手 == 棋手.X ? 棋手.O : 棋手.X
}
}
return 可落子
}
func $位置已占(横格, 纵格) {
return any(map(某子 -> 某子.横 == 横格 and 某子.纵 == 纵格, $所有子))
}
func $已赢 {
return false if len($所有子) < 赢了
获胜方式 = [
[tuple(-1, 0), tuple(1, 0)],
[tuple(0, -1), tuple(0, 1)],
[tuple(-1, -1), tuple(1, 1)],
[tuple(-1, 1), tuple(1, -1)]] //判断获胜的四个方向
for 反向, 正向 in 获胜方式 {
dx, dy = 反向
反向方向个数 = $数子(dx, dy)
dx, dy = 正向
正向方向个数 = $数子(dx, dy)
return true if 反向方向个数 + 正向方向个数 + 1 == 赢了
}
return false
}
func $数子(dx, dy) {
末子 = $所有子[-1]
tx, ty = 末子.横, 末子.纵
个数 = 0
loop {
tx += dx
ty += dy
if $在棋盘内(tx, ty) and $所有子.__contains__(步(tx, ty, 末子.棋手)) {
个数 += 1
} else {
return 个数
}
}
}
func $在棋盘内(横格, 纵格) {
return 横格 >= 0 and 横格 < $格数 and 纵格 >= 0 and 纵格 < $格数
}
func $取结语 {
return 结语[$进行状态]
}
func $结束 {
return $进行状态 != 状态.对弈
}
}
相等(false, [步(1, 1, 棋手.O)].__contains__(步(1, 1, 棋手.X)), "包含步")
相等(true, [步(1, 1, 棋手.O)].__contains__(步(1, 1, 棋手.O)), "包含步")
| .ul | mulan | MIT | A | eda3a77ee765cda834050449e4998a7c595e3cbaf636a17579076e3e81f8ab47 | 2,727 | 109 | 0.505632 | true |
000030_mulan__00030_MulanRevive__mulan-rework__棋盘.ul | using Enum in enum
using pygame
type 棋盘事件 : Enum {
{
退出 = 1
鼠标按键 = 2
}
}
边框 = 60
格子尺寸 = 100
半格 = 格子尺寸 / 2
线宽 = 5
// 参考: https://pygame-zero.readthedocs.io/en/latest/colors_ref.html
// https://github.com/pygame/pygame/blob/master/src_py/colordict.py
背景色 = pygame.Color("darkorange")
红色 = pygame.Color("red")
黑色 = pygame.Color("black")
type 棋盘图样 {
func $棋盘图样(格数) {
$格数 = 格数
$棋盘内边长 = 格子尺寸 * 格数
棋盘尺寸 = $棋盘内边长 + 边框 * 2
pygame.init()
pygame.display.set_caption('井字棋')
$屏幕 = pygame.display.set_mode(tuple(棋盘尺寸, 棋盘尺寸))
}
func $画棋盘 {
$屏幕.fill(背景色)
$画格子()
}
func $画格子 {
for x in 0..$格数 {
位置 = 格子尺寸 * x + 边框
pygame.draw.line($屏幕, 黑色, tuple(位置, 边框), tuple(位置, $棋盘内边长 + 边框), 线宽)
pygame.draw.line($屏幕, 黑色, tuple(边框, 位置), tuple($棋盘内边长 + 边框, 位置), 线宽)
}
}
func $画棋子(所有子) {
for 落子 in 所有子 {
横格, 纵格 = 落子.横, 落子.纵
if 落子.棋手为X() {
$画X(横格, 纵格)
} else {
$画O(横格, 纵格)
}
}
}
func $画X(横格, 纵格) {
中心x, 中心y = $取中心位置(横格, 纵格)
pygame.draw.line($屏幕, 黑色, tuple(中心x - 半格, 中心y - 半格), tuple(中心x + 半格, 中心y + 半格), 8)
pygame.draw.line($屏幕, 黑色, tuple(中心x + 半格, 中心y - 半格), tuple(中心x - 半格, 中心y + 半格), 8)
}
func $画O(横格, 纵格) {
中心x, 中心y = $取中心位置(横格, 纵格)
pygame.draw.circle($屏幕, 黑色, tuple(中心x, 中心y), 半格, 线宽)
}
func $取中心位置(横格, 纵格) {
中心x = int((横格 + 0.5) * 格子尺寸 + 边框)
中心y = int((纵格 + 0.5) * 格子尺寸 + 边框)
return 中心x, 中心y
}
func $鼠标位置所在格 {
x, y = pygame.mouse.get_pos()
横格 = int((x - 边框) * 1.0 / 格子尺寸)
纵格 = int((y - 边框) * 1.0 / 格子尺寸)
return 横格, 纵格
}
func $宣布结果(用词) {
字体 = pygame.font.SysFont("pmingliu", 50)
文字 = 字体.render(用词, true, 红色)
$屏幕.blit(文字, tuple(20, 10))
}
func $更新 {
pygame.display.update()
}
func $取事件 {
for 事件 in pygame.event.get() {
事件类型 = 事件.__getattribute__('type')
if 事件类型 == pygame.QUIT {
pygame.quit()
quit()
} elif 事件类型 == pygame.MOUSEBUTTONUP {
return 棋盘事件.鼠标按键
}
}
}
} | .ul | mulan | MIT | A | 246097449a41d104fbde0c83c6aeb1d74b12294152e75e158b0be9c7c8fd70f5 | 2,785 | 103 | 0.366375 | true |
000031_mulan__00031_MulanRevive__mulan-rework__模型.ul | using Enum in enum
type 棋手 : Enum {
{
X = 1
O = 2
}
}
type 状态 : Enum {
{
对弈 = 1
X胜 = 2
O胜 = 3
平局 = 4
}
}
| .ul | mulan | MIT | B | a74e01680d3a320aa06925d5505ce34b1d0a52e2ec17e03e2bca477a14af108d | 159 | 17 | 0.222222 | true |
000032_mulan__00032_MulanRevive__mulan-rework__中.ul | using 点 in 测试.实用.规划.点
using 范围, 全区, 部分区域, 二乘二, 三格, 长折, 短折, 一字 in 测试.实用.规划.范围
using 占地 in 测试.实用.规划.占地
using 相等 in 测试.实用.通用.测试相关
// 需记录占据情况
// TODO: 指定形参的类型
func 各种朝向(初始形状){
所有形状 = [初始形状]
转后形状 = 初始形状
for 旋转次数 in 1..3 {
转后形状 = 转后形状.顺时针转90度()
if 转后形状 != 初始形状 {
所有形状.append(转后形状)
} else {
break
}
}
return 所有形状
}
func 可放位置(形状, 区域) {
所有位置 = []
各朝向的形状 = 各种朝向(形状)
for 某形 in 各朝向的形状 {
for 定点 in 区域.所有点 {
该形占地 = 占地(某形, 定点)
该形范围 = 该形占地.范围
所有位置.append([该形占地, 区域.除去(该形范围)]) if 该形范围.未超出(区域)
}
}
return 所有位置
}
// TODO: 返回值类型化(实际上也是更可读(省去文档说明))
func 取所有摆放方案(之前方案, 区域, 所有形状) {
//println("形状数 " + str(len(所有形状)))
// 最后结构
if len(所有形状) == 0 {
return [[之前方案, 区域]]
}
首个形状 = 所有形状[0]
该形状可放位置 = 可放位置(首个形状, 区域)
所有方案 = []
// [占地, 剩余区域]
for 某位置 in 该形状可放位置 {
占地 = 某位置[0]
剩余区域 = 某位置[1]
//println("新方案: " + str(之前方案))
//[形1位置 + 形2信息[0] + 形3信息[0], 形3信息[1]])
所有方案 = 所有方案 + 取所有摆放方案(之前方案 + [占地], 剩余区域, 所有形状[1:])
}
return 所有方案
}
// TODO: 方案可视化
for 方案 in 取所有摆放方案([], 部分区域, [长折, 短折, 一字]) {
println(方案)
}
print(全区.可视化())
// TODO: 指定三个定点求解
/******* 测试 ******/
相等([
范围([[-1, 0], [0, 0], [1, 0]]),
范围([
[0, 1],
[0, 0],
[0, -1]
])
], 各种朝向(一字), "一字各种朝向")
相等(4, len(可放位置(短折, 二乘二)), "可放位置")
相等(1, len(取所有摆放方案([], 三格, [一字])), "取所有摆放方案1")
相等(4, len(取所有摆放方案([], 二乘二, [短折])), "取所有摆放方案2")
相等(62, len(取所有摆放方案([], 全区, [长折, 短折, 一字])), "取所有摆放方案3")
| .ul | mulan | MIT | A | 590aa637a82c78f562f339721a6515374aa9a19728b7c7cbd4599b7d7e31d549 | 2,497 | 83 | 0.742938 | true |
000033_mulan__00033_MulanRevive__mulan-rework__占地.ul | using 范围 in 测试.实用.规划.范围
using 点 in 测试.实用.规划.点
using 相等 in 测试.实用.通用.测试相关
type 占地 {
func $占地(某范围, 原点) {
$原点 = 原点
横偏移 = 原点.横
纵偏移 = 原点.纵
$范围 = 范围(list(map(某点 -> [某点.横 + 横偏移, 某点.纵 + 纵偏移], 某范围.所有点)))
}
func $__repr__ {
return "中心为`$原点`的`$范围`"
}
}
相等(范围([
[1, 2],
[1, 1], [2, 1]
]), 占地(范围([
[0, 1],
[0, 0], [1, 0]
]), 点(1, 1)).范围, "偏移")
| .ul | mulan | MIT | A | 0d0d3a76f2a3ba35e462fa0ce6aded3e4c0ed2f5afca882499528b5ce1b410d3 | 582 | 25 | 0.666667 | true |
000034_mulan__00034_MulanRevive__mulan-rework__点.ul | using 相等 in 测试.实用.通用.测试相关
type 点 {
func $点(横, 纵) {
$横, $纵 = 横, 纵
}
operator == (另一点) {
return $横 == 另一点.横 and $纵 == 另一点.纵
}
func __repr__(self) {
return "(`$横`, `$纵`)"
}
}
相等(0, 点(0, 1).横, "点横坐标")
相等(1, 点(0, 1).纵, "点纵坐标")
相等(true, 点(0, 1) == 点(0, 1), "点相等")
相等(false, 点(1, 1) == 点(0, 1), "点不相等") | .ul | mulan | MIT | A | efafe2be1919ad3811f20e552323bbc78ff0af0de658a9a4e0064304c89da7bc | 473 | 20 | 0.528 | true |
000035_mulan__00035_MulanRevive__mulan-rework__范围.ul | using 点 in 测试.实用.规划.点
using 相等 in 测试.实用.通用.测试相关
using 按某项生成映射 in 测试.实用.通用.结构
type 范围 {
func $范围(所有坐标) {
self.所有点 = list(map(坐标数组 -> 点(坐标数组[0], 坐标数组[1]), 所有坐标))
}
func 创建方阵(长, 宽) {
所有点 = []
for 纵坐标 in (宽 - 1)..0 by -1 {
for 横坐标 in 0..<长 {
所有点.append([横坐标, 纵坐标])
}
}
return 范围(所有点)
}
func 包含点(self, 点) {
return any(map(某点 -> 某点 == 点, self.所有点))
}
func 未超出(self, 某范围) {
return len(某范围.所有点) >= len(self.所有点) and
all(map(某点 -> 某范围.包含点(某点), self.所有点))
}
/* 仅处理横纵轴上的点 */
func 顺时针转90度(self) {
return 范围(list(map(某点 -> [某点.纵, -某点.横], self.所有点)))
}
func 除去(self, 某块) {
新范围 = 范围([])
新范围.所有点 = list(filter(某点 -> !某块.包含点(某点), self.所有点))
return 新范围
}
func 可视化(self) {
行 = max(map(某点 -> 某点.纵, self.所有点))
点表 = 按某项生成映射(self.所有点, 某点 -> 某点.纵, 某点 -> 某点.横)
输出 = ""
for 行号 in 0..行 {
最大列号 = max(点表[行号])
行 = " " * (最大列号 + 1)
for 列号 in 点表[行号] {
行 = 行[:列号] + "○" + 行[列号 + 1:]
}
行 += "\n"
输出 = 行 + 输出
}
return 输出
}
operator == (另一范围) {
return len(另一范围.所有点) == len(self.所有点) and self.未超出(另一范围)
}
func __repr__(self) {
return len(self.所有点) == 0 ? "空" : "点阵: " + " ".join(map(str, self.所有点))
}
}
// [x, y]
全区 = 范围.创建方阵(4, 4).除去(范围([
[0, 3], [3, 3],
[0, 0]
]))
部分区域 = 全区.除去(范围([
[0, 1], [2, 1],
[2, 0]
]))
二乘二 = 范围.创建方阵(2, 2)
三格 = 范围([[-1, 0], [0, 0], [1, 0]])
// [0, 0] 为中心，其他为相对坐标。按照实际形状进行排列，以便阅读。
长折 = 范围([
[0, 2],
[0, 1],
[0, 0], [1, 0]
])
短折 = 范围([
[0, 1],
[0, 0], [1, 0]
])
一字 = 范围([[-1, 0], [0, 0], [1, 0]])
相等(true, 二乘二.包含点(点(1, 1)), "包含点")
相等(范围([
[0, 0], [1, 0],
[0, -1]
]), 短折.顺时针转90度(), "右旋90度")
相等(true, 短折.未超出(二乘二), "未超出")
相等(范围([[1, 1]]), 二乘二.除去(短折), "除去")
相等(范围([
[0, 1], [1, 1],
[0, 0], [1, 0]
]), 范围.创建方阵(2, 2), "创建方阵")
相等("○○\n○○\n", 二乘二.可视化(), "可视化")
相等(" ○○\n○○○○\n○○○○\n ○○○\n", 全区.可视化(), "可视化")
| .ul | mulan | MIT | A | 923cd2a762b9a7a7f0b8a60987e9cfb3c4105c3eff8e27b50e457f3105778fc5 | 2,917 | 111 | 0.5953 | true |
000036_mulan__00036_MulanRevive__mulan-rework__库_常用字.ul | 字表 = {
"1": "一乙",
"2": "二十丁厂七卜八人入儿九几了乃刀力又",
"3": "三干于亏士土工才下寸丈大与万上小口山巾千乞川亿个么久勺丸夕凡及广亡门义之尸已弓己卫子也女飞刃习叉马乡",
"4": "丰王井开夫天元无云专扎艺木五支厅不太犬区历友尤匹车巨牙屯比互切瓦止少日中贝内水冈见手午牛毛气升长仁什片仆化仇币仍仅斤爪反介父从今凶分乏公仓月氏勿风欠丹匀乌勾凤六文方火为斗忆计订户认心尺引丑巴孔队办以允予劝双书幻",
"5": "玉刊末未示击打巧正扑扒功扔去甘世古节本术可丙左厉石右布龙平灭轧东卡北占业旧帅归目旦且叮叶甲申号电田由只央史兄叼叫叨另叹四生失禾丘付仗代仙们仪白仔他斥瓜乎丛令用甩印乐句匆册犯外处冬鸟务包饥主市立闪兰半汁汇头汉宁穴它讨写让礼训必议讯记永司尼民出辽奶奴加召皮边孕发圣对台矛纠母幼丝",
"6": "式刑动扛寺吉扣考托老圾巩执扩扫地扬场耳共芒亚芝朽朴机权过臣再协西压厌在百有存而页匠夸夺灰达列死成夹轨邪划迈毕至此贞师尘尖劣光当早吐吓虫曲团同吊吃因吸吗屿帆岁回岂则刚网肉年朱先丢舌竹迁乔伟传乒乓休伍伏优伐延件任伤价份华仰仿伙伪自血向似后行舟全会杀合兆企众爷伞创肌朵杂危旬旨负各名多争色壮冲冰庄庆亦刘齐交次衣产决充妄闭问闯羊并关米灯州汗污江池汤忙兴宇守宅字安讲军许论农讽设访寻那迅尽导异孙阵阳收阶阴防奸如妇好她妈戏羽观欢买红纤约级纪驰巡",
"7": "寿弄麦形进戒吞远违运扶抚坛技坏扰拒找批扯址走抄坝贡攻赤折抓扮抢孝均抛投坟坑抗坊抖护壳志块扭声把报却劫芽花芹芬苍芳严芦劳克苏杆杜杠材村杏极李杨求更束豆两丽医辰励否还歼来连步坚旱盯呈时吴助县里呆园旷围呀吨足邮男困吵串员听吩吹呜吼吧别岗帐财钉针告我乱利秃秀私每兵估体何但伸作伯伶佣低你住位伴身皂佛近彻役返余希坐谷妥含邻岔肝肚肠龟免狂犹角删条卵岛迎饭饮系言冻状亩况床库疗应冷这序辛弃冶忘闲间闷判灶灿弟汪沙汽沃泛沟没沈沉怀忧快完宋宏牢究穷灾良证启评补初社识诉诊词译君灵即层尿尾迟局改张忌际陆阿陈阻附妙妖妨努忍劲鸡驱纯纱纲纳纵驳纷纸纹纺驴纽",
"8": "奉玩环武青责现表规抹拢拔拣坦担押抽拐拖者拍顶拆拥抵拘势抱垃拉拦幸拌招坡披拨择抬其取苦若茂苹苗英范直茄茎茅林枝杯柜析板松枪构杰述枕丧或画卧事刺枣雨卖矿码厕奔奇奋态欧垄妻轰顷转斩轮软到非叔肯齿些虎虏肾贤尚旺具果味昆国昌畅明易昂典固忠咐呼鸣咏呢岸岩帖罗帜岭凯败贩购图钓制知垂牧物乖刮秆和季委佳侍供使例版侄侦侧凭侨佩货依的迫质欣征往爬彼径所舍金命斧爸采受乳贪念贫肤肺肢肿胀朋股肥服胁周昏鱼兔狐忽狗备饰饱饲变京享店夜庙府底剂郊废净盲放刻育闸闹郑券卷单炒炊炕炎炉沫浅法泄河沾泪油泊沿泡注泻泳泥沸波泼泽治怖性怕怜怪学宝宗定宜审宙官空帘实试郎诗肩房诚衬衫视话诞询该详建肃隶录居届刷屈弦承孟孤陕降限妹姑姐姓始驾参艰线练组细驶织终驻驼绍经贯",
"9": "奏春帮珍玻毒型挂封持项垮挎城挠政赴赵挡挺括拴拾挑指垫挣挤拼挖按挥挪某甚革荐巷带草茧茶荒茫荡荣故胡南药标枯柄栋相查柏柳柱柿栏树要咸威歪研砖厘厚砌砍面耐耍牵残殃轻鸦皆背战点临览竖省削尝是盼眨哄哑显冒映星昨畏趴胃贵界虹虾蚁思蚂虽品咽骂哗咱响哈咬咳哪炭峡罚贱贴骨钞钟钢钥钩卸缸拜看矩怎牲选适秒香种秋科重复竿段便俩货顺修保促侮俭俗俘信皇泉鬼侵追俊盾待律很须叙剑逃食盆胆胜胞胖脉勉狭狮独狡狱狠贸怨急饶蚀饺饼弯将奖哀亭亮度迹庭疮疯疫疤姿亲音帝施闻阀阁差养美姜叛送类迷前首逆总炼炸炮烂剃洁洪洒浇浊洞测洗活派洽染济洋洲浑浓津恒恢恰恼恨举觉宣室宫宪突穿窃客冠语扁袄祖神祝误诱说诵垦退既屋昼费陡眉孩除险院娃姥姨姻娇怒架贺盈勇怠柔垒绑绒结绕骄绘给络骆绝绞统",
"10": "耕耗艳泰珠班素蚕顽盏匪捞栽捕振载赶起盐捎捏埋捉捆捐损都哲逝捡换挽热恐壶挨耻耽恭莲莫荷获晋恶真框桂档桐株桥桃格校核样根索哥速逗栗配翅辱唇夏础破原套逐烈殊顾轿较顿毙致柴桌虑监紧党晒眠晓鸭晃晌晕蚊哨哭恩唤啊唉罢峰圆贼贿钱钳钻铁铃铅缺氧特牺造乘敌秤租秧积秩称秘透笔笑笋债借值倚倾倒倘俱倡候俯倍倦健臭射躬息徒徐舰舱般航途拿爹爱颂翁脆脂胸胳脏胶脑狸狼逢留皱饿恋桨浆衰高席准座症病疾疼疲脊效离唐资凉站剖竞部旁旅畜阅羞瓶拳粉料益兼烤烘烦烧烛烟递涛浙涝酒涉消浩海涂浴浮流润浪浸涨烫涌悟悄悔悦害宽家宵宴宾窄容宰案请朗诸读扇袜袖袍被祥课谁调冤谅谈谊剥恳展剧屑弱陵陶陷陪娱娘通能难预桑绢绣验继",
"11": "球理捧堵描域掩捷排掉推堆掀授教掏掠培接控探据掘职基著勒黄萌萝菌菜萄菊萍菠营械梦梢梅检梳梯桶救副票戚爽聋袭盛雪辅辆虚雀堂常匙晨睁眯眼悬野啦晚啄距跃略蛇累唱患唯崖崭崇圈铜铲银甜梨犁移笨笼笛符第敏做袋悠偿偶偷您售停偏假得衔盘船斜盒鸽悉欲彩领脚脖脸脱象够猜猪猎猫猛馅馆凑减毫麻痒痕廊康庸鹿盗章竟商族旋望率着盖粘粗粒断剪兽清添淋淹渠渐混渔淘液淡深婆梁渗情惜惭悼惧惕惊惨惯寇寄宿窑密谋谎祸谜逮敢屠弹随蛋隆隐婚婶颈绩绪续骑绳维绵绸绿",
"12": "琴斑替款堪塔搭越趁趋超提堤博揭喜插揪搜煮援裁搁搂搅握揉斯期欺联散惹葬葛董葡敬葱落朝辜葵棒棋植森椅椒棵棍棉棚棕惠惑逼厨厦硬确雁殖裂雄暂雅辈悲紫辉敞赏掌晴暑最量喷晶喇遇喊景践跌跑遗蛙蛛蜓喝喂喘喉幅帽赌赔黑铸铺链销锁锄锅锈锋锐短智毯鹅剩稍程稀税筐等筑策筛筒答筋筝傲傅牌堡集焦傍储奥街惩御循艇舒番释禽腊脾腔鲁猾猴然馋装蛮就痛童阔善羡普粪尊道曾焰港湖渣湿温渴滑湾渡游滋溉愤慌惰愧愉慨割寒富窜窝窗遍裕裤裙谢谣谦属屡强粥疏隔隙絮嫂登缎缓骗编缘",
"13": "瑞魂肆摄摸填搏塌鼓摆携搬摇搞塘摊蒜勤鹊蓝墓幕蓬蓄蒙蒸献禁楚想槐榆楼概赖酬感碍碑碎碰碗碌雷零雾雹输督龄鉴睛睡睬鄙愚暖盟歇暗照跨跳跪路跟遣蛾蜂嗓置罪罩错锡锣锤锦键锯矮辞稠愁筹签简毁舅鼠催傻像躲微愈遥腰腥腹腾腿触解酱痰廉新韵意粮数煎塑慈煤煌满漠源滤滥滔溪溜滚滨粱滩慎誉塞谨福群殿辟障嫌嫁叠缝缠",
"14": "静碧璃墙嘉摧截誓境摘摔撇聚慕暮蔑蔽模榴榜榨歌遭酷酿酸磁愿需裳颗嗽蜻蜡蝇蜘赚锹锻舞稳算箩管僚鼻魄貌膜膊膀鲜疑馒裹敲豪膏遮腐瘦辣竭端旗精歉弊熄熔漆漂漫滴演漏慢寨赛察蜜谱嫩翠熊凳骡缩",
"15": "慧撕撒趣趟撑播撞撤增聪鞋蕉蔬横槽樱橡飘醋醉震霉瞒题暴瞎影踢踏踩踪蝶蝴嘱墨镇靠稻黎稿稼箱箭篇僵躺僻德艘膝膛熟摩颜毅糊遵潜潮懂额慰劈",
"16": "操燕薯薪薄颠橘整融醒餐嘴蹄器赠默镜赞篮邀衡膨雕磨凝辨辩糖糕燃澡激懒壁避缴",
"17": "戴擦鞠藏霜霞瞧蹈螺穗繁辫赢糟糠燥臂翼骤",
"18": "鞭覆蹦镰翻鹰",
"19": "警攀蹲颤瓣爆疆",
"20": "壤耀躁嚼嚷籍魔灌",
"21": "蠢霸露",
"22": "囊",
"23": "罐"
}
字集 = {:}
for 笔画数 in 字表 {
for 字 in 字表[笔画数] {
字集[字] = 笔画数
}
}
func 为常用字(字) {
return 字集.get(字) != nil
}
assert(为常用字("罐"), "是")
assert(!为常用字("罡"), "非") | .ul | mulan | MIT | A | 41602bd28d538e920a25cf4a4005a4c1100c44532c971fc69eb4bc5286649f3e | 8,017 | 39 | 0.985266 | true |
000037_mulan__00037_MulanRevive__mulan-rework__测试相关.ul |
func 相等(目标, 实际, 信息) {
if 实际 != 目标 {
println("`信息`出错。目标: `目标`, 但实际为: `实际`")
}
}
| .ul | mulan | MIT | A | ac8b1ce2aafe9f536a16498af858f249d7afd3e0b1de00293fc1d0e48376e0a6 | 142 | 6 | 0.675 | true |
000038_mulan__00038_MulanRevive__mulan-rework__结构.ul |
func 按某项生成映射(列表, 生成键, 生成值) {
点表 = {:}
for 项 in 列表 {
键 = 生成键(项)
值 = 生成值(项)
if 点表.get(键) {
点表[键].append(值)
} else {
点表[键] = [值]
}
}
return 点表
} | .ul | mulan | MIT | A | 00f85282e7a78fa690d1e7f7548c74a01733cd70a25bb559d70afbfa5dc9e09c | 294 | 14 | 0.589041 | true |
000039_mulan__00039_MulanRevive__mulan-rework__引用木兰多个.ul | using 测试.包.module_ul, 测试引用2
测试.包.module_ul.talk()
测试引用2.唱()
| .ul | mulan | MIT | A | cf203a3f3d9b20a2397201c81e0d76a6f25430f65cb965d57d725af5d3a65318 | 90 | 3 | 0.375 | true |
000040_mulan__00040_MulanRevive__mulan-rework__引用本地包内木兰.ul | using 测试.包.module_ul
测试.包.module_ul.talk() | .ul | mulan | MIT | B | 3542aa7eaa1ac5593829c5b89714450233b7bfbc4625462e36564b649533e177 | 54 | 2 | 0.193548 | true |
000041_mulan__00041_MulanRevive__mulan-rework__引用本地包内木兰某内容.ul | using talk in 测试.包.module_ul
talk() | .ul | mulan | MIT | B | d47a0859a7a0d2b4e174cd6a2fabb01fbcbaf28934b7043059c45dfe4c567d23 | 41 | 2 | 0.115385 | true |
000042_mulan__00042_MulanRevive__mulan-rework__取毫秒.ul | using time
毫秒 = time.time() * 1000
print(毫秒) | .ul | mulan | MIT | B | a69e8e0bf591dbd08dbb7f4ee3d99a59589ceb77b33f36b99fb06c0825bbb4a8 | 53 | 4 | 0.153846 | true |
000043_mulan__00043_MulanRevive__mulan-rework__命令行.ul | using Cmd in cmd; using randrange in random
type 猜数字 : Cmd {
{
intro, prompt = "木兰想了个 100 之内的数，猜是几？", "\n猜猜吧: "
想的 = randrange(1000) / 10; 历史 = []
}
func $default(行) {
try { 数 = int(行) }
catch 例外 : ValueError { println("`行` 不是数，请再试"); return }
$历史.append(数); $比较(数)
}
func $比较(数) {
{ println("中了!"); 再会() } if 数 == $想的
println("太" + (数 > $想的 ? "大" : "小") + "了!")
println("不过接近咯") if $接近了()
}
func $接近了 {
最近 = min(map(数 -> { 差 = 数 - $想的; return fabs(差) }, $历史))
return #$历史 > 1 and fabs($历史[-1] - $想的) == 最近
}
}
猜数字().cmdloop() | .ul | mulan | MIT | A | 4af407000ae5547969525610cdd0e3f8bc2d6b5d38704f817885837840b66cc9 | 771 | 27 | 0.334545 | true |
000044_mulan__00044_MulanRevive__mulan-rework__断言.ul | assert(2>1, 'pass')
assert(2<1, 'fail')
/*
(..•˘_˘•..) fail
见第2行：assert(2<1, 'fail')
*/ | .ul | mulan | MIT | B | 1585e6678fdbaee1799fb9a920df3f4054011fa65a37587e418687d75b7e9665 | 101 | 6 | 0.105263 | true |
000045_mulan__00045_MulanRevive__mulan-rework__草蟒_图快.ul | using * in 图快
窗口 = 主窗口类()
窗口.标题('图形应用程序')
窗口.尺寸('500x300+600+300')
func 登录(){
登录窗口 = 顶级窗口类(窗口)
登录窗口.标题('请登录...')
登录窗口.尺寸('200x200+750+350')
}
登录按钮 = 按钮类(文本='登录', 命令=登录)
登录按钮.位置布局(相对x=0.5, 相对y=0.5)
窗口.主循环() | .ul | mulan | MIT | A | 91531b538449c57cfae2cc62468a00409d15d29f81bcf49f917337be9263ce8f | 385 | 16 | 0.845361 | true |
000046_mulan__00046_MulanRevive__mulan-rework__草蟒_海龟.ul | /* Python 库“草蟒”： grasspy-modules 已失效，此例程不再运行 */
using * in 海龟
颜色("黄色", "红色")
开始填充()
for 转角 in 0..4 {
前进(200); 右转(144)
}
结束填充()
主循环()
| .ul | mulan | MIT | A | f8074e93ffda9e4f78c12b597dbb911e35a57a25adb30a511de0835a1bc22b14 | 220 | 10 | 0.555556 | true |
000047_mulan__00047_MulanRevive__mulan-rework__列表取值.ul | 列表=[1,2,3]
print(列表[1])
列表[1] = 4
print(列表[1])
列表.append(5)
print(列表[3])
print(列表[0:2])
print(列表[2:])
print(列表[:2])
print(列表[:]) | .ul | mulan | MIT | A | dbc2969e8993da422f97bc7ecfc30165ebe20ed09a1d093a94f9e56563ad9ae1 | 168 | 10 | 0.327869 | true |
000048_mulan__00048_MulanRevive__mulan-rework__枚举.ul | using Enum in enum
type 颜色 : Enum {
{
红 = 1
黄 = 2
}
}
for 某色 in 颜色 {
print(某色.value)
} | .ul | mulan | MIT | B | 447949ff636484ebd7592000e2fdb89b8e4aae3e59785e3e7fbb8f9fdf55c8f2 | 120 | 10 | 0.208333 | true |
000049_mulan__00049_MulanRevive__mulan-rework__lambda_1参.ul | print((n -> n + 1)(2))
/* 没认出这个词 "(" */ | .ul | mulan | MIT | A | 83d091ad864de45272b966c3cbf33f8dbbd4bb87d7cc173629bee888c0566f14 | 51 | 2 | 0.461538 | true |
000050_mulan__00050_MulanRevive__mulan-rework__lambda_2参.ul | print(list(map((x,y) -> x + y, [(1,2)])))
/* 没认出这个词 "," */ | .ul | mulan | MIT | B | d52bb3c1ce6bb9078b2fa20a2e59e979fc0d5550b405a5875878558239a1bf54 | 70 | 2 | 0.272727 | true |
000051_mulan__00051_MulanRevive__mulan-rework__lambda_无参.ul | func 平方(n) {
return func {
print(n*n)
}
}
print(平方(2)())
/* TypeError: required field "args" missing from arguments */ | .ul | mulan | MIT | B | e42d85e3379778042df611c37ab0e36e714eccecd9278b06b6602bb66376182d | 134 | 7 | 0.051948 | true |
000052_mulan__00052_MulanRevive__mulan-rework__中文标识符.ul | func 过(年) {
print(年 + 1)
}
过(2019) | .ul | mulan | MIT | A | 65908f3db380d5066bcbc2fc036801ca363c58e458f89d1be601fddbcf24ec21 | 44 | 4 | 0.307692 | true |
000053_mulan__00053_MulanRevive__mulan-rework__注释块.ul | /* 测试 1 */print(2)
/*
测试
2
*/
// 测试 3
print(3)
| .ul | mulan | MIT | A | 4275d13849a73a01a7435f0b028a20dfc296ba2dd0ef7579b30d2848470a04fe | 59 | 7 | 0.375 | true |
000054_mulan__00054_MulanRevive__mulan-rework__冒泡.ul | /* 参考: https://stackabuse.com/sorting-algorithms-in-python/ */
func 冒泡(数列) {
换过 = true
while 换过 {
换过 = false
for i in 0..len(数列) - 2 {
前项 = 数列[i]
后项 = 数列[i + 1]
if 前项 > 后项 {
数列[i], 数列[i + 1] = 后项, 前项
换过 = true
}
}
}
}
打乱数列 = [5, 2, 1, 8, 4]
冒泡(打乱数列)
print(打乱数列) | .ul | mulan | MIT | A | 840982d61bd20a34751d0b58390d1c30dbd5cbfbe92de8cac735e10c06c34cdd | 420 | 19 | 0.37037 | true |
000055_mulan__00055_MulanRevive__mulan-rework__快速.ul | func 分区(数列, 下界, 上界) {
中值 = 数列[上界] // 中值可以取任意一个位置的
前位 = 下界
for 后位 in 下界..上界 {
if 数列[后位] < 中值 {
数列[前位], 数列[后位] = 数列[后位], 数列[前位]
前位 += 1
}
}
数列[前位], 数列[上界] = 数列[上界], 数列[前位]
return 前位
}
func 快速排序(数列) {
func 递归(各项, 下界, 上界) {
if 下界 < 上界 {
中位 = 分区(各项, 下界, 上界)
递归(各项, 下界, 中位 - 1)
递归(各项, 中位 + 1, 上界)
}
}
递归(数列, 0, len(数列) - 1)
}
打乱数列 = [5, 2, 1, 8, 4]
快速排序(打乱数列)
print(打乱数列)
| .ul | mulan | MIT | A | 2484d0ba4c1ac12a80a5c4d0970dfdd8db50a1f3207dff2059ff05ce8de7ae91 | 721 | 28 | 0.804469 | true |
000056_mulan__00056_MulanRevive__mulan-rework__插入.ul | func 插入(数列) {
for i in 1..<len(数列) {
挑出 = 数列[i]
位置 = i - 1
while 位置 >= 0 and 数列[位置] > 挑出 {
数列[位置 + 1] = 数列[位置]
位置 -= 1
}
数列[位置 + 1] = 挑出
}
}
打乱数列 = [5, 2, 1, 8, 4]
插入(打乱数列)
print(打乱数列)
| .ul | mulan | MIT | A | 57a5a4f4eb5d49baec8b1a9191020882a967a4a16d3f1c5e8b96f97e93536d9e | 322 | 15 | 0.641026 | true |
000057_mulan__00057_MulanRevive__mulan-rework__个体属性.ul | type Person {
func $Person(name) {
self.name = name
$名字 = name
$type = name
}
}
mulan = Person(1)
print(mulan.name)
print(mulan.名字)
print(mulan.__getattribute__('type'))
/* 等价于：
for attribute, value in mulan.__dict__.items() {
print(attribute, '=', value) if attribute == 'type'
}
*/
| .ul | mulan | MIT | C | db358bc3aa329cab5aa497df4d40a01e68ec5eacc3cadf2f95fdf5e120e5ce08 | 335 | 16 | 0.043478 | true |
000058_mulan__00058_MulanRevive__mulan-rework__定义方法self.ul | type Person {
func getAge(self) {
return 1
}
func $自身() {
return $
}
}
mulan = Person()
print(mulan.getAge())
print(mulan.自身().getAge()) | .ul | mulan | MIT | C | f69842552501e17db94561cf46b4cb4cf50851582dbacd1008af0cdabb09fe6d | 176 | 11 | 0.045977 | true |
000059_mulan__00059_MulanRevive__mulan-rework__构造方法原始.ul | type Person {
{
name = "小白"
}func $__init__(name) {
self.name = name
}
}
mulan = Person("Mulan")
print(mulan.name) | .ul | mulan | MIT | C | 50e50c2f7e7e8ac4570980e17d2bcdbae24f932c07bff1cabe8f0d54570b8aea | 146 | 9 | 0.028571 | true |
000060_mulan__00060_MulanRevive__mulan-rework__继承.ul | type Animal {
func getName() {
return 1
}
}
type 当地 {
{}
}
type Person : Animal {
{}
}
type 当地人 : Person, 当地 {
{}
}
print(Person.getName())
/*
必须先定义 Animal
*/ | .ul | mulan | MIT | B | 907f0acdd44b1d98e7530e640cc67d259c5f37e7eb18d1776e163638387634a2 | 198 | 18 | 0.129032 | true |
000061_mulan__00061_MulanRevive__mulan-rework__乘.ul | print(2*3)
长 = 2
宽 = 3
print(3长 + 4 宽)
print(6/2(1+2))
正方形边长 = 2
print(4(正方形边长:int)) | .ul | mulan | MIT | A | 8e87f6c7e5ae099328be23bc3643b3bb339b5325139cae9c50e3cf0ed594c6a6 | 112 | 7 | 0.378378 | true |
000062_mulan__00062_MulanRevive__mulan-rework__综合.ul | func 累积(上限) {
数 = 1
和 = 0
while 1==1 and 2==2 or 3==3 {
if 数 <= 上限 {
和 = 和 + 数
数 = 数 + 1
continue
} elif 1!=2 {
break
} else {
break
}
}
return 和
}
print(累积(4)) | .ul | mulan | MIT | B | 0e9051c9afc88e101768cc5e310fd0a55015e29d80ca9bb0a52bade85b2d4519 | 250 | 17 | 0.242857 | true |
000063_mulan__00064_MulanRevive__mulan-rework__引用模块.ul | using * in 测试.错误处理.下标越界函数
a()
| .ul | mulan | MIT | A | a58f9c03a40a3529d616b277579489d7b264dff0aec096577629f977a877b99a | 55 | 3 | 0.6 | true |
000064_mulan__00065_MulanRevive__mulan-rework__引用问题模块.ul | using * in 测试.错误处理.无此变量
print(a)
| .ul | mulan | MIT | A | 86683235ade0c7db26f168106038d6ce2a92c822e0faee08f749bd373edaa353 | 54 | 3 | 0.434783 | true |
000065_mulan__00066_MulanRevive__mulan-rework__a.ul | using * in 测试.错误处理.循环引用.b
aa = bb
print("aa in a: " + aa) | .ul | mulan | MIT | B | 5ca980b2f082535f6c67146a6cff395cf82fef7ee08be2dfa441a18c7f65b0c1 | 78 | 4 | 0.294118 | true |
000066_mulan__00067_MulanRevive__mulan-rework__b.ul | using * in 测试.错误处理.循环引用.a
bb = aa
print("bb in b: " + bb) | .ul | mulan | MIT | B | c7cc1b027df95bf2ffff19792f158119b226a93ff4917f32bf65bb58a205a37e | 78 | 4 | 0.294118 | true |
000067_mulan__00068_MulanRevive__mulan-rework__未定义变量于多层函数.ul | func 加(数) {
return 数1 + 1
}
func 输出(数) {
print(数)
}
输出(加(2))
| .ul | mulan | MIT | A | 80cd8437a6e4b8bd5a29795c3f4d85b6de4172889e802469b5a638fab1fa724c | 85 | 7 | 0.344828 | true |
000068_mulan__00069_MulanRevive__mulan-rework__类型定义中使用本类型.ul | type Person {
{
name = "小白"
}
func $__init__(name) {
self.name = name
}
func newPerson(): Person {
return 0
}
}
| .ul | mulan | MIT | C | 7d2596200df82f2543e2d58df6af24d71fd493f036fbce798c2a9533203d4788 | 166 | 13 | 0.030769 | true |
000069_mulan__00070_MulanRevive__mulan-rework__自身.ul | type 长方 {
func $长方(长, 宽) {
$长 = 长
$宽 = 宽
}
func $面积() {
return $.长 * $宽
}
}
块 = 长方(3, 4)
print(块.面积())
| .ul | mulan | MIT | A | fc180af171f6bf457b3fffe1472de61e969604be6efa83f2a9ae1923b42cf196 | 164 | 12 | 0.465116 | true |
000070_mulan__00072_MulanRevive__mulan-rework__调用错误函数.ul | using a in 测试.错误处理.函数内不识变量
a()
| .ul | mulan | MIT | A | e96a1cbe0e73b66154980d12137a630614bc729f9e89714f0f8fbe89a61544c6 | 58 | 3 | 0.590909 | true |
000071_mulan__00074_python2008__mulan-rework__猜数字.ul | using sys, cmd
using 随机范围数 in 随机数
type 猜数字 : cmd.Cmd {
{
intro, prompt = tuple('我想了个 100 之内的数，猜猜是几？', '请猜吧: ')
想的 = 随机范围数(1000) / 10
}
func $default(行) {
try {
数 = int(行)
}
catch 例外 : ValueError {
println(行 + ' 不是数，请再试')
return
}
$比较(数)
}
func $比较(数) {
if (数 == $想的) {
println('中了!')
sys.exit()
}
println((数 > $想的) ? '太大了!' : '太小了!')
}
}
猜数字().cmdloop() | .ul | mulan | MIT | A | 842b6d8d33e070c049ead4a247165202a7e9aade2a9ea40dceceab8ade0fda03 | 582 | 30 | 0.365979 | true |
000072_mulan__00075_python2008__mulan-rework__常用字拆分.ul | using 为常用字 in 测试.实用.通用.库_常用字
using json
// 不包含常用字, 比如"广"
// ⻖和⻏分别为左/右耳朵旁
// TODO: 问题: 辶⻌不同!
一笔 = "乚"
二笔 = "刂冫匚𠆢亠⺆勹亻辶⻌廴冖讠⻖⻏"
三笔 = "氵彡丬口囗扌忄饣彳宀艹纟犭彐"
四笔 = "灬歹𤣩𠃜龵⺼攵"
五笔 = "疒𢀖矢衤钅⺲皿覀缶耒糸𧾷癶"
常用部首 = 一笔 + 二笔 + 三笔 + 四笔 + 五笔
// 数据中, 部首 礻为"示"
// 数据来源：http://git.chise.org/gitweb/?p=chise/ids.git;a=blob_plain;f=IDS-UCS-Basic.txt;hb=HEAD
源数据 = open("测试/实用/字/IDS-UCS-Basic.txt", 'rt', encoding="utf-8")
所有行 = 源数据.read().split("\n")
源数据.close()
带部首的字 = {:}
拆字 = {:}
无法拆的字 = []
for 行 in 所有行 {
字段 = 行.split("\t")
// TODO: 暂时只考察两部分构成的字
continue if len(字段) != 3
字 = 字段[1]
信息 = 字段[2]
if 为常用字(字) and 字 != 信息 {
字型 = 信息[0]
部分 = []
都为常用字 = true
for i in 1..<len(信息) {
if !为常用字(信息[i]) {
if 常用部首.find(信息[i]) >= 0 {
部首 = 信息[i]
if 带部首的字.get(部首) {
带部首的字[部首].append(字)
} else {
带部首的字[部首] = [字]
}
} else {
都为常用字 = false
无法拆的字.append(字)
break
}
}
部分.append(信息[i])
}
拆字[字] = {"字型": 字型, "部分": 部分} if 都为常用字
}
}
常用字数据 = open('测试/实用/字/常用字拆字.json', 'w', encoding="utf-8")
json.dump(拆字, 常用字数据, ensure_ascii=false, indent = 4)
常用字数据.close()
print(str(len(无法拆的字)) + "".join(无法拆的字))
/*
for 部首 in 带部首的字 {
println(部首 + " -> " + str(带部首的字[部首]))
}
for 部首 in 常用部首 {
if !带部首的字.get(部首) {
print(部首)
}
}*/ | .ul | mulan | MIT | A | 280daa9643ac00e5b4b7b9a2f87bfb85348793567e9721589c8e9bd81a1d370f | 2,032 | 67 | 0.502256 | true |
000073_mulan__00077_python2008__mulan-rework__中.ul | using 代码段 in 编辑器.代码段
using * in 编辑器.日志
using * in 编辑器.笔谈
using time
// TODO: 重构(提取 UI 无关部分并添加测试)
// TODO: 已知问题: 输入中文符号"（"时，实际为退格，"）"时为空格。thonny 也有同样问题。
if len(sys.argv) == 3 {
源码文件 = sys.argv[2]
} else {
源码文件 = "编辑器/中.ul"
}
源码 = 读文件内容(源码文件)
logging.info("打开源码文件：`源码文件`")
会话 = 笔谈(源码文件, 源码)
| .ul | mulan | MIT | A | 1ca38a7b75ed4be5c37c5899dd57a551f2faee9b2ac71380bfdaa98361c54c58 | 515 | 20 | 0.568421 | true |
000074_mulan__00078_python2008__mulan-rework__代码分析.ul |
using * in 木兰.分析器.词法分析器
using 代码段 in 编辑器.代码段
using * in 编辑器.常量
using * in 编辑器.日志
using 按某项生成映射 in 测试.实用.通用.结构
func 解析(源码) {
各词 = 分词器.lex(源码)
各代码段 = list(map(词 -> {
行号 = 词.getsourcepos().lineno
列号 = 词.getsourcepos().colno - 1
内容 = 词.getstr()
词长 = len(内容)
词性 = 词.name
if 词性 == 标识符 {
if 内置函数表.__contains__(内容) {
词性 = 内置函数
} elif 内置类型表.__contains__(内容) {
词性 = 内置类型
} elif 内容 == 自身 {
词性 = 自身
}
}
return 代码段(词性, 内容, 行号, 列号, 列号 + 词长)
}, 各词))
各行代码段 = 按某项生成映射(各代码段, 段 -> 段.行, 段 -> 段)
所有行 = 源码.splitlines()
for 索引 in range(len(所有行)) {
行号 = 索引 + 1
列号 = 0
完整代码段 = []
// 取本行所有代码段, 将跳过部分全部置为注释 TODO: 保险起见最好再次检查是否为注释
if 各行代码段.__contains__(行号) {
本行代码段 = 各行代码段.get(行号)
for 段 in 本行代码段 {
if 段.起 > 列号 + 1 {
内容 = 所有行[索引][列号 : 段.起]
词性 = 内容 == " " * (段.起 - 列号) ? 空格 : 注释
完整代码段.append(代码段(词性, 内容, 行号, 列号, 段.起))
}
完整代码段.append(段)
列号 = 段.止
}
}
行长 = len(所有行[索引])
if 列号 < 行长 {
内容 = 所有行[索引][列号 : 行长]
词性 = 内容 == " " * (行长 - 列号) ? 空格 : 注释
完整代码段.append(代码段(词性, 内容, 行号, 列号, 行长))
}
各行代码段[行号] = 完整代码段
}
// TODO: 考虑直接使用 各行代码段, 今后演化为代码抽象结构(介于 AST 和文本形式之间)
所有代码段 = []
for 行号 in 1..len(所有行) {
所有代码段 += 各行代码段[行号]
}
return 所有代码段
}
func 处理后大括号(各代码段) {
已处理 = []
上一代码段 = nil
for 代码段 in 各代码段 {
if 代码段.词性 == 后大括号 {
换行数 = 代码段.内容.count("\n")
代码段.行 = 代码段.行 + 换行数
代码段.内容 = 代码段.内容[换行数:]
代码段.止 = 代码段.止 - 代码段.起 - 换行数
代码段.起 = 0
} elif 代码段.位置重合(上一代码段) {
// 除去多余注释段
continue
}
已处理.append(代码段)
上一代码段 = 代码段
}
return 已处理
}
func 未配对括号数(各代码段) {
未配对 = 0
for 代码段 in 各代码段 {
if 代码段.词性 == 前大括号 {
未配对 += 1
} elif 代码段.词性 == 后大括号 {
未配对 -= 1
}
}
if 各代码段 and 各代码段[-1].词性 == 前大括号 {
未配对 -= 1
}
return 未配对
}
func 全为空格(各代码段) {
return all(map(代码段 -> 代码段.词性 == 空格, 各代码段))
}
func 格式化(源码) {
缩进单位 = " "
所有行 = 源码.splitlines()
格式源码 = []
// 只解析一次全部代码, 遍历一次所有代码段后生成每行缩进量
各代码段 = 处理后大括号(解析(源码))
各行代码段 = 按某项生成映射(各代码段, 段 -> 段.行, 段 -> 段)
每行缩进量 = {1:0}
for 行号 in 1..len(所有行) {
if !各行代码段.__contains__(行号) {
每行缩进量[行号] = 0
continue
}
本行代码段 = 各行代码段[行号]
缩进增量 = 未配对括号数(本行代码段)
if 行号 > 1 {
上行代码段 = 各行代码段.get(行号 - 1)
if 上行代码段 and 上行代码段[-1].词性 == 前大括号 {
缩进增量 += 1
}
}
每行缩进量[行号] = 行号 == 1 ? 缩进增量 : 每行缩进量[行号 - 1] + 缩进增量
//logging.info(本行代码段)
每行缩进量[行号] = 0 if 全为空格(本行代码段)
}
for 行号 in 1..len(所有行) {
logging.info("`行号`行缩进量`每行缩进量[行号]`")
格式源码.append(每行缩进量[行号] * 缩进单位 + 所有行[行号 - 1].strip())
}
return "\n".join(格式源码)
}
| .ul | mulan | MIT | A | abe2be42a4b8f591d03c8a75e701e3b2cb31c788d211bf3d248891fc9025f0dc | 4,431 | 142 | 0.678125 | true |
000075_mulan__00079_python2008__mulan-rework__代码段.ul |
type 代码段 {
func $代码段(词性, 内容, 行, 起, 止) {
$词性 = 词性
$内容 = 内容
$行 = 行
$起, $止 = 起, 止
}
func $开始 {
return "`$行`.`$起`"
}
func $结束 {
return "`$行`.`$止`"
}
func $位置重合(另一代码段) {
return 另一代码段 and $行 == 另一代码段.行 and $起 == 另一代码段.起 and $止 == 另一代码段.止
}
operator == (另一代码段) {
return $位置重合(另一代码段) and $词性 == 另一代码段.词性 and $内容 == 另一代码段.内容
}
func $__repr__ {
return "[`$词性` 行:`$行` 列:`$起`~`$止`], 内容: `$内容`"
}
}
| .ul | mulan | MIT | A | daa0a87ce826c349e1041c4fa9afa75867d495769ea01ee1cf3b5b2e530a917f | 678 | 29 | 0.582474 | true |
000076_mulan__00080_python2008__mulan-rework__常量.ul |
using * in 木兰.分析器.词法分析器
空格 = "空格"
注释 = "注释"
内置函数 = "函数"
内置类型 = "类型"
自身 = "self"
内置类型表 = set(["str", "list"])
内置函数表 = set(["len", "all", "filter", "map", "print"])
// TODO: 颜色常量化
高亮风格 = {
"紫红": [动词_引用, 动词_返回, 连词_于, 连词_对, 连词_每当, 连词_如果, 连词_否则如果, 连词_否则, 点点小于, 点点, 动词_终止, 动词_跳过],
"黄绿": [整数],
"橙": [双引号字符串, 单引号字符串],
"蓝": [名词_函数, 名词_类型, 名词_真, 名词_假, 自身, 箭头],
"绿": [注释]
}
// 颜色表: https://www.w3schools.com/colors/colors_names.asp
颜色表 = {
"紫红": "VioletRed",
"番茄": "Tomato",
"黄绿": "YellowGreen",
"水蓝": "MediumAquaMarine",
"橙": "orange",
"蓝": "blue",
"绿": "green"
}
高亮风格表 = {:}
for 颜色 in 高亮风格 {
for 词性 in 高亮风格[颜色] {
高亮风格表[词性] = 颜色
}
}
高亮风格表[内置类型] = "水蓝"
高亮风格表[内置函数] = "番茄"
// 界面相关
文本字体 = "Courier"
总高度 = 35
宽度 = 90
| .ul | mulan | MIT | A | 54b0ce8e1d8507c1be785b79a31ebac98614302415b987c155fab23d4fd286a9 | 1,210 | 45 | 0.575198 | true |
000077_mulan__00081_python2008__mulan-rework__日志.ul | using logging
日志文件 = '编辑器/事件.log'
logging.basicConfig(
filename=日志文件,
format='%(asctime)s %(message)s',
level=logging.INFO)
| .ul | mulan | MIT | B | b1f3478cb76ff8b1109bdcdb299fe96f1055fc666381b7bc7b4806546464e946 | 158 | 8 | 0.141304 | true |
000078_mulan__00082_python2008__mulan-rework__笔谈.ul | using * in tkinter
using Font in tkinter.font
using scrolledtext in tkinter
using * in 编辑器.代码分析
using * in 编辑器.常量
using * in 编辑器.日志
using * in 编辑器.词.常量
默认要求 = "`动词.保存.value`"
/* TODO: 在 HTML 的代码编辑器效果达到 tk 版本后, 删除 tk 相关部分 */
type 笔谈 : Tk {
func $笔谈(源码文件, 源码) {
$源码文件 = 源码文件
$源码 = 源码
root = Tk()
root.title("木兰笔谈")
// 行间距设置, 参考: https://www.javatpoint.com/python-tkinter-text
$文本 = scrolledtext.ScrolledText(root, spacing1=3, spacing3=3, height=总高度, width=宽度)
$文本.pack(side=LEFT)
右边 = Frame(root, height=2, bd=1, relief=SUNKEN)
右边.pack(fill=X, padx=5, pady=5)
输入框 = Entry(右边,
background="#a0ffa0",foreground="#000000",
disabledbackground="#7f7f7f",disabledforeground="#000000",
font=Font(family=文本字体, size=24), width=40)
输入框['fg'] = 'grey'
输入框.insert(INSERT, 默认要求)
输入框.pack(side=BOTTOM)
输入框.bind('<Return>', event -> $回应(输入框.get()))
$输出文本 = scrolledtext.ScrolledText(右边, spacing1=3, spacing3=3, height=总高度 - 2, width=宽度 / 2)
$输出文本.configure(font=Font(family=文本字体, size=16))
$输出文本.pack(side=TOP)
for 颜色 in 颜色表 {
$文本.tag_config(颜色, foreground=颜色表[颜色])
}
$文本.configure(font=Font(family=文本字体, size=16))
$更新高亮(源码)
$刷新日志()
// 参考: https://www.delftstack.com/howto/python-tkinter/how-to-set-tkinter-backgroud-color/
root.mainloop()
}
func $更新高亮(源码) {
$文本.delete(1.0, END)
$文本.insert(INSERT, 源码)
for 代码段 in 解析(源码) {
$文本.tag_add(高亮风格表[代码段.词性], 代码段.开始(), 代码段.结束()) if 高亮风格表.get(代码段.词性)
}
}
func $回应(要求) {
logging.info(要求)
if 要求 == "格式化，保存" {
$执行(动词.格式化)
$执行(动词.保存)
} else {
$执行(动词[要求])
}
$刷新日志()
}
func $执行(要求) {
if 要求 == 动词.格式化 {
格式源码 = 格式化($取文本内容())
$更新高亮(格式源码)
logging.info("格式化完成")
} elif 要求 == 动词.保存 {
源码 = $取文本内容()
logging.debug("源码长度:`len(源码)`")
保存文件($源码文件, $源码)
logging.info("保存`len(源码)`字到`$源码文件`")
}
}
func $刷新日志 {
$输出文本.insert(INSERT, 读文件内容(日志文件))
$输出文本.see(END)
}
func $取文本内容 {
// https://stackoverflow.com/questions/14824163/how-to-get-the-input-from-the-tkinter-text-widget
return $文本.get(1.0, 'end-1c')
}
}
func 读文件内容(文件名) {
f = open(文件名, 'r', encoding='utf-8')
内容 = f.read()
logging.debug("打开“`文件名`”长度:`len(内容)`")
f.close()
return 内容
}
func 保存文件(文件名, 内容) {
f = open(文件名, 'w', encoding='utf-8')
f.write(内容)
f.close()
}
| .ul | mulan | MIT | A | 12f69b2520452045ecd1e162d367dc182b82c0c922dd8df4fbbf6f01f224242b | 3,271 | 113 | 0.302651 | true |
000079_mulan__00083_python2008__mulan-rework__统计行数.ul | using Path in pathlib
using json
func 有几行(文件名) {
f = open(文件名, 'r', encoding='utf-8')
内容 = f.read()
f.close()
// 末尾空行不算
return #内容.strip().split('\n')
}
// TODO: 略过 .gitignore 部分
各文件类型忽略目录 = {
'py': set(['.eggs', 'build', '临时']),
'ul': set(['临时'])
}
各源码文件行数 = {:}
各文件类型行数 = {:}
for 扩展名 in 各文件类型忽略目录 {
总行数 = 0
for 完整路径 in list(Path('.').glob('**/*.' + 扩展名)) {
路径文本 = str(完整路径)
continue if 各文件类型忽略目录[扩展名].__contains__(路径文本[:路径文本.find('/')])
行数 = 有几行(完整路径)
各源码文件行数[路径文本] = 行数
总行数 += 行数
}
各文件类型行数[扩展名] = 总行数
}
当前统计 = open('临时/行数统计' + '.json', 'w', encoding="utf-8")
json.dump(各源码文件行数, 当前统计, ensure_ascii=false, indent = 4)
当前统计.close()
println("总行数:`各文件类型行数`")
| .ul | mulan | MIT | A | 7a8e9ea5e13e1ca433a05aa41ccb6eba3cf080d4874955ee182f3fe42dd5ef8b | 1,052 | 34 | 0.446429 | true |
000080_mulan__00084_python2008__mulan-rework__行数差异.ul | using DeepDiff in deepdiff
using Path in pathlib
using json
func 读取(文件名) {
try 文件 = open(文件名, 'r', encoding="utf-8") { return json.load(文件) }
}
旧行数, 新行数 = 读取('临时/行数统计_0718.json'), 读取('临时/行数统计_0725.json')
func 取总行数(各文件行数) {
各类型行数 = {'py':0, 'ul':0}
for 文件名 in 各文件行数 {
各类型行数[文件名[-2:]] += 各文件行数[文件名]
}
return 各类型行数
}
func 取目录下行数(各文件行数, 目录, 类型) {
行数 = 0
for 文件路径 in 各文件行数 {
if 目录 == 文件路径[:文件路径.find('/')] and 文件路径[-2:] == 类型 {
行数 += 各文件行数[文件路径]
}
}
return 行数
}
旧总行数, 新总行数 = 取总行数(旧行数), 取总行数(新行数)
println('-----------\n\n### ***附：[木兰重现项目](https://gitee.com/MulanRevive/mulan-rework) 代码量统计***\n\n主要部分的代码行数统计与修改之处：上次->现在。')
println('- 木兰 `旧总行数["ul"]` -> `新总行数["ul"]`')
编辑器旧行数, 编辑器新行数 = 取目录下行数(旧行数, '编辑器', 'ul'), 取目录下行数(新行数, '编辑器', 'ul')
println(' - 木兰测试用例、一些实用小程序如井字棋：' + str(旧总行数["ul"] - 编辑器旧行数) + ' -> ' + str(新总行数["ul"] - 编辑器新行数))
println(' - 运行环境、行数统计：' + str(编辑器旧行数) + ' -> ' + str(编辑器新行数))
println('- Python（实现、测试框架，py转木兰的测试用例） `旧总行数["py"]` -> `新总行数["py"]`')
差异概要 = DeepDiff(旧行数, 新行数)
所有新添 = list(map(n->str(n), 差异概要['dictionary_item_added']))
所有修改 = list(差异概要['values_changed'])
所有差异 = list(filter(路径 -> 路径[-4:-2] == 'py', 所有新添 + 所有修改))
所有差异.sort(key=路径 -> -新行数[路径[6:-2]])
for 原始文件路径 in 所有差异 {
文件路径 = 原始文件路径[6:-2]
print(' - `文件路径`：')
println(旧行数.__contains__(文件路径) ? '`旧行数[文件路径]` -> `新行数[文件路径]`' : '`新行数[文件路径]`')
}
| .ul | mulan | MIT | A | 3ed985a33872b204c646f2362951104b01d57a1a03850c82b4970a9453e2c47c | 2,227 | 51 | 0.551546 | true |
000081_mulan__00085_python2008__mulan-rework__过往请求.ul | using SQLAlchemy in tornado_sqlalchemy
using DateTime, Column, String in sqlalchemy
db = SQLAlchemy(url="sqlite:///编辑器/请求历史.db")
type 过往请求 : db.Model {
{
__tablename__ = '请求历史'
时间 = Column(DateTime, primary_key=true)
请求 = Column(String(255))
}
func $__repr__ {
return str($时间) + $请求
}
}
| .ul | mulan | MIT | B | 6601a26dc53ed991df0c498a50f91d7308c9694f29853995ca39eb4a91aec6b5 | 361 | 17 | 0.118557 | true |
000082_mulan__00086_python2008__mulan-rework__运行.ul | using logging
using tornado.ioloop
using tornado.web
using Path in pathlib
using 预估请求 in 编辑器.访问处理.预估请求
using 聊天渠道 in 编辑器.访问处理.聊天渠道
using 首页 in 编辑器.访问处理.首页
using db in 编辑器.过往请求
type 应用 : tornado.web.Application {
func $应用 {
相应处置 = [tuple("/", 首页),
tuple("/chatsocket", 聊天渠道),
tuple("/requests", 预估请求)]
当前目录 = Path(__file__).parent
super.__init__(相应处置,
db=db,
template_path = 当前目录 / "模板",
static_path = 当前目录 / "静态资源",
xsrf_cookies=true
)
}
}
func 中 {
app = 应用()
db.create_all()
app.listen(8888)
logging.info("服务启动于 http://localhost:8888")
tornado.ioloop.IOLoop.current().start()
}
if __name__ == "__main__" {
中()
} | .ul | mulan | MIT | B | 2582b9fad0bb35625cf3bb31fa3b04d039099b7283a10b35cf2e05d9ceff3421 | 892 | 38 | 0.237745 | true |
000083_mulan__00087_python2008__mulan-rework__代码分析.ul | using * in 编辑器.代码分析
using 相等 in 测试.实用.通用.测试相关
using * in 编辑器.常量
空函数 = "func a {\n \n}"
后段注释 = "a = -1// b"
部分函数 = "func a {\n return 1"
后段空格 = "a = 1 "
空行 = ""
两层 = "func a {\nif 1 {\nreturn 1\n}\n}"
带多余空格 = "if 1{\nreturn 1\n \n}"
带tab = "if 1{\n return 1\n\t\n}"
带空行 = "if 1{\n return 1\n\n}"
空行在前 = "if 1{\n\n return 1\n}"
大括号后注释 = "loop{\nif 1{//a\nreturn 1\n}\n}"
// TODO: 保留末尾空行
相等(后大括号, 解析(空函数)[-2].词性, "后大括号位置")
相等(2, 解析(空函数)[-2].行, "后大括号行号问题")
各代码段 = 处理后大括号(解析(空函数))
相等(代码段(后大括号, "}", 3, 0, 1), 各代码段[-1], "后大括号处理")
// 暂无法解决?
相等(注释, 解析(空函数)[-1].词性, "注释误判")
各代码段 = 解析(部分函数)
相等(整数, 各代码段[-1].词性, "注释误判_部分函数")
相等(注释, 解析(后段注释)[-1].词性, "后段注释")
相等(空格, 解析(后段空格)[-1].词性, "后段空格")
相等([], 解析(空行), "空行")
相等(1, 未配对括号数(各代码段), "未配对括号数_部分函数")
相等(0, 未配对括号数(解析(空函数)), "未配对括号数_空函数")
相等(0, 未配对括号数(解析("func a{")), "未配对括号数_前大括号于末尾")
相等(0, 未配对括号数(解析(空行)), "未配对括号数_空行")
相等("a = 1", 格式化(后段空格), "格式化_后段空格")
相等("func a {\n\n}", 格式化(空函数), "格式化_空函数")
相等("func a {\n if 1 {\n return 1\n }\n}", 格式化(两层), "格式化_两层")
相等("if 1{\n return 1\n\n}", 格式化(带多余空格), "格式化_带多余空格")
相等("if 1{\n return 1\n\n}", 格式化(带tab), "格式化_带tab")
// TODO：不应删除缩进
相等("if 1{\n\nreturn 1\n}", 格式化(空行在前), "格式化_空行在前")
// TODO：if 前只应有一个缩进
相等("loop{\n if 1{//a\n return 1\n }\n}", 格式化(大括号后注释), "格式化_大括号后注释")
相等(带空行, 格式化(带空行), "格式化_带空行")
| .ul | mulan | MIT | A | 027d56a7c79dd6064f534bf83d754e1437110e3af7c1819dae00f80d4fafa34a | 2,213 | 53 | 0.66716 | true |
000084_mulan__00088_python2008__mulan-rework__基本.ul | /* 不 */
func 累积(上限) {
数 = 888
文 = "666"
return 0
} | .ul | mulan | MIT | A | 3ce234723535ee5f2dc18f64def7aebbaf9c22d28be9502869e43b1e55d16782 | 70 | 6 | 0.411765 | true |
000085_mulan__00089_python2008__mulan-rework__注释误判.ul | if 1 {
}
else {
}
/*
else 会被识别为注释(绿色)
*/ | .ul | mulan | MIT | A | b4aad042d6187e56f239136d2343fc2d2b6a1441c8178bbe420d802b732ab96a | 60 | 9 | 0.473684 | true |
000086_mulan__00090_python2008__mulan-rework__聊天渠道.ul | using datetime
using logging
using uuid
using tornado.escape
using tornado.websocket
using SessionMixin in tornado_sqlalchemy
using 过往请求 in 编辑器.过往请求
using 读文件内容, 保存文件 in 编辑器.笔谈
using 运行木兰代码 in 编辑器.运行木兰
type 聊天渠道 : SessionMixin, tornado.websocket.WebSocketHandler {
func $on_message(内容) {
logging.info("收到消息: %r", 内容)
请求 = tornado.escape.json_decode(内容)["请求内容"]
输入 = $包装(请求, "要求")
$write_message(输入)
logging.info(请求)
try 会话=self.make_session() {
会话.add(过往请求(时间=datetime.datetime.now(), 请求=请求))
}
分词 = 请求.split(" ")
if len(分词) == 2 {
命令 = 分词[0]
文件 = 分词[1]
if 命令 == "打开" {
源码 = 读文件内容(文件)
// TODO: 同时返回语法信息?
$write_message($包装(源码, "编辑器"))
// TODO: 如果读文件出错, 反馈信息
$write_message($包装("打开完成", "反馈"))
} elif 命令 == "运行" {
$write_message($包装(运行木兰代码(文件), "反馈"))
} elif 命令 == "保存" {
源码 = tornado.escape.json_decode(内容)["编辑器内容"]
保存文件(文件, 源码)
// TODO: 检查保存状态
$write_message($包装("保存完成", "反馈"))
}
// TODO: 添加代码格式化
} else {
$write_message($包装("不懂", "反馈"))
}
}
func $包装(字符串, 类型) {
消息 = {"id": str(uuid.uuid4()), "类型": 类型, "内容": 字符串}
消息["html"] = tornado.escape.to_basestring(
$render_string("消息.html", 语句=消息)
)
return 消息
}
}
| .ul | mulan | MIT | A | c7181d44ebc73289de1bb01e91d3cfae33f8c43ddbcb20130d3f0c6ca0bf3364 | 1,798 | 58 | 0.330544 | true |
000087_mulan__00091_python2008__mulan-rework__预估请求.ul | using logging
using tornado.web
using SessionMixin in tornado_sqlalchemy
using desc, distinct in sqlalchemy
using 过往请求 in 编辑器.过往请求
type 预估请求: SessionMixin, tornado.web.RequestHandler {
func $get {
提示 = self.get_argument('term', nil)
所有请求 = []
// TODO: 优化?
历史请求 = self.session.query(过往请求)
if 提示 != nil {
历史请求 = 历史请求.filter(过往请求.请求.like("%" + 提示 + "%"))
}
历史请求 = 历史请求.order_by(desc(过往请求.时间)).group_by(过往请求.请求).distinct()
//个数 = self.session.query(distinct(过往请求.请求)).count()
// logging.info(str(历史请求)) // 可查看 sql 语句
// TODO: 通过拼音补全
for 记录 in 历史请求 {
所有请求.append(记录.请求)
}
// logging.info("|".join(所有请求))
$write({"历史" : 所有请求})
}
}
| .ul | mulan | MIT | B | 042a54366d5bb7e2fcf6f7c22e3f43b890eba33123657bd43f345d6a72cbbe77 | 934 | 29 | 0.2723 | true |
000088_mulan__00092_python2008__mulan-rework__首页.ul | using tornado.web
type 首页 : tornado.web.RequestHandler {
func $get {
$render("首页.html", 所有对话=[])
}
}
| .ul | mulan | MIT | B | 69b11d12fdfe141258b15cb25a964675c36691501957d119c10ce835e7b617a1 | 126 | 7 | 0.117647 | true |
000089_mulan__00093_python2008__mulan-rework__常量.ul | using Enum in enum
type 动词 : Enum {
{
格式化 = "格式化"
保存 = "保存"
}
} | .ul | mulan | MIT | A | ba61c0048bde3cfeb4e7b9504453ae0cb6a8e1f2f94b956f0ee5ffbdb4472fc2 | 100 | 8 | 0.342857 | true |
000090_mulan__00095_xy1282127821__mulan-rework__命令行.ul | using Cmd in cmd; using 随机范围数 in 随机数
type 猜数字 : Cmd {
{
intro, prompt = "木兰想了个 100 之内的数，猜是几？", "猜猜吧: "
想的 = 随机范围数(1000) / 10; 历史 = []; 至今最近 = 100
}
func $default(行) {
try { 数 = int(行) }
catch 例外 : ValueError { println("`行` 不是数，请再试"); return }
$历史.append(数); $比较(数)
}
func $比较(数) {
if 数 == $想的 { println("中了!"); 再会() }
else {
println("太" + (数 > $想的 ? "大" : "小") + "了!")
println("不过接近咯") if $接近了()
}
}
func $接近了 {
最近 = min(map(数 -> { 差 = 数 - $想的; return fabs(差) }, $历史))
{ $至今最近 = 最近; return true } if $至今最近 > 最近
}
}
猜数字().cmdloop() | .ul | mulan | MIT | A | 366223d2d1282491b91d94d5606e5977d511b4c2fbba95accbc3d30cf4b169b1 | 828 | 28 | 0.412409 | true |
000091_mulan__00096_xy1282127821__mulan-rework__草蟒_海龟.ul | using * in 海龟
颜色("黄色", "红色")
开始填充()
for 转角 in 0..4 {
前进(200); 右转(144)
}
结束填充()
主循环()
/* 需安装 Python 库“草蟒”： grasspy-modules */ | .ul | mulan | MIT | A | 7c5a0f4157cc45573bd35fbfc5fd7b87c32016a6b0351593876acc8a2eb63dd9 | 195 | 10 | 0.5 | true |
000092_mulan__00097_cndp__mulan-rework__变长参数.ul | func 回复(...) {
print(...)
}
回复(1, 2, 3) | .ul | mulan | MIT | A | caefd8ed25da7b1504389638e7328612c8b5eee1c2326fbba4d5f0e3cccd9936 | 51 | 4 | 0.307692 | true |
000093_mulan__00098_nianqingmallhq__mulan-rework__匿名函数.ul | print(list(filter(func (n) { return n>0 }, [1,-1])))
print(list(filter(n -> n>0, [1,-1])))
print(list(filter(n -> {
平方 = n*n
return 平方>5
}, [1,3])))
print(list(filter(
边长 -> { 面积 = 边长 * 边长; return 面积 > 5 },
[1,3]
)))
print(list(map(
func (边长) { 面积 = 边长 * 边长; return 面积 },
[1, 2]
)))
print(func (长, 宽) {
面积 = 长 * 宽;
return 面积
}(3, 4))
type 形状 {
{}
}
print(func (边长) : 形状 {
return 形状()
}(1) != nil) | .ul | mulan | MIT | B | 883ee1ab2968d7335ad3ba1ab8f64b8d8260e74f48f9b8926bbde853657f4d19 | 494 | 24 | 0.212766 | true |
000094_mulan__00099_nianqingmallhq__mulan-rework__乘.ul | print(2*3)
长 = 2
宽 = 3
print(3长 + 4 宽)
print(6/2(1+2)) | .ul | mulan | MIT | B | 968d68b8980af02fdde5be43e275e568d502e2acc309a9f918fda8a28877ab2e | 62 | 5 | 0.210526 | true |
000095_mulan__00100_labsite__mulan-rework__扩展拆字游戏.ul | using json
部分1 = "又寸土工斤木白旦各莫十分丁户少合青鸟包羊月古"
部分2 = "亻讠木又火口目⺼扌日氵𧾷宀艹广门辶"
// 待加：广门辶
// 待定: 纟钅
常用字数据 = open('测试/实用/字/常用字拆字.json', 'r', encoding="utf-8")
拆字 = json.load(常用字数据)
常用字数据.close()
func 搜索偏旁(偏旁) {
字数 = 0
所有字 = []
for 字 in 拆字 {
字型, 部分 = 拆字[字]['字型'], 拆字[字]['部分']
if 部分[0] == 偏旁 or 部分[1] == 偏旁 {
字数 += 1
所有字.append(字)
}
}
println(str(字数) + " " + 偏旁 + " -> " + "".join(所有字))
}
// 字型: ⿱⿰⿸⿵⿴
func 取字(包含偏旁, 排除偏旁) {
带偏旁的字 = {:}
for 字 in 拆字 {
字型, 部分 = 拆字[字]['字型'], 拆字[字]['部分']
for 偏旁 in 包含偏旁 {
if 部分[0] == 偏旁 {
偏旁位置 = 0
} elif 部分[1] == 偏旁 {
偏旁位置 = 1
} else {
continue
}
// TODO: 需要 catch ValueError
// 偏旁位置 = 部分.index(偏旁)
if 偏旁位置 >= 0 {
部首位置 = 1 - 偏旁位置
}
部首 = 部分[部首位置]
// continue if 排除偏旁.find(部首) >= 0
if 带偏旁的字.get(部首) {
带偏旁的字[部首].append(字)
} else {
带偏旁的字[部首] = [字]
}
}
}
return 带偏旁的字
}
带偏旁的字 = 取字(部分2, 部分1)
/*for 偏旁 in 带偏旁的字 {
println(偏旁 + ": " + str(带偏旁的字[偏旁])) if len(带偏旁的字[偏旁]) > 2
}*/
for 偏旁 in 部分2 {
搜索偏旁(偏旁)
}
| .ul | mulan | MIT | A | 64df40cf0a427754be9dc834ad86c61978729b28060f630b93c91a633b9fe368 | 1,698 | 63 | 0.602062 | true |
000096_mulan__00101_labsite__mulan-rework__聊天演示.ul | /*
#!/usr/bin/env python
#
# Copyright 2009 Facebook
#
# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
"""Simplified chat demo for websockets.
Authentication, error handling, etc are left as an exercise for the reader :)
"""
在原始 tornado 源码库例程基础上改为木兰实现
*/
using logging
using tornado.escape
using tornado.ioloop
using tornado.options
using tornado.web
using tornado.websocket
using os.path
using uuid
using define, options in tornado.options
// type 为语言关键词, 因而不可以作为函数形参的关键词
func 定义(名称 : str, 默认=nil, 类型=nil, 帮助=nil) {
define(名称, 默认, 类型, 帮助)
}
定义("port", 默认=8888, 帮助="在此端口运行服务", 类型=int)
type 应用 : tornado.web.Application {
func $应用 {
相应处置 = [tuple("/", 主页面),
tuple("/chatsocket", 聊天渠道)]
// 不支持 **
super.__init__(相应处置,
cookie_secret="__TODO: 生成随机内容",
template_path=os.path.join(os.path.dirname(__file__), "templates"),
static_path=os.path.join(os.path.dirname(__file__), "static"),
xsrf_cookies=true
)
}
}
type 主页面 : tornado.web.RequestHandler {
func $get {
$render("index.html", messages=聊天渠道.历史)
}
}
type 聊天渠道 : tornado.websocket.WebSocketHandler {
{
接收端 = set()
历史 = []
历史长度 = 200
}
func $get_compression_options {
// Non-None enables compression with default options.
return {:}
}
func $open {
聊天渠道.接收端.add($)
}
func $on_close {
聊天渠道.接收端.remove($)
}
func 更新历史(消息) {
// 必须指定类
聊天渠道.历史.append(消息)
if len(聊天渠道.历史) > 聊天渠道.历史长度 {
聊天渠道.历史 = 聊天渠道.历史[-聊天渠道.历史长度 :]
}
}
func 广播(消息) {
logging.info("发到%d个接收端", len(聊天渠道.接收端))
for 某接收端 in 聊天渠道.接收端 {
// TODO: try catch 尚待重现
//try:
某接收端.write_message(消息)
//except:
// logging.error("Error sending message", exc_info=True)
}
}
func $on_message(内容) {
logging.info("收到消息: %r", 内容)
parsed = tornado.escape.json_decode(内容)
消息 = {"id": str(uuid.uuid4()), "body": parsed["body"]}
消息["html"] = tornado.escape.to_basestring(
$render_string("message.html", message=消息)
)
聊天渠道.更新历史(消息)
聊天渠道.广播(消息)
}
}
func 中 {
tornado.options.parse_command_line()
app = 应用()
app.listen(options.port)
tornado.ioloop.IOLoop.current().start()
}
if __name__ == "__main__" {
中()
}
| .ul | mulan | MIT | B | d862a5d359a4c78b2860aa26057292f873b59288c27ad887350140323e6f1ee4 | 3,267 | 124 | 0.153268 | true |
000097_mulan__00102_hrw123__mulan-rework__运算.ul | 长 = 6
宽 = 2
println(长 == 3宽)
println(2^3宽)
// println(-1 宽..4 宽 by 2 宽)
// println(-1..6)
println(-1 ? 1 : 2..true ? 6 : 5)
println(-1..true)
println(1==-1..4)
println(-1..4 + 5)
| .ul | mulan | MIT | B | 9b982013e6478f596bc6c7d118e82cc3338c16f5e6f06ed83b4cb0ef730dff8e | 195 | 10 | 0.108108 | true |
000098_mulan__00103_hydrati__mulan-rework__命令行.ul | using Cmd in cmd; using exit in sys; using 随机范围数 in 随机数
type 猜数字 : Cmd {
{
intro, prompt = "木兰想了个 100 之内的数，猜是几？", "猜猜吧: "
想的 = 随机范围数(1000) / 10; 历史 = []; 至今最近 = 100
}
func $default(行) {
try { 数 = int(行) }
catch 例外 : ValueError { println("`行` 不是数，请再试"); return }
$历史.append(数); $比较(数)
}
func $比较(数) {
if 数 == $想的 { println("中了!"); exit() }
else {
println("太" + (数 > $想的 ? "大" : "小") + "了!")
println("不过接近咯") if $接近了()
}
}
func $接近了 {
最近 = min(map(数 -> { 差 = 数 - $想的; return 差 > 0 ? 差 : -差 }, $历史))
{ $至今最近 = 最近; return true } if $至今最近 > 最近
}
}
猜数字().cmdloop() | .ul | mulan | MIT | A | 4e0a75ddc1fe1b84cc2317aa0c23ae74f19cd81bd56e0be1b6331c733d68a474 | 856 | 28 | 0.392361 | true |
000099_mulan__00104_Jameskinglzz__mulan-rework__儿歌.ul | type 儿歌 {
func $儿歌(题目, 内容) {
self.题目 = 题目
self.内容 = 内容
}
}
func 春天在哪里小节(哪儿, 有啥) {
return ["春天在哪里呀 春天在哪里", "春天在那" + 哪儿 + "里", 有啥,
"还有那会唱歌的小黄鹂"] +
["嘀哩哩哩哩嘀哩哩嘀哩哩哩哩哩"] * 2 +
["春天在" + 哪儿 + "里", "还有那会唱歌的小黄鹂"]
}
春天在哪里 = 儿歌("春天在哪里",
春天在哪里小节("青翠的山林", "这里有红花呀 这里有绿草") +
春天在哪里小节("湖水的倒影", "映出红的花呀 映出绿的草") +
春天在哪里小节("小朋友眼睛", "看见红的花呀 看见绿的草")
)
凤阳花鼓 = 儿歌("凤阳花鼓",
[
"左手锣 右手鼓",
"手拿着锣鼓来唱歌",
"别的歌儿我也不会唱",
"单会唱个凤阳歌",
"凤凤阳鼓啊 咿呀哎哟",
"得儿铛铛飘一飘 得儿铛铛飘一飘",
"得儿飘 得儿飘",
"得儿飘得儿飘 飘飘一得儿 飘飘飘一飘"
])
小毛驴 = 儿歌("小毛驴",
[
"我有一只小毛驴我从来也不骑",
"有一天我心血来潮骑着去赶集",
"我手里拿着小皮鞭我心里正得意",
"不知怎么哗啦啦啦啦我摔了一身泥"
])
一分钱 = 儿歌("一分钱",
[
"我在马路边 捡到一分钱",
"把它交到警察叔叔手里边",
"叔叔拿着钱 对我把头点",
"我高兴地说了声：叔叔，再见！"
])
func 小螺号小节(听了) {
return ["小螺号滴滴滴吹", 听了]
}
小螺号 = 儿歌("小螺号",
小螺号小节("海鸥听了展翅飞") +
小螺号小节("浪花听了笑微微") +
小螺号小节("声声唤船归啰") +
小螺号小节("阿爸听了快快回啰") +
["茫茫的海滩 蓝蓝的海水",
"吹起了螺号 心里美吔"
])
func 小兔子小节(开否) {
return ["小兔子乖乖 把门儿开开",
"快点儿开开 我要进来"] + 开否
}
小兔子乖乖 = 儿歌("小兔子乖乖",
小兔子小节(["不开不开我不开",
"妈妈没回来 谁来也不开"]) +
小兔子小节(["就开就开我就开",
"妈妈回来了 这就把门开"])
)
鲁冰花 = 儿歌("鲁冰花",
[
"啊~ 啊~",
"夜夜想起妈妈的话",
"闪闪的泪光鲁冰花",
"天上的星星不说话",
"地上的娃娃想妈妈",
"天上的眼睛眨呀眨",
"妈妈的心呀鲁冰花",
"家乡的茶园开满花",
"妈妈的心肝在天涯",
"夜夜想起妈妈的话",
"闪闪的泪光鲁冰花",
"啊~ 啊~",
"夜夜想起妈妈的话",
"闪闪的泪光鲁冰花",
"啊~ 啊~",
"夜夜想起妈妈的话",
"闪闪的泪光"
])
func 两只老虎小节(没啥) {
return ["两只老虎，两只老虎",
"跑得快，跑得快",
"一只没有" + 没啥,
"一只没有尾巴",
"真奇怪！真奇怪！"]
}
两只老虎 = 儿歌("两只老虎",
两只老虎小节("眼睛") +
两只老虎小节("耳朵")
)
采蘑菇的小姑娘 = 儿歌("采蘑菇的小姑娘",
[
"采蘑菇的小姑娘",
"背着一个大竹筐",
"清早光着小脚丫",
"走遍树林和山冈",
"她采的蘑菇最多",
"多得像那星星数不清",
"她采的蘑菇最大",
"大得像那小伞装满筐",
"噻箩箩箩箩箩箩哩噻箩哩噻",
"噻箩箩箩箩箩箩哩噻箩哩噻",
"噻箩箩箩 噻箩箩箩 噻箩箩箩 噻箩箩箩噻 箩箩箩哩噻",
"谁不知山里的蘑菇香",
"她却不肯尝一尝",
"盼到赶集的那一天",
"快快背到集市上",
"换上一把小镰刀",
"再换上几块棒棒糖",
"和那小伙伴一起",
"把劳动的幸福来分享",
"噻箩箩箩箩箩箩哩噻箩哩噻",
"噻箩箩箩箩箩箩哩噻箩哩噻",
"噻箩箩箩 噻箩箩箩 噻箩箩箩 噻箩箩箩噻",
"箩箩箩箩箩箩箩箩箩箩箩箩哩噻",
"箩噻"
])
func 小鸭子小节(早晚, 告别) {
return [
"我们村里养了一群小鸭子",
早晚,
"小鸭子向着我嘎嘎嘎地叫",
告别,
告别]
}
小鸭子 = 儿歌("小鸭子",
小鸭子小节("我天天早晨赶着它们到池塘里", "再见吧小鸭子我要上学了") +
小鸭子小节("我放学回来赶着它们到棚里去", "睡觉吧小鸭子太阳下山了")
)
小燕子 = 儿歌("小燕子",
[
"小燕子，穿花衣",
"年年春天来这里",
"我问燕子你为啥来",
"燕子说：“这里的春天最美丽！”",
"小燕子，告诉你",
"今年这里更美丽",
"我们盖起了大工厂",
"装上了新机器",
"欢迎你，长期住在这里"
])
歌声与微笑 = 儿歌("歌声与微笑",
[
"请把我的歌带回你的家",
"请把你的微笑留下"] * 2 +
["明天明天这歌声飞遍海角天涯",
"飞遍海角天涯",
"明天明天这微笑将是遍野春花",
"将是遍野春花"
])
func 四季童谣小节(季节, 景致) {
到了 = 季节 + "天到 "
return [到了 * 2 + 景致[0],
到了 * 2 + 景致[1],
景致[2], 景致[3],
到了 * 4 + 景致[4]]
}
四季童谣 = 儿歌("四季童谣",
四季童谣小节("春", ["田野青青牛羊跑", "山坡青青花朵笑", "杨柳青青小鸟跳呀", "河水清清船儿漂", "春天的宝宝又长高"]) +
四季童谣小节("夏", ["天上打雷下冰雹", "大槐树上知了叫", "爸爸的啤酒冒白泡呀", "奶奶的扇子摇呀摇", "夏天的宝宝睡不好"]) +
四季童谣小节("秋", ["蓝天白云风景好", "坐在河边把鱼钓", "大雁排队向南飞呀", "放个风筝跟着跑", "秋天的宝宝蹦蹦跳"]) +
四季童谣小节("冬", ["赶快穿上厚棉袄", "跑出门外凑热闹", "捂着耳朵放鞭炮呀", "蘸着雪花吃年糕", "冬天里唱起四季谣"])
)
蝴蝶 = 儿歌("蝴蝶",
[
"蝴蝶蝴蝶生的真美丽",
"头戴着金丝 身穿花花衣",
"你爱花儿 花儿也爱你",
"你会跳舞 它有甜蜜"
])
我是卖报的小行家 = 儿歌("我是卖报的小行家",
[
"啦啦啦！啦啦啦！",
"我是卖报的小行家",
"不等天明去等卖报",
"一边走，一边叫",
"今天的新闻真正好",
"七个铜板就买两份报",
"啦啦啦！啦啦啦！",
"我是卖报的小行家",
"大风大雨里满街跑",
"走不好，滑一跤",
"满身的泥水惹人笑",
"饥饿寒冷只有我知道",
"啦啦啦！啦啦啦！",
"我是卖报的小行家",
"耐饥耐寒地满街跑",
"吃不好，睡不好",
"痛苦的生活向谁告",
"总有一天光明会来到"
])
我的好妈妈 = 儿歌("我的好妈妈",
[
"我的好妈妈",
"下班回到家",
"劳动了一天",
"多么辛苦呀",
"妈妈、妈妈快坐下",
"妈妈、妈妈快坐下",
"请喝一杯茶",
"让我亲亲你吧",
"让我亲亲你吧",
"我的好妈妈"
])
数鸭子 = 儿歌("数鸭子",
[
"门前大桥下",
"游过一群鸭",
"快来快来数一数",
"二四六七八",
"嘎嘎嘎嘎",
"真呀真多呀",
"数不清到底多少鸭",
"数不清到底多少鸭",
"赶鸭老爷爷",
"胡子白花花",
"唱呀唱着家乡戏",
"还会说笑话",
"小孩，小孩",
"快快上学校",
"别考个鸭蛋抱回家",
"别考个鸭蛋抱回家"
])
三个和尚 = 儿歌("三个和尚",
[
"一个呀和尚 挑呀么挑水喝",
"嘿嘿 挑呀么挑水喝",
"咿咿 挑呀么挑水喝",
"两个呀和尚 抬呀么抬水喝",
"嘿嘿 抬呀么抬水喝",
"咿咿 抬呀么抬水喝",
"三个和尚没水喝呀 没呀没水喝呀",
"嘿 没呀没水喝呀",
"咿 没呀没水喝呀",
"你说这是为什么呀为呀为什么",
"嘿嘿 你说这是为什么呀为呀为什么",
"为什么那和尚越来越多",
"嘿嘿 越来越多",
"咿咿 越来越多",
"为什么那和尚越来越懒惰",
"嘿嘿 越来越懒惰",
"咿咿 越来越懒惰",
"为什么那长老呀不来说一说呀",
"嘿 不来说一说呀",
"咿 不来说一说呀",
"睁着眼闭着眼只念阿弥陀佛",
"嘿嘿 睁着眼闭着眼只念阿弥陀佛",
"大和尚说挑水我挑的最多",
"嘿嘿 挑的最多",
"咿咿 挑的最多",
"二和尚说新来的应该多干活",
"嘿嘿 应该多干活",
"咿咿 应该多干活",
"小和尚说年幼身体太单薄呀",
"嘿 身体太单薄呀",
"咿 身体太单薄呀",
"白胡子的长老说年老不够格",
"嘿嘿 白胡子的长老说年老不够格",
"一个和尚挑呀挑水喝",
"两个和尚抬呀抬水喝",
"三个和尚没呀没水喝呀",
"你说这是为什么呀为什么",
"从此以后呀和尚都不挑水喝",
"不挑水的日子还是一样过",
"谁也不用奇怪也别问为什么呀",
"几千年的奥妙谁也不会说破",
"几千年的奥妙谁也不会说破",
"谁也不会说破"
])
所有歌 = [
凤阳花鼓,
春天在哪里,
小毛驴,
一分钱,
小螺号,
小兔子乖乖,
鲁冰花,
两只老虎,
采蘑菇的小姑娘,
小鸭子,
小燕子,
歌声与微笑,
四季童谣,
蝴蝶,
我是卖报的小行家,
我的好妈妈,
数鸭子,
三个和尚
]
| .ul | mulan | MIT | A | 154558155a30837317c22800a3316724d24d3b1060fe052c590754292fd10ad4 | 8,737 | 318 | 0.968412 | true |
End of preview. Expand in Data Studio
Language Decoded — Community Code
Natively-authored multilingual code for the Language Decoded project (part of Cohere's Tiny Aya Expedition). This dataset contains code written by developers in non-English programming languages and code with significant CJK content — not mechanically transpiled from English.
This data serves as a component of Condition 3 ("Mixed Native Sources") in the Language Decoded experiment, which tests whether a richer mix of native-language code improves multilingual reasoning beyond keyword swapping alone.
Available Configs
| Config | Language | Files | Description |
|---|---|---|---|
zh |
Chinese | 3,486 | Natively Chinese-authored code from 5 sources |
Schema
| Column | Type | Description |
|---|---|---|
filename |
string | Unique file identifier |
content |
string | Full file content |
extension |
string | File extension (e.g., .py, .java, .wy, .qi) |
source |
string | Origin dataset or project |
license |
string | SPDX license identifier or UNKNOWN |
quality_tier |
string | Quality tier: A (highest), B, C, D |
sha256 |
string | SHA-256 hash of file content for deduplication |
byte_size |
int64 | File size in bytes |
total_lines |
int64 | Number of lines in the file |
cjk_ratio |
float | Ratio of CJK characters to total non-whitespace chars |
has_cjk |
bool | Whether the file contains any CJK characters |
Chinese (zh) Source Breakdown
| Source | Files | Extensions | Description |
|---|---|---|---|
thestack |
1,948 | .py, .js, .java, … | Code from The Stack with CJK in comments, strings, identifiers |
program_in_chinese |
703 | .java, .js, .ts, … | Program in Chinese — code with Chinese identifiers |
qi |
239 | .qi | Qi — Chinese-syntax programming language |
mulan |
166 | .ul | Mulan — Chinese programming language |
wenyan |
81 | .wy | Wenyan — Classical Chinese programming language (20K+ GitHub stars) |
Quality Tier Distribution
| Tier | Count | Description |
|---|---|---|
| A | 778 | High quality, rich CJK |
| B | 1,158 | Good quality |
| C | 789 | Moderate quality |
| D | 412 | Lower quality, sparse CJK |
File Type Distribution
| Extension | Count | Extension | Count |
|---|---|---|---|
| .py | 2,003 | .ul | 166 |
| .java | 288 | .wy | 81 |
| .qi | 239 | .ts | 59 |
| .js | 205 | .c | 36 |
| Others | 59 |
Usage
from datasets import load_dataset
# Load Chinese native code
ds = load_dataset("legesher/language-decoded-community", "zh")
train = ds["train"] # 3,137 files
val = ds["validation"] # 349 files
# Filter by source
wenyan = train.filter(lambda x: x["source"] == "wenyan")
# Filter by quality
high_quality = train.filter(lambda x: x["quality_tier"] in ("A", "B"))
Relationship to Other Datasets
- legesher/language-decoded-data: The main experiment dataset with transpiled code (conditions 1–2) and blended datasets (condition 3). Condition 3 combines native code from this repo with transpiled code.
- This repo stores the raw native code with full metadata. The blended training datasets live in
language-decoded-data.
License
Apache 2.0
- Downloads last month
- 18