Autogram程序

34

这句话使用了两个a，两个c，两个d，二十八e，五个f，三个g，八个h，十一个i，三个l，两个m，十三个n，九个o，两个p，五个r，二十五s，二十三个t，六个v，十个w，两个x，五个y和一个z。

这样的句子被称为自动词。您的任务是编写一个具有类似属性的程序或函数：它将一个字节作为输入，并输出一个整数，表示该字节出现在程序源代码中的次数。如果其输入未出现在其源中，则应输出0。

您的程序不得直接或间接读取其自身的源代码，而必须将其提供给输出的所有数据硬编码为quine样式。您的程序的长度必须至少为一个字节。

这是代码高尔夫，因此最短的条目（以字节为单位）获胜。我不会接受答案，请随时使用您喜欢的语言竞争最短的解决方案。

强烈建议您在帖子中添加解释。

排行榜

以下是总体得分和每种语言的排行榜：

显示代码段

code-golf  self-referential 
— 纳撒尼尔
source
5
沙盒。（自2014年以来一直在那儿！）
— Nathaniel
是允许功能，还是仅允许完整程序？
— Uriel '18
1
注意：与此答案类似的答案不再视为有效答案。
— user202729 '18
1
FWIW，适当的奎纳定义比我对这个挑战的真正要求要强一些。例如，我很高兴看到一个程序使用某个连续范围内的所有字符，并且即使输入内容不在该范围内，它也只会输出1，即使该程序没有“程序的另一部分”。出于这个原因，我本来愿意允许使用视网膜示例，但是如果它已经使其他人停止发布，那将是令人失望的，因为它仅仅是1个字节。（@ user202729）
— 纳撒尼尔
1
由于我的上述评论，我删除了适用奎因规则的声明。（我保留了不阅读源代码的部分。）
— Nathaniel

Answers:

15

八度，44字节

@(x)sum([[39,'(())*,239==@[[]]msuxx']]==x)*2

在线尝试！

当使用函数中的每个字符作为输入时，函数的结果：

'  (  )  *  ,  2  3  9  =  @  [  ]  m  s  u  x  
2  4  4  2  2  2  2  2  4  2  4  4  2  2  2  4

所有其他输入字符返回零。

我不得不逃避的事实'使这段时间更长了。为了说明4个括号，我在字符串中只做了一个重复。但是，重复的撇号需要加上撇号，因此这仅使我们离正确的结果还很远。因此，我必须用ASCII值来计算撇号的数量39。当然，这意味着我必须检查的人物3和9太，使得这一切了很多时间。

— 斯蒂夫·格里芬
source
2
这是我希望看到更多的东西。（针对问题进行了优化，而不仅仅是采用标准的quine并添加了对字符进行计数的代码。）
— Nathaniel，
7

Excel，84个字节

