字母,数字,符号,空格,重复


36

人们经常会遇到97个ASCII字符。它们分为四类:

  1. 字母(共52个)

    ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz
    
  2. 数字或数字(共10个)

    0123456789
    
  3. 符号和标点符号(共32个)

    !"#$%&'()*+,-./:;<=>?@[\]^_`{|}~
    
  4. 空格(共3个)

    空格 ,制表符\t和换行符\n。(我们会将换行符\r\n视为一个字符。)

为简洁起见,我们将这些类别分别称为L,N,S和W。

选择LNSW您想要的字母的24个排列中的任意一个,然后无限重复,以形成自己的编程模板。

例如,您可以选择permutation NLWS,因此您的编程模板为:

NLWSNLWSNLWSNLWSNLWS...

您需要基于此模板编写程序或函数,其中:

  1. 每个L字母都替换为任何字母(ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz)。

  2. 每个数字N都替换为任何数字(0123456789)。

  3. 每个S符号均替换为任何符号(!"#$%&'()*+,-./:;<=>?@[\]^_`{|}~)。

  4. 每个W都将替换为任何空格字符( \t\n)。

基本上,您的代码必须遵循以下模式

<letter><number><symbol><whitespace><letter><number><symbol><whitespace>...

如问题标题所建议的那样,除非您可以根据需要选择四个字符类别的不同顺序。

注意:

  • 类别的替换可以是不同的字符。例如,9a ^8B\t~7c\n]有效地符合模板NLWSNLWSNLWS\t\n将它们的字面字符)。

  • 没有代码长度限制。例如1A +2B -and 1A +2B1A and 1都符合模板NLWSNLWSNLWS...

符合模板的代码必须执行的操作是接受一个未扩展的ASCII字符,并根据其在上述分类中所属于的类别,输出一个介于0到4之间的数字。也就是说,1如果输入是字母,2数字,3符号和4空格,则输出。输出0如果输入是没有这些(一个控制字符)。

对于输入,您可以选择输入0到127之间的一个数字(包括0和127),代表输入ASCII字符的代码。

您的代码必须具有的输入(作为char代码)和输出对如下所示:

in out
0 0
1 0
2 0
3 0
4 0
5 0
6 0
7 0
8 0
9 4
10 4
11 0 or 4
12 0 or 4
13 0 or 4
14 0
15 0
16 0
17 0
18 0
19 0
20 0
21 0
22 0
23 0
24 0
25 0
26 0
27 0
28 0
29 0
30 0
31 0
32 4
33 3
34 3
35 3
36 3
37 3
38 3
39 3
40 3
41 3
42 3
43 3
44 3
45 3
46 3
47 3
48 2
49 2
50 2
51 2
52 2
53 2
54 2
55 2
56 2
57 2
58 3
59 3
60 3
61 3
62 3
63 3
64 3
65 1
66 1
67 1
68 1
69 1
70 1
71 1
72 1
73 1
74 1
75 1
76 1
77 1
78 1
79 1
80 1
81 1
82 1
83 1
84 1
85 1
86 1
87 1
88 1
89 1
90 1
91 3
92 3
93 3
94 3
95 3
96 3
97 1
98 1
99 1
100 1
101 1
102 1
103 1
104 1
105 1
106 1
107 1
108 1
109 1
110 1
111 1
112 1
113 1
114 1
115 1
116 1
117 1
118 1
119 1
120 1
121 1
122 1
123 3
124 3
125 3
126 3
127 0

输入11、12和13对应于有时被认为是空格的字符,因此它们的输出可能是04您想要的。

以字节为单位的最短代码获胜。


5
以二维语言向第一个答案发送Cookie。
加尔文的业余爱好

2
因此,只需使用BF并使用字母SSSS
Christopher

2
这基本上排除了所有常规编程语言🙄此外,使用自己的代码页的语言(例如Jelly)怎么办?
kennytm

1
不允许使用其他字符。
加尔文的业余爱好

2
一元制胜了!
Christopher

Answers:


38

Haskell 300字节

此代码不应包含尾随换行符。该函数m1将输入作为a Char,并将答案作为a返回Char

f1 (l1 :n1 :p1 :y1 :l2 :n2 :p2 :y2 :r3 )x1 |y1 >p1 =b1 (x1 )y2 (f1 (r3 )x1 )y1 (n1 )n2 |p2 <p1 =b1 (x1 )y1 (n1 )p2 (f1 (p2 :y2 :r3 )x1 )l2 |p2 >p1 =b1 (x1 )p1 (l2 )l1 (n2 )n1
;b1 (x1 )s1 (r1 )b1 (r2 )r3 |x1 <s1 =r1 |x1 >b1 =r2 |s1 <b1 =r3
;m1 =f1 "d0 \t4 \r0 ~d3 {d1 `d3 [d1 @d3 :d2 /d3 !d4 \n0 ?d0 "

