ฟังก์ชั่นนี้จะนำปัจจัยสี่จำนวนเต็ม ( a, b, c, d) และกลับคำไบนารีขึ้นอยู่กับค่าเท่ากับสูงสุดของสี่

ค่าตอบแทนจะอยู่ระหว่างและ10xF

ตัวอย่างเช่น:

a = 6, b = 77, c = 1, d = 4

คืนค่า2(ไบนารี0010; มีการตั้งค่าบิตที่มีนัยสำคัญน้อยที่สุดเป็นอันดับที่สองที่สอดคล้องกับbค่าสูงสุดเพียงอย่างเดียว)

a = 4, b = 5, c = 10, d = 10

คืนค่า0xC(ไบนารี1100; บิตที่มีนัยสำคัญน้อยที่สุดที่ 3 และ 4 ตั้งค่าให้สอดคล้องcและdเท่ากับค่าสูงสุด)

a = 1, b = 1, c = 1, d = 1

ส่งกลับ0xF(ไบนารี1111; ทั้งสี่บิตตั้งค่าเพราะค่าทั้งหมดเท่ากับสูงสุด)

นี่คือการดำเนินการที่เรียบง่าย:

int getWord(int a, int b, int c, int d)
{
    int max = a;
    int word = 1;
    if (b > max)
    {
        max = b;
        word = 2;
    }
    else if (b == max)
    {
        word |= 2;
    }
    if (c > max)
    {
        max = c;
        word = 4;
    }
    else if (c == max)
    {
        word |= 4;
    }
    if (d > max)
    {
        word = 8;
    }
    else if (d == max)
    {
        word |= 8;
    }
    return word;
}

ค่าส่งคืนสามารถเป็นสตริงของ 0 และ 1 ของเวกเตอร์บูล / บิตหรือจำนวนเต็ม

เยลลี่ 2 ไบต์

[d,c,b,a]จะเข้าเป็น ส่งคืนรายการ Booleans

Ṁ=

ลองออนไลน์!

Ṁ M aximum

= เท่ากับ (หมายถึงอาร์กิวเมนต์อื่นคืออาร์กิวเมนต์ดั้งเดิม; vectorises)

R , 17 ไบต์

max(a<-scan())==a

ลองออนไลน์!

ส่งคืนเวกเตอร์ของ booleans เนื่องจากเอาต์พุตนี้ได้รับการยืนยันจึงเป็นสิ่งที่ดีกว่าเอาท์พุทตัวเลขเนื่องจากจะมีความยาวมากกว่าสองเท่า:

R , 33 ไบต์

sum(2^which(max(a<-scan())==a)/2)

ลองออนไลน์!

APL (Dyalog Unicode) , 4 ไบต์^SBCS

ฟังก์ชันนำหน้าเงียบโดยไม่ระบุชื่อ ใช้[a,b,c,d]เป็นอาร์กิวเมนต์ ส่งกลับอาร์เรย์แบบบูลบูลีน *

⌈/=⌽

ลองออนไลน์!

⌈/ ทำข้อโต้แย้งได้สูงสุด

= เท่ากัน (vectorises)

⌽ ย้อนกลับของการโต้แย้งหรือไม่

* โปรดทราบว่า APL เก็บอาร์เรย์ของบูลีนโดยใช้หนึ่งบิตต่อหนึ่งค่าดังนั้นนี่จะส่งคืนคำที่ 4 บิตแม้ว่าจะเป็นรูปแบบการแสดงผล0 0 1 0ก็ตาม

Haskell , 20 18 ไบต์

บันทึก 2 ไบต์ขอบคุณhaskeller ที่ภาคภูมิใจ

map=<<(==).maximum

ลองออนไลน์!

Perl 6 , 12 ไบต์

{$_ X==.max}

ลองออนไลน์!

บล็อกโค้ดแบบไม่ระบุชื่อที่รับรายการจำนวนเต็มและส่งคืนรายการบูลีน ถ้าเราต้องการที่จะกลับมาเป็นตัวเลขก็ 4 2:[...]ไบต์ห่อภายในของการป้องกันรหัสด้วย