=IFERROR(MID("65496331125442343343233",FIND(A1,"""123456789,()=MINORFADEOMEN"),1),0)

Find()会A1在字符串中的单元格中查找值"123456789,()=MINORFADEOMEN（"""开始时是转义字符并求值为"）。

根据的结果Find()，该Mid()函数将从数字字符串中返回相应的字符。该字符串是通过迭代创建的，直到停止更改为止。

如果A1找不到in中的字符，则Find()返回错误，因此该IfError()函数对其进行转义以返回0。

将OMEN在字符串被搜查结束Find()功能重复的字母所以他们的位置将永远不会被退回，但他们需要调整的字符数。没有它们，计数就会无休止地循环。字母排列是样式选择。

— 工程师吐司
source
5

JavaScript（ES6），70个字节

不读取函数的源代码，但这很长。将输入作为1个字符的字符串。

i=>~(n='\\34=\'in(|)0257?:.>[]Odefx~'.indexOf(i))?'3733544333'[n]||2:0

在线尝试！

— Arnauld
source
您可以通过重做一些操作以减少不同字符的数量来缩短一堆：（i=>'36335633'[i='\\36=\'i|&()25.>[]Odefx~n'.indexOf(i)]||~i&&2节省了8个字节）
— Yair Rand
5

视网膜，1个字节

如果严格遵守quine规则，这将是无效的，但是OP 在comment中明确允许它。

x

在线尝试！

在视网膜中，单行程序对输入中该正则表达式的出现进行计数。这一挑战，除了任意单个ASCII字符解决`，.，+，*，?，[，(，)，^，$，\和换行符。

— 狮子座
source
5

C＃（Visual C＃编译器），88 57字节

x=>"\\\"(())==>>??..::3300CCaaiinoossttx".Contains(x)?3:0

在线尝试！

如果字符串包含传递的char，则返回3，否则返回0。该字符串包含代码中的每个字符至少一次，并且恰好等于在代码中具有3次char所需的数量。

-31字节感谢Kevin Cruijssen

— Hyarus
source
不错的方法！向我+1。您可以通过删除括号(a)=>并将输入作为字符串而不是char 来节省一些字节，因此.ToString()不再需要（并且a+""也可以使用，对于不需要的代码高尔夫球挑战.ToString()）。另外，由于.Contains已经包含一个a，您可以使输入变量成为一个不同的未使用字符（如x或q），每个字符有3个而不是4个。编辑：不用担心最后一部分，我"现在也使用了4次。
— 凯文·克鲁伊森
@KevinCruijssen感谢您的建议。但是字符串可以作为输入有效吗？考虑到OP要求输入字节作为输入？
— Hyarus
只要是单个字符串，我就可以确定。多数语言无论如何只能输入字符串值，而有些包含字符的语言仍选择输入为字符串（例如Java，JavaScript和Japt。输入和输出格式通常非常灵活。但是您总是可以在如果您仍然怀疑，请发表评论。:)
— Kevin Cruijssen
1
@KevinCruijssen听起来很合理。如果我们逃脱了其中之一，“我们甚至可以降低到每个字符3个所需的值
— Hyarus
2
我可以输入单个字符串作为输入。
— 纳撒尼尔（Nathaniel）'18
4

Haskell，66个字节

前两个版本实际上是一个quine，可以过滤所需的字符，然后采用长度：

q c=length.filter(==c)$id<>show$"q c=length.filter(==c)$id<>show$"

在线尝试或测试所有角色！*

不带(<>)，72字节的备用

q c=length.filter(==c)$(++)<*>show$"q c=length.filter(==c)$(++)<*>show$"

在线尝试或测试所有角色！

非五进制替代，87 86字节

可能仍需改进，但我很高兴将它归结为三个不同的小组。

我喜欢这个最好的，即使它占用最多的字节数。它以2,3和7的总和来计算字符/字节数（请注意某些字符在多个组中如何）：

u t=sum[fst e|e<-[(2," ()-237<=dflnst|"),(3," ()[\\]`mstu"),(7,"\",ee")],t`elem`snd e]

在线尝试或测试所有角色！

*导入，(<>)因为TIO的GHC版本是8.0.2

— ბიმო
source
3

Python 2中，54个 52 32字节

-20字节归功于ovs

("''+.23cnotu()"*2+'"*'*3).count

在线尝试！

— 竿
source
1
为什么没有lambda或输入呢？
— Stewie Griffin
2
@StewieGriffin Python自动绑定方法引用，因此"xxx".count等效于lambda c:"xxx".count(c)。
— Neil
@StewieGriffin和您使用相同的方式-> f="xxx".count并被f=lambda c:"xxx".count(c)称为f('a')
— Rod
3

外壳，11 10 8字节

感谢狮子座 -2个字节！

#sD"#sD"

在线尝试！

说明

这样可以确保它仅使用ASCII（因为show会弄乱它），并且每个字符包含两次：

#sD"#sD"  -- character as input, eg. '"'
   "#sD"  -- string literal (note the redundant '"'): "#sD"
  D       -- double: "#sD#sD"
 s        -- show: "\"#sD#sD\""
#         -- number of occurences: 2

