Lâu nay, tôi gặp phải một vấn đề khi đếm trên đầu ngón tay, cụ thể là tôi chỉ có thể đếm đến mười. Giải pháp của tôi cho vấn đề đó là đếm nhị phân trên ngón tay, đưa ngón tay cái lên một, ngón trỏ của tôi cho hai, cả ngón cái và ngón trỏ cho ba, v.v. Tuy nhiên, chúng tôi gặp phải một chút vấn đề khi chúng tôi gặp phải số bốn. Cụ thể, nó yêu cầu chúng tôi đưa ngón tay giữa lên, điều này dẫn đến một cử chỉ khá đáng tiếc, thường không được chấp nhận trong xã hội. Loại số này là một số thô lỗ . Chúng ta đến con số thô lỗ tiếp theo ở tuổi 36, khi chúng ta giơ ngón tay cái lên bàn tay thứ hai và ngón giữa của bàn tay thứ nhất. Định nghĩa về một số thô lỗ là bất kỳ con số đó, theo hệ thống này của đếm, kết quả trong chúng ta đưa lên chỉngón giữa của bất kỳ bàn tay nào. Khi chúng tôi vượt qua 1023 (số lượng tối đa có thể tiếp cận trên một người, với hai bàn tay của năm ngón tay), giả sử chúng tôi tiếp tục với một bàn tay thứ ba, với các bàn tay bổ sung được thêm vào theo yêu cầu.

Nhiệm vụ của bạn:

Viết chương trình hoặc hàm nhận đầu vào và xuất giá trị trung thực / giả dựa trên việc đầu vào có phải là số thô lỗ hay không.

Đầu vào:

Một số nguyên từ 0 đến 10 ⁹ (đã bao gồm).

Đầu ra:

Giá trị trung thực / giả mạo cho biết liệu đầu vào có phải là số thô lỗ hay không.

Các trường hợp thử nghiệm:

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

Ghi điểm:

Đây là môn đánh gôn , vì vậy điểm thấp nhất tính bằng byte sẽ thắng.

APL (dzaima / APL) , 5 byte

4∊32⊤

Hãy thử trực tuyến!

4∊ là 4 thành viên của

32⊤ đến căn cứ-32?

Regex (ECMAScript), 37 byte

Đầu vào là đơn nhất, là độ dài của một chuỗi xs.

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

Hãy thử trực tuyến!

