你知道那种语言吗？

34

任务：

您面临的挑战是，鉴于先前提交的内容及其本身作为输入，以以下格式输出使用其编写的语言：

假设第一个程序在Ruby中。它必须输出1，因为Ruby是1此挑战中使用的主要语言。一个示例程序是：

a=gets
puts 1

当自身作为输入时，它返回1。

下一个程序可能在Python中。它必须输出2，因为Python是2挑战中使用的第二种语言。一个示例程序是：

print(1 if input()[0]=="a"else 2)

给定第一个提交，它输出1，给定它自己，它输出2。

您可以重复语言，但不能以上一个答案的语言提交答案。

例如，如果第三个程序是Ruby，则必须在1给定第一个程序及其本身的情况下输出（因为Ruby是所1使用的st语言），而在给定第二个程序时必须输出2。

规则：

  • 如果n挑战中当前有答案，那么至少必须使用floor(n / 3)不同的语言。任何违反此规则的提交都将被取消参赛资格。
  • 没有两个“相邻答案”（例如answer n和answer n+1）不能使用相同的语言。
  • 语言的不同版本不算作其他语言（so Python 2 == Python 3）。
  • 答案必须以先前提交的全部内容作为输入。
  • 第一个提交必须接受输入。
  • 您不允许连续提交多个答案。
  • 不允许使用“重复答案”（答案与以前提交的代码完全相同）。
  • 答案不允许超过该答案的已分配字节数-有关更多详细信息，请参见“已分配字节数”。

分配的字节数：

对于每个答案号n，为该答案分配的字节数为45 + 5n。

答案格式：

格式化您的答案，如下所示：

# {answer no.}, {language}
{program}
This prints:
- `1` in answer(s) {all answers using 1st language, with links}
- `2` in answer(s) {all answers using 2nd language, with links}
...
{optional explanation}

对于答案列表，请执行以下操作：

- `1` in answers [1]({link to answer}), [3]({link to answer})...

得分：

生存7天后第一个未获任何有效提交的答案，即获胜者。

classification  answer-chaining 
— 基督教
source
1
一个用户可以连续发布两个连续的提交吗？
— Kritixi Lithos
因此，就目前情况而言，我可以按原样重复我的答案n°6，将其回答为n°8，之后马丁可以重复他的数字n°7（除非我弄错了）等，直到答案为n°达到强加的阈值（即floor(n / 3)语言）之前的15 。我猜这不是故意的行为。
— plannapus
@plannapus我也注意到了这一点。当然，您的目标是得到最后一个答案，因此知道我也将进行一次微不足道的跟进，您可能希望使事情复杂化（在发布自己的答案之前我没有考虑过）。
— Martin Ender
3
分配的字节数随着几何级数的增长而增长，这些挑战可能要等到我们用完所有语言后才能终止，这不是因为代码会变得太长。
— Wolfram
2
IMO有一个合理的固定限制（例如384或256字节），效果会更好，并最终引发激烈的竞争。
— Zeppelin

Answers:

4

26. > <>（语言12），164字节

我在> <>中的第一个程序！它是156个字符，但在UTF-8中为164个字节。

^$|(?![⊂⍴])[⊂-⍴]|\B=|{}
{:}&1+&=?v
      .&0/
v+!?='>'i41i
v+?='y'i47
v+?=' 'i12
v+?=' 'i24
v4
v6
v7
v8
v9
va
  v?(0:i
v1
n;\b1laa*)?+
/"^mwfPes{'tc"i2&01.;

打印：

  • 1与答案1，5，7，9，和14（视网膜）。

  • 2答案2（Brain-Flak）。

  • 3答案3（APL）。

  • 4与答案4，12，和15（使用Javascript）。

  • 5答案为6和8（R）。

  • 6与答案10，17，20，22，和25（击）。

  • 7答案11和19（Mathematica）。

  • 8答案13（Python）。

  • 9答案为16（Perl）。

  • 10与答案18，21，和23（C / C ++）。

  • 11答案为24（Zsh）。

  • 12 这个答案（> <>）。

在线尝试！

说明：

第一行只是答案＃5。它什么也没做，只是将指令指针发送到底行。 /将鱼右转，然后将角色^mwfPes{'tc放到堆栈上。读取输入的单个字符（i）。（让我们称这个字符C为博览会。）2放入寄存器（2&）。然后，我们跳到第二行（第1行）的开头（01.）。

此行与C堆栈上的每个字符进行比较。的副本C保留在堆栈的底部。{旋转堆栈，使其C位于顶部；:复制它；}将副本旋转回底部。我们增加寄存器（&1+&）直到找到匹配项。（因此，如果C为“ c”，则在找到匹配项时该寄存器将保留3；如果C为“ t”，则该寄存器将保留4，依此类推。）然后我们跳转到寄存器中行号的第一个字符（0&.） 。

第3至13行分别处理Cc，t，'，{等时的情况。跳转时，指令指针向后移动；它落在给定行的第一个字符上，但是在跳转之后它在执行之前前进了一个刻度，所以它从行的末尾开始执行。每行将适当的语言编号压入堆栈，然后将鱼发送到n指令，然后将其打印出来。

^是最复杂的情​​况，因为我对这个答案的第一行含糊不清。第13行读取输入，直到EOF。然后，它直接指向第15行，该行将堆栈（l）的长度与100（aa*）进行比较。如果更长（)?），我们将语言加+ b和1得到12。否则，堆栈顶部将保留1。

— 尼克·马特奥
source
12

2. Brain-Flak，22个字节

{<>(())(<>)}{}(<>{}())

在线尝试！

这将检查堆栈的顶部，如果不为零，则在相对的堆栈上放置一个。然后，它递增并返回相反的堆栈。这使它为空程序返回1，为其他任何程序返回2。

由于Brain-Flak中的堆栈默认为零，因此，空程序的堆栈顶部将为零，而其他任何程序（以空字符结尾的程序除外）都将为真值。这意味着我们可以在输入堆栈上运行非常简单的if程序。

{      (<>)}{}              #If not zero
 <>(())                     #Push one to the other stack
              (<>{}())      #Switch to other stack and increment by one
— 小麦巫师
source
您可以编辑此答案吗？我不小心弃了它：)
— Conor O'Brien
9

3. APL，7个字节

' {'⍳⊃⍞

说明：

      ⍞  read from the keyboard
     ⊃   first item of list, or space if empty
' {'⍳    index into the string ' {', giving N+1 (=3) if not found
— 马里纳斯
source
8

10. Bash（+ coreutils）[语言6]， 44，74字节

固定版本（返回语言ID）

expr substr "1234151516" $(expr index "365f8dc0eb" `md5sum|cut -c12`) 1 #G

注意：在输入程序文本之后，这需要尾随换行符

— 齐柏林飞艇
source
7

9. Retina（语言1），20字节

$|}\{|[:'][^]']|,\b1

在线尝试！

像Plannapus一样，我决定进行重写以稍微改变一下内容，这也最终导致代码大大缩短（我想对Plannapus的最新版本做出的最后一个回答的修改将以大约32个字节结尾）。

说明

像我的其他答案一样，这只是计算各种正则表达式匹配项的数量，但是处理起来却效率更高：

  • $匹配字符串的结尾。即使在字符串末尾一直存在匹配项，这始终有效，因此这为我们提供1了所有输入的基线。
  • }\{在第二个程序（Brain-Flak）中找到一个匹配项，从而使计数增加到2。反斜杠对于转义不是必需的，但可以防止正则表达式的这一部分与自身匹配。
  • [:'][^]']真的很漂亮。唯一的目的是计算'APL程序中的两个（语言3）和:JavaScript程序中的三个（语言4），但是我们需要防止这部分与自身匹配。因此，我们也保证了下一个字符既不是'，也不是]（因为那些没有我们的那些出现后也想匹配，但他们在这里出现在这个节目）。
  • 在'从以前的部分已经导致在R程序一场比赛，所以我们需要三个。子字符串,1在两者中都出现3次，并且没有其他程序出现。我们通过在之间添加重言式词边界,\b1来匹配它，以防止它再次匹配自己。
— 马丁·恩德
source
嗯，刚刚意识到这根本不会挫败R的答案，因为1仅仅是它们的默认输出。下一个答案，我将不得不对此做些事情。
— 马丁·恩德
7

18. C（语言10），121字节

这是C89或C90标准。它可以在在线试用中与clang或gcc一起使用。

main(n){char*v=" ^{ s ePfwm",b[999],*c;gets(b);c=strchr(v,*b);n=strlen(b);printf("%d",n?c?c-v:n>99?4:n>60?5:n>15?1:3:1);}

打印：

  • 1与答案1，5，7，9，和14（视网膜）。

  • 2答案2（Brain-Flak）。

  • 3答案3（APL）。

  • 4与答案4，12，和15（使用Javascript）。

  • 5答案为6和8（R）。

  • 6答案为10和17（重击）。

  • 7答案11（Mathematica）。

  • 8答案13（Python）。

  • 9答案为16（Perl）。

  • 10 答案（C）。

这是一个bash驱动程序，可运行并在线尝试所有18个答案！

非高尔夫等效（646字节）：

#include <string.h>
#include <stdio.h>
int main(){
    char *v=" ^{ s ePfwm", b[999];
    gets(b); /* buffer overrun if more than 998 characters in the input.
                could be a problem if we get to 191 answers */
    char *c = strchr(v, b[0]); /* Find first character of input in v, or null */
    int n = strlen(b);
    if (!n) {
        printf("1");
    } else if (c) {
        printf("%d", c-v); /* Index of first character of input in v */
    } else if (n > 99) {
        printf("4");
    } else if (n > 60) {
        printf("5");
    } else if (n > 15) {
        printf("1");
    } else {
        printf("3");
    }
    return 0;
}
— 尼克·马特奥
source
6

5. Retina（语言1），23个字节

^$|(?![⊂⍴])[⊂-⍴]|\B=|{}

在线尝试！（测试所有可能的输入。）

计算输入中各种事物的匹配：

  • ^$ 匹配输入字符串，即第一个答案一次。
  • {} 匹配自身，在第二个程序中有两个，在这个程序中有一个。
  • (?![⊂⍴])[⊂-⍴]匹配代码点为8834至9076（不包括）的字符，该字符在第三个程序中找到三个匹配项。我们使用负前瞻以避免在此程序中匹配范围的两端。
  • \B=匹配的=是不是一个文字字符开头。这与=第四个程序中的四个匹配，=与该程序中的不匹配。
— 马丁·恩德
source
4

4，JavaScript（ES6），32字节

s=>s?s[0]==`{`?2:s[0]==`s`?4:3:1

为空输入输出1，如果输入以a开头，则输出2，如果输入以a开头，则输出{4 s，否则为3。

— 路加
source
您可以替换s[0]=='{'通过s[0]>'z'
1
@Masterzagh我也在考虑如何打高尔夫球，但是可惜，这不是代码高尔夫：/
— Kritixi Lithos
@KritixiLithos好吧，但是他已经有点打高尔夫了，所以我认为他想走得更远。
@Masterzagh人们应避免在此类挑战中编辑有效答案，因为他们可能会使a）以后的答案，b）当前正在处理的答案无效。
— Martin Ender
@MartinEnder，你是对的。因此，我不会编辑它。我知道它看起来像是打高尔夫球（由于三元运算符），但是我并不是故意写它的……尽管如此，感谢所有反馈！
— 路加福音
4

11. Mathematica [语言7]，53个字节

Position[Characters@"^{'sceP",#&@@#][[1,1]]/._@__->1&

未命名函数，以字符列表作为参数并输出一个正整数。只需在输入的第一个字母上分支，即可使用其在字符串中的位置"^{'sceP"来确定输出。除了最初的空视网膜程序和最近的视网膜答案外，这可以为以前的所有提交提供正确的答案 ; 这两个吐痰错误，但是输出通过将/._@__->1未评估的函数转换为的规则修复1。

— 格雷格·马丁
source
我认为是时候弄清楚第一个字符策略了：)
— Martin Ender
1
我打算去，但后来我想起我也必须正确输出自己的语言：D
— 格雷格·马丁
4

16. Perl（语言9），94个字节

while(<>){print substr("1234151516748149",index("0F=POmS6D4e_XWVH",chr(47+length($_)%70)),1);}

在线尝试！（检查所有答案）。输出“ 1234151516748149”

打印：

  • 1，答案为1、5、7、9和14（视网膜）。
  • 2，答案2（Brain-Flak）。
  • 3，答案3（APL）。
  • 4，答案4、12和15（JavaScript）。
  • 5，答案6和8（R）。
  • 6，答案10（重击）。
  • 7与答案11（Mathematica）。
  • 8，答案13（Python）。
  • 9与这个答案（Perl）。

该程序检查输入长度并将其映射到当前语言分布。

— 乐思
source
3

6. R（语言5），61字节

cat(switch(substr(readline(),1,1),"{"=2,"'"=3,"s"=4,"c"=5,1))

检查输入的第一个字符是什么，并相应地选择输出。

因此打印：

  • 1答案1和5（视网膜）。

  • 2答案2（Brain-Flak）。

  • 3答案3（APL）。

  • 4答案4（Javascript）。

  • 和5这个答案。

用法：

> cat(switch(substr(readline(),1,1),"{"=2,"'"=3,"s"=4,"c"=5,1))

1
> cat(switch(substr(readline(),1,1),"{"=2,"'"=3,"s"=4,"c"=5,1))
{<>(())(<>)}{}(<>{}())
2
> cat(switch(substr(readline(),1,1),"{"=2,"'"=3,"s"=4,"c"=5,1))
' {'⍳⊃⍞
3
> cat(switch(substr(readline(),1,1),"{"=2,"'"=3,"s"=4,"c"=5,1))
s=>s?s[0]==`{`?2:s[0]==`s`?4:3:1
4
> cat(switch(substr(readline(),1,1),"{"=2,"'"=3,"s"=4,"c"=5,1))
^$|(?![⊂⍴])[⊂-⍴]|\B=|{}
1
> cat(switch(substr(readline(),1,1),"{"=2,"'"=3,"s"=4,"c"=5,1))
cat(switch(substr(readline(),1,1),"{"=2,"'"=3,"s"=4,"c"=5,1))
5
— 浮游动物
source
要在REPL之外运行此代码，请参见答案8下的注释
— 。– plannapus
3

8. R（语言5），76个字节

c=which(c("","{","'","s","c")==substr(readline(),1,1));ifelse(length(c),c,1)

检查输入的第一个字母，并且将其与含有一个向量相比较（以该顺序）的空字符串，{，'，s和c。然后，它输出匹配项的索引（R索引基于1），如果没有匹配项，则输出1。

与答案n° 6相同，但阻止答案n° 7匹配它。

打印：

  • 1与答案1， 5和7（视网膜）。

  • 2答案2（Brain-Flak）。

  • 3答案3（APL）。

  • 4答案4（Javascript）。

  • 以及5答案6和这个答案（R）。

如果我没记错的话，此答案的字节数允许为94字节。

— 浮游动物
source
FYI R在线解释器（rfiddle，ideone和tryitonline）似乎在处理stdin（至少使用readline（））时遇到问题，因此无法正常运行。如果您想尝试此操作（以及上一个答案），恐怕必须在R的已安装版本上进行本地尝试。
— plannapus
^好的，readline应该在REPL之外替换readLines(file("stdin"))。这意味着还有16个字符：因此，答案6应该为77字节（允许的79个字节），而答案为92字节（允许的94个字节）。进行此更改后，它也适用于在线口译员。
— plannapus
3

12. Javascript（语言4），117个字节

注意：我更改了一个字符以纠正此错误。

c=>c?c[0]=='e'?6:c[0]=='$'||c[0]=='^'?1:c[0]=='c'&&c.length>80?4:c[0]=='P'?7:c[0]=='c'?5:c[0]=='{'?2:c[0]=='s'?4:3:1;

检查输入的第一个字母，如果为c，则检查输入的长度。

输出：

  • 1代表答案1、5、7、9
  • 答案2
  • 答案3
  • 4为答案4和此答案
  • 5为答案6、8
  • 6代表答案10
  • 答案7 7
— 德夫斯曼
source
3

13. Python（语言8），110字节

注意：根据OP的建议，此答案在发布后6小时内已更改。

from hashlib import*;print("1234151516748"["a5e1f936cd78b".index(sha256(input().encode()).hexdigest()[34])])#N

这与答案10（用bash表示）的想法相同，但是在Python 3中使用。（这种方法最多可以再使用3个条目，然后再用完十六进制数字）。

打印：

  • 1与答案1，5，7，和9（视网膜）。

  • 2答案2（Brain-Flak）。

  • 3答案3（APL）。

  • 4答案4和12（Javascript）。

  • 5答案为6和8（R）。

  • 6答案为10（重击）。

  • 7答案11（Mathematica）。

  • 8 对于这个答案（Python）。

在线尝试！适用于：答案1， 答案2， 答案3， 答案4， 答案5， 答案6， 答案7， 答案8， 答案9， 答案10， 答案11， 答案12或 此答案。

— 尼克·马特奥
source
当前的字节数限制是多少？
— 六。
@Vi .：好吧，答案13是149，答案14是163；但是OP只是将字节计数规则更改为45 + 5n，因此答案13的字节数为110字节，答案14的字节数为115字节。
— 尼克利玛窦
您可能应该提出110字节的解决方案。
— clismique
@ Qwerp-Derp：好的。希望这不会破坏任何人正在进行的工作。
— 尼克·马特奥
好的，等待大约60个答案，直到达到Java友好的字节限制为止。
— 六。
3

24. Zsh（语言11），142个字节

对于所有后续条目（demo），我在C中的上一个答案＃18仍能正常工作。因此，让我们混合一下。

typeset -A p
p=("[\$^]*|'\[*" 1 '{*' 2 "' *" 3 '?=>*' 4 'c?[wt]*' 5 'e*' 6 'P*' 7 'f*' 8 'w*' 9 'm*' 10 'ty*' 11)
echo ${p[(k)$1]:-1} #@<`w&X{

最后的注释的目的是匹配答案21和23的长度，并使用Lyth的C ++答案检查的字符，确保到目前为止，每个答案的sha256或sha384哈希值都不唯一。;-)

打印：

  • 1有答案1，5，7，9，和14（视网膜）。

  • 2答案2（Brain-Flak）。

  • 3答案3（APL）。

  • 4 有答案 4，12，和15（使用Javascript）。

  • 5答案为6和8（R）。

  • 6有答案10， 17，20，和22（击）。

  • 7答案11和19（Mathematica）。

  • 8答案13（Python）。

  • 9 有答案 16（Perl）。

  • 10与答案18，21，和23（C / C ++）。

  • 11 这个答案（Zsh）。

在线尝试！

— 尼克·马特奥
source
我认为这是第一个被多行回答的答案... +1。
— clismique
2

14. Retina（语言1），39个字节

'[ ⍳]|}\{|[o@:][^]'c@:]|^c|,\b1|1\d|$

在线尝试！（测试所有有效输入。）

— 马丁·恩德
source
1
来吧，马丁，用另一种语言发帖...另外，您能做答案格式的事情吗？
— clismique
3
@ Qwerp-Derp实际上，这正变成标准正则表达式高尔夫上一个有趣的变化。不必拥有一组输入，而必须匹配其中一些输入并使其他输入失败，这里您必须在每个输入上获取特定数量的匹配项。我确实不知道此正则表达式是否会在某个时候成倍增加。
— Martin Ender
真的是39个字节吗？TIO报告37个字节。
— Arnauld
1
由于经常使用单字节编码，因此@Arnauld TIO进行了硬编码，只为Retina计数字符。但是，此答案需要UTF-8。
— 马丁·恩德
2

15. Javascript（语言4），108字节

打高尔夫球

t=>({24:2,86:3,5:4,73:5,68:5,74:7,4:6,79:4,1:8,67:4})[[...t].reduce((r,c,i)=>r*i^c.charCodeAt(0),0)&0x5F]||1
— 齐柏林飞艇
source
2

17. Bash（+ coreutils + openssl）（语言6），103个字节

打高尔夫球

expr substr 69418476151514321 $(expr index 2PtgBOlrvfDVC8ZHL `openssl md5 -binary|base64|cut -c2`) 1 #x

使用与我的答案＃10相同的技术，但使用Base64编码的字典，而不是Hex。

我整理了以下数据文件进行测试：

6 17 expr substr 69418476151514321 $(expr index 2PtgBOlrvfDVC8ZHL `openssl md5 -binary|base64|cut -c2`) 1 #x
9 16 while(<>){print substr("1234151516748149",index("0F=POmS6D4e_XWVH",chr(47+length($_)%70)),1);}
4 15 t=>({24:2,86:3,5:4,73:5,68:5,74:7,4:6,79:4,1:8,67:4})[[...t].reduce((r,c,i)=>r*i^c.charCodeAt(0),0)&0x5F]||1
1 14 '[ ⍳]|}\{|[o@:][^]'c@:]|^c|,\b1|1\d|$
8 13 from hashlib import*;print("1234151516748"["a5e1f936cd78b".index(sha256(input().encode()).hexdigest()[34])])#N
4 12 c=>c?c[0]=='e'?6:c[0]=='$'||c[0]=='^'?1:c[0]=='c'&&c.length>80?4:c[0]=='P'?7:c[0]=='c'?5:c[0]=='{'?2:c[0]=='s'?4:3:1;
7 11 Position[Characters@"^{'sceP",#&@@#][[1,1]]/._@__->1&
6 10 expr substr "1234151516" $(expr index "365f8dc0eb" `md5sum|cut -c12`) 1 #G
1 09 $|}\{|[:'][^]']|,\b1
5 08 c=which(c("","{","'","s","c")==substr(readline(),1,1));ifelse(length(c),c,1)
1 07 ^$|(?![⊂⍴])[⊂-⍴]|\B=|{}|\b5
5 06 cat(switch(substr(readline(),1,1),"{"=2,"'"=3,"s"=4,"c"=5,1))
1 05 ^$|(?![⊂⍴])[⊂-⍴]|\B=|{}
4 04 s=>s?s[0]==`{`?2:s[0]==`s`?4:3:1
3 03 ' {'⍳⊃⍞
2 02 {<>(())(<>)}{}(<>{}())
1 01

测试

for i in `seq 17`
do
  echo -n `cat lchain|sed -n $i'{p;q}'|cut -c1`=\>
  cat lchain|sed -n $i'{p;q}'|cut -c6-|\
  expr substr 69418476151514321 $(expr index 2PtgBOlrvfDVC8ZHL `openssl md5 -binary|base64|cut -c2`) 1 #x
done

6=>6
9=>9
4=>4
1=>1
8=>8
4=>4
7=>7
6=>6
1=>1
5=>5
1=>1
5=>5
1=>1
4=>4
3=>3
2=>2
1=>1
— 齐柏林飞艇
source
2

19. Mathematica（语言7），96字节

Position[ToCharacterCode@StringSplit@";NRU$ Q B [1: =L J, 5% 3 # >",Mod[Length@#,59,33]][[1,1]]&

未命名函数，将字符列表作为输入并返回整数：

  • 1与答案1，5，7，9，和14（视网膜）。

  • 2答案2（Brain-Flak）。

  • 3答案3（APL）。

  • 4与答案4，12，和15（使用Javascript）。

  • 5答案为6和8（R）。

  • 6答案为10和17（重击）。

  • 7答案11和这个答案（Mathematica）。

  • 8答案13（Python）。

  • 9答案为16（Perl）。

  • 10答案18（C）。

到目前为止，所有答案的长度都是不同的，甚至是59的模数，因此可以检测到它们与33、34，...，91范围内的哪个整数一致（模数59）。这些都是可打印的ASCII字符，由字符串编码";NRU$ Q B [1: =L J, 5% 3 # >"；使用ToCharacterCode@StringSplit@将该字符串转换为该范围内十个整数列表的列表，并Position[...,Mod[Length@#,59,33]][[1,1]]查找十个子列表中的哪一个与输入的修改长度匹配。

— 格雷格·马丁
source
1

20. Bash（+ coreutils + openssl）（语言6），121字节

打高尔夫球

expr substr 67A69418476151514321 $(expr index 7042PtgBOlrvfDVC8ZHL `openssl md5 -binary|base64|cut -c2`) 1| dc -e16i?p #u

与我的答案17相同的方法（反过来又基于我的原始答案10）。

由于我们现在有10种不同的语言，因此我已切换到十六进制位置编码。

数据

6 20 expr substr 67A69418476151514321 $(expr index 7042PtgBOlrvfDVC8ZHL `openssl md5 -binary|base64|cut -c2`) 1| dc -e16i?p #u
7 19 Position[ToCharacterCode@StringSplit@";NRU$ Q B [1: =L J, 5% 3 # >",Mod[Length@#,59,33]][[1,1]]&
A 18 main(n){char*v=" ^{ s ePfwm",b[999],*c;gets(b);c=strchr(v,*b);n=strlen(b);printf("%d",n?c?c-v:n>99?4:n>60?5:n>15?1:3:1);}
6 17 expr substr 69418476151514321 $(expr index 2PtgBOlrvfDVC8ZHL `openssl md5 -binary|base64|cut -c2`) 1 #x
9 16 while(<>){print substr("1234151516748149",index("0F=POmS6D4e_XWVH",chr(47+length($_)%70)),1);}
4 15 t=>({24:2,86:3,5:4,73:5,68:5,74:7,4:6,79:4,1:8,67:4})[[...t].reduce((r,c,i)=>r*i^c.charCodeAt(0),0)&0x5F]||1
1 14 '[ ⍳]|}\{|[o@:][^]'c@:]|^c|,\b1|1\d|$
8 13 from hashlib import*;print("1234151516748"["a5e1f936cd78b".index(sha256(input().encode()).hexdigest()[34])])#N
4 12 c=>c?c[0]=='e'?6:c[0]=='$'||c[0]=='^'?1:c[0]=='c'&&c.length>80?4:c[0]=='P'?7:c[0]=='c'?5:c[0]=='{'?2:c[0]=='s'?4:3:1;
7 11 Position[Characters@"^{'sceP",#&@@#][[1,1]]/._@__->1&
6 10 expr substr "1234151516" $(expr index "365f8dc0eb" `md5sum|cut -c12`) 1 #G
1 09 $|}\{|[:'][^]']|,\b1
5 08 c=which(c("","{","'","s","c")==substr(readline(),1,1));ifelse(length(c),c,1)
1 07 ^$|(?![⊂⍴])[⊂-⍴]|\B=|{}|\b5
5 06 cat(switch(substr(readline(),1,1),"{"=2,"'"=3,"s"=4,"c"=5,1))
1 05 ^$|(?![⊂⍴])[⊂-⍴]|\B=|{}
4 04 s=>s?s[0]==`{`?2:s[0]==`s`?4:3:1
3 03 ' {'⍳⊃⍞
2 02 {<>(())(<>)}{}(<>{}())
1 01

测试（输出）

./test
6=>6
7=>7
A=>10
6=>6
9=>9
4=>4
1=>1
8=>8
4=>4
7=>7
6=>6
1=>1
5=>5
1=>1
5=>5
1=>1
4=>4
3=>3
2=>2
— 齐柏林飞艇
source
1

23. C（gcc）（语言10），142字节

main(c){int d[256]={0};while((c=getchar())!=EOF)d[c]++;printf("%d",d[88]?9:d[119]?5*d[123]:d[35]?d[38]?7:8-d[96]:d[48]?4:d[60]?2:1+d[158]*2);}

在线尝试！

  • 1与答案1，5，7，9，和14（视网膜）。

  • 2答案2（Brain-Flak）。

  • 3答案3（APL）。

  • 4与答案4，12，和15（使用Javascript）。

  • 5答案为6和8（R）。

  • 6与答案10，17，20和22（击）。

  • 7答案11和19（Mathematica）。

  • 8答案13（Python）。

  • 9答案为16（Perl）。

  • 10与答案18，21和此答案（C）。

该程序计算不同字符的数量（以ASCII表示，因此多字节UTF-8字符被分成几个条目），然后根据该字符出现的次数遵循精心设计的决策树。

决策树与＃21相同（是！）。我不允许发布完全相同的代码，因此我们将在稍作修改的情况下返回纯C语言。

— 乐思
source
0

21. C ++（gcc）（语言10是C的变体），142个字节

main(){int K,d[256]{0};while((K=getchar())!=EOF)d[K]++;printf("%d",d[88]?9:d[119]?5*d[123]:d[35]?d[38]?7:8-d[96]:d[48]?4:d[60]?2:1+d[158]*2);}

在线尝试！

  • 1与答案1，5，7，9，和14（视网膜）。

  • 2答案2（Brain-Flak）。

  • 3答案3（APL）。

  • 4与答案4，12，和15（使用Javascript）。

  • 5答案为6和8（R）。

  • 6与答案10，17和20（击）。

  • 7答案11和19（Mathematica）。

  • 8答案13（Python）。

  • 9答案为16（Perl）。

  • 10答案18和这个答案（C）。

该程序计算不同字符的数量（以ASCII表示，因此多字节UTF-8字符被分成几个条目），然后根据该字符出现的次数遵循精心设计的决策树。

琐事：直到输入此项，才使用字母K。字母I，E，Y，j，k，q，z保持未使用状态。

— 乐思
source
还有就是要考虑C ++语言的11个选项，几个字节都留给了适合该英寸
— 里茨
0

22. Bash（+ coreutils）[语言6]， 123，131字节

编辑：首先发布了错误的版本，现在应该修复。

打高尔夫球

expr substr 6A67A69418476151514321 $(expr index i3xFepQsAalyIvtqPY7ZN+ \\`openssl sha256 -binary|base64|cut -c10`) 1| dc -e16i?p #L

与我的答案＃20，＃17和＃10相同的技术。

数据

6 22 expr substr 6A67A69418476151514321 $(expr index i3xFepQsAalyIvtqPY7ZN+ \\`openssl sha256 -binary|base64|cut -c10`) 1| dc -e16i?p #L
A 21 main(){int K,d[256]{0};while((K=getchar())!=EOF)d[K]++;printf("%d",d[88]?9:d[119]?5*d[123]:d[35]?d[38]?7:8-d[96]:d[48]?4:d[60]?2:1+d[158]*2);}
6 20 expr substr 67A69418476151514321 $(expr index 7042PtgBOlrvfDVC8ZHL `openssl md5 -binary|base64|cut -c2`) 1| dc -e16i?p #u
7 19 Position[ToCharacterCode@StringSplit@";NRU$ Q B [1: =L J, 5% 3 # >",Mod[Length@#,59,33]][[1,1]]&
A 18 main(n){char*v=" ^{ s ePfwm",b[999],*c;gets(b);c=strchr(v,*b);n=strlen(b);printf("%d",n?c?c-v:n>99?4:n>60?5:n>15?1:3:1);}
6 17 expr substr 69418476151514321 $(expr index 2PtgBOlrvfDVC8ZHL `openssl md5 -binary|base64|cut -c2`) 1 #x
9 16 while(<>){print substr("1234151516748149",index("0F=POmS6D4e_XWVH",chr(47+length($_)%70)),1);}
4 15 t=>({24:2,86:3,5:4,73:5,68:5,74:7,4:6,79:4,1:8,67:4})[[...t].reduce((r,c,i)=>r*i^c.charCodeAt(0),0)&0x5F]||1
1 14 '[ ⍳]|}\{|[o@:][^]'c@:]|^c|,\b1|1\d|$
8 13 from hashlib import*;print("1234151516748"["a5e1f936cd78b".index(sha256(input().encode()).hexdigest()[34])])#N
4 12 c=>c?c[0]=='e'?6:c[0]=='$'||c[0]=='^'?1:c[0]=='c'&&c.length>80?4:c[0]=='P'?7:c[0]=='c'?5:c[0]=='{'?2:c[0]=='s'?4:3:1;
7 11 Position[Characters@"^{'sceP",#&@@#][[1,1]]/._@__->1&
6 10 expr substr "1234151516" $(expr index "365f8dc0eb" `md5sum|cut -c12`) 1 #G
1 09 $|}\{|[:'][^]']|,\b1
5 08 c=which(c("","{","'","s","c")==substr(readline(),1,1));ifelse(length(c),c,1)
1 07 ^$|(?![⊂⍴])[⊂-⍴]|\B=|{}|\b5
5 06 cat(switch(substr(readline(),1,1),"{"=2,"'"=3,"s"=4,"c"=5,1))
1 05 ^$|(?![⊂⍴])[⊂-⍴]|\B=|{}
4 04 s=>s?s[0]==`{`?2:s[0]==`s`?4:3:1
3 03 ' {'⍳⊃⍞
2 02 {<>(())(<>)}{}(<>{}())
1 01

测试运行

./test
6=>6
A=>10
6=>6
7=>7
A=>10
6=>6
9=>9
4=>4
1=>1
8=>8
4=>4
7=>7
6=>6
1=>1
5=>5
1=>1
5=>5
1=>1
4=>4
3=>3
2=>2
1=>1
— 齐柏林飞艇
source
什么44啊
— clismique
22 * 2󠀠󠀠󠀠󠀠󠀠？
— 六。
@ Qwerp-Derp，只是一个错字
— 齐柏林飞艇
拜托，您的答案现在变得无聊了-如果您的下一个答案是这样，我正在考虑投票（这很有趣，您知道吗？）
— clismique
1
这里不对劲。您的散列字母（3PgT等）中只有20个条目。对于空输入，我得到一个错误，对于答案2，我得到“ 4”（都与答案20一起正常工作。）
— Nick Matteo
0

25. Bash（语言6），169个字节

与我的答案＃22，＃20，＃17和＃10相同的技术。

抱歉@ Qwerp-Derp！;）我保证这是最后一个了:)

打高尔夫球

{ echo -n 'addsomesalt?';cat; }|expr substr 6BA6A67A69418476151514321 $(expr index 1W0TC4YrKwRGAJupDqn7Xlcog \\`openssl sha256 -binary|base64|cut -c40`) 1| dc -e16i?p #8

数据

请注意，答案＃24的换行符编码为\ n

6 25 { echo -n 'addsomesalt?';cat; }|expr substr 6BA6A67A69418476151514321 $(expr index 1W0TC4YrKwRGAJupDqn7Xlcog \\`openssl sha256 -binary|base64|cut -c40`) 1| dc -e16i?p #8
B 24 typeset -A p\np=("[\$^]*|'\[*" 1 '{*' 2 "' *" 3 '?=>*' 4 'c?[wt]*' 5 'e*' 6 'P*' 7 'f*' 8 'w*' 9 'm*' 10 'ty*' 11)\necho ${p[(k)$1]:-1} #@<`w&X{
A 23 main(c){int d[256]={0};while((c=getchar())!=EOF)d[c]++;printf("%d",d[88]?9:d[119]?5*d[123]:d[35]?d[38]?7:8-d[96]:d[48]?4:d[60]?2:1+d[158]*2);}
6 22 expr substr 6A67A69418476151514321 $(expr index i3xFepQsAalyIvtqPY7ZN+ \\`openssl sha256 -binary|base64|cut -c10`) 1| dc -e16i?p #L
A 21 main(){int K,d[256]{0};while((K=getchar())!=EOF)d[K]++;printf("%d",d[88]?9:d[119]?5*d[123]:d[35]?d[38]?7:8-d[96]:d[48]?4:d[60]?2:1+d[158]*2);}
6 20 expr substr 67A69418476151514321 $(expr index 7042PtgBOlrvfDVC8ZHL `openssl md5 -binary|base64|cut -c2`) 1| dc -e16i?p #u
7 19 Position[ToCharacterCode@StringSplit@";NRU$ Q B [1: =L J, 5% 3 # >",Mod[Length@#,59,33]][[1,1]]&
A 18 main(n){char*v=" ^{ s ePfwm",b[999],*c;gets(b);c=strchr(v,*b);n=strlen(b);printf("%d",n?c?c-v:n>99?4:n>60?5:n>15?1:3:1);}
6 17 expr substr 69418476151514321 $(expr index 2PtgBOlrvfDVC8ZHL `openssl md5 -binary|base64|cut -c2`) 1 #x
9 16 while(<>){print substr("1234151516748149",index("0F=POmS6D4e_XWVH",chr(47+length($_)%70)),1);}
4 15 t=>({24:2,86:3,5:4,73:5,68:5,74:7,4:6,79:4,1:8,67:4})[[...t].reduce((r,c,i)=>r*i^c.charCodeAt(0),0)&0x5F]||1
1 14 '[ ⍳]|}\{|[o@:][^]'c@:]|^c|,\b1|1\d|$
8 13 from hashlib import*;print("1234151516748"["a5e1f936cd78b".index(sha256(input().encode()).hexdigest()[34])])#N
4 12 c=>c?c[0]=='e'?6:c[0]=='$'||c[0]=='^'?1:c[0]=='c'&&c.length>80?4:c[0]=='P'?7:c[0]=='c'?5:c[0]=='{'?2:c[0]=='s'?4:3:1;
7 11 Position[Characters@"^{'sceP",#&@@#][[1,1]]/._@__->1&
6 10 expr substr "1234151516" $(expr index "365f8dc0eb" `md5sum|cut -c12`) 1 #G
1 09 $|}\{|[:'][^]']|,\b1
5 08 c=which(c("","{","'","s","c")==substr(readline(),1,1));ifelse(length(c),c,1)
1 07 ^$|(?![⊂⍴])[⊂-⍴]|\B=|{}|\b5
5 06 cat(switch(substr(readline(),1,1),"{"=2,"'"=3,"s"=4,"c"=5,1))
1 05 ^$|(?![⊂⍴])[⊂-⍴]|\B=|{}
4 04 s=>s?s[0]==`{`?2:s[0]==`s`?4:3:1
3 03 ' {'⍳⊃⍞
2 02 {<>(())(<>)}{}(<>{}())
1 01

测试输出

6=>6
B=>11
A=>10
6=>6
A=>10
6=>6
7=>7
A=>10
6=>6
9=>9
4=>4
1=>1
8=>8
4=>4
7=>7
6=>6
1=>1
5=>5
1=>1
5=>5
1=>1
4=>4
3=>3
2=>2
1=>1
— 齐柏林飞艇
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.