标准quine扩展名，11个字节

#hS+s"#hS+s

在线尝试！

说明

#hS+s"#hS+s  -- character as input, eg. '"'
     "#hS+s  -- string literal: "#hS+s"
  S+         -- join with itself: ("#hS+s"++)
    s        -- | and itself shown: "\"#hS+s\""
             -- : "#hS+s\"#hS+s\""
 h           -- init: "#hS+s\"#hS+s"
#            -- number of occurences in string: 1
— ბიმო
source
1
您可以通过在显示字符串之前将字符串加倍来更轻松地管理引号：在线尝试！
— 狮子座
3

Java 10，164 81 57字节

q->"q-->>\\\"..ccoonttaaiiss(())??33::00".contains(q)?3:0

@Hyarus的C＃答案端口，因此请确保对他进行投票！

说明：

在线尝试。

q->      // Method with String parameter and integer return-type
  "q->\\\"..ccoonttaaiiss(())??33::00".contains(q)?
         //  If the string above contains the input character
   3     //   Return 3
  :      //  Else:
   0     //   Return 0

旧quine 164字节答案：

c->{var s="c->{var s=%c%s%1$c;return s.format(s,34,s).replaceAll(%1$c[^%1$c+c+']',%1$c%1$c).length();}";return s.format(s,34,s).replaceAll("[^"+c+']',"").length();}

说明：

在线尝试。

c->{                                  // Method with char parameter and integer return-type
  var s="c->{var s=%c%s%1$c;return s.format(s,34,s).replaceAll(%1$c[^%1$c+c+']',%1$c%1$c).length();}";
                                      //  Unformatted source code
  return s.format(s,34,s)             //  Create the formatted source code (the quine),
          .replaceAll("[^"+c+']',"")  //  remove all characters not equal to the input,
          .length();}                 //  and return the length

quine -part：

  • 字符串s包含未格式化的源代码。
  • %s用于将String本身输入s.format(...)。
  • %c，%1$c以及34用于格式化双引号。
  • s.format(s,34,s) 放在一起

挑战部分：

  • .replaceAll("[^"+c+']',"") 除去所有等于输入的字符。
  • .length() 然后采用此String的长度。

注意：（.split(c).length使用Stringinput代替char）可能看起来更短，但是有两个问题：

  1. 第一个字符给出的结果不正确，因此，如果输入c（带c->前导部分），它将错误地返回一个字符太少。可以通过添加+(c==99?1:0)源代码和未格式化的源代码String（并将其更改.split(c)为）来.split(c+"")解决此问题，但是我们仍然遇到以下问题：
  2. 如果$输入了正则表达式字符（即），.split则会将其解释为正则表达式，给出错误的结果。
— 凯文·克鲁伊森
source
3

Haskell，58个字节

f c=sum[2|x<-succ '!':"f c=sum[2|x<-succ '!':,x==c]",x==c]

在线尝试！或验证解决方案。

相同的字节数替代方案：

f c=sum[2|x<-tail$show"f c=sum[2|x<-tail$show,x==c]",x==c]
f c=sum[1|x<-id<>show$"f c=sum[1|x<-id<>show$,x==c]",x==c]

90字节的Haskell

sum.($zip"1234\"$,.[\\]opu+()iklmsz652"$[4,4,11,3,3,3,16,5,3,3,3,3,3,3,3]++[2,2..]).lookup

在线尝试！或验证解决方案。使用事实，sum Nothing = 0例如sum (Just 4) = 4。

— 莱科尼
source
3

Smalltalk，112132字节

Smalltalk并不完全以高尔夫适合性而闻名：-)

在Character类中定义的方法（在VA Smalltalk和Squeak中进行了测试，也应在其他方言中使用，例如VisualWorks和Pharo）：

a^(0to:6),#(10 18)at:(#('' ',[]^|+68cForu' '#0adefln' '1it' '()' ':s' ' ' '''')findFirst:[:s|s includes:self])+1

