ในขณะนี้ฉันได้พบปัญหาเมื่อนับนิ้วของฉันโดยเฉพาะที่ฉันสามารถนับถึงสิบ วิธีแก้ปัญหาของฉันคือการนับเลขฐานสองบนนิ้วของฉันวางนิ้วหัวแม่มือของฉันหนึ่งนิ้วชี้ของฉันสำหรับสองนิ้วหัวแม่มือและนิ้วชี้สำหรับสาม ฯลฯ อย่างไรก็ตามเราพบปัญหาเล็กน้อยเมื่อเราไป หมายเลขสี่ โดยเฉพาะอย่างยิ่งมันต้องการให้เราวางนิ้วกลางของเราซึ่งส่งผลให้เกิดท่าทางที่ค่อนข้างโชคร้ายซึ่งโดยทั่วไปจะไม่ได้รับการยอมรับในสังคม ประเภทของจำนวนนี้เป็นจำนวนหยาบคาย เรามาถึงหมายเลขหยาบคายต่อไปที่ 36 เมื่อเรายกนิ้วบนมือสองของเราและนิ้วกลางของมือแรกของเรา คำจำกัดความของหมายเลขหยาบคายคือหมายเลขใด ๆ ที่อยู่ภายใต้ระบบการนับนี้จะทำให้เราใส่ได้เท่านั้นนิ้วกลางของมือใด ๆ เมื่อเราผ่าน 1,023 (จำนวนสูงสุดที่สามารถเข้าถึงได้ในหนึ่งคนด้วยสองมือห้านิ้วแต่ละนิ้ว) สมมติว่าเราดำเนินการต่อด้วยมือที่สามด้วยมือที่เพิ่มเข้ามาตามที่ต้องการ

งานของคุณ:

เขียนโปรแกรมหรือฟังก์ชั่นที่ได้รับอินพุทและเอาท์พุทเป็นค่าความจริง / ผิดพลาดขึ้นอยู่กับว่าอินพุตเป็นหมายเลขหยาบ

การป้อนข้อมูล:

จำนวนเต็มตั้งแต่ 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?

Regex (ECMAScript) ขนาด 37 ไบต์

อินพุตมีค่าเป็น unary เนื่องจากความยาวของสตริงxเป็น s

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

ลองออนไลน์!

บันทึก 17 ไบต์ด้วยวิธีการของ@tsh

APL + ชนะ 10 ไบต์

แสดงพร้อมต์สำหรับอินพุตจำนวนเต็ม

4∊(6⍴32)⊤⎕

ต้องใช้การสังเกตหกมือเพื่อแสดง 10 ^ 9 แปลงเป็นเวกเตอร์ขององค์ประกอบ 6 รายการของการแสดงฐาน 32 และตรวจสอบว่ามี 4 องค์ประกอบในองค์ประกอบใด ๆ หรือไม่

Perl 6 , 16 ไบต์

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

ลองออนไลน์!

ตรวจสอบว่ามี4การแสดงหมายเลข 32 ในฐาน ส่งกลับอย่างใดอย่างหนึ่ง Nil 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

ลองออนไลน์!

Julia 1.0 , 25 ไบต์

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

ลองออนไลน์!

Julia 1.0 , 26 ไบต์

ทางเลือกที่สั้นกว่า 1 ตัวอักษร แต่ยาวกว่า 1 ไบต์ไม่ดีเท่าที่∈ใช้เป็น 3 ไบต์ในหน่วย Unicode

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

ลองออนไลน์!

05AB1E , 5 ไบต์

32B4å

ท่าเรือ@ อดัม 's APL (dzaima / APL) คำตอบ

ลองมันออนไลน์หรือตรวจสอบกรณีทดสอบทั้งหมด

คำอธิบาย:

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

Catholicon , 4 ไบต์

ǔ?QǑ

รับตัวเลขเป็นสตริงฐาน 256

ลองออนไลน์!

ชุดทดสอบ

C # (Visual C # Interactive คอมไพเลอร์) , 31 ไบต์

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

ส่งออกโดยการขว้างข้อยกเว้น วิธีที่คุณแปลงตัวเลขหนึ่งตัวจากฐานสิบเป็นฐานอีกฐานหนึ่งก็คือการหารจำนวนทศนิยมด้วยฐานนั้นซ้ำ ๆ และนำส่วนที่เหลือเป็นตัวเลข นั่นคือสิ่งที่เราทำและเราตรวจสอบว่าตัวเลขใดมีค่าเป็น 4 ในฐาน -32 หรือไม่