คำอธิบาย:

{          }  # Anonymous code block
 $_           # With the input
    X==       # Which values are equal
       .max   # To the maximum element

Japt, 5

m¶Urw

ลองมัน!

-4 ไบต์ขอบคุณ @Oliver!
-2 ไบต์ขอบคุณ @Shaggy!

อินพุตเป็นอาร์เรย์ 4 องค์ประกอบในรูปแบบต่อไปนี้:

[d, c, b, a]

เอาต์พุตเป็นอาร์เรย์ของบิต

รหัสเครื่อง x86 (MMX / SSE1), 26 ไบต์ (4x int16_t)

รหัสเครื่อง x86 (SSE4.1), 28 ไบต์ (4x int32_t หรือ uint32_t)

รหัสเครื่อง x86 (SSE2), 24 ไบต์ (4x float32) หรือ 27B ถึง cvt int32

(เวอร์ชันล่าสุดที่แปลง int32 เป็น float ไม่ถูกต้องสมบูรณ์สำหรับจำนวนเต็มขนาดใหญ่ที่ปัดเป็น float เดียวกันด้วยอินพุตลอยการปัดเศษเป็นปัญหาของผู้โทรและฟังก์ชันนี้ทำงานอย่างถูกต้องหากไม่มี NaNs ระบุลอยที่เปรียบเทียบ == ถึงจำนวนสูงสุดรุ่นจำนวนเต็มใช้งานได้กับอินพุตทั้งหมดโดยถือว่าเป็นส่วนเติมเต็มของ 2 ที่ได้รับการรับรอง)

ทั้งหมดนี้ทำงานในโหมด 16/32/64 บิตพร้อมกับรหัสเครื่องเดียวกัน

รูปแบบการเรียก stack-args จะทำให้สามารถวนรอบ args สองครั้ง (การหาค่าสูงสุดและการเปรียบเทียบ) อาจทำให้เรามีการใช้งานที่น้อยลง แต่ฉันไม่ได้ลองวิธีนั้น

x86 SIMD มี vector-> bitmap จำนวนเต็มเป็นคำสั่งเดียว ( pmovmskbหรือmovmskpsหรือ pd) ดังนั้นจึงเป็นเรื่องธรรมดาสำหรับเรื่องนี้แม้ว่าคำสั่ง MMX / SSE จะมีความยาวอย่างน้อย 3 ไบต์ SSSE3 และคำแนะนำในภายหลังนั้นยาวกว่า SSE2 และคำสั่ง MMX / SSE1 นั้นสั้นที่สุด รุ่นที่แตกต่างกันของpmax*(maxed vertical-integer ในแนวตั้งเต็มจำนวน) ถูกนำมาใช้ในเวลาที่ต่างกันด้วย SSE1 (สำหรับ mmx regs) และ SSE2 (สำหรับ xmm regs) มีเพียงคำที่ลงนาม (16 บิต) และไบต์ที่ไม่ได้ลงนาม

( pshufwและpmaxswในการลงทะเบียน MMX นั้นใหม่กับ Katmai Pentium III ดังนั้นจริงๆแล้วพวกเขาต้องการ SSE1 ไม่ใช่บิตของ CPU MMX เท่านั้น)

นี่คือ callable จาก C รวมunsigned max4_mmx(__m64)กับ i386 ระบบวี ABI ซึ่งผ่านหาเรื่องใน__m64 mm0(ไม่ x86-64 System V ซึ่งผ่าน__m64ในxmm0!)

   line         code bytes
    num  addr   
     1                         global max4_mmx
     2                             ;; Input 4x int16_t in mm0
     3                             ;; output: bitmap in EAX
     4                             ;; clobbers: mm1, mm2
     5                         max4_mmx:
     6 00000000 0F70C8B1           pshufw    mm1, mm0, 0b10110001   ; swap adjacent pairs
     7 00000004 0FEEC8             pmaxsw    mm1, mm0
     8                         
     9 00000007 0F70D14E           pshufw    mm2, mm1, 0b01001110   ; swap high/low halves
    10 0000000B 0FEECA             pmaxsw    mm1, mm2
    11                         
    12 0000000E 0F75C8             pcmpeqw   mm1, mm0               ; 0 / -1
    13 00000011 0F63C9             packsswb  mm1, mm1               ; squish word elements to bytes, preserving sign bit
    14                         
    15 00000014 0FD7C1             pmovmskb  eax, mm1          ; extract the high bit of each byte
    16 00000017 240F               and       al, 0x0F          ; zero out the 2nd copy of the bitmap in the high nibble
    17 00000019 C3                 ret