我无法抗拒有人声称不可能使用“传统”语言的挑战。

您可能会质疑Haskell是否计数,但是大多数关键字和标识符都是多个字符,因此无法使用。但是,只要字母位于数字的前面,并且如果符号也位于字母的前面,则顶级函数定义,列表,字符串文字,严格的比较,模式匹配和带有保护的分支都可以工作,并且如果符号也位于字母的前面,则可以使用转义字符如\t\r。不幸的是,适用于常规编程的排列不允许数字文字,因此我无法以任何有用的方式获取数字。

怎么运行的:

  • 字符类的间隔在最后一行的字符串中进行编码,大多数符号处都带有边界字符,而大多数数字位中都带有结果字符,尽管末尾有些填充。
  • 主要功能是m1
  • x1 是要分析的字符。
  • f1函数使用列表模式匹配将字符串分解,并具有三个分支:用于边界是大于空格的符号时,用于边界被转义的小于空格的控制字符时以及用于与空间本身进行最终比较时。列表项的名称是第一个分支的助记符:字母,数字,空格,符号,余数。
  • b1函数一次处理两个边界字符的分支s1 < b1

在线尝试


1
欢迎光临本站!我的猜测是,这将比实际上可以达到所需结果的大多数非常规语言短。
乔纳森·艾伦

讨厌的答案!我尝试使用Haskell,但不久后就放弃了
Laikoni

14

视网膜,113字节

字母,数字,空格,符号,重复

T1 `a0 @a0 `b1	:D0
+T1 `d9 `a2
+T1 `a9	\n9 `a4
+T1 `l9 @L9 `a1
+T1 `d9 @p9 `d3
\b4
$n3
\b3
$n2
\b2
$n1
\b1
$n0
\n

在线尝试!

对其进行测试!

视网膜似乎是完成这项工作的好工具:我们可以在舞台配置中灵活使用所有类型的字符,并且我们提供了一些有用的预定义字符类。

我认为这个问题可以通过替换阶段或音译阶段解决。我之所以选择音译,是因为它们更灵活,并且具有最有用的字符类。关于源代码的模式,我被迫将符号放在字母前,以便\n用于换行符(实际上,对于换行符,我使用更实用的¶来解决更短的解决方案,但禁止使用非ascii字符)。

说明

第一阶段是音译。我们使用+1作为选项来保持模式继续进行,但是它们不会影响阶段的结果。语法是T`from`to将中的每个字符映射from到中相同位置的字符to。如果to小于from,则根据需要重复其最终字符。如果from具有重复的字符,则仅考虑每个字符的第一次出现。一些字母对应于字符类,例如d等价于0123456789

T1 `a0 @a0 `b   :D0

通过这种方式,我们将某些字符映射到同一类的其他字符,以便为后续音译“腾出空间”。(a-> b0-> 1space-> tab@-> ;)。决赛:D0只是一个笑脸:D0

+T1 `d9 `a2

我们先从数字,d是人物类0-9,在这里,我们正在改变0- > a1-9- > 2space- > 2:为音译0space是错误的,但这些人物都被以前的音译消除。

+T1 `a9 \n9 `a4

