现在有一段时间，我指望手指时一直遇到问题，特别是我只能数到十。我对这个问题的解决方案是用手指数二进制，将拇指放一个，食指放两个，拇指和食指放三个，等等。但是，当我们进入四号。具体而言，它要求我们举起中指，这会导致一个相当不幸的手势，这在社会上通常是不可接受的。这种数字是粗鲁的数字。当我们抬起第二只手的拇指和第一只手的中指时，我们到达下一个粗鲁的数字36。原始数字的定义是在这种计数系统下导致我们仅输入任何手的中指。一旦我们超过了1023（一个人可以达到的最大数目，两只手各五个手指），就假设我们继续第三只手，并根据需要添加其他手。

你的任务：

编写一个程序或函数，该程序或函数接收输入，并根据输入是否为粗鲁的数字输出真/假值。

输入：

0到10 ⁹（含）之间的整数。

输出：

真/假值，指示输入是否为粗鲁的数字。

测试用例：

Input:    Output:
0   --->  falsy
3   --->  falsy
4   --->  truthy
25  --->  falsy
36  --->  truthy
127 --->  falsy
131 --->  truthy

得分：

这是代码高尔夫球，因此以字节为单位的最低分数获胜。

APL（dzaima / APL），5 个字节

4∊32⊤

在线尝试！

4∊ 是4的成员

32⊤ 到基数32？

正则表达式（ECMAScript），37个字节

输入为一元，为xs 字符串的长度。

^((?=(x+)(\2{31}x*))\3)*(x{32})*x{4}$

在线尝试！

^
(
    (?=(x+)(\2{31}x*))    # \2 = floor(tail / 32); \3 = tool to make tail = \2
    \3                    # tail = \2
)*                        # Loop the above as many times as necessary to make
                          # the below match
(x{32})*x{4}$             # Assert that tail % 32 == 4

JavaScript（SpiderMonkey），23字节

f=x=>x&&x%32==4|f(x>>5)

在线尝试！

这是一个简单的解决方案，您只想转换为以32为基数并检查其中是否有4。

JavaScript（SpiderMonkey），26字节

x=>x.toString(32).match(4)

在线尝试！

有趣的是，它/4/.test(...)比花费了一个字节....match(4)。

Japt，5个字节

sH ø4

在线尝试！

说明

      // Implicit input
sH    // To a base-H (=32) string
   ø  // Contains
    4 // 4 (JavaScript interprets this as a string)

Ruby，36个 19字节

->n{n.to_s(32)[?4]}

在线尝试！

使用@tsh的方法节省了17个字节。

APL + WIN，10个字节

提示输入整数

4∊(6⍴32)⊤⎕

注意需要六只手来表示将10 ^ 9转换为基数32表示的6个元素的向量，并检查在任何元素中是否存在4。

Perl 6、16个字节

{.base(32)~~/4/}

在线尝试！

检查数字的4以32为底的表示形式是否存在。返回Nil为false或包含的Match 4。

您可以通过的事实来证明这一点，因此每个数字都是每只手的状态。$2^5 = 32$

Python 2中，34 32个字节

f=lambda a:a%32==4or a>0<f(a/32)

在线尝试！

2字节感谢tsh

x86机器码，17个字节

6A 20 59 85 C0 74 09 99 F7 F9 83 FA 04 75 F4 91 C3

上述字节定义一个函数，它的数量作为输入在EAX寄存器中，并返回结果作为一个布尔值EAX寄存器（EAX== 0，如果输入是不是一个粗鲁数; EAX！= 0，如果该输入是一个粗鲁数）。

在人类可读的汇编助记符中：

; Determines whether the specified number is a "rude" number.
; Input:    The number to check, in EAX
; Output:   The Boolean result, in EAX (non-zero if rude; zero otherwise)
; Clobbers: ECX, EDX
IsRudeNumber:
    push    32           ; \ standard golfing way to enregister a constant value
    pop     ecx          ; /  (in this case: ECX <= 32)
CheckNext:
    test    eax, eax     ; \ if EAX == 0, jump to the end and return EAX (== 0)
    jz      TheEnd       ; /  otherwise, fall through and keep executing
    cdq                  ; zero-out EDX because EAX is unsigned (shorter than XOR)
    idiv    ecx          ; EAX <= (EAX / 32)
                         ; EDX <= (EAX % 32)
    cmp     edx, 4       ; \ if EDX != 4, jump back to the start of the loop
    jne     CheckNext    ; /  otherwise, fall through and keep executing
    xchg    eax, ecx     ; store ECX (== 32, a non-zero value) in EAX
TheEnd:
    ret                  ; return, with result in EAX

在线尝试！

朱莉娅1.0，25个字节

f(n)=n%32==4||n>0<f(n>>5)

在线尝试！

朱莉娅1.0，26字节

替代方案是短1个字符，但长1个字节，太糟糕了，∈以Unicode占用3个字节。

n->'4'∈string(n,base=32)

在线尝试！

05AB1E，5 个字节

32B4å

@Adám的APL（dzaima / APL）答案的端口。

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

说明：

32B    # Convert the (implicit) input to Base-32
   4å  # And check if it contains a 4
       # (output the result implicitly)

天主教徒，4字节

ǔ?QǑ

将数字作为以256为基数的字符串。

在线尝试！

测试套件

C＃（Visual C＃交互式编译器），31字节

n=>{for(;n>0;n/=n%32==4?0:32);}

通过抛出异常输出。将一个数字从十进制转换为另一基数的方法是，将十进制数反复除以该基数，然后将其余部分作为数字。这就是我们的工作，我们检查是否有任何数字在base-32中的值为4；

在线尝试！

J，12个字节

4 e.32#.inv]

在线尝试！

R，50 48字节

any(2^(0:4)%*%matrix(scan()%/%2^(0:34)%%2,5)==4)

在线尝试！

现在使用基于矩阵的整洁方法（由@Giueseppe提供）。它生成一个5x7的位矩阵，将其转换为一系列以32为基数的整数，并检查是否有4s。

Python 3，43个字节

检查每个5位块，看是否粗鲁（等于4）。

lambda n:any(n>>5*i&31==4for i in range(n))

在线尝试！

C（gcc），34个字节

f(i){return i?i&31^4?f(i/32):1:0;}

在线尝试！

木炭，6个字节

№⍘Ｎ³²4

在线尝试！链接是详细版本的代码。-根据数字的粗鲁程度输出s。说明：

  Ｎ     Input as a number
 ⍘      Convert to base as a string
   ³²   Literal 32
№       Count occurrences of
     4  Literal string `4`

我用字符串基转换，以避免必须为分离的数字文字32和4。

整洁，18个字节

{x:4∈base(32,x)}

在线尝试！检查是否4是base(32,x)（基本转换）的元素。

Haskell，31个字节

elem 9.(mapM(:[6..36])[0..5]!!)

在线尝试！

Cubix，26个字节

u!@-W14;OIS%/\;;,p;?wO@u/s

在线尝试！

如下包裹到边长为3的立方体上

      u ! @
      - W 1
      4 ; O
I S % / \ ; ; , p ; ? w
O @ u / s . . . . . . .
. . . . . . . . . . . .
      . . .
      . . .
      . . .

观看它运行

一个相当基本的实现，没有它的所有重定向：

• IS 通过将输入和32压入堆栈来启动程序
• %4-! 获取余数并通过减法检查是否为4
• 1O@ 如果为4则输出1并停止
• ;;, 清理堆栈并进行整数除法
• p;? 清理堆栈底部并检查div结果是否为0
• O@ 如果div结果为零输出并停止
• s 交换堆栈顶部，然后从上面的步骤2重新开始

MATL，8字节

32YA52=a

在线尝试！

批，77 45字节

@cmd/cset/a"m=34636833,n=%1^m*4,(n-m)&~n&m*16

基于这些乱七八糟的骇客。说明：由于需要支持的输入范围有限（30位），因此仅需要检查6手。魔数m等于111111基数32，因此第一个操作会切换输入数字中的粗鲁位。然后剩下的就是找到6张牌中哪张现在为零。

x86机器码，14个字节

（相同的机器码可在16位，32位和64位上工作。在16位模式下，它在32和64位模式下使用AX和DI而不是EAX和EDI。）

算法：使用来检查低5位x & 31 == 4，然后右移5位，如果移位结果为非零，则重复该操作。

可char isrude(unsigned n);根据x86-64 System V调用约定从C 调用。0是真实的，非0是虚假的（这是asm，而不是C ¹）。

 line   addr    code bytes
  num
     1                             ; input:  number in EDI
     2                             ; output: integer result in AL: 0 -> rude, non-zero non-rude
     3                             ; clobbers: RDI
     4                         isrude:
     5                         .check_low_bitgroup:
     6 00000000 89F8               mov    eax, edi
     7 00000002 241F               and    al, 31          ; isolate low 5 bits
     8 00000004 2C04               sub    al, 4           ; like cmp but leaves AL 0 or non-zero
     9 00000006 7405               jz    .rude            ; if (al & 31 == 4) return 0;
    10                         
    11 00000008 C1EF05             shr    edi, 5
    12 0000000B 75F3               jnz   .check_low_bitgroup
    13                             ;; fall through to here is only possible if AL is non-zero
    14                         .rude:
    15 0000000D C3                 ret


    16          0E             size:  db $ - isrude

这利用op al, imm8了AND和SUB 的简短格式编码。我本来可以XOR al,4在等式上产生0，但是SUB更快，因为它可以与JZ宏融合到Sandybridge-family上的单个子分支uop中。

有趣的事实：对于P6系列车来说，将换档的标志结果使用大于1的速度会很慢（前端档位直到换档退休），但这很好。

脚注1：这是一种汇编语言函数，而x86 asm具有jz和jnz，因此根据元数据，我可以选择其中一种方式。我不希望这与C真/假匹配。

可以使用AL而不是EFLAGS方便地返回AL，因此我们可以在不使用包装器的情况下将函数描述为C编译器，但是我对true / falsy的选择不受使用C调用程序进行测试的限制。

ES6，31 30 26个字节

b=>b.toString(32).match`4`

如有任何想法，请随意发表想法。

视网膜0.8.2，31字节

.+
$*
+`(1+)\1{31}
$1;
\b1111\b

在线尝试！链接包括测试用例。除非数字粗鲁，否则输出零。通过将输入转换为一元然后转换为一元编码的基数32并计算4结果中s 的数量来工作。

Java 8，40 33字节

n->n.toString(n,32).contains("4")

@Adám的APL（dzaima / APL）答案的端口。

在线尝试。

说明：

n->                 // Method with Integer parameter and boolean return-type
  n.toString(n,32)  //  Convert the input to a base-32 String
   .contains("4")   //  And check if it contains a "4"

> <>，28个字节

粗鲁数字的输出4引发非粗鲁数字的异常。

:1(?^:" ":\
,&-v?=4:%&/
 ;n<

在线尝试！

Wolfram语言（Mathematica），37字节 36字节 29字节

Jonathan Frech的 -2个字节

#~IntegerDigits~32~MemberQ~4&

在线尝试！

31字节的解决方案：

MemberQ[IntegerDigits[#,32],4]&

在线尝试！

Java 8，28 22 21字节

n->n%32==4|n>>5%32==4

受到@ kevin-cruijssen的回答的启发。仅适用于2手。

在线尝试！

说明：

n->                 // Method with int parameter and boolean return-type
  n%32              // Only consider right 5 bytes (fingers)
  ==4               // Middle finger
  | ... n>>5       // Repeat with shifted bits for other hand