size = 0x1A = 26 bytes

หากมี a pmovmskwสิ่งที่จะบันทึกpacksswbและand(3 + 2 ไบต์) เราไม่ต้องการand eax, 0x0fเพราะpmovmskbในการลงทะเบียน MMX แล้วจำนวนศูนย์บนไบต์ การลงทะเบียน MMX มีความกว้างเพียง 8 ไบต์ดังนั้น 8-bit AL จะครอบคลุมบิตที่ไม่เป็นศูนย์ทั้งหมด

หากเรารู้ว่าอินพุตของเราไม่เป็นลบเราสามารถpacksswb mm1, mm0สร้างไบต์ที่เซ็นชื่อแบบไม่ลบใน 4 ไบต์บนของmm1โดยหลีกเลี่ยงความต้องการandหลังจากpmovmskbนั้น ดังนั้น 24 ไบต์

x86 แพ็คที่มีความอิ่มตัวที่ลงนามแล้วจะถือว่าอินพุตและเอาต์พุตเป็นสัญญาณดังนั้นมันจึงสงวนบิตของสัญญาณไว้เสมอ ( https://www.felixcloutier.com/x86/packsswb:packssdw ) ข้อเท็จจริงที่น่าสนุก: x86 แพ็คที่มีความอิ่มตัวที่ไม่ได้ลงชื่อยังคงถือว่าอินพุตเป็นสัญญาณ นี่อาจเป็นสาเหตุที่PACKUSDWยังไม่ถูกนำมาใช้จนกระทั่ง SSE4.1 ในขณะที่มีการรวมกันของขนาดและการเซ็นชื่ออีก 3 รายการตั้งแต่ MMX / SSE2

หรือด้วยจำนวนเต็ม 32 บิตในการลงทะเบียน XMM (และpshufdแทนpshufw) คำสั่งทุกคำสั่งจะต้องมีไบต์นำหน้าเพิ่มอีกหนึ่งตัวยกเว้นการmovmskpsแทนที่แพ็ค / และ แต่pmaxsd/pmaxudต้องเพิ่มไบต์พิเศษ ...

callable จาก C รวมunsigned max4_sse4(__m128i);กับ x86-64 System V หรือ MSVC vectorcall ( -Gv) ซึ่งทั้งสองผ่าน__m128i/ __m128d/ __m128args ใน XMM regs xmm0เริ่มต้นด้วย

    20                         global max4_sse4
    21                             ;; Input 4x int32_t in xmm0
    22                             ;; output: bitmap in EAX
    23                             ;; clobbers: xmm1, xmm2
    24                         max4_sse4:
    25 00000020 660F70C8B1         pshufd    xmm1, xmm0, 0b10110001   ; swap adjacent pairs
    26 00000025 660F383DC8         pmaxsd    xmm1, xmm0
    27                         
    28 0000002A 660F70D14E         pshufd    xmm2, xmm1, 0b01001110   ; swap high/low halves
    29 0000002F 660F383DCA         pmaxsd    xmm1, xmm2
    30                         
    31 00000034 660F76C8           pcmpeqd   xmm1, xmm0               ; 0 / -1
    32                         
    33 00000038 0F50C1             movmskps  eax, xmm1          ; extract the high bit of each dword
    34 0000003B C3                 ret

size = 0x3C - 0x20 = 28 bytes

หรือถ้าเรายอมรับอินพุตเป็นfloatเราสามารถใช้คำแนะนำ SSE1 floatรูปแบบสามารถเป็นตัวแทนของความหลากหลายของค่าจำนวนเต็ม ...

หรือถ้าคุณคิดว่ามันก้มกฏมากเกินไปเริ่มต้นด้วย 3-byte 0F 5B C0 cvtdq2ps xmm0, xmm0เพื่อทำการแปลงทำให้ฟังก์ชั่น 27- ไบต์ที่ทำงานกับจำนวนเต็มทั้งหมดที่สามารถแทนได้อย่างแน่นอนเช่น IEEE binary32floatและชุดอินพุตจำนวนมากที่อินพุตบางตัวได้รับ ปัดเศษเป็นทวีคูณของ 2, 4, 8 หรืออะไรก็ตามในระหว่างการแปลง (ดังนั้นมันจึงเล็กกว่ารุ่น SSE4.1 1 ไบต์และใช้งานได้กับ x86-64 ใด ๆ ด้วย SSE2 เท่านั้น)

ถ้าใด ๆ ของปัจจัยการผลิตที่ลอยอยู่น่านทราบว่าmaxps a,bว่าการดำเนินการ(a<b) ? a : b, การรักษาองค์ประกอบจากตัวถูกดำเนินการครั้งที่ 2 เรียงลำดับ ดังนั้นจึงอาจเป็นไปได้ที่สิ่งนี้จะกลับมาพร้อมกับบิตแมปที่ไม่เป็นศูนย์แม้ว่าอินพุตจะมี NaN บางตัวขึ้นอยู่กับว่าพวกเขาอยู่ที่ไหน

unsigned max4_sse2(__m128);

    37                         global max4_sse2
    38                             ;; Input 4x float32 in xmm0
    39                             ;; output: bitmap in EAX
    40                             ;; clobbers: xmm1, xmm2
    41                         max4_sse2:
    42                         ;    cvtdq2ps  xmm0, xmm0
    43 00000040 660F70C8B1         pshufd    xmm1, xmm0, 0b10110001   ; swap adjacent pairs
    44 00000045 0F5FC8             maxps     xmm1, xmm0
    45                         
    46 00000048 660F70D14E         pshufd    xmm2, xmm1, 0b01001110   ; swap high/low halves
    47 0000004D 0F5FCA             maxps     xmm1, xmm2
    48                         
    49 00000050 0FC2C800           cmpeqps   xmm1, xmm0               ; 0 / -1
    50                         
    51 00000054 0F50C1             movmskps  eax, xmm1          ; extract the high bit of each dword
    52 00000057 C3                 ret

size = 0x58 - 0x40 = 24 bytes

คัดลอกและสับเปลี่ยนกับpshufdยังคงเป็นทางออกที่ดีที่สุดของเรา: shufps dst,src,imm8อ่านการป้อนข้อมูลสำหรับครึ่งต่ำจากdst dstและเราต้องการการคัดลอกและสับเปลี่ยนแบบไม่ทำลายทั้งสองครั้งดังนั้น 3 ไบต์movhlpsและunpckhps/ pd จึงออกมาทั้งคู่ ถ้าเราแคบลงถึงค่าสเกลาร์แม็กซ์เราสามารถใช้มัน แต่มันมีค่าใช้จ่ายคำสั่งอื่นในการออกอากาศก่อนที่จะเปรียบเทียบถ้าเราไม่มีค่าสูงสุดในองค์ประกอบทั้งหมดแล้ว

ที่เกี่ยวข้อง: SSE4.1 phminposuwสามารถค้นหาตำแหน่งและมูลค่าขั้นต่ำuint16_tในการลงทะเบียน XMM ฉันไม่คิดว่ามันจะชนะการลบจาก 65535 เพื่อใช้สำหรับสูงสุด แต่ดูคำตอบดังนั้นเกี่ยวกับการใช้มันสำหรับสูงสุดไบต์หรือจำนวนเต็มเซ็น

Python 3.8 (เผยแพร่ล่วงหน้า) , 67 ไบต์

ฟังก์ชั่นแลมบ์ดาที่ใช้ในจำนวนเต็ม 4 จำนวนบิตเลื่อนผลบูลีนของการเปรียบเทียบกับค่าสูงสุดด้วยความช่วยเหลือจากผู้ดำเนินการมอบหมายงานใหม่ของ Python 3.8 และส่งกลับค่า OR หรือบิตของผลลัพธ์

lambda a,b,c,d:((m:=max(a,b,c,d))==d)<<3|(m==c)<<2|(m==b)<<2|(a==m)

ลองออนไลน์!

Java (JDK) , 78 ไบต์

a->{int m=a[0],w=1,p=1;for(int t:a){w=t<m?w:p|(t>m?(m=t)^m:w);p*=2;}return w;}

ลองออนไลน์!

• [a,b,c,d]จะเข้าเป็นอาร์เรย์ของ

05AB1E , 3 2 ไบต์

ZQ

อินพุตเป็นรายการ[d,c,b,a]เอาต์พุตเป็นรายการบูลีน

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

คำอธิบาย:

Z    # Take the maximum of the implicit input-list
 Q   # Check for each in the (implicit) input-list if it equals this value
     # (and output implicitly as result)

JavaScript (ES6), 30 ไบต์

([d,c,b,a])จะเข้าเป็น ส่งคืนค่าบูลีน 4 ค่า

a=>a.map(x=>x==Math.max(...a))

ลองออนไลน์!

ทับทิม , 34 22 ไบต์

รับอินพุตเป็นอาร์เรย์[d, c, b, a]และส่งคืนอาร์เรย์ 1s และ 0s

->r{r.map{|e|e/r.max}}

ลองออนไลน์!

Python 3 , 59 ไบต์ 66 ไบต์

def f(l):
 n=max(a)
 for i in 0,1,2,3:a[i]=a[i]==n
 return a[::-1]

ลองออนไลน์!

ใช้อินพุตเป็น [a,b,c,d]และเอาต์พุตรายการ booleans

แก้ไขแล้วว่าเป็นฟังก์ชั่นที่เหมาะสมจากนั้นบันทึก 2 ไบต์ด้วยการลบวงเล็บไปตามเงื่อนไข

1. Python 3.5, 90 ไบต์

ใช้ลำดับของตัวเลขเป็นพารามิเตอร์ ส่งคืนสตริง "binary"

import sys;v=[*map(int,sys.argv[1:])];m=max(v);s=""
for e in v:s=str(int(e==m))+s
print(s)

ตัวอย่าง:

$ ./script.py 6 77 1 4 77
10010

คำอธิบาย

import sys
# convert list of string parameters to list of integers
v=[*map(int,sys.argv[1:])]
# get max
m=max(v)
# init outstring
s=""
# walk through list
for e in v:
    # prepend to outstring: int(True)=>1, int(False)=>0
    s=str(int(e==m))+s
# print out result
print(s)

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

n=>n.Select(a=>a==n.Max())

ลองออนไลน์!

ใช้อินพุตในรูปแบบ [d,c,b,a]จะเข้าในรูปแบบคนอื่น ๆ ทั้งหมดด้านล่างรับข้อมูลเป็น[a,b,c,d]

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

n=>n.Select((a,b)=>n[3-b]==n.Max())

ส่งคืน IEnumerable<bool>ส่งกลับ

ลองออนไลน์!

C # (Visual C # Interactive Compiler) , 39 ไบต์

n=>n.Select((a,b)=>n[3-b]==n.Max()?1:0)

ส่งคืน IEnumerable<int>ซึ่งแสดงถึงบิต

ลองออนไลน์!

C # (Visual C # Interactive Compiler) , 49 ไบต์

n=>{for(int i=4;i-->0;Write(n[i]==n.Max()?1:0));}

พิมพ์สตริงไบนารีไปที่ STDOUT

ลองออนไลน์!

PHP, 54 ไบต์

while($i<4)$argv[++$i]<max($argv)||$r+=1<<$i-1;echo$r;

หรือ

while($i<4)$argv[++$i]<max($argv)||$r+=1<<$i;echo$r/2;

รับอินพุตจากอาร์กิวเมนต์บรรทัดรับคำสั่ง ทำงานด้วย-nrหรือลองพวกเขาออนไลน์

นี่คือเวอร์ชัน JS ที่แสดงผลเป็นไบนารี

อัปเดต: สั้นกว่าด้วยการเข้าร่วมและไม่มีการค้นหา:

JavaScript (Node.js)ขนาด 42 ไบต์

a=>a.map(x=>+(x==Math.max(...a))).join('')

ลองออนไลน์!

ก่อนหน้านี้ด้วยการค้นหา 49 ไบต์

a=>a.map(x=>[0,1][+(x==Math.max(...a))]).join('')

ลองออนไลน์!

ก่อนหน้านี้ด้วยการลดขนาด 52 ไบต์:

a=>a.reduce((y,x)=>y+[0,1][+(x==Math.max(...a))],'')

ลองออนไลน์!

fa=>a.map(x=>+(x==Math.max(...a))).join('')
console.log(f([ 4, 1,77, 6])) // 0010
console.log(f([10,10, 5, 4])) // 1100
console.log(f([ 1, 1, 1, 1])) // 1111

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

x=>{for(int m=x.Max(),i=4;i-->0;)x[i]=x[i]==m?1:0;}

ลองออนไลน์!

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

ด้านล่างเป็นฟังก์ชั่นวนซ้ำที่แสดงผลเป็นจำนวนเต็ม

C # (Visual C # Interactive Compiler) , 60 ไบต์

int f(int[]x,int i=3)=>i<0?0:2*f(x,i-1)|(x[i]==x.Max()?1:0);

ลองออนไลน์!

ทั้งสองฟังก์ชั่นรับอินพุตเป็นอาเรย์ 4 องค์ประกอบ

[d, c, b, a]

Python 2 , 35 ไบต์

lambda i:[int(x==max(i))for x in i]

ลองออนไลน์!

รับอินพุตในรูปแบบ [d, c, b, a] เช่นเดียวกับคำตอบที่ยอมรับจากAdámดังนั้นฉันเดาว่ามันใช้ได้

ทางเลือกสำหรับ 41 ถ้าไม่ใช่ ...

Python 2 , 41 ไบต์

lambda i:[int(x==max(i))for x in i][::-1]

ลองออนไลน์!

Python 3 , 42 ไบต์

f=lambda a:list(map(lambda x:x==max(a),a))

เพียงส่งคืนรายการว่าองค์ประกอบนั้นเป็นค่าสูงสุดสำหรับแต่ละองค์ประกอบในอินพุตหรือไม่ -2 ไบต์ถ้าคุณไม่นับการf=บ้าน

ลองออนไลน์!

แบตช์, 92 ไบต์

@set m=%1
@set f=@for %%i in (%*)do @
%f%set/a"m=m+(m-=%%i)*(m>>31)
%f%cmd/cset/a!(m-%%i)

รับอาร์กิวเมนต์เป็นพารามิเตอร์บรรทัดคำสั่งในลำดับย้อนกลับ ทำงานโดยการคำนวณค่าพารามิเตอร์สูงสุดด้วยการลดจำนวนลงและเพิ่มความแตกต่างในเชิงบวกเฉพาะจากค่าสูงสุดที่รันอยู่จากนั้นจึงทำการจับคู่แต่ละพารามิเตอร์อีกครั้งคราวนี้เปรียบเทียบกับค่าสูงสุด สะดวกcmd/cset/aไม่ส่งออกบรรทัดใหม่ดังนั้นผลลัพธ์จะถูกรวมเข้าด้วยกันโดยอัตโนมัติ %f%เพียงช่วยประหยัด 5 ไบต์ในสิ่งที่จะสร้างซ้ำแล้วซ้ำอีก