空白,变换a- > a,( ,9tab\nspace - > 49在上一阶段已被删除。

+T1 `l9 @L9 `a1

字母,这里我们使用两种不同的字符类(因为缺少更完整的字符类):l小写字母和L大写字母。它们都被映射到1,以及之前阶段已经处理过的其他一些字符

+T1 `d9 @p9 `d3

符号。由于所有其他类已经变成了一个数字,在这里,我们与所有数字映射到自己d- > d,然后将所有可打印的字符来3p- > 3。数字也是可打印的字符之一,但第一个音译获胜。

现在我们需要分配0给控制字符,但是我发现没有有效的方法来明确寻址该类。相反,我们将每个数字转换为一进制:控制字符不是数字,因此它们被视为空字符串,等于0一进制。不幸的是,视网膜中的一元转换命令是$*,这是彼此靠近的两个符号,因此我们将使用替代“手动”转换。

\b4
$n3
\b3
$n2
\b2
$n1
\b1
$n0

我们的一进制数字是$n,这是换行符的替换模式。\b匹配“边界”,其中字母数字词开始或结束:在我们的情况下,它将始终在任何数字之前匹配。我们基本上是用n换行符plus 替换每个数字n-1

\n

最后,我们计算换行符的数量并获得理想的结果。


11

基数 2240 2224字节

使用的模板LSNW

a%1
a:1 a.0 a.0 a.0 a.0 a.0 a.0 a.0 a.0 a.0 a.0 a.0 a.0 a.0 a.0 a.0 a.0 a.0 a.0 a>0 a>0 a>0 a>0 a>0 a>0 a>0 a+1 a+1 a+1 a+1 a.1 x.1 a.0 a.0 a.0 a.0 a.0 a.0 a.0 a.0 a.0 a.0 a.0 a.0 a.0 a.0 a.0 a.0 a.0 a.0 a.0 a.0 a.0 a.0 a.0 a.0 a.0 a.0 a.0 a.0 a.0 a.0 a.0 a.0 a.0 a.0 a.0 a.0 a.0 a>0 a+1 a+1 a+1 a+1 a.1 x>0 a>0 a>0 a>0 a>0 a>0 a>0 a>0 a>0 a>0 a>0 a>0 a>0 a>0 a>0 a>0 a>0 a>0 a>0 a>0 a>0 a>0 a>0 a>0 a>0 a>0 a>0 a>0 a>0 a+1 a+1 a+1 a.0 x>1 a>0 a>0 a>0 a>0 a>0 a>0 a>0 a>0 a>0 a>0 a>0 a>0 a>0 a>0 a>0 a>0 a>0 a>0 a+1 a+1 a.0 x>1 a>0 a>0 a>0 a>0 a>0 a>0 a>0 a>0 a>0 a>0 a>0 a>0 a+1 a+1 a+1 a.0 x>1 a>1 a>1 a>1 a>1 a>1 a>1 a>1 a>1 a>1 a>1 a>1 a>1 a>1 a>1 a>1 a>1 a>1 a>1 a>1 a>1 a>1 a>1 a>1 a>1 a>1 a>1 a>1 a>1 a>1 a>1 a>1 a>1 a>1 a>1 a>1 a>1 a>1 a>1 a>1 a>1 a>1 a>1 a>1 a>1 a>1 a>1 a>1 a>1 a>1 a>1 a+1 a.0 x>1 a>1 a>1 a>1 a>1 a>1 a>1 a>1 a>1 a>1 a>1 a+1 a+1 a+1 a.0 x>1 a>1 a>1 a>1 a>1 a>1 a>1 a>1 a>1 a>1 a>1 a>1 a>1 a>1 a>1 a>1 a>1 a>1 a>1 a>1 a>1 a>1 a>1 a>1 a>1 a>1 a>1 a>1 a>1 a>1 a>1 a>1 a>1 a>1 a>1 a>1 a>1 a>1 a>1 a>1 a>1 a>1 a>1 a>1 a>1 a>1 a>1 a>1 a>1 a>1 a>1 a+1 a.0 x>1 a>1 a>1 a>1 a>1 a>1 a>1 a+1 a+1 a+1 a.0
a>1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a>1 a>1 a>1 a>1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a>1 a>1 a>1 a>1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a>1 a>1 a>1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a>1 a>1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a>1 a>1 a>1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a>1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a>1 a>1 a>1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a>1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^0 a.0

该代码末尾有换行符。

怎么运行的:

此代码包含许多未使用的字符。
%释放所有方向的指针。他们中的3人刚好碰上了一条线而死。
最后一个指针在处输入一个输入:
然后将该输入与0到127中的每个值进行比较。

打印:
0表示0-8
4表示9-12
0 0表示13-31
4表示32
3表示33-47
2表示48-57
3表示58-64
1表示65-90
3表示91-96
1表示97-122
3表示123-126
0表示127

使用的操作:
J =如果非零,则跳过下一个操作
^ =将方向更改为向上
> =将方向更改为向左
-=减量
+ =递增
:=接受输入
%=在程序开始时创建指针
x =删除指针
0 =设置为活动状态指向0的指针的值

在线尝试


7

Perl 5,293个字节

291个字节的代码+ 2个-0p

我被告知命令行标志是免费的,但是我在这里添加了它们以提高可见性,因为TIO链接不包含-0,以便于测试。

y 0-a 1"a 1#a 1$a 1%a 1&a 1'a 1(a 1)a 1*a 1+a 1,a 1.a 1/a 1_a 1{a 1|a 1}a 1~a 0!a 1!a 1!a 1!a 1!a 1!a 1!a 1!a 1!a 1!a 1!a 1!a 1!a 1!a 1!a 1!a 1!a 1!a 1!a 0;s 0\s
0\t
0;s 0\d
0\r
0;s 0\w
0\n
0;y 1!a 9-a 1_a 0-Z 1;s 0\w
0\u 3\u 0;s 1\S
1\u 0\u 1;s 0\t
0\u 4\u 0;s 0\r
0\u 2\u 0;s 0\n
0\u 1\u 0

在线尝试!

用几乎所有语言解决这都是一个特别棘手的挑战,因此我很高兴能够(最终,在很长一段时间内反复修改)在Perl中工作。希望数字前后没有其他空格。

选择序列顺序特别棘手,但幸运的是s///y///可以接受任何其他字符作为分隔符,因此可以使用允许使用s 0...0...0;和的字母,空格,数字,符号y 0...0...0;

对于appraoch所需的第一件事就是更换_!,这样\w只会匹配[0-9a-zA-Z],则更换所有空白(\s)与\t所有数字,\r和所有其余的字字符(\w)用\n后易于匹配上。然后,使用y///运算符,将所有剩余的符号转换为!_并将所有其他字符(9和之间的字符a)下移9个位置,将其转​​换为字母或数字。然后,将这些替换\w3,并将其他先前进行的替换替换为其编号。


1

空格,1332字节

Y0! Y0! Y0! Y0!
Y0! Y0!
Y0! Y0! Y0!
Y0! Y0! Y0! Y0! Y0! Y0! Y0!
Y0! Y0! Y0!
Y0! Y0! Y0!
Y0! Y0! Y0!
Y0! Y0! Y0!
Y0! Y0! Y0!
Y0! Y0! Y0!
Y0! Y0! Y0!
Y0! Y0! Y0!
Y0! Y0! Y0!
Y0! Y0! Y0! Y0! Y0! Y0! Y0! Y0! Y0!
Y0! Y0! Y0! Y0! Y0!
Y0! Y0! Y0! Y0!
Y0! Y0! Y0! Y0! Y0! Y0! Y0! Y0!
Y0! Y0! Y0! Y0! Y0!
Y0! Y0! Y0! Y0!
Y0! Y0! Y0! Y0! Y0! Y0! Y0! Y0! Y0! Y0!
Y0! Y0! Y0! Y0! Y0! Y0!
Y0! Y0!
Y0! Y0! Y0! Y0!
Y0!
Y0! Y0! Y0! Y0! Y0!
Y0! Y0! Y0! Y0! Y0! Y0! Y0! Y0! Y0! Y0!
Y0! Y0! Y0! Y0! Y0!
Y0! Y0! Y0!
Y0! Y0! Y0! Y0! Y0! Y0! Y0! Y0! Y0! Y0!
Y0! Y0! Y0! Y0! Y0!
Y0! Y0! Y0! Y0! Y0!
Y0! Y0! Y0! Y0! Y0! Y0! Y0! Y0! Y0! Y0! Y0!
Y0! Y0! Y0! Y0! Y0!
Y0! Y0! Y0!
Y0! Y0! Y0! Y0! Y0! Y0! Y0! Y0! Y0! Y0! Y0!
Y0! Y0! Y0! Y0! Y0!
Y0! Y0! Y0! Y0!
Y0! Y0! Y0! Y0! Y0! Y0! Y0! Y0! Y0! Y0! Y0!
Y0! Y0! Y0! Y0! Y0!
Y0! Y0! Y0!
Y0! Y0! Y0! Y0! Y0! Y0! Y0! Y0! Y0! Y0! Y0!
Y0! Y0! Y0! Y0! Y0!
Y0! Y0! Y0! Y0!
Y0! Y0! Y0! Y0! Y0! Y0! Y0! Y0! Y0! Y0! Y0!
Y0! Y0! Y0! Y0! Y0!
Y0! Y0! Y0!
Y0!
Y0! Y0!
Y0! Y0! Y0!
Y0!
Y0! Y0! Y0! Y0!
Y0! Y0! Y0! Y0! Y0! Y0! Y0!
Y0! Y0!
Y0! Y0! Y0!
Y0!
Y0!
Y0!
Y0! Y0! Y0!
Y0! Y0! Y0! Y0! Y0! Y0!
Y0! Y0!
Y0! Y0! Y0!
Y0!
Y0!
Y0!
Y0! Y0! Y0! Y0! Y0!
Y0! Y0! Y0! Y0! Y0! Y0!
Y0! Y0!
Y0! Y0! Y0!
Y0!
Y0!
Y0!
Y0! Y0! Y0! Y0!
Y0! Y0! Y0! Y0! Y0!
Y0! Y0!
Y0! Y0! Y0!
Y0!
Y0!
Y0!
Y0! Y0! Y0! Y0! Y0!
Y0! Y0! Y0! Y0!
Y0! Y0!
Y0! Y0! 

顺序为1234/ LNSW(字母,数字,符号,空格)。

在线尝试(输入为代表字符unicode的整数)。

说明:

空格是一种基于堆栈的语言,其中除空格,制表符和换行符之外的所有字符都将被忽略。这是不带YO!333字节)的相同程序:

[S S S N
_Push_0][S N
S _Duplicate_0][T   N
T   T   _Read_STDIN_as_integer][T   T   T   _Retrieve][S N
S _Duplicate_input(9)][S N
S _Duplicate_input(10][S N
S _Duplicate_input(32)][S N
S _Duplicate_input(33-47)][S N
S _Duplicate_input(48-57)][S N
S _Duplicate_input(58-64)][S N
S _Duplicate_input(65-90)][S N
S _Duplicate_input(91-96)][S N
S _Duplicate_input(97-122)][S N
S _Duplicate_input(123-126)][S S S T    S S T   N
_Push_9][T  S S T   _Subtract][N
T   S S N
_If_0_Jump_to_Label_WHITESPACE][S S S T S T S N
_Push_10][T S S T   _Subtract][N
T   S S N
_If_0_Jump_to_Label_WHITESPACE][S S S T S S S S S N
_Push_32][T S S T   _Subtract][S N
S _Duplicate][N
T   S S N
_If_0_Jump_to_Label_WHITESPACE][N
T   T   S T N
_If_negative_Jump_to_Label_NONE][S S S T    T   S S S S N
_Push_48][T S S T   _Subtract][N
T   T   N
_If_negative_Jump_to_Label_SYMBOL][S S S T  T   T   S T S N
_Push_58][T S S T   _Subtract][N
T   T   S S N
_If_negative_Jump_to_Label_DIGIT][S S S T   S S S S S T N
_Push_65][T S S T   _Subtract][N
T   T   N
_If_negative_Jump_to_Label_SYMBOL][S S S T  S T T   S T T   N
_Push_91][T S S T   _Subtract][N
T   T   T   N
_If_negative_Jump_to_Label_LETTER][S S S T  T   S S S S T   N
_Push_97][T S S T   _Subtract][N
T   T   N
_If_negative_Jump_to_Label_SYMBOL][S S S T  T   T   T   S T T   N
_Push_123][T    S S T   _Subtract][N
T   T   T   N
_If_negative_Jump_to_Label_LETTER][S S S T  T   T   T   T   T   T   N
_Push_127][T    S S T   _Subtract][N
T   T   N
_If_negative_Jump_to_Label_SYMBOL][N
S N
S T N
_Jump_to_Label_NONE][N
S S S N
_Create_Label_WHITESPACE][S S S T   S S N
_Push_4][T  N
S T _Print_as_integer][N
N
N
_Exit][N
S S N
_Create_Label_SYMBOL][S S S T   T   N
_Push_3][T  N
S T _Print_as_integer][N
N
N
_Exit][N
S S S S N
_Create_Label_DIGIT][S S S T    S N
_Push_2][T  N
S T _Print_as_integer][N
N
N
_Exit][N
S S T   N
_Create_Label_LETTER][S S S T   N
_Push_1][T  N
S T _Print_as_integer][N
N
N
_Exit][N
S S S T N
_Create_Label_NONE][S S S N
_Push_0][T  N
S T _Print_as_integer]

字母S(空格),T(制表符)和N(换行符)仅作为突出显示而添加。
[..._some_action]仅作为说明添加。

在线尝试。

用伪代码编写程序:

If the input is 9, 10 or 32: call function WHITESPACE()
Else-if the input is below 32: call function NONE()
Else-if the input is below 48: call function SYMBOL()
Else-if the input is below 58: call function DIGIT()
Else-if the input is below 65: call function SYMBOL()
Else-if the input is below 91: call function LETTER()
Else-if the input is below 97: call function SYMBOL()
Else-if the input is below 123: call function LETTER()
Else-if the input is below 127: call function SYMBOL()
Else (the input is 127 or higher): call function NONE()

WHITESPACE():
  Print 4
  Exit program
SYMBOL():
  Print 3
  Exit program
DIGIT():
  Print 2
  Exit program
LETTER():
  Print 1
  Exit program
NONE():
  Print 0
  (Implicit exit with error: Exit not defined)
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.