ลองออนไลน์!

J , 12 ไบต์

4 e.32#.inv]

ลองออนไลน์!

R , 50 48 ไบต์

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

ลองออนไลน์!

ใช้วิธีที่อิงกับเมทริกซ์ที่เรียบร้อยแล้วในตอนนี้ (ความอนุเคราะห์ของ @Gi Portugueseppe) มันสร้างเมทริกซ์ 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`

ฉันใช้การแปลงฐานสตริงเพื่อหลีกเลี่ยงการแยกตัวอักษรตัวเลขสำหรับและ324

เรียบร้อย 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@ เอาท์พุท 1 ถ้ามันเป็น 4 และหยุด
• ;;, ทำความสะอาดสแต็กและแบ่งจำนวนเต็ม
• 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

ขึ้นอยู่กับการแฮ็กสองบิตนี้ คำอธิบาย: ต้องตรวจสอบ 6 มือเท่านั้นเนื่องจากช่วงที่ จำกัด (30 บิต) ของอินพุตที่จำเป็นต้องได้รับการสนับสนุน หมายเลขเวทย์มนตร์mนั้นเทียบเท่ากับ111111ในฐาน 32 เพื่อให้การดำเนินการครั้งแรกสลับบิตหยาบคายในหมายเลขอินพุต จากนั้นยังคงพบว่ามือใดใน 6 มือที่เป็นศูนย์

รหัสเครื่อง x86, 14 ไบต์

(รหัสเครื่องเดียวกันทำงานใน 16 บิต, 32 บิตและ 64 บิตในโหมด 16 บิตจะใช้ AX และ DI แทน EAX และ EDI ในโหมด 32 และ 64 บิต)

อัลกอริทึม: ตรวจสอบ 5 บิตต่ำด้วย x & 31 == 4จากนั้นเลื่อนขวา 5 บิทและทำซ้ำหากผลการเลื่อนไม่ใช่ศูนย์

เรียกได้จาก C char isrude(unsigned n);ตามการเรียกระบบ x86-64 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 ให้เป็น sub-and-branch uop บน Sandybridge-family

ความจริงแล้วสนุก: การใช้แฟล็ก - ผลลัพธ์ของการเลื่อนมากกว่า 1 จะช้าในตระกูล P6 (แผงด้านหน้าจนกว่าการเปลี่ยนจะหยุด) แต่ก็ไม่เป็นไร

เชิงอรรถ 1: นี่คือฟังก์ชั่นภาษาแอสเซมบลีและ x86 asm มีทั้งjzและjnzดังนั้นตามเมตาที่ฉันสามารถเลือกได้ทั้งสองวิธี ฉันไม่ได้ตั้งใจที่จะจับคู่ C ความจริง / เท็จ

มันสะดวกที่จะกลับมาเป็น AL แทนที่จะเป็น EFLAGS ดังนั้นเราสามารถอธิบายฟังก์ชั่นนี้ให้กับคอมไพเลอร์ C โดยไม่มีเสื้อคลุม แต่ตัวเลือกความจริง / ความเท็จของฉันไม่ได้ถูก จำกัด โดยการใช้

ES6, 31 30 26 ไบต์

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

อย่าลังเลที่จะพูดแนวคิดเกี่ยวกับวิธีลดสิ่งนี้เพิ่มเติมหากมี

เรติน่า 0.8.2 , 31 ไบต์

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

ลองออนไลน์! ลิงค์มีกรณีทดสอบ เอาต์พุตเป็นศูนย์ยกเว้นว่าตัวเลขนั้นหยาบ ทำงานโดยแปลงอินพุตเป็นเอกฐานแล้วแปลงเป็นเบสแบบเข้ารหัส 32 และนับจำนวน4s ในผลลัพธ์

Java 8, 40 33 ไบต์

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

ท่าเรือ@ อดัม 's 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 ไบต์

-2 bytes โดยJonathan Frech

#~IntegerDigits~32~MemberQ~4&

ลองออนไลน์!

วิธีแก้ปัญหา 31 ไบต์:

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

ลองออนไลน์!

Java 8, 28 22 21 ไบต์

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

แรงบันดาลใจจาก@ kevin-cruijssenคำตอบ 's ใช้งานได้สำหรับ 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