源中出现的字符按出现次数分组。对包含第一个接收者的组进行测试，然后返回匹配的发生次数。

旧方法：

a^('''''((((())))):::[[[[]]]]^^^^^0000066666aaaacccccdddddeefffFFFFFiiilllnnnnnrrrrrsssTTTTTuuuu'includes:self)ifTrue:[6]ifFalse:[0]

方法中确实出现的每个字符都会出现准确的6次（通过在字符串常量中重复），因此该方法仅检查字符串中是否包含接收者，如果是则返回6，否则返回0。

在定义完上述方法之后，您可以使用进行验证

| code |
code := Character sourceCodeAt: #a.
((0 to: 255) collect: [:b | b asCharacter]) reject: [:c | c a = (code occurrencesOf: c)]

结果应为空。

— 汉斯·马丁·莫斯纳
source
1
欢迎来到PPCG！
— Martin Ender '18
2

JavaScript，31个字节

f=c=>~-`f=${f}`.split(c).length

在线尝试

— 毛茸茸
source
1
我认为这读取了自己的源代码，不是吗？该问题以粗体明确禁止使用。
— 纳撒尼尔（Nathaniel）'18
1
@Nathaniel，看这里。
— 毛茸茸的
2
嗯 老实说，我认为这很愚蠢，但我不能完全不同意我认为的元共识。
— 纳撒尼尔（Nathaniel）'18
1
@Nathaniel对于所有使eval容易的程序，它们也使quine容易。
— user202729 '18
1
@ user202729我认为这不是吗？例如，您不能在Python中做同样的事情。这是反向评估，而不是评估
— Nathaniel
2

Haskell，96个字节

n"n"=15;n"="=14;n" "=2;n";"=13;n"\\"=3;n"\""=25;n"0"=2;n"1"=4;n"2"=4;n"3"=4;n"4"=5;n"5"=5;n n3=0

在线尝试！

Haskell，109个字节

n 'n'=15;n '='=14;n ' '=14;n ';'=13;n '\\'=3;n '\''=25;n '0'=2;n '1'=5;n '2'=4;n '3'=4;n '4'=5;n '5'=5;n n3=0

在线尝试！

Haskell，122个字节

n 'n'=21
n '='=14
n ' '=14
n '\n'=12
n '\\'=4
n '\''=32
n '0'=2
n '1'=5
n '2'=5
n '3'=3
n '4'=5
n '5'=5
n nnnnnn4'''''''=0

在线尝试！

说明

这些答案并非十分复杂。它是一系列声明，程序中存在的每个字符一个。最后，我们捕获了所有程序中不存在的字符都返回0的catch。

我使用了一些技巧来最大程度地减少程序中必需的字符数，然后从那里弄弄东西直到数字正确为止。您可以看到我在所有三个变量的最后一个声明中都填充了变量名。这三个程序之间的区别在于我是选择使用换行符还是;换行符，以及是否选择将Chars作为输入或Strings。这种;方法似乎并不固有地优于其他方法，只是运气好，最终变得更短，但是似乎确实比Strings使用Strings是个更好的主意，因为Chars在函数名后面需要空格，而Strings不需要。

— 小麦巫师
source
：| 发生了什么事你拼写的解释
— ASCII-仅
2

空格，140字节

[S S S N
_Push_0][S N
S _Duplicate][S N
S _Duplicate][T N
T   S _Read_STDIN_as_character][T   T   T   _Retrieve][S S S T  S S T   N
_Push_9][T  S S T   _Subtract][S N
S _Duplicate][N
T   S S T   N
_If_0_Jump_to_Label_TAB][S S S T    N
_Push_1][T  S S T   _Subtract][S N
S _Duplicate][N
T   S S N
_If_0_Jump_to_Label_NEWLINE][S S S T    S T T   S N
_Push_22][T S S T   _Subtract][N
T   S T N
_If_0_Jump_to_Label_SPACE][N
S T N
_Jump_to_Label_PRINT][N
S S S T N
_Create_Label_TAB][S S S T  S S T   S T N
_Push_37][N
S T N
_Jump_to_Label_PRINT][N
S S S N
_Create_Label_NEWLINE][S S S T  S S S S T   N
_Push_33][N
S T N
_Jump_to_Label_PRINT][N
S S T   N
_Create_Label_SPACE][S S S T    S S S T T   S N
_Push_70][N
S S N
_Create_Label_PRINT][T  N
S T _Print_as_integer]

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

使用了70个空格，37个制表符和33个换行符。

通常我用的是创建标签的顺序NSSN，NSSSN，NSSTN，NSSSSN，NSSSTN，NSSTSN，NSSTTN，等，但由于印刷数，其中二元S=0/ T=1被用来影响我需要输出的数量，我使用的标签NSSN，NSSSN，NSSTN，和NSSSTN替代，这给了完美数量的空格/制表符，要用二进制数字SSSTSSSSTN（33；换行数），SSSTSSTSTN（37；制表符数量）和SSSTSSSTTSN（70；空格数）。

伪代码中的解释：

Character c = STDIN-input as character
If c is a tab:
  Print 37
Else if c is a new-line:
  Print 33
Else if c is a space:
  Print 70
Else
  Print 0

示例运行：

输入：空格

Command       Explanation                   Stack       Heap     STDIN   STDOUT   STDERR

SSSN          Push 0                        [0]
SNS           Duplicate top (0)             [0,0]
SNS           Duplicate top (0)             [0,0,0]
TNTS          Read STDIN as character       [0,0]       {0:32}   \n
TTT           Retrieve                      [0,32]      {0:32}
SSSTSSTN      Push 9                        [0,32,9]    {0:32}
TSST          Subtract top two (32-9)       [0,23]      {0:32}
SNS           Duplicate top (23)            [0,23,23]   {0:32}
NTSSTN        If 0: Jump to Label_TAB       [0,23]      {0:32}
SSSTN         Push 1                        [0,23,1]    {0:32}
TSST          Subtract top two (23-1)       [0,22]      {0:32}
SNS           Duplicate top (22)            [0,22,22]   {0:32}
NTSSN         If 0: Jump to Label_NEWLINE   [0,22]      {0:32}
SSSTSTTSN     Push 22                       [0,22,22]   {0:32}
TSST          Subtract top two (22-22)      [0,0]       {0:32}
NTSTN         If 0: Jump to Label_SPACE     [0]         {0:32}
NSSTN         Create Label_SPACE            [0]         {0:32}
SSSTSSSTTSN   Push 70                       [0,70]      {0:32}
NSTN          Jump to Label_PRINT           [0,70]      {0:32}
NSSN          Create Label_PRINT            [0,70]      {0:32}
TNST          Print as integer              [0]         {0:32}            70
                                                                                  error

程序因错误而停止：未定义出口。
在线尝试（仅使用空格，制表符和换行符）。

输入：标签

STDIN将改为\t（9），在这种情况下，它将0处于第一次If 0检查状态，转到LABEL_TAB/ NSSSTN，然后推送并打印37。

在线尝试（仅使用空格，制表符和换行符）。

输入：换行

STDIN将改为\n（10），在这种情况下，它将0处于第二次If 0检查，转到Label_NEWLINE/ NSSSN，然后将其推入并打印33。

在线尝试（仅使用空格，制表符和换行符）。

输入：其他

NSTN在第三次If 0检查之后，任何其他输入字符都将执行（跳转到Label_PRINT），打印0仍在堆栈中的（我们在开始时就已经重复了）。

在线尝试（仅使用空格，制表符和换行符）。

— 凯文·克鲁伊森
source
1
这是应对挑战的绝佳语言。
— qwr
2

Japt，27个字节

\Ua"" a a a " ÄU\\\"a "aU Ä
            " ÄU\\\"a "     // Given this string literal,
                       aU   // find the last index of the input
                          Ä // and add +1.
\Ua"" a a a                 // Do nothing useful, but make the results match.

比现有的Japt答案更长，但是使用了不同的方法。
具有固有的局限性，即所有字符都必须发生唯一的次数。

将输入作为字符串。

在线尝试！

— 尼特
source
2

Perl，130个字节

+print+0+((0)x40,6,6,0,3,43,0,0,0,22,12,6,3,5,2,4,0,1,0,0,0,1,0,1,(0)x28,1,0,1,(0)x6,1,(0)x4,1,(0)x4,1,1,1,0,2,0,1,0,0,0,5)[ord<>]

没有换行符或其他空格。从标准输出中读取一行，但仅关心其第一个字节，然后以十进制（不含换行符）的形式显示该字节在其自身源代码中出现的次数。

该程序很简单。大部分源代码都被文字表占用，该表给出了每个可能字节的答案。尾随的零被省略，相邻的零在运行时被压缩，但是除此之外没有别的技巧。程序的其余部分仅读取输入并在表中查找答案。

例如，22, 12, 6, 3, 5, 2, 4, 0, 1, 0源代码中的部分给出了数字的频率，因此源代码中有22个零，12个，6个二等。结果，如果您输入0程序的标准输入，程序将打印22。

— b_jonas
source
2

C（gcc），1033字节

#include <stdio.h>
int main(int argc,char *argv[]){int r=0*14811;switch((int)argv[1][0]){case' ':r=6;break;case'"':r=3;break;case'#':r=2;break;case'%':r=2;break;case'\'':r=101;break;case'(':r=5;break;case')':r=5;break;case'*':r=5*1*1;break;case'.':r=2;break;case':':r=51;break;case';':r=103;break;case'<':r=2;break;case'=':r=52;break;case'>':r=2;break;case'[':r=4;break;case'\\':r=3;break;case']':r=4;break;case'0':r=11;break;case'1':r=20;break;case'2':r=20;break;case'3':r=9;break;case'4':r=7;break;case'5':r=12;break;case'6':r=3;break;case'7':r=2;break;case'8':r=5;break;case'9':r=2;break;case'a':r=106;break;case'b':r=51;break;case'c':r=55;break;case'd':r=4;break;case'e':r=102;break;case'f':r=2;break;case'g':r=4;break;case'h':r=4;break;case'i':r=10;break;case'k':r=51;break;case'l':r=2;break;case'm':r=2;break;case'n':r=8;break;case'o':r=2;break;case'p':r=2;break;case'r':r=108;break;case's':r=53;break;case't':r=8;break;case'u':r=2;break;case'v':r=3;break;case'w':r=2;break;case'{':r=3;break;case'}':r=3;break;}printf("%d",r);}

在线尝试！

这绝不是一个简单的答案，但是尝试以我不熟悉的语言完成这一挑战很有趣。直到找到数字出现的时候，这并不是一个特别困难的挑战，现在这是一个挑战。不得不做一些创造性的平衡:)

— X1M4L
source
2

C（gcc），192字节

F(J){J=J-70?J-40?J-41?J-74?J-'{'?J-'}'?J-39?J-48?J-49?J-50?J-51?J-52?J-53?J-54?J-55?J-56?J-57?J-47?J-61?J-63?J-45?J-58?J-59?0:1:23:23:23:1:2:3:3:4:4:14:14:10:10:15:6:4:2:2:25:1:1:1;}//84332211

在线尝试！

可能进一步打下去。在末尾使用注释作为“临时空间”以添加额外的数字。当我必须将数字从X更改为Y时，我将从头开始将Y的其中之一更改为X以进行补偿。除此之外，这只是一个使用整数的函数，使用赋值技巧根据大三元条件返回值。

— LambdaBeta
source
0*84332211像在其他C答案中一样，我可以通过将数字常量移动到零之后来保存1个字节，但是我也可以通过将其重构为更小的形式来保存字节，所以我现在还不会打扰。
— LambdaBeta
您可以通过对较不常见的数字进行范围检查来节省字节吗？也就是说，如果assme 4-9是稀有字符，则可以通过条件检查一次处理所有字符。
— qwr
几乎肯定。我们可以通过为事物选择一个聪明的名字来删除更多的东西，以便某些符号永远不会出现，或者可以使用位模式（例如J&1?，匹配所有奇数字符）。如果有时间的话，我可能会进一步打高尔夫球。
— LambdaBeta
2

x86 .COM，17个字节，有争议

0120 BF2001        MOV     DI,0120 (120 be the current address)
0123 B91100        MOV     CX,0011
0126 AE            SCASB
0127 7502          JNZ     012B
0129 FEC4          INC     AH
012B E2F9          LOOP    0126
012D C1E808        SHR     AX,8
0130 C3            RET

36字节

0100 BF????        MOV     DI,(an copy of this code)
0103 B91200        MOV     CX,0012
0106 AE            SCASB
0107 7503          JNZ     010C
0109 80C402        ADD     AH,02
010C E2F8          LOOP    0106
010E C1E808        SHR     AX,8
0111 C3            RET
— 平方米
source
2
这不是在读自己的代码吗？
— 拉兹万·索科尔
@RazvanSocol我认为这就像JavaScript解决方案
— l4m2
@RazvanSocol很好，它不需要保存在文件中，所以可以。许多fungeoids和JS也可以做到这一点
— ASCII码仅
我认为您正在读取已执行的代码，这被视为“读取自己的源代码”。现在您可以争辩说，像这里的大多数解决方案一样，拥有程序的字符串副本也“正在读取源代码”，但是该字符串未执行。
— qwr
1

Japt，14个字节

Qi"QiUè² " ²èU

试试吧

说明

                   :Implicit input of character string U
  "QiUè² "         :String literal
Qi                 :Append a quotation mark
           ²       :Repeat twice
            èU     :Count the occurrences of U
— 毛茸茸
source
1

果冻，16字节

“;⁾w⁸a2”;⁾“”w⁸a2

在线尝试！

每个字符正好出现两次。

“;⁾w⁸a2”;⁾“”w⁸a2
“;⁾w⁸a2”;⁾“”     the string ;⁾w⁸a2“”
            w⁸a2 return 2 if input in string
— 艾莉
source
1

86，42 40个字节

在这里，我使用与其他策略相同的策略：创建具有唯一字节的程序的字符串副本，al如果输入al在字符串中，则返回2 。如果我们允许自己读取实际运行的代码，则可以得到l4m2的解决方案。

我必须利用一个很酷的字符串指令scasb。据我所知，没有重复的字节，但是我很容易搞砸。载入字符串地址需要5个字节，但我不知道任何较短的溶液（64位lea的rip带偏移的需要6个字节）。

-2向后跳，避免使用02两次。

.section .text
.globl main
main:
        mov     $0xff, %eax

start:
        push    $20             # program length
        pop     %ecx            # counter
        mov     $str, %edi      # load string

loop:
        scasb                   # if (al == *(edi++))  
        jne     loop1           
        mov     $2, %al         # ret 2
end:    ret             
loop1:
        loop    loop            # do while (--counter)
        xor     %eax, %eax      # ret 0
        jmp     end

str:    .byte 0x6a,0x14,0x59,0xbf,0xf4,0x83,0x04,0x08 
        .byte 0xae,0x75,0x03,0xb0,0x02,0xc3,0xe2,0xf8
        .byte 0x31,0xc0,0xeb,0xf9

十六进制转储（二进制文件格式elf32-i386，因为obj文件不幸地具有00用于str地址的字节）：

000003e0  6a 14 59 bf f4 83 04 08  ae 75 03 b0 02 c3 e2 f8  |j.Y......u......|
000003f0  31 c0 eb f9 6a 14 59 bf  f4 83 04 08 ae 75 03 b0  |1...j.Y......u..|
00000400  02 c3 e2 f8 31 c0 eb f9                           |....1...|

x86，256字节

无聊的回答相当于一个巨大的评论。输入in cl，立即返回1 in al。有空的时候我会做一个实际的答案。

00000039  b0 01 c3 00 02 03 04 05  06 07 08 09 0a 0b 0c 0d  |................|
00000049  0e 0f 10 11 12 13 14 15  16 17 18 19 1a 1b 1c 1d  |................|
00000059  1e 1f 20 21 22 23 24 25  26 27 28 29 2a 2b 2c 2d  |.. !"#$%&'()*+,-|
00000069  2e 2f 30 31 32 33 34 35  36 37 38 39 3a 3b 3c 3d  |./0123456789:;<=|
00000079  3e 3f 40 41 42 43 44 45  46 47 48 49 4a 4b 4c 4d  |>?@ABCDEFGHIJKLM|
00000089  4e 4f 50 51 52 53 54 55  56 57 58 59 5a 5b 5c 5d  |NOPQRSTUVWXYZ[\]|
00000099  5e 5f 60 61 62 63 64 65  66 67 68 69 6a 6b 6c 6d  |^_`abcdefghijklm|
000000a9  6e 6f 70 71 72 73 74 75  76 77 78 79 7a 7b 7c 7d  |nopqrstuvwxyz{|}|
000000b9  7e 7f 80 81 82 83 84 85  86 87 88 89 8a 8b 8c 8d  |~...............|
000000c9  8e 8f 90 91 92 93 94 95  96 97 98 99 9a 9b 9c 9d  |................|
000000d9  9e 9f a0 a1 a2 a3 a4 a5  a6 a7 a8 a9 aa ab ac ad  |................|
000000e9  ae af b1 b2 b3 b4 b5 b6  b7 b8 b9 ba bb bc bd be  |................|
000000f9  bf c0 c1 c2 c4 c5 c6 c7  c8 c9 ca cb cc cd ce cf  |................|
00000109  d0 d1 d2 d3 d4 d5 d6 d7  d8 d9 da db dc dd de df  |................|
00000119  e0 e1 e2 e3 e4 e5 e6 e7  e8 e9 ea eb ec ed ee ef  |................|
00000129  f0 f1 f2 f3 f4 f5 f6 f7  f8 f9 fa fb fc fd fe ff  |................|
— wr
source
1

APL（Dyalog Classic），30字节

⊢⊢⊢11-11-11-'''''''1''⊢-⍳⍳0'⍳⊢

在线尝试！

说明

在APL中，字符串中的单引号通过加倍转义，'''''''1''⊢-⍳⍳0'字符串'''1'⊢-⍳⍳0，也包含程序中使用的每个字符。

APL数组默认为1索引，有趣的是，index-of函数返回 1 + max index如果找不到该元素。

因此，通过在字符串上使用index-of，输入将返回

Input    Index    Count
'        1        10
1        4        7
⊢        6        5
-        7        4
⍳        8        3
0        10       1
<other>  11       0

可以看到，11 - index给出了程序中字符的计数。因此，基本算法是

11-'''''''1''⊢-⍳⍳0'⍳⊢

其余的使字符数膨胀，使它们很好地适合插槽。

— 黄昏
source
1

R，135字节

受此Python答案的启发。

以前的版本已损坏。感谢@Giuseppe指出这paste不是必需的，它节省了18个字节左右。lengths(regmatches(z,gregexpr(x,z)))是从这个答案。

function(x,z=rep(c("afilo2679=:","hmpu15'","nstxz","cgr","e","()",'"',","),c(2:5,7,9,15,16)))sum(lengths(regmatches(z,gregexpr(x,z))))

在线尝试！

— 杰西
source
0

Ruby，48个字节

->x{%q[->x{%q[].count(x.chr)*2}].count(x.chr)*2}

%q[str]比起"str"可以直接嵌套在字符串内部而不进行任何转义的方式，它是一种写字符串文字的更方便的方法。因此，我只将整个代码（除了副本）放入其中，然后将计数加倍。

— 历史学家
source
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.