^
(
    (?=(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 byte

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

Hãy thử trực tuyến!

Đây là một giải pháp tầm thường, bạn chỉ muốn chuyển đổi sang cơ sở 32 và kiểm tra xem có 4 trong đó không.

JavaScript (SpiderMonkey) , 26 byte

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

Hãy thử trực tuyến!

Thật thú vị khi /4/.test(...)chi phí nhiều hơn một byte ....match(4).

Japt , 5 byte

sH ø4

Hãy thử trực tuyến!

Giải trình

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

Ruby, 36 19 byte

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

Hãy thử trực tuyến!

Đã lưu 17 byte với phương thức @tsh .

APL + THẮNG, 10 byte

Lời nhắc cho đầu vào của số nguyên

4∊(6⍴32)⊤⎕

Cần chú ý sáu tay để đại diện cho 10 ^ 9 chuyển đổi thành vectơ của 6 phần tử của biểu diễn cơ sở 32 và kiểm tra xem 4 có tồn tại trong bất kỳ phần tử nào không.

Perl 6 , 16 byte

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

Hãy thử trực tuyến!

Kiểm tra nếu có một 4đại diện trong cơ sở 32 của số. Trả về Nil là false hoặc Match chứa a 4.

$2^5 = 32$

Python 2 , 34 32 byte

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

Hãy thử trực tuyến!

2 byte nhờ tsh

Mã máy x86, 17 byte

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

Các byte ở trên xác định hàm lấy số làm đầu vào trong thanh EAXghi và trả về kết quả dưới dạng giá trị Boolean trong thanh EAXghi ( EAX== 0 nếu đầu vào không phải là số thô ; EAX! = 0 nếu đầu vào là số thô ).

Trong bộ nhớ lắp ráp có thể đọc được của con người:

; 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

Hãy thử trực tuyến!

Julia 1.0 , 25 byte

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

Hãy thử trực tuyến!

Julia 1.0 , 26 byte

Thay thế ngắn hơn 1 ký tự, nhưng dài hơn 1 byte, quá tệ, ∈mất 3 byte trong unicode.

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

Hãy thử trực tuyến!

05AB1E , 5 byte

32B4å

Câu trả lời APL (dzaima / APL) của cảng @ Adám .

Hãy thử trực tuyến hoặc xác minh tất cả các trường hợp thử nghiệm .

Giải trình:

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

Catholicon , 4 byte

ǔ?QǑ

Lấy một số là một chuỗi cơ sở 256.

Hãy thử trực tuyến!

Bộ kiểm tra

C # (Trình biên dịch tương tác Visual C #) , 31 byte

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

Đầu ra bằng cách ném một ngoại lệ. Cách bạn chuyển đổi một số từ số thập phân sang cơ sở khác là liên tục chia số thập phân cho cơ sở đó và lấy phần còn lại làm chữ số. Đó là những gì chúng tôi làm và chúng tôi kiểm tra xem có bất kỳ chữ số nào có giá trị 4 trong cơ sở-32 không;

Hãy thử trực tuyến!

J , 12 byte

4 e.32#.inv]

Hãy thử trực tuyến!

R , 50 48 byte

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

Hãy thử trực tuyến!

Sử dụng một cách tiếp cận dựa trên ma trận gọn gàng ngay bây giờ (lịch sự của @Giueseppe). Nó tạo ra một ma trận 5x7 của các bit, chuyển đổi nó thành một chuỗi các số nguyên cơ sở 32 và kiểm tra bất kỳ 4s nào.

Python 3 , 43 byte

Kiểm tra mỗi đoạn 5 bit để xem nó có thô lỗ không (bằng 4).

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

Hãy thử trực tuyến!

C (gcc) , 34 byte

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

Hãy thử trực tuyến!

Than , 6 byte

№⍘Ｎ³²4

Hãy thử trực tuyến! Liên kết là phiên bản dài dòng của mã. Đầu ra -s theo số lượng thô lỗ như thế nào. Giải trình:

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

Tôi sử dụng chuyển đổi cơ sở chuỗi để tránh phải phân tách các chữ số cho 32và 4.

Gọn gàng , 18 byte

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

Hãy thử trực tuyến! Kiểm tra nếu 4là một yếu tố của base(32,x)(chuyển đổi cơ sở).

Haskell , 31 byte

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

Hãy thử trực tuyến!

Khối , 26 byte

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

Hãy thử trực tuyến!

Kết hợp với khối lập phương có chiều dài cạnh 3 như sau

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

Xem nó chạy

Một triển khai khá cơ bản, không có tất cả các chuyển hướng nó thực hiện:

• IS khởi tạo chương trình bằng cách đẩy đầu vào và 32 vào ngăn xếp
• %4-! lấy phần còn lại và kiểm tra nếu nó bằng 4 bằng phép trừ
• 1O@ đầu ra 1 nếu là 4 và tạm dừng
• ;;, dọn dẹp ngăn xếp và chia số nguyên
• p;? dọn sạch đáy ngăn xếp và kiểm tra kết quả div cho 0
• O@ nếu div kết quả đầu ra bằng không và dừng lại
• s hoán đổi đỉnh ngăn xếp và bắt đầu quay lại ở bước 2 ở trên

MATL , 8 byte

32YA52=a

Hãy thử trực tuyến!

Hàng loạt, 77 45 byte

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

Dựa trên những hack hack twiddling . Giải thích: Chỉ cần kiểm tra 6 tay do phạm vi giới hạn (30 bit) của đầu vào cần phải được hỗ trợ. Số ma thuật mtương đương với 111111cơ sở 32, do đó thao tác đầu tiên sẽ bật các bit thô lỗ trong số đầu vào. Sau đó, vẫn còn để tìm thấy trong số 6 tay bây giờ là số không.

mã máy x86, 14 byte

(cùng mã máy hoạt động ở chế độ 16 bit, 32 bit và 64 bit. Ở chế độ 16 bit, nó sử dụng AX và DI thay vì EAX và EDI ở chế độ 32 và 64 bit.)

Thuật toán: kiểm tra 5 bit thấp x & 31 == 4, sau đó dịch chuyển sang phải 5 bit và lặp lại nếu kết quả dịch chuyển khác không.

Có thể gọi từ C char isrude(unsigned n);theo quy ước gọi Hệ thống V x86-64. 0 là sự thật, không phải là 0 là giả (đây là asm, không phải 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

Điều này tận dụng lợi thế của op al, imm8mã hóa dạng ngắn cho AND và SUB. Tôi có thể đã sử dụng XOR al,4để tạo 0 trên đẳng thức, nhưng SUB nhanh hơn vì nó có thể hợp nhất vĩ mô với JZ thành một uop nhánh và nhánh phụ duy nhất trên gia đình Sandybridge.

Thực tế thú vị: sử dụng kết quả cờ của ca làm việc nhiều hơn 1 sẽ chậm đối với gia đình P6 (quầy hàng phía trước cho đến khi ca nghỉ hưu), nhưng điều đó tốt.

Chú thích 1: Đây là chức năng ngôn ngữ lắp ráp và x86 asm có cả hai jzvà jnz, vì vậy theo meta tôi có thể chọn một trong hai cách. Tôi không có ý định này để phù hợp với C thật / giả.

Thật thuận tiện khi quay trở lại trong AL thay vì EFLAGS, vì vậy chúng tôi có thể mô tả chức năng cho trình biên dịch C mà không cần trình bao bọc, nhưng sự lựa chọn của tôi về sự thật / giả dối không bị hạn chế bằng cách sử dụng trình gọi C để kiểm tra nó.

ES6, 31 30 26 byte

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

Hãy nói ý tưởng về cách giảm điều này hơn nữa, nếu có.

Võng mạc 0.8.2 , 31 byte

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

Hãy thử trực tuyến! Liên kết bao gồm các trường hợp thử nghiệm. Đầu ra bằng 0 trừ khi số đó là thô lỗ. Hoạt động bằng cách chuyển đổi đầu vào thành unary và sau đó sang cơ sở 32 được mã hóa đơn và đếm số 4s trong kết quả.

Java 8, 40 33 byte

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

Câu trả lời APL (dzaima / APL) của cảng @ Adám .

Hãy thử trực tuyến.

Giải trình:

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 byte

Đầu ra 4 cho các số thô lỗ ném ngoại lệ cho các số không thô lỗ.

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

Hãy thử trực tuyến!

Ngôn ngữ Wolfram (Mathicala) , 37 byte 36 byte 29 byte

-2 byte bởi Jonathan Frech

#~IntegerDigits~32~MemberQ~4&

Hãy thử trực tuyến!

Giải pháp 31 byte:

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

Hãy thử trực tuyến!

Java 8, 28 22 21 byte

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

Lấy cảm hứng từ câu trả lời của @ kevin-cruijssen . Chỉ hoạt động cho 2 tay.

Hãy thử trực tuyến!

Giải trình:

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