官方Ruby检查器

30

这是一个简单的ASCII艺术红宝石：

  ___
 /\_/\
/_/ \_\
\ \_/ /
 \/_\/

作为ASCII宝石公司的珠宝商，您的工作是检查新近获得的红宝石，并留下任何发现的缺陷的注释。

幸运的是，只有12种类型的缺陷是可能的，并且您的供应商保证没有任何一种红宝石会存在多个缺陷。

12个缺陷对应于更换12内中的一个的_，/或\红宝石的字符与一个空格字符（）。红宝石的外围永远不会有缺陷。

缺陷根据内部字符在其位置留有空格的方式编号：

缺陷编号

因此，缺陷为1的红宝石如下所示：

  ___
 /\_/\
/_/  _\
\ \_/ /
 \/_\/

缺陷为11的红宝石如下所示：

  ___
 /\_/\
/_/ \_\
\ \_/ /
 \ _\/

其他所有缺陷也是相同的想法。

挑战

编写一个程序或函数，该程序或函数采用单个可能有缺陷的红宝石的字符串。缺陷编号应打印或退回。如果没有缺陷，则缺陷编号为0。

从文本文件，stdin或字符串函数参数获取输入。返回缺陷编号或将其打印到标准输出。

您可以假设红宝石带有尾随换行符。您可能不会假定它有任何空格或前导换行符。

以字节为单位的最短代码获胜。（方便的字节计数器。）

测试用例

13种准确的红宝石类型，紧随其后的是预期产量：

  ___
 /\_/\
/_/ \_\
\ \_/ /
 \/_\/
0
  ___
 /\_/\
/_/  _\
\ \_/ /
 \/_\/
1
  ___
 /\ /\
/_/ \_\
\ \_/ /
 \/_\/
2
  ___
 /\_/\
/_  \_\
\ \_/ /
 \/_\/
3
  ___
 /\_/\
/_/ \_\
\  _/ /
 \/_\/
4
  ___
 /\_/\
/_/ \_\
\ \ / /
 \/_\/
5
  ___
 /\_/\
/_/ \_\
\ \_  /
 \/_\/
6
  ___
 /\_/\
/_/ \ \
\ \_/ /
 \/_\/
7
  ___
 /\_ \
/_/ \_\
\ \_/ /
 \/_\/
8
  ___
 / _/\
/_/ \_\
\ \_/ /
 \/_\/
9
  ___
 /\_/\
/ / \_\
\ \_/ /
 \/_\/
10
  ___
 /\_/\
/_/ \_\
\ \_/ /
 \ _\/
11
  ___
 /\_/\
/_/ \_\
\ \_/ /
 \/_ /
12
code-golf  ascii-art  kolmogorov-complexity 
— 卡尔文的爱好
source
为了澄清，红宝石不能有任何尾随空格，对吗？
— Optimizer
@Optimizer正确
— 加尔文的爱好
@ Calvin'sHobbies愿我们也假设输入也不会有换行符？
— orlp 2015年
@orlp是的。这是整点5。
— 加尔文的爱好2015年
红宝石是对称的。因此，例如错误7与错误10不应相同吗？
— DavidC

Answers:

13

CJam，27 23字节

F7EC5ZV4DI8G6]qBb67%J%#

转换基数11，取模67，取结果的模19，然后找到数组中的索引

[15, 7, 14, 12, 5, 3, 0, 4, 13, 18, 8, 16, 6]

魔法！

在线尝试。

— Sp3000
source
34

Ruby 2.0，69个字节

#!ruby -Kn0rdigest
p'×ñF<ìX‚ɲŸ_'.index Digest::MD5.digest(gets)[0]

十六进制转储（忠实地显示字符串中的二进制数据）：

00000000  23 21 72 75 62 79 20 2d  4b 6e 30 72 64 69 67 65  |#!ruby -Kn0rdige|
00000010  73 74 0a 70 27 d7 f1 46  3c 1f ec 58 82 c9 b2 9f  |st.p'..F<..X....|
00000020  5f 02 27 2e 69 6e 64 65  78 20 44 69 67 65 73 74  |_.'.index Digest|
00000030  3a 3a 4d 44 35 2e 64 69  67 65 73 74 28 67 65 74  |::MD5.digest(get|
00000040  73 29 5b 30 5d                                    |s)[0]|

说明：

  1. 该-Kn选项将源文件读取为ASCII-8BIT（二进制）。
  2. 该-0选项允许gets读取整个输入（而不仅仅是一行）。
  3. 该-rdigest选项将加载digest模块，该模块提供Digest::MD5。
  4. 然后，代码对输入进行MD5处理，获取摘要的第一个字节，并在给定的二进制字符串中获取其索引。
— 克里斯·杰斯特·杨
source
幸运的是，MD5在第一个字符本身上是独一无二的
— Optimizer
15
不需要运气。每个字节有256种可能性，因此第一个字节在13个哈希值之间并不相同。但是，如果它们由于任何原因发生冲突，我只会使用哈希的第二个字节。
— 克里斯·杰斯特·杨
14
用Ruby编写Ruby检查器。自然！
— 2015年
下一个挑战：检查此帖子本身
— Redwolf Programs
7

朱莉娅 90 59个字节

绝对不是最短的，但是淑女茱莉亚在检查皇家红宝石时会格外小心。

s->search(s[vec([18 10 16 24 25 26 19 11 9 15 32 34])],' ')

这将创建一个lambda函数，该函数接受字符串s并返回相应的红宝石缺陷编号。要给它起个名字，例如f=s->...。

取消+说明：

function f(s)
    # Strings can be indexed like arrays, so we can define d to
    # be a vector of indices corresponding to potential defect
    # locations

    d = vec([18 10 16 24 25 26 19 11 9 15 32 34])

    # Check the specified locations for defects, returning the
    # defect number as the index where a space was found and
    # was not expected. If no spaces are found, 0 is returned.

    search(s[d], ' ')
end

例子：

julia> f("  ___
 /\\ /\\
/_/ \\_\\
\\ \\_/ \/
 \\/_\\/")
2

julia> f("  ___
 /\\_/\\
/_/ \\_\\
\\ \\_/ \/
 \\/_\\/")
0

注意，反斜杠必须在输入中转义。我通过@ Calvin'sHobbies确认没关系。

如果您有任何问题或建议，请告诉我！

编辑：在Andrew Piliser的帮助下保存了31个字节！

— 亚历克斯·A
source
您可以使用search和数组索引来摆脱for循环。s->(d=reshape([18 10 16 24 25 26 19 11 9 15 32 34],12);search(s[d],' '))。我不喜欢重塑，但我想不出一种更简单的方法来获得一维数组。
— 安德鲁说，请
@AndrewPiliser：谢谢，非常感谢您的投入！我编辑使用了您的建议。另外，比reshape()使用的方法更短vec()。:)
— Alex A.
7

> <>（鱼），177字节

这是一个漫长而独特的解决方案。该程序除了将输入字符插入代码中的固定位置外，不包含任何算术运算或分支运算。

注意，所有检查过的红宝石构建字符（/ \ _）在> <>代码中都可以是“镜像”，它们会更改指令指针（IP）的方向。

我们可以使用这些输入字符通过代码修改指令p在它们之间构建一个迷宫，并且在每个出口（由输入中缺少的镜像创建的出口）处，我们都可以打印相应的数字。

iiiiiiiii19pi1cpi18piiii2bpi27pii28pi3apiiiii37pi49pi36piiiii00pi45pii46p

    ;
   ;n
  ;nb
 ;n6S    0n;
 n3SB   cn;
 8SB!  4n;
 SB!  1n;
>B! U9n;
 ! U5
  U7n
 Uan;
 2n;
 n;
 ;

S B U字母是/ \ _分别更改为的字母。如果输入是完整的红宝石，则最终代码为：

\iiiiiiii19pi1cpi18piiii2bpi27pii28pi3apiiiii37pi49pi36piiiii00pi45pii46p

    ;
   ;n
  ;nb
 ;n6/    0n;
 n3/\   cn;
 8/\!  4n;
 /\!  1n;
>\! _9n;
 ! _5
  _7n
 _an;
 2n;
 n;
 ;

您可以使用此出色的在线视觉解释器尝试该程序。由于您无法在其中输入换行符，因此必须使用一些虚拟字符，以便输入完整的红宝石，例如SS___LS/\_/\L/_/S\_\L\S\_/S/LS\/_\/。（由于降价，空格也更改为S。）

— Randomra
source
5

CJam，41 31 29 28字节

"-RI)11a!"q103b1e3%A/c#

像往常一样，对于不可打印的字符，请点击此链接。

在这里在线尝试

即将解释

以前的方法：

可以肯定的是，可以通过更改数字/转换逻辑来减少这种情况。但是这里是第一次尝试：

"<KJ[]\"O=":iqN-"/\\_ "4,er4b1e3%A/#

像往常一样，将此链接用于不可打印的字符。

逻辑很简单

  • "Hash for each defect":i -这使我得到每个缺陷的哈希值作为索引
  • qN-"/\\_ "4,er -这会将字符转换为数字
  • 4b1e3%A/ -这是基本转换号码中的唯一号码
  • # 然后我只需在哈希中找到唯一编号的索引

在这里在线尝试

— 优化器
source
如此接近，我比您短1个字符！
— orlp 2015年
哦，我已经28岁了。太忙了，无法更新
— Optimizer
我认为我的答案最适合Pyth。Pyth确实需要一个哈希函数（.h现在是无用的，因为它使用了内置的unreliable和bad hash()），直到那时我都做不到。
— orlp 2015年
4

滑，123 108 + 3 = 111个字节

^6 (`\\`_.?<?.?[ _]?|`_(`\.?(<.?|>)|`/.?.?>.?.?).?)| `_(`\.?<.?>?.?.?|`/(.?>.?.?.?|<`_))| `/\`_.?(.<.?>?.?)?

用n和o标志运行，即

py -3 slip.py regex.txt input.txt no

或者，在线尝试。

Slip是一种类似于regex的语言，是2D模式匹配挑战的一部分。Slip可以p通过以下程序使用位置标记检测缺陷的位置：

^6? `_[/\]|( `/|^6 `\)\`_

查找以下模式之一（此处S表示此处开始比赛）：

S_/    S_\    /_S    \_S    S/      _
                              _      \S

在线尝试 -坐标以（x，y）对形式输出。一切看起来像普通的正则表达式，除了：

  • ` 用于逃避，
  • <> 分别向左/向右转动比赛指针，
  • ^6 将匹配指针设置为朝左，
  • \ 将匹配指针正交向右滑动（例如，如果指针朝右，则它向下一行）

但不幸的是，我们需要的是从0到12的说法单数，其被检测到的缺陷，而不是在那里它被检测到。Slip只有一种输出单个数字的方法，n即输出找到的匹配数的标志。

因此，要做到这一点，我们将在o重叠匹配模式的帮助下，扩展上述正则表达式以匹配每个缺陷的正确次数。细分为以下组件：

1 11:    `_`\.?<.?>?.?.?
2 10:    `/\`_.?(.<.?>?.?)?
4 9:     `_`/(.?>.?.?.?|<`_)
3 12:   ^6 `_`/.?.?>.?.?.?
5 7:    ^6 `\\`_.?<?.?[ _]?
6 8:    ^6 `_`\.?(<.?|>).?

是的，这是过度使用?以使数字正确的：P

— Sp3000
source
哈哈，太神奇了。我需要为我的语言添加更多类型的输出。
— BMac
4

JavaScript（ES6），67 72

只需在给定的12个位置中查找空白

编辑保存的5个字节，thx @apsillers

F=b=>[..."0h9fnopia8evx"].map((v,i)=>b[parseInt(v,34)]>' '?0:d=i)|d

在Firefox / FireBug控制台中测试

x='  ___\n /\\_/\\\n/_/ \\_\\\n\\ \\_/ /\n \\/_\\/' // no defects
;[...x].forEach((c,p,a)=>{
  a[p]=' ' // put a blank
  y=a.join('') // rebuild a string
  d=F(y) // check
  if (d) console.log('\n'+y+'\n'+d) // if defect, output
  a[p]=c // remove the blamk
})

输出量

  ___
 / _/\
/_/ \_\
\ \_/ /
 \/_\/
9

  ___
 /\ /\
/_/ \_\
\ \_/ /
 \/_\/
2

  ___
 /\_ \
/_/ \_\
\ \_/ /
 \/_\/
8

  ___
 /\_/\
/ / \_\
\ \_/ /
 \/_\/
10

  ___
 /\_/\
/_  \_\
\ \_/ /
 \/_\/
3

  ___
 /\_/\
/_/  _\
\ \_/ /
 \/_\/
1

  ___
 /\_/\
/_/ \ \
\ \_/ /
 \/_\/
7

  ___
 /\_/\
/_/ \_\
\  _/ /
 \/_\/
4

  ___
 /\_/\
/_/ \_\
\ \ / /
 \/_\/
5

  ___
 /\_/\
/_/ \_\
\ \_  /
 \/_\/
6

  ___
 /\_/\
/_/ \_\
\ \_/ /
 \ _\/
11

  ___
 /\_/\
/_/ \_\
\ \_/ /
 \/_ /
12
— edc65
source
@apsillers很好，甚至更好，谢谢。由于输入字符串始终以''开头，因此前导0会在第一个循环中强制将d初始化为i，因此可以删除'd = 0'。
— edc65
2

C，98 84字节

g(char*b){char*c="/'-5670(&,=?",*a=c;for(;*c&&!(*b=b[*c++-30]-32?0:c-a););return*b;}

更新：对该字符串稍加巧妙，并修复了未变形红宝石的问题。

拆解：

g(char*b){
    char*c="/'-5670(&,=?",*a=c;
    for(;*c&&!(*b=b[*c++-30]-32?0:c-a);)
        ;
    return*b;
}

非常简单，并且只在100个字节。

供测试用：

#include "stdio.h"
int main() {
    char b[100];
    scanf("%35c", b);
    printf("%d\n", g(b));
    return 0;
}

输入到STDIN。

怎么运行的

红宝石中的每个缺陷都位于不同的字符处。此列表显示了每个缺陷在输入字符串中出现的位置：

Defect 1: 17
Defect 2: 9
Defect 3: 15
Defect 4: 23
Defect 5: 24
Defect 6: 25
Defect 7: 18
Defect 8: 10
Defect 9: 8
Defect 10: 14
Defect 11: 31
Defect 12: 33

由于制作一个数组需要{17,9,15,23,24,25,18,10,8,14,31,33}花费很多字节，因此我们找到了一种创建此列表的较短方法。请注意，将每个数字加30会得到一个整数列表，这些整数可以表示为可打印的ASCII字符。此列表如下："/'-5670(&,=?"。因此，我们可以c为此字符串设置一个字符数组（在代码中），并从该列表中检索的每个值中减去30，即可得到原始的整数数组。我们将其定义a为等于，c以跟踪沿着列表获得的距离。代码中唯一剩下的就是for循环。它检查以确保我们还没有结束c，然后检查b当前字符c是否为空格（ASCII 32）。如果是，我们设置第一个未使用的元素b 到缺陷编号并返回。

— 脑钢
source
2

Python 2，146 88 86 71字节

该函数f测试每个段的位置并返回缺陷段的索引。对输入字符串的第一个字节进行测试可确保0在未发现任何缺陷的情况下返回。

现在，我们将段偏移量打包成一个紧凑的字符串，并用于ord()恢复它们：

f=lambda s:sum(n*(s[ord('ARJPXYZSKIO`b'[n])-65]<'!')for n in range(13))

用完美的红宝石进行测试：

f('  ___\n /\\_/\\\n/_/ \\_\\\n\\ \\_/ /\n \\/_\\/')
0

使用段2代替空格进行测试：

f('  ___\n /\\ /\\\n/_/ \\_\\\n\\ \\_/ /\n \\/_\\/')
2

编辑：感谢@xnor的好sum(n*bool for n in...)技术。

EDIT2：感谢@ Sp3000提供更多高尔夫技巧。

— 逻辑骑士
source
2
我认为您可以使用indicator-sum节省字符sum(n*(s[...]==' ')for ...)。
— xnor 2015年
1
考虑到替换的字符全都是空格，因此您可以执行类似的操作，<'!'而不用写==' '一个字节。您也可以使用生成列表map(ord, ...)，但是我不确定您对无法打印的商品的感觉:)
— Sp3000 2015年
1

Pyth，35 31 28字节

hx"*6#,54@"C%imCds.zT67

需要修补的Pyth，当前最新版本的Pyth具有一个错误，.z该错误会删除尾随字符。

该版本不使用哈希函数，而是滥用Pyth中的基本转换函数来计算非常愚蠢但有效的哈希。然后，我们将该哈希值转换为字符，然后在字符串中查找其索引。

答案包含无法打印的字符，请使用以下Python3代码在您的计算机上准确生成程序：

garbage = [42, 22, 54, 35, 44, 28, 31, 53, 52, 64, 16, 11]
prg = 'hx"' + "".join(chr(c) for c in garbage) +'"C%imCds.zT67'
open("golf_gen.pyth", "w").write(prg)
print(len(prg))
— 奥尔普
source
1

Haskell，73个字节

f l=last[x|x<-[0..12],l!!([0,17,9,15,23,24,25,18,10,8,14,31,33]!!x)==' ']

与许多其他解决方案相同的策略：在给定位置寻找空间。查找返回一个索引列表，我从中获取最后一个元素，因为总会命中索引0。

— 妮米
source
0

05AB1E，16 个字节

•W)Ì3ô;4(•₆вèðk>

在线尝试或验证所有测试用例。

说明：

•W)Ì3ô;4(•        # Push compressed integer 2272064612422082397
          ₆в      # Converted to Base-36 as list: [17,9,15,23,24,25,18,10,8,14,31,33]
            è     # Index each into the (implicit) input-string
             ðk   # Get the 0-based index of the first space in the indexed characters
                  # (-1 if not found, which means the ruby had no defects)
               >  # And increase it by 1 (which is output implicitly as result)

请参阅我的05AB1E技巧（如何压缩大整数？和如何压缩整数列表？）以了解为什么•W)Ì3ô;4(•is 2272064612422082397和•W)Ì3ô;4(•₆вis [17,9,15,23,24,25,18,10,8,14,31,33]。

— 凯文·克鲁